gsd-pi 2.12.0 → 2.13.1

package/src/resources/extensions/gsd/tests/worktree-e2e.test.ts

@@ -0,0 +1,321 @@
+/**
+ * worktree-e2e.test.ts -- End-to-end tests for worktree-isolated git flow.
+ *
+ * Covers 5 cross-cutting groups not tested by individual slice tests:
+ *   1. Full lifecycle chain (create -> slice commits -> merge to milestone -> merge to main)
+ *   2. Preference gating (shouldUseWorktreeIsolation with overrides)
+ *   3. merge_to_main mode resolution (getMergeToMainMode)
+ *   4. Self-heal in merge context (abortAndReset, withMergeHeal)
+ *   5. Doctor detection of orphaned worktrees
+ */
+
+import {
+  mkdtempSync, mkdirSync, writeFileSync, rmSync,
+  existsSync, realpathSync, readFileSync,
+} from "node:fs";
+import { join } from "node:path";
+import { tmpdir } from "node:os";
+import { execSync } from "node:child_process";
+
+import {
+  createAutoWorktree,
+  mergeMilestoneToMain,
+  mergeSliceToMilestone,
+  shouldUseWorktreeIsolation,
+} from "../auto-worktree.ts";
+import { getSliceBranchName } from "../worktree.ts";
+import { abortAndReset, withMergeHeal, MergeConflictError } from "../git-self-heal.ts";
+import { runGSDDoctor } from "../doctor.ts";
+import { createTestContext } from "./test-helpers.ts";
+
+const { assertEq, assertTrue, assertMatch, report } = createTestContext();
+
+// ---- Helpers ----
+
+function run(cmd: string, cwd: string): string {
+  return execSync(cmd, { cwd, stdio: ["ignore", "pipe", "pipe"], encoding: "utf-8" }).trim();
+}
+
+function createTempRepo(): string {
+  const dir = realpathSync(mkdtempSync(join(tmpdir(), "wt-e2e-test-")));
+  run("git init", dir);
+  run("git config user.email test@test.com", dir);
+  run("git config user.name Test", dir);
+  writeFileSync(join(dir, "README.md"), "# test\n");
+  mkdirSync(join(dir, ".gsd"), { recursive: true });
+  writeFileSync(join(dir, ".gsd", "STATE.md"), "# State\n");
+  run("git add .", dir);
+  run("git commit -m init", dir);
+  run("git branch -M main", dir);
+  return dir;
+}
+
+function makeRoadmap(
+  milestoneId: string,
+  title: string,
+  slices: Array<{ id: string; title: string }>,
+): string {
+  const sliceLines = slices.map(s => `- [x] **${s.id}: ${s.title}**`).join("\n");
+  return `# ${milestoneId}: ${title}\n\n## Slices\n${sliceLines}\n`;
+}
+
+function addSliceToMilestone(
+  repo: string,
+  wtPath: string,
+  milestoneId: string,
+  sliceId: string,
+  sliceTitle: string,
+  commits: Array<{ file: string; content: string; message: string }>,
+): void {
+  const normalizedPath = wtPath.replaceAll("\\", "/");
+  const marker = "/.gsd/worktrees/";
+  const idx = normalizedPath.indexOf(marker);
+  const worktreeName = idx !== -1 ? normalizedPath.slice(idx + marker.length).split("/")[0] : null;
+
+  const sliceBranch = getSliceBranchName(milestoneId, sliceId, worktreeName);
+
+  run(`git checkout -b ${sliceBranch}`, wtPath);
+  for (const c of commits) {
+    writeFileSync(join(wtPath, c.file), c.content);
+    run("git add .", wtPath);
+    run(`git commit -m "${c.message}"`, wtPath);
+  }
+  run(`git checkout milestone/${milestoneId}`, wtPath);
+  mergeSliceToMilestone(repo, milestoneId, sliceId, sliceTitle);
+}
+
+async function main(): Promise<void> {
+  const savedCwd = process.cwd();
+  const tempDirs: string[] = [];
+
+  try {
+    // ================================================================
+    // Group 1: Full lifecycle chain
+    // ================================================================
+    console.log("\n=== Full lifecycle: worktree -> slices -> milestone merge -> main ===");
+    {
+      const repo = createTempRepo();
+      tempDirs.push(repo);
+
+      // Count commits on main before
+      const mainLogBefore = run("git log --oneline main", repo);
+      const commitCountBefore = mainLogBefore.split("\n").length;
+
+      // Create worktree for M001
+      const wtPath = createAutoWorktree(repo, "M001");
+      tempDirs.push(wtPath);
+      assertTrue(existsSync(wtPath), "worktree directory created");
+
+      // Add two slices with commits
+      addSliceToMilestone(repo, wtPath, "M001", "S01", "Add auth", [
+        { file: "auth.ts", content: "export const auth = true;\n", message: "feat: add auth" },
+      ]);
+      addSliceToMilestone(repo, wtPath, "M001", "S02", "Add dashboard", [
+        { file: "dash.ts", content: "export const dash = true;\n", message: "feat: add dashboard" },
+      ]);
+
+      // Build roadmap content
+      const roadmapContent = makeRoadmap("M001", "First milestone", [
+        { id: "S01", title: "Add auth" },
+        { id: "S02", title: "Add dashboard" },
+      ]);
+
+      // Merge milestone to main
+      process.chdir(wtPath);
+      const result = mergeMilestoneToMain(repo, "M001", roadmapContent);
+      process.chdir(savedCwd);
+
+      // Assert exactly one new commit on main
+      const mainLogAfter = run("git log --oneline main", repo);
+      const commitCountAfter = mainLogAfter.split("\n").length;
+      assertEq(commitCountAfter, commitCountBefore + 1, "exactly one new commit on main");
+
+      // Commit message contains both slice titles
+      const lastCommitMsg = run("git log -1 --format=%B main", repo);
+      assertMatch(lastCommitMsg, /Add auth/, "commit message contains S01 title");
+      assertMatch(lastCommitMsg, /Add dashboard/, "commit message contains S02 title");
+
+      // Worktree directory removed
+      assertTrue(!existsSync(wtPath), "worktree directory removed after merge");
+
+      // Milestone branch deleted
+      const branches = run("git branch", repo);
+      assertTrue(!branches.includes("milestone/M001"), "milestone branch deleted");
+    }
+
+    // ================================================================
+    // Group 2: Preference gating (shouldUseWorktreeIsolation)
+    // ================================================================
+    console.log("\n=== Preference gating ===");
+    {
+      const repo = createTempRepo();
+      tempDirs.push(repo);
+
+      // Override to branch mode
+      const branchResult = shouldUseWorktreeIsolation(repo, { isolation: "branch" });
+      assertEq(branchResult, false, "isolation=branch returns false");
+
+      // Override to worktree mode
+      const wtResult = shouldUseWorktreeIsolation(repo, { isolation: "worktree" });
+      assertEq(wtResult, true, "isolation=worktree returns true");
+
+      // Default (no legacy branches) returns true
+      const defaultResult = shouldUseWorktreeIsolation(repo);
+      assertEq(defaultResult, true, "new project defaults to worktree (true)");
+    }
+
+    // ================================================================
+    // Group 3: merge_to_main mode resolution
+    // ================================================================
+    console.log("\n=== merge_to_main mode ===");
+    {
+      // getMergeToMainMode reads from loadEffectiveGSDPreferences — test via legacy branch detection
+      // Instead, test that the function returns the default "milestone" when no prefs set
+      // (Cannot inject overridePrefs — function signature doesn't accept them)
+      // We verify the shouldUseWorktreeIsolation override path handles legacy detection
+      const repo = createTempRepo();
+      tempDirs.push(repo);
+
+      // Create a legacy gsd/*/* branch to test legacy detection
+      run("git checkout -b gsd/M001/S01", repo);
+      writeFileSync(join(repo, "legacy.txt"), "legacy\n");
+      run("git add .", repo);
+      run("git commit -m legacy", repo);
+      run("git checkout main", repo);
+
+      const legacyResult = shouldUseWorktreeIsolation(repo);
+      assertEq(legacyResult, false, "legacy gsd branches detected -> branch mode");
+
+      // Explicit worktree override wins over legacy detection
+      const overrideResult = shouldUseWorktreeIsolation(repo, { isolation: "worktree" });
+      assertEq(overrideResult, true, "explicit worktree override wins over legacy");
+    }
+
+    // ================================================================
+    // Group 4: Self-heal (abortAndReset, withMergeHeal)
+    // ================================================================
+    console.log("\n=== Self-heal ===");
+    {
+      // 4a: abortAndReset cleans up MERGE_HEAD
+      const repo = createTempRepo();
+      tempDirs.push(repo);
+
+      // Create conflicting branches
+      run("git checkout -b feature", repo);
+      writeFileSync(join(repo, "conflict.txt"), "feature content\n");
+      run("git add .", repo);
+      run("git commit -m feature", repo);
+      run("git checkout main", repo);
+      writeFileSync(join(repo, "conflict.txt"), "main content\n");
+      run("git add .", repo);
+      run("git commit -m main-change", repo);
+
+      // Trigger merge conflict
+      try { run("git merge feature", repo); } catch { /* expected */ }
+      assertTrue(existsSync(join(repo, ".git", "MERGE_HEAD")), "MERGE_HEAD exists before abort");
+
+      const abortResult = abortAndReset(repo);
+      assertTrue(!existsSync(join(repo, ".git", "MERGE_HEAD")), "MERGE_HEAD removed after abort");
+      assertTrue(abortResult.cleaned.length > 0, "abortAndReset reports cleaned items");
+    }
+    {
+      // 4b: withMergeHeal throws MergeConflictError for real conflicts
+      const repo = createTempRepo();
+      tempDirs.push(repo);
+
+      run("git checkout -b conflict-branch", repo);
+      writeFileSync(join(repo, "file.txt"), "branch version\n");
+      run("git add .", repo);
+      run("git commit -m branch-ver", repo);
+      run("git checkout main", repo);
+      writeFileSync(join(repo, "file.txt"), "main version\n");
+      run("git add .", repo);
+      run("git commit -m main-ver", repo);
+
+      let caughtError: unknown = null;
+      try {
+        withMergeHeal(repo, () => {
+          execSync("git merge conflict-branch", { cwd: repo, stdio: "pipe" });
+        });
+      } catch (e) {
+        caughtError = e;
+      }
+      assertTrue(caughtError instanceof MergeConflictError, "withMergeHeal throws MergeConflictError");
+      if (caughtError instanceof MergeConflictError) {
+        assertTrue(caughtError.conflictedFiles.length > 0, "MergeConflictError has conflictedFiles");
+      }
+    }
+
+    // ================================================================
+    // Group 5: Doctor detects orphaned worktrees
+    // Skip on Windows: git worktree path resolution in temp dirs uses
+    // UNC/8.3 forms that don't match after normalization.
+    // ================================================================
+    if (process.platform !== "win32") {
+    console.log("\n=== Doctor: orphaned worktree detection ===");
+    {
+      // Build a repo with a completed milestone
+      const repo = createTempRepo();
+      tempDirs.push(repo);
+
+      // Create completed milestone roadmap
+      const msDir = join(repo, ".gsd", "milestones", "M001");
+      mkdirSync(msDir, { recursive: true });
+      writeFileSync(join(msDir, "ROADMAP.md"), `---
+id: M001
+title: "Test Milestone"
+---
+
+# M001: Test Milestone
+
+## Vision
+Test
+
+## Success Criteria
+- Done
+
+## Slices
+- [x] **S01: Test slice** \`risk:low\` \`depends:[]\`
+  > After this: done
+
+## Boundary Map
+_None_
+`);
+      run("git add -A", repo);
+      run("git commit -m \"add milestone\"", repo);
+
+      // Create orphaned worktree
+      mkdirSync(join(repo, ".gsd", "worktrees"), { recursive: true });
+      run("git worktree add -b milestone/M001 .gsd/worktrees/M001", repo);
+
+      // Detect
+      const detect = await runGSDDoctor(repo);
+      const orphanIssues = detect.issues.filter(i => i.code === "orphaned_auto_worktree");
+      assertTrue(orphanIssues.length > 0, "doctor detects orphaned worktree");
+      assertEq(orphanIssues[0]?.unitId, "M001", "orphaned worktree unitId is M001");
+
+      // Fix
+      const fixed = await runGSDDoctor(repo, { fix: true });
+      assertTrue(
+        fixed.fixesApplied.some(f => f.includes("removed orphaned worktree")),
+        "doctor fix removes orphaned worktree",
+      );
+
+      // Verify gone
+      const wtList = run("git worktree list", repo);
+      assertTrue(!wtList.includes("milestone/M001"), "worktree gone after doctor fix");
+    }
+    } else {
+      console.log("\n=== Doctor: orphaned worktree detection (skipped on Windows) ===");
+    }
+  } finally {
+    process.chdir(savedCwd);
+    for (const d of tempDirs) {
+      try { rmSync(d, { recursive: true, force: true }); } catch { /* ignore */ }
+    }
+  }
+
+  report();
+}
+
+main();

