feat: worktree mode switch with full diff options (#196)

Selecting a worktree now enters "worktree mode" — the dropdown
replaces its contents with standard diff options (uncommitted,
last-commit, vs main) scoped to that worktree. A "Back to main
repo" entry returns to the original view.

- Add parseWorktreeDiffType() for compound types like worktree:/path:last-commit
- Add getWorktreeDiffOptions() to build worktree-mode dropdown entries
- Update runGitDiff() to handle worktree sub-types
- Update /api/diff/switch to return diffOptions on mode transitions
- Update App.tsx to consume updated diffOptions and refresh dropdown
- Add test sandbox with 4 worktrees for manual testing

Co-Authored-By: Claude Opus 4.6 <noreply@anthropic.com>

Author: backnotprop

packages/review-editor/App.tsx

@@ -368,14 +368,22 @@ const ReviewApp: React.FC = () => {
         rawPatch: string;
         gitRef: string;
         diffType: string;
+        diffOptions?: { id: string; label: string }[];
+        error?: string;
       };
 
       const newFiles = parseDiffToFiles(data.rawPatch);
       setFiles(newFiles);
       setDiffType(data.diffType);
       setActiveFileIndex(0);
       setPendingSelection(null);
-      setDiffError((data as { error?: string }).error || null);
+      setDiffError(data.error || null);
+
+      // Update dropdown options on worktree mode transitions
+      if (data.diffOptions) {
+        setGitContext(prev => prev ? { ...prev, diffOptions: data.diffOptions! } : prev);
+      }
+
       // Note: We keep existing annotations - they may still be relevant
       // or user can clear them manually
     } catch (err) {
@@ -837,7 +845,11 @@ const ReviewApp: React.FC = () => {
                           {diffType === 'unstaged' && "No unstaged changes. All changes are staged."}
                           {diffType === 'last-commit' && "No changes in the last commit."}
                           {diffType === 'branch' && `No changes between this branch and ${gitContext?.defaultBranch || 'main'}.`}
-                          {diffType?.startsWith('worktree:') && "No uncommitted changes in this worktree."}
+                          {diffType?.startsWith('worktree:') && (
+                            diffType.endsWith(':last-commit') ? "No changes in the last commit in this worktree." :
+                            diffType.endsWith(':branch') ? `No changes vs ${gitContext?.defaultBranch || 'main'} in this worktree.` :
+                            "No uncommitted changes in this worktree."
+                          )}
                         </p>
                       </>
                     )}

packages/server/git.ts

@@ -195,6 +195,40 @@ async function getUntrackedFileDiffs(srcPrefix = 'a/', dstPrefix = 'b/', cwd?: s
   }
 }
 
+/**
+ * Parse a worktree diff type like `worktree:/path:last-commit` into path + sub-type.
+ * Falls back to `uncommitted` if no sub-type suffix (backwards compatible).
+ */
+const WORKTREE_SUB_TYPES = new Set(["uncommitted", "last-commit", "branch"]);
+
+function parseWorktreeDiffType(diffType: string): { path: string; subType: string } | null {
+  if (!diffType.startsWith("worktree:")) return null;
+  const rest = diffType.slice("worktree:".length);
+  const lastColon = rest.lastIndexOf(":");
+  if (lastColon !== -1) {
+    const maybeSub = rest.slice(lastColon + 1);
+    if (WORKTREE_SUB_TYPES.has(maybeSub)) {
+      return { path: rest.slice(0, lastColon), subType: maybeSub };
+    }
+  }
+  return { path: rest, subType: "uncommitted" };
+}
+
+/**
+ * Build diff options for worktree mode: back-to-main, separator, then
+ * standard diff types with the worktree path baked into each id.
+ */
+export function getWorktreeDiffOptions(worktreePath: string, defaultBranch: string): DiffOption[] {
+  const prefix = `worktree:${worktreePath}:`;
+  return [
+    { id: "back-to-main" as DiffType, label: "\u2190 Back to main repo" },
+    { id: "separator", label: "" },
+    { id: `${prefix}uncommitted` as DiffType, label: "Uncommitted changes" },
+    { id: `${prefix}last-commit` as DiffType, label: "Last commit" },
+    { id: `${prefix}branch` as DiffType, label: `vs ${defaultBranch}` },
+  ];
+}
+
 /**
  * Run git diff with the specified type
  */
