Implement conflict resolution features in GitActionsControl

- Add functionality to open conflicted files in the editor when a resolve conflicts action is triggered.
- Update the UI to display a warning message and an option to open conflicted files when merge conflicts are detected.
- Enhance tests to cover conflict resolution scenarios and ensure proper handling of Git status with conflicts.

Author: BunsDev

apps/web/src/components/GitActionsControl.logic.test.ts

@@ -14,6 +14,8 @@ function status(overrides: Partial<GitStatusResult> = {}): GitStatusResult {
   return {
     branch: "feature/test",
     hasWorkingTreeChanges: false,
+    hasConflicts: false,
+    conflictedFiles: [],
     workingTree: {
       files: [],
       insertions: 0,
@@ -87,6 +89,44 @@ describe("when: branch is clean and has an open PR", () => {
   });
 });
 
+describe("when: repository has merge conflicts", () => {
+  it("resolveQuickAction surfaces a resolve conflicts action", () => {
+    const quick = resolveQuickAction(
+      status({
+        hasConflicts: true,
+        conflictedFiles: ["src/app.tsx", "README.md"],
+        hasWorkingTreeChanges: true,
+      }),
+      false,
+    );
+    assert.deepInclude(quick, {
+      kind: "resolve_conflicts",
+      label: "Resolve conflicts",
+      disabled: false,
+    });
+  });
+
+  it("buildMenuItems disables commit, push, and pr actions", () => {
+    const items = buildMenuItems(
+      status({
+        hasConflicts: true,
+        conflictedFiles: ["src/app.tsx"],
+        hasWorkingTreeChanges: true,
+        aheadCount: 1,
+      }),
+      false,
+    );
+    assert.deepEqual(
+      items.map((item) => ({ id: item.id, disabled: item.disabled })),
+      [
+        { id: "commit", disabled: true },
+        { id: "push", disabled: true },
+        { id: "pr", disabled: true },
+      ],
+    );
+  });
+});
+
 describe("when: actions are busy", () => {
   it("resolveQuickAction returns running disabled state", () => {
     const quick = resolveQuickAction(status(), true);

apps/web/src/components/GitActionsControl.tsx

@@ -677,6 +677,10 @@ export default function GitActionsControl({ gitCwd, activeThreadId }: GitActions
       void promise.catch(() => undefined);
       return;
     }
+    if (quickAction.kind === "resolve_conflicts") {
+      openConflictedFilesInEditor();
+      return;
+    }
     if (quickAction.kind === "show_hint") {
       toastManager.add({
         type: "info",
@@ -689,7 +693,13 @@ export default function GitActionsControl({ gitCwd, activeThreadId }: GitActions
     if (quickAction.action) {
       void runGitActionWithToast({ action: quickAction.action });
     }
-  }, [openExistingPr, pullMutation, quickAction, threadToastData]);
+  }, [
+    openConflictedFilesInEditor,
+    openExistingPr,
+    pullMutation,
+    quickAction,
+    threadToastData,
+  ]);
 
   const openDialogForMenuItem = useCallback(
     (item: GitActionMenuItem) => {
@@ -758,6 +768,56 @@ export default function GitActionsControl({ gitCwd, activeThreadId }: GitActions
     [gitCwd, threadToastData],
   );
 
+  const openConflictedFilesInEditor = useCallback(() => {
+    const conflictedFiles = gitStatusForActions?.conflictedFiles ?? [];
+    if (!gitCwd || conflictedFiles.length === 0) {
+      toastManager.add({
+        type: "info",
+        title: "No conflicted files",
+        description: "Refresh git status if you recently resolved conflicts.",
+        data: threadToastData,
+      });
+      return;
+    }
+
+    const api = readNativeApi();
+    if (!api) {
+      toastManager.add({
+        type: "error",
+        title: "Editor opening is unavailable.",
+        data: threadToastData,
+      });
+      return;
+    }
+
+    const openPromise = (async () => {
+      for (const filePath of conflictedFiles) {
+        const target = resolvePathLinkTarget(filePath, gitCwd);
+        await openInPreferredEditor(api, target);
+      }
+      return conflictedFiles.length;
+    })();
+
+    toastManager.promise(openPromise, {
+      loading: { title: "Opening conflicted files...", data: threadToastData },
+      success: (count) => ({
+        title: count === 1 ? "Opened conflicted file" : "Opened conflicted files",
+        description:
+          count === 1
+            ? conflictedFiles[0] ?? undefined
+            : `${count} files opened in your editor.`,
+        data: threadToastData,
+      }),
+      error: (error) => ({
+        title: "Unable to open conflicted files",
+        description: error instanceof Error ? error.message : "An error occurred.",
+        data: threadToastData,
+      }),
+    });
+
+    void openPromise.catch(() => undefined);
+  }, [gitCwd, gitStatusForActions?.conflictedFiles, threadToastData]);
+
   if (!gitCwd) return null;
 
   return (
@@ -866,6 +926,18 @@ export default function GitActionsControl({ gitCwd, activeThreadId }: GitActions
                   Detached HEAD: create and checkout a branch to enable push and PR actions.
                 </p>
               )}
+              {gitStatusForActions?.hasConflicts && (
+                <div className="space-y-2 px-2 py-2">
+                  <p className="text-warning text-xs">
+                    Resolve merge conflicts before committing, pulling, pushing, or opening a PR.
+                  </p>
+                  {gitStatusForActions.conflictedFiles.length > 0 ? (
+                    <Button size="xs" variant="outline" onClick={openConflictedFilesInEditor}>
+                      Open conflicted files
+                    </Button>
+                  ) : null}
+                </div>
+              )}
               {gitStatusForActions &&
                 gitStatusForActions.branch !== null &&
                 !gitStatusForActions.hasWorkingTreeChanges &&

packages/contracts/src/git.test.ts

@@ -6,6 +6,7 @@ import {
   GitPreparePullRequestThreadInput,
   GitRunStackedActionInput,
   GitResolvePullRequestResult,
+  GitStatusResult,
 } from "./git";
 
 const decodeCreateWorktreeInput = Schema.decodeUnknownSync(GitCreateWorktreeInput);
@@ -14,6 +15,7 @@ const decodePreparePullRequestThreadInput = Schema.decodeUnknownSync(
 );
 const decodeRunStackedActionInput = Schema.decodeUnknownSync(GitRunStackedActionInput);
 const decodeResolvePullRequestResult = Schema.decodeUnknownSync(GitResolvePullRequestResult);
+const decodeGitStatusResult = Schema.decodeUnknownSync(GitStatusResult);
 
 describe("GitCreateWorktreeInput", () => {
   it("accepts omitted newBranch for existing-branch worktrees", () => {
@@ -71,3 +73,26 @@ describe("GitRunStackedActionInput", () => {
     expect(parsed.action).toBe("commit");
   });
 });
+
+describe("GitStatusResult", () => {
+  it("decodes conflict metadata", () => {
+    const parsed = decodeGitStatusResult({
+      branch: "feature/conflicts",
+      hasWorkingTreeChanges: true,
+      hasConflicts: true,
+      conflictedFiles: ["src/app.tsx"],
+      workingTree: {
+        files: [{ path: "src/app.tsx", insertions: 0, deletions: 0 }],
+        insertions: 0,
+        deletions: 0,
+      },
+      hasUpstream: true,
+      aheadCount: 0,
+      behindCount: 1,
+      pr: null,
+    });
+
+    expect(parsed.hasConflicts).toBe(true);
+    expect(parsed.conflictedFiles).toEqual(["src/app.tsx"]);
+  });
+});