package/src/resources/extensions/gsd/worktree-manager.ts

@@ -17,7 +17,7 @@
 
 import { existsSync, mkdirSync, realpathSync } from "node:fs";
 import { execSync } from "node:child_process";
-import { join, resolve } from "node:path";
+import { join, resolve, sep } from "node:path";
 
 // ─── Types ─────────────────────────────────────────────────────────────────
 
@@ -120,15 +120,17 @@ export function worktreeBranchName(name: string): string {
 /**
  * Create a new git worktree under .gsd/worktrees/<name>/ with branch worktree/<name>.
  * The branch is created from the current HEAD of the main branch.
+ *
+ * @param opts.branch — override the default `worktree/<name>` branch name
  */
-export function createWorktree(basePath: string, name: string): WorktreeInfo {
+export function createWorktree(basePath: string, name: string, opts: { branch?: string } = {}): WorktreeInfo {
   // Validate name: alphanumeric, hyphens, underscores only
   if (!/^[a-zA-Z0-9_-]+$/.test(name)) {
     throw new Error(`Invalid worktree name "${name}". Use only letters, numbers, hyphens, and underscores.`);
   }
 
   const wtPath = worktreePath(basePath, name);
-  const branch = worktreeBranchName(name);
+  const branch = opts.branch ?? worktreeBranchName(name);
 
   if (existsSync(wtPath)) {
     throw new Error(`Worktree "${name}" already exists at ${wtPath}`);
@@ -211,7 +213,11 @@ export function listWorktrees(basePath: string): WorktreeInfo[] {
 
     const entryPath = wtLine.replace("worktree ", "");
     const branch = branchLine.replace("branch refs/heads/", "");
-    const branchWorktreeName = branch.startsWith("worktree/") ? branch.slice("worktree/".length) : null;
+    const branchWorktreeName = branch.startsWith("worktree/")
+      ? branch.slice("worktree/".length)
+      : branch.startsWith("milestone/")
+        ? branch.slice("milestone/".length)
+        : null;
     const entryVariants = [resolve(entryPath)];
     if (existsSync(entryPath)) {
       entryVariants.push(realpathSync(entryPath));
@@ -260,17 +266,17 @@ export function listWorktrees(basePath: string): WorktreeInfo[] {
 export function removeWorktree(
   basePath: string,
   name: string,
-  opts: { deleteBranch?: boolean; force?: boolean } = {},
+  opts: { deleteBranch?: boolean; force?: boolean; branch?: string } = {},
 ): void {
   const wtPath = worktreePath(basePath, name);
   const resolvedWtPath = existsSync(wtPath) ? realpathSync(wtPath) : wtPath;
-  const branch = worktreeBranchName(name);
+  const branch = opts.branch ?? worktreeBranchName(name);
   const { deleteBranch = true, force = false } = opts;
 
   // If we're inside the worktree, move out first — git can't remove an in-use directory
   const cwd = process.cwd();
   const resolvedCwd = existsSync(cwd) ? realpathSync(cwd) : cwd;
-  if (resolvedCwd === resolvedWtPath || resolvedCwd.startsWith(resolvedWtPath + "/")) {
+  if (resolvedCwd === resolvedWtPath || resolvedCwd.startsWith(resolvedWtPath + sep)) {
     process.chdir(basePath);
   }
 

package/src/resources/extensions/search-the-web/native-search.ts

@@ -105,16 +105,21 @@ export function registerNativeSearchHooks(pi: NativeSearchPI): { getIsAnthropic:
     const payload = event.payload as Record<string, unknown>;
     if (!payload) return;
 
-    // Detect Anthropic provider. Prefer the model_select flag when available,
-    // but fall back to checking the model name in the payload. model_select
-    // may not fire when the session restores with the same model already set
-    // (modelsAreEqual guard in the SDK suppresses the event). When model_select
-    // HAS fired and said "not Anthropic" (e.g. Copilot serving claude-*),
-    // respect that — don't override with model name heuristic.
-    const modelName = typeof payload.model === "string" ? payload.model : "";
-    const isAnthropic = modelSelectFired
-      ? isAnthropicProvider
-      : modelName.startsWith("claude-");
+    // Detect Anthropic provider. Use the model object from the event (most
+    // reliable — comes directly from the resolved Model), then fall back to
+    // the model_select flag, then to the model name heuristic (last resort).
+    // The model name heuristic is needed for session restores where
+    // modelsAreEqual suppresses model_select AND the SDK doesn't pass model.
+    const eventModel = event.model as { provider: string } | undefined;
+    let isAnthropic: boolean;
+    if (eventModel?.provider) {
+      isAnthropic = eventModel.provider === "anthropic";
+    } else if (modelSelectFired) {
+      isAnthropic = isAnthropicProvider;
+    } else {
+      const modelName = typeof payload.model === "string" ? payload.model : "";
+      isAnthropic = modelName.startsWith("claude-");
+    }
     if (!isAnthropic) return;
 
     // Strip thinking blocks from history to avoid signature validation errors