@@ -207,22 +241,46 @@ export async function runGitDiff(
 
   // Handle worktree diffs — run git commands in the worktree's directory
   if (diffType.startsWith("worktree:")) {
-    const worktreePath = diffType.slice("worktree:".length);
+    const parsed = parseWorktreeDiffType(diffType);
+    if (!parsed) {
+      return { patch: "", label: "Worktree error", error: "Could not parse worktree diff type" };
+    }
+
+    const { path: wtPath, subType } = parsed;
+
     try {
-      const trackedDiff = (await $`git diff HEAD --src-prefix=a/ --dst-prefix=b/`.quiet().cwd(worktreePath)).text();
-      const untrackedDiff = await getUntrackedFileDiffs('a/', 'b/', worktreePath);
-      patch = trackedDiff + untrackedDiff;
+      switch (subType) {
+        case "uncommitted": {
+          const trackedDiff = (await $`git diff HEAD --src-prefix=a/ --dst-prefix=b/`.quiet().cwd(wtPath)).text();
+          const untrackedDiff = await getUntrackedFileDiffs('a/', 'b/', wtPath);
+          patch = trackedDiff + untrackedDiff;
+          label = "Uncommitted changes";
+          break;
+        }
+        case "last-commit":
+          patch = (await $`git diff HEAD~1..HEAD --src-prefix=a/ --dst-prefix=b/`.quiet().cwd(wtPath)).text();
+          label = "Last commit";
+          break;
+        case "branch":
+          patch = (await $`git diff ${defaultBranch}..HEAD --src-prefix=a/ --dst-prefix=b/`.quiet().cwd(wtPath)).text();
+          label = `Changes vs ${defaultBranch}`;
+          break;
+        default:
+          patch = "";
+          label = "Unknown worktree diff type";
+      }
 
-      // Derive label from branch name in the worktree
+      // Prefix label with worktree branch name for context
       try {
-        const branch = (await $`git rev-parse --abbrev-ref HEAD`.quiet().cwd(worktreePath)).text().trim();
-        label = `Worktree: ${branch}`;
+        const branch = (await $`git rev-parse --abbrev-ref HEAD`.quiet().cwd(wtPath)).text().trim();
+        label = `${branch}: ${label}`;
       } catch {
-        label = `Worktree: ${worktreePath.split("/").pop()}`;
+        label = `${wtPath.split("/").pop()}: ${label}`;
       }
 
       return { patch, label };
     } catch (error) {
+      console.error(`Git diff error for ${diffType}:`, error);
       const errorMessage = error instanceof Error ? error.message : String(error);
       return { patch: "", label: "Worktree error", error: errorMessage };
     }

packages/server/review.ts

@@ -10,7 +10,7 @@
  */
 
 import { isRemoteSession, getServerPort } from "./remote";
-import { type DiffType, type GitContext, runGitDiff } from "./git";
+import { type DiffType, type GitContext, runGitDiff, getWorktreeDiffOptions } from "./git";
 import { getRepoInfo } from "./repo";
 import { handleImage, handleUpload, handleAgents, handleServerReady, handleDraftSave, handleDraftLoad, handleDraftDelete, type OpencodeClient } from "./shared-handlers";
 import { contentHash, deleteDraft } from "./draft";
@@ -141,7 +141,7 @@ export async function startReviewServer(
           if (url.pathname === "/api/diff/switch" && req.method === "POST") {
             try {
               const body = (await req.json()) as { diffType: DiffType };
-              const newDiffType = body.diffType;
+              let newDiffType = body.diffType;
 
               if (!newDiffType) {
                 return Response.json(
@@ -150,8 +150,16 @@ export async function startReviewServer(
                 );
               }
 
-              // Run the new diff
               const defaultBranch = gitContext?.defaultBranch || "main";
+              const previousDiffType = currentDiffType;
+
+              // Handle "back to main repo" sentinel
+              const isBackToMain = newDiffType === ("back-to-main" as DiffType);
+              if (isBackToMain) {
+                newDiffType = "uncommitted" as DiffType;
+              }
+
+              // Run the new diff
               const result = await runGitDiff(newDiffType, defaultBranch);
 
               // Update state
@@ -160,12 +168,27 @@ export async function startReviewServer(
               currentDiffType = newDiffType;
               currentError = result.error;
 
-              return Response.json({
+              // Build response — include diffOptions on worktree mode transitions
+              const response: Record<string, unknown> = {
                 rawPatch: currentPatch,
                 gitRef: currentGitRef,
                 diffType: currentDiffType,
                 ...(currentError && { error: currentError }),
-              });
+              };
+
+              if (isBackToMain) {
+                // Exiting worktree mode: restore original dropdown options
+                response.diffOptions = gitContext?.diffOptions;
+              } else if (
+                newDiffType.startsWith("worktree:") &&
+                !previousDiffType.startsWith("worktree:")
+              ) {
+                // Entering worktree mode: send worktree-scoped dropdown options
+                const wtPath = newDiffType.slice("worktree:".length).replace(/:(?:uncommitted|last-commit|branch)$/, "");
+                response.diffOptions = getWorktreeDiffOptions(wtPath, defaultBranch);
+              }
+
+              return Response.json(response);
             } catch (err) {
               const message =
                 err instanceof Error ? err.message : "Failed to switch diff";

tests/README.md

@@ -17,6 +17,7 @@ These scripts test the UI components and require a browser.
 
 ```bash
 ./tests/manual/local/test-opencode-review.sh  # Code review UI test
+./tests/manual/local/test-worktree-review.sh  # Worktree support test (creates sandbox with 4 worktrees)
 ```
 
 See [UI-TESTING.md](../docs/UI-TESTING.md) for detailed UI testing documentation.

tests/manual/local/test-worktree-review.sh

@@ -0,0 +1,42 @@
+#!/bin/bash
+# Test script for worktree support in code review
+#
+# Usage:
+#   ./test-worktree-review.sh [--keep]
+#
+# Options:
+#   --keep  Don't clean up the temp repo on exit (for debugging)
+#
+# What it does:
+#   1. Builds the review app (ensures latest code)
+#   2. Creates a temp git repo with 4 worktrees:
+#      - feature-auth: new file + modified file
+#      - fix-parser: modified file + untracked file
+#      - empty-branch: no changes (tests empty state)
+#      - detached HEAD: new file on detached HEAD
+#   3. Launches review server — browser opens automatically
+#   4. You test the worktree dropdown and diff switching
+#   5. Cleans up on exit (unless --keep)
+
+set -e
+
+SCRIPT_DIR="$(cd "$(dirname "$0")" && pwd)"
+PROJECT_ROOT="$(cd "$SCRIPT_DIR/../../.." && pwd)"
+
+echo "=== Plannotator Worktree Review Test ==="
+echo ""
+
+# Build first to ensure latest code
+echo "Building review app..."
+cd "$PROJECT_ROOT"
+bun run build:review
+
+echo ""
+echo "Setting up sandbox with worktrees..."
+echo ""
+
+# Forward args to the TypeScript test server
+bun run "$PROJECT_ROOT/tests/manual/test-worktree-review.ts" "$@"
+
+echo ""
+echo "=== Test Complete ==="