refactor(shared): align types and imports across modules

- Add optional cause to ConfigError and other error schemas
- Comment out ApiError formatting path in error formatter
- Adjust imports and TS path suffixes to .ts extensions
- Refactor process result types and error handling with Effect
- Stabilize progress config typings and label keys to match new enums

refactor that updates shared module typings and imports, and improves
error handling paths and process typings. the changes align extensions
and optional fields to support more robust error information.

Co-Authored-By: Git Agent <noreply@git-agent.dev>

Author: xesrevinu

src/shared/errors.ts

@@ -8,6 +8,7 @@ export class CliUsageError extends Schema.TaggedErrorClass<CliUsageError>()("Cli
 
 export class ConfigError extends Schema.TaggedErrorClass<ConfigError>()("ConfigError", {
   message: Schema.String,
+  cause: Schema.optional(Schema.Unknown),
 }) {
   static is = Schema.is(this);
 }
@@ -28,6 +29,7 @@ export class ApiError extends Schema.TaggedErrorClass<ApiError>()("ApiError", {
   message: Schema.String,
   status: Schema.optional(Schema.Number),
   body: Schema.optional(Schema.String),
+  cause: Schema.optional(Schema.Unknown),
 }) {
   static is = Schema.is(this);
 }
@@ -65,16 +67,16 @@ export const renderError = (error: unknown): string => {
   if (ConfigError.is(error)) {
     return error.message;
   }
-  if (ApiError.is(error)) {
-    const parts = [error.message];
-    if (typeof error.status === "number") {
-      parts.push(`status: ${error.status}`);
-    }
-    if (typeof error.body === "string" && error.body.trim().length > 0) {
-      parts.push(error.body.trim());
-    }
-    return parts.join("\n");
-  }
+  // if (ApiError.is(error)) {
+  //   const parts = [error.message];
+  //   if (typeof error.status === "number") {
+  //     parts.push(`status: ${error.status}`);
+  //   }
+  //   if (typeof error.body === "string" && error.body.trim().length > 0) {
+  //     parts.push(error.body.trim());
+  //   }
+  //   return parts.join("\n");
+  // }
   if (ProcessExecutionError.is(error)) {
     const details = error.stderr.trim().length > 0 ? error.stderr.trim() : error.stdout.trim();
     return `${error.command} exited with code ${error.exitCode}${details.length > 0 ? `\n${details}` : ""}`;

src/shared/output.ts

@@ -1,5 +1,5 @@
 import { Console, Effect } from "effect";
-import type { SingleCommitResult } from "../domain/commit";
+import type { SingleCommitResult } from "../domain/commit.ts";
 
 const indent = (value: string, prefix = "   "): string =>
   value

src/shared/process.ts

@@ -1,20 +1,22 @@
-import { Effect, Stream } from "effect";
+import { Effect, Schema, Stream } from "effect";
 import { ChildProcess } from "effect/unstable/process";
-import { ProcessExecutionError } from "./errors";
+import { ProcessExecutionError } from "./errors.ts";
 
-export interface ProcessResult {
-  readonly stdout: string;
-  readonly stderr: string;
-  readonly exitCode: number;
-}
+export const ProcessResult = Schema.Struct({
+  stdout: Schema.String,
+  stderr: Schema.String,
+  exitCode: Schema.Number,
+});
+
+export type ProcessResult = typeof ProcessResult.Type;
 
 export interface RunProcessOptions {
   readonly command: string;
-  readonly args?: ReadonlyArray<string>;
-  readonly cwd?: string;
-  readonly env?: Record<string, string | undefined>;
-  readonly stdin?: string;
-  readonly allowFailure?: boolean;
+  readonly args?: ReadonlyArray<string> | undefined;
+  readonly cwd?: string | undefined;
+  readonly env?: Record<string, string | undefined> | undefined;
+  readonly stdin?: string | undefined;
+  readonly allowFailure?: boolean | undefined;
 }
 
 const encoder = new TextEncoder();
@@ -70,8 +72,8 @@ export const runProcess = ({
     }).pipe(
       Effect.catch((cause) =>
         ProcessExecutionError.is(cause)
-          ? Effect.failSync(() => cause)
-          : Effect.failSync(() => toProcessExecutionError(command, args, cause)),
+          ? Effect.fail(cause)
+          : Effect.fail(toProcessExecutionError(command, args, cause)),
       ),
     ),
   );

src/shared/progress-config.ts

@@ -1,4 +1,4 @@
-import type { ProgressAttributeDescriptor, ProgressRenderConfig } from "./tracing";
+import type { ProgressAttributeDescriptor, ProgressRenderConfig } from "./tracing.ts";
 
 const hiddenAttributePrefixes = ["http.request.header.", "http.response.header."];
 
@@ -18,7 +18,6 @@ const hiddenAttributeKeys = new Set([
 
 const orderedInteractiveAttributeKeys = [
   "vcs",
-  "requested_vcs",
   "dry_run",
   "no_stage",
   "amend",
@@ -57,32 +56,21 @@ const interactiveLabelByKey: Record<string, string> = {
 };
 
 const friendlySpanNames: Record<string, string> = {
-  "commit.prepare-request": "Prepare commit",
-  "commit.run": "Run commit",
-  "commit.resolve-provider": "Resolve provider",
-  "commit.load-project-config": "Load project config",
-  "commit.scan-changes": "Scan changes",
-  "commit.plan-groups": "Plan commits",
-  "commit.resolve-message": "Resolve commit message",
-  "commit.refresh-scopes": "Refresh scopes",
-  "commit.replan-groups": "Replan commits",
-  "commit.generate-message": "Generate commit message",
-  "commit.run-hooks": "Run commit hooks",
-  "commit.create": "Create commit",
-  "commit.load-previous": "Load previous commit",
-  "commit.generate-amend-message": "Generate amended message",
-  "commit.amend": "Amend commit",
-  "init.run": "Run init",
-  "init.resolve-provider": "Resolve provider",
-  "init.initialize-repository": "Initialize repository",
-  "init.generate-gitignore": "Generate .gitignore",
-  "init.generate-scopes": "Generate scopes",
-  "init.write-default-hook": "Write default hook",
-  "init.write-hook": "Write hook config",
-  "init.write-project-config": "Write project config",
-  "config.resolve-provider": "Resolve provider config",
-  "config.resolve-field": "Resolve config value",
-  "hooks.execute": "Run hook",
+  "Commit.ScanChanges": "Scan changes",
+  "Commit.PlanGroups": "Plan commits",
+  "Commit.ResolveMessage": "Resolve commit message",
+  "Commit.ReplanGroups": "Replan commits",
+  "Commit.Create": "Create commit",
+  "Commit.create": "Create commit",
+  "Commit.LoadPrevious": "Load previous commit",
+  "Commit.Amend": "Amend commit",
+  "Config.GenerateGitignore": "Generate .gitignore",
+  "Config.GenerateScopes": "Generate scopes",
+  "Config.ResolveProvider": "Resolve provider",
+  "Init.WriteDefaultHook": "Write default hook",
+  "Init.WriteHook": "Write hook config",
+  "LLM.GenerateMessage": "Generate commit message",
+  "LLM.PlanCommits": "Plan commits",
   "LanguageModel.generateText": "Call model",
 };
 
@@ -141,7 +129,7 @@ const toDescriptors = (
     key: string,
     value: unknown,
     label = simplifyInteractiveLabel(key),
-    dedupeKey?: string,
+    dedupeKey?: string | undefined,
   ) => {
     if (value === undefined || value === null) {
       return;

src/shared/text.ts

@@ -1,4 +1,4 @@
-import type { Trailer } from "../domain/commit";
+import type { Trailer } from "../domain/commit.ts";
 
 export const countLines = (content: string): number => {
   if (content.length === 0) {

src/shared/tracing.ts

@@ -1,6 +1,6 @@
 import { clearScreenDown, cursorTo, moveCursor } from "node:readline";
-import { Cause, Duration, Effect, Exit, Layer, ServiceMap, Tracer } from "effect";
-import { renderError } from "./errors";
+import { Cause, Duration, Effect, Exit, Layer, Schema, ServiceMap, Tracer } from "effect";
+import { renderError } from "./errors.ts";
 
 type ProgressStatus = "running" | "done" | "failed" | "interrupted";
 
@@ -34,59 +34,73 @@ interface CompactAttributeToken {
 
 export type ProgressRenderMode = "interactive" | "raw";
 
-export interface ProgressAttributeDescriptor {
-  readonly key: string;
-  readonly label?: string;
-  readonly value: unknown;
-  readonly dedupeKey?: string;
-}
+export const ProgressAttributeDescriptor = Schema.Struct({
+  key: Schema.String,
+  label: Schema.optionalKey(Schema.String),
+  value: Schema.Unknown,
+  dedupeKey: Schema.optionalKey(Schema.String),
+});
 
-export interface ProgressAttributeFormatInput {
-  readonly key: string;
-  readonly value: unknown;
-  readonly defaultLabel: string;
-}
+export type ProgressAttributeDescriptor = typeof ProgressAttributeDescriptor.Type;
 
-export interface ProgressAttributeFormatOutput {
-  readonly label?: string;
-  readonly value?: unknown;
-  readonly dedupeKey?: string;
-}
+export const ProgressAttributeFormatInput = Schema.Struct({
+  key: Schema.String,
+  value: Schema.Unknown,
+  defaultLabel: Schema.String,
+});
 
-export interface ProgressStatusSymbols {
-  readonly runningParent: string;
-  readonly success: string;
-  readonly failed: string;
-  readonly interrupted: string;
-}
+export type ProgressAttributeFormatInput = typeof ProgressAttributeFormatInput.Type;
+
+export const ProgressAttributeFormatOutput = Schema.Struct({
+  label: Schema.optionalKey(Schema.String),
+  value: Schema.optionalKey(Schema.Unknown),
+  dedupeKey: Schema.optionalKey(Schema.String),
+});
+
+export type ProgressAttributeFormatOutput = typeof ProgressAttributeFormatOutput.Type;
+
+export const ProgressStatusSymbols = Schema.Struct({
+  runningParent: Schema.String,
+  success: Schema.String,
+  failed: Schema.String,
+  interrupted: Schema.String,
+});
+
+export type ProgressStatusSymbols = typeof ProgressStatusSymbols.Type;
 
 export interface ProgressRenderConfig {
-  readonly headerLabel?: string;
-  readonly spinnerFrames?: ReadonlyArray<string>;
-  readonly symbols?: Partial<ProgressStatusSymbols>;
-  readonly formatSpanName?: (
-    name: string,
-    options: {
-      readonly mode: ProgressRenderMode;
-      readonly span: Tracer.Span;
-    },
-  ) => string;
-  readonly formatAttributes?: (
-    input: {
-      readonly attributes: ReadonlyMap<string, unknown>;
-    },
-    options: {
-      readonly mode: ProgressRenderMode;
-      readonly span: Tracer.Span;
-    },
-  ) => ReadonlyArray<ProgressAttributeDescriptor> | undefined;
-  readonly formatAttribute?: (
-    attribute: ProgressAttributeFormatInput,
-    options: {
-      readonly mode: ProgressRenderMode;
-      readonly span: Tracer.Span;
-    },
-  ) => ProgressAttributeFormatOutput | undefined;
+  readonly headerLabel?: string | undefined;
+  readonly spinnerFrames?: ReadonlyArray<string> | undefined;
+  readonly symbols?: Partial<ProgressStatusSymbols> | undefined;
+  readonly formatSpanName?:
+    | ((
+        name: string,
+        options: {
+          readonly mode: ProgressRenderMode;
+          readonly span: Tracer.Span;
+        },
+      ) => string)
+    | undefined;
+  readonly formatAttributes?:
+    | ((
+        input: {
+          readonly attributes: ReadonlyMap<string, unknown>;
+        },
+        options: {
+          readonly mode: ProgressRenderMode;
+          readonly span: Tracer.Span;
+        },
+      ) => ReadonlyArray<ProgressAttributeDescriptor> | undefined)
+    | undefined;
+  readonly formatAttribute?:
+    | ((
+        attribute: ProgressAttributeFormatInput,
+        options: {
+          readonly mode: ProgressRenderMode;
+          readonly span: Tracer.Span;
+        },
+      ) => ProgressAttributeFormatOutput | undefined)
+    | undefined;
 }
 
 const defaultHeaderLabel = "progress";