Add structured Git action failures and retry UI (#55)

* Refactor Git action error handling and enhance WebSocket communication

- Introduce GitActionExecutionError for structured error handling in git actions.
- Update WebSocket server to serialize Git action errors with detailed failure information.
- Enhance client-side handling of WebSocket errors to preserve structured error data.
- Add utility functions for summarizing and resolving Git action failures in the UI.
- Improve tests to cover new error handling scenarios and ensure proper decoding of structured errors.

* Migrate dialog and input primitives to Base UI

- Switch dialogs to Base UI primitives and update close handling
- Add richer button/input composition for shared component use
- Tweak destructive actions and GitHub review link rendering

Author: BunsDev

apps/server/src/git/Errors.ts

@@ -1,3 +1,4 @@
+import type { GitActionFailure } from "@okcode/contracts";
 import { Schema } from "effect";
 
 /**
@@ -57,10 +58,26 @@ export class GitManagerError extends Schema.TaggedErrorClass<GitManagerError>()(
   }
 }
 
+/**
+ * GitActionExecutionError - Structured failure information for a stacked git action.
+ */
+export class GitActionExecutionError extends Error {
+  readonly failure: GitActionFailure;
+  override readonly cause?: unknown;
+
+  constructor(input: { failure: GitActionFailure; cause?: unknown }) {
+    super(input.failure.summary, input.cause !== undefined ? { cause: input.cause } : undefined);
+    this.name = "GitActionExecutionError";
+    this.failure = input.failure;
+    this.cause = input.cause;
+  }
+}
+
 /**
  * GitManagerServiceError - Errors emitted by stacked Git workflow orchestration.
  */
 export type GitManagerServiceError =
+  | GitActionExecutionError
   | GitManagerError
   | GitCommandError
   | GitHubCliError

apps/server/src/git/Layers/GitManager.test.ts

@@ -962,7 +962,7 @@ it.layer(GitManagerTestLayer)("GitManager", (it) => {
         Effect.map((error) => error.message),
       );
 
-      expect(errorMessage).toContain("no changes to commit");
+      expect(errorMessage).toContain("no staged or working tree changes");
     }),
   );
 
@@ -1413,7 +1413,7 @@ it.layer(GitManagerTestLayer)("GitManager", (it) => {
         Effect.flip,
         Effect.map((error) => error.message),
       );
-      expect(errorMessage).toContain("GitHub CLI (`gh`) is required");
+      expect(errorMessage).toContain("requires GitHub CLI");
     }),
   );
 
@@ -1442,7 +1442,7 @@ it.layer(GitManagerTestLayer)("GitManager", (it) => {
         Effect.flip,
         Effect.map((error) => error.message),
       );
-      expect(errorMessage).toContain("gh auth login");
+      expect(errorMessage).toContain("not authenticated");
     }),
   );
 
@@ -2077,7 +2077,7 @@ it.layer(GitManagerTestLayer)("GitManager", (it) => {
         Effect.map((error) => error.message),
       );
 
-      expect(errorMessage).toContain("hook: fail");
+      expect(errorMessage).toContain("repository hook rejected");
       expect(events).toEqual(
         expect.arrayContaining([
           expect.objectContaining({
@@ -2087,6 +2087,11 @@ it.layer(GitManagerTestLayer)("GitManager", (it) => {
           expect.objectContaining({
             kind: "action_failed",
             phase: "commit",
+            failure: expect.objectContaining({
+              code: "hook_failed",
+              title: "Commit hook blocked the action",
+              detail: expect.stringContaining("hook: fail"),
+            }),
           }),
         ]),
       );

apps/server/src/git/Layers/GitManager.ts

@@ -9,7 +9,7 @@ import {
   sanitizeFeatureBranchName,
 } from "@okcode/shared/git";
 
-import { GitManagerError } from "../Errors.ts";
+import { GitActionExecutionError, GitManagerError } from "../Errors.ts";
 import {
   GitManager,
   type GitActionProgressReporter,
@@ -19,6 +19,7 @@ import {
 import { GitCore } from "../Services/GitCore.ts";
 import { GitHubCli } from "../Services/GitHubCli.ts";
 import { TextGeneration } from "../Services/TextGeneration.ts";
+import { buildGitActionFailure } from "../actionFailure.ts";
 
 const COMMIT_TIMEOUT_MS = 10 * 60_000;
 const MAX_PROGRESS_TEXT_LENGTH = 500;
@@ -1261,13 +1262,27 @@ export const makeGitManager = Effect.gen(function* () {
 
       return yield* runAction.pipe(
         Effect.catch((error) =>
-          progress
-            .emit({
+          Effect.gen(function* () {
+            const failure = buildGitActionFailure({
+              action: input.action,
+              phase: currentPhase,
+              error,
+            });
+
+            yield* progress.emit({
               kind: "action_failed",
               phase: currentPhase,
-              message: error.message,
-            })
-            .pipe(Effect.flatMap(() => Effect.fail(error))),
+              message: failure.summary,
+              failure,
+            });
+
+            return yield* Effect.fail(
+              new GitActionExecutionError({
+                failure,
+                cause: error,
+              }),
+            );
+          }),
         ),
       );
     },

apps/server/src/git/actionFailure.test.ts

@@ -0,0 +1,55 @@
+import { describe, expect, it } from "vitest";
+import { buildGitActionFailure } from "./actionFailure.ts";
+import { GitCommandError, GitHubCliError } from "./Errors.ts";
+
+describe("buildGitActionFailure", () => {
+  it("classifies GitHub auth failures during PR creation", () => {
+    const failure = buildGitActionFailure({
+      action: "commit_push_pr",
+      phase: "pr",
+      error: new GitHubCliError({
+        operation: "createPullRequest",
+        detail: "GitHub CLI is not authenticated. Run `gh auth login` and retry.",
+      }),
+    });
+
+    expect(failure.code).toBe("github_auth_required");
+    expect(failure.title).toBe("Authenticate GitHub CLI");
+    expect(failure.summary).toContain("branch was pushed");
+    expect(failure.nextSteps).toContain("Run `gh auth login` in this environment.");
+  });
+
+  it("classifies protected branch push failures", () => {
+    const failure = buildGitActionFailure({
+      action: "commit_push",
+      phase: "push",
+      error: new GitCommandError({
+        operation: "GitCore.pushCurrentBranch",
+        command: "git push origin main",
+        cwd: "/repo",
+        detail: "remote: error: GH006: Protected branch update failed for refs/heads/main.",
+      }),
+    });
+
+    expect(failure.code).toBe("branch_protected");
+    expect(failure.title).toBe("Protected branch rejected the push");
+    expect(failure.command).toBe("git push origin main");
+  });
+
+  it("classifies commit hook failures", () => {
+    const failure = buildGitActionFailure({
+      action: "commit",
+      phase: "commit",
+      error: new GitCommandError({
+        operation: "GitCore.commit.commit",
+        command: "git commit -m Fix",
+        cwd: "/repo",
+        detail: "pre-commit hook failed:\nlint errors found",
+      }),
+    });
+
+    expect(failure.code).toBe("hook_failed");
+    expect(failure.summary).toBe("A repository hook rejected the commit.");
+    expect(failure.nextSteps[0]).toContain("Review the hook output");
+  });
+});