gsd-pi 2.76.0 → 2.77.0-dev.2daa994b6

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

@@ -1,73 +1,109 @@
 /**
  * worktree-health-monorepo.test.ts — #2347
  *
- * The worktree health check in auto/phases.ts falsely rejects monorepos
- * where package.json (or other project markers) is in a parent directory.
- * This test verifies that the health check walks parent directories.
+ * The worktree health check previously rejected monorepos where the
+ * project markers (package.json, Cargo.toml, etc.) live in a parent
+ * directory rather than in the worktree's own checkout. The fix extracts
+ * the parent-walk into `hasProjectFileInAncestor` in detection.ts; these
+ * tests exercise that helper directly over a synthetic filesystem.
+ *
+ * Assertions cover:
+ *   - a parent directory with a project marker is detected
+ *   - the walk stops at a `.git` boundary so ancestors above the repo root
+ *     (e.g. $HOME) cannot cause false positives
+ *   - returns false when no ancestor has a marker
+ *   - works for nested worktree layouts (monorepo/worktree/...)
  */
 
-import { readFileSync } from "node:fs";
+import { test } from "node:test";
+import assert from "node:assert/strict";
+import { mkdtempSync, mkdirSync, writeFileSync, rmSync } from "node:fs";
 import { join } from "node:path";
-import { createTestContext } from "./test-helpers.ts";
-
-const { assertTrue, report } = createTestContext();
-
-const srcPath = join(import.meta.dirname, "..", "auto", "phases.ts");
-const src = readFileSync(srcPath, "utf-8");
-
-console.log("\n=== #2347: Worktree health check supports monorepos ===");
-
-// ── Test 1: The health check region exists ──────────────────────────────
-
-const healthCheckIdx = src.indexOf("Worktree health check");
-assertTrue(healthCheckIdx > 0, "auto/phases.ts has worktree health check section");
-
-const healthCheckRegion = src.slice(healthCheckIdx, healthCheckIdx + 2000);
-
-// ── Test 2: The check walks parent directories for project markers ──────
-
-// The fix should check parent directories for project files, not just s.basePath.
-// Look for patterns like: walking up directories, dirname, parent, or a helper
-// function that checks ancestors.
-const checksParentDirs =
-  healthCheckRegion.includes("dirname") ||
-  healthCheckRegion.includes("parent") ||
-  healthCheckRegion.includes("ancestor") ||
-  healthCheckRegion.includes("walk") ||
-  // Or a helper function that's called with the base path
-  /hasProjectFileInAncestor|findProjectRoot|checkParent/i.test(healthCheckRegion);
-
-assertTrue(
-  checksParentDirs,
-  "Health check should walk parent directories for project markers (monorepo support) (#2347)",
-);
-
-// ── Test 3: The parent walk stops at a .git boundary ──────────────────
-
-// The parent directory walk must not escape the git repository root.
-// Without this guard, ancestor directories like ~ or /usr/local that
-// happen to contain package.json would cause false positive health checks.
-const hasGitBoundary = healthCheckRegion.includes('.git') &&
-  (healthCheckRegion.includes('break') || healthCheckRegion.includes('stop'));
-
-assertTrue(
-  hasGitBoundary,
-  "Parent directory walk must stop at .git repository boundary to prevent false positives",
-);
-
-// ── Test 4: The greenfield warning should only trigger when no parent has markers ─
-
-// The original code was:
-//   const hasProjectFile = PROJECT_FILES.some((f) => deps.existsSync(join(s.basePath, f)));
-// The fix should check parents too, so the greenfield warning only fires
-// when NO ancestor directory has project markers either.
-const hasParentCheck = healthCheckRegion.includes("parent") ||
-  healthCheckRegion.includes("dirname") ||
-  /ancestor|walk.*up/i.test(healthCheckRegion);
-
-assertTrue(
-  hasParentCheck,
-  "Greenfield check should consider parent directories before warning (#2347)",
-);
-
-report();
+import { tmpdir } from "node:os";
+
+import { hasProjectFileInAncestor } from "../detection.ts";
+
+function makeTempRoot(t: { after: (fn: () => void) => void }): string {
+  const dir = mkdtempSync(join(tmpdir(), "gsd-monorepo-health-"));
+  t.after(() => rmSync(dir, { recursive: true, force: true }));
+  return dir;
+}
+
+test("#2347: parent directory containing package.json is detected", (t) => {
+  const root = makeTempRoot(t);
+  const worktree = join(root, "packages", "app");
+  mkdirSync(worktree, { recursive: true });
+  writeFileSync(join(root, "package.json"), "{}");
+
+  assert.equal(
+    hasProjectFileInAncestor(worktree),
+    true,
+    "monorepo package.json in parent should be detected",
+  );
+});
+
+test("#2347: parent with Cargo.toml is detected (not just JS ecosystems)", (t) => {
+  const root = makeTempRoot(t);
+  const worktree = join(root, "crates", "foo");
+  mkdirSync(worktree, { recursive: true });
+  writeFileSync(join(root, "Cargo.toml"), "[workspace]\n");
+
+  assert.equal(hasProjectFileInAncestor(worktree), true);
+});
+
+test("#2347: walk stops at .git boundary (no false positive from grandparent)", (t) => {
+  const root = makeTempRoot(t);
+  // Layout:
+  //   root/package.json       ← must NOT trigger (above .git)
+  //   root/repo/.git          ← repo boundary
+  //   root/repo/worktree/     ← start dir (no markers)
+  writeFileSync(join(root, "package.json"), "{}");
+  const repo = join(root, "repo");
+  mkdirSync(join(repo, ".git"), { recursive: true });
+  const worktree = join(repo, "worktree");
+  mkdirSync(worktree, { recursive: true });
+
+  assert.equal(
+    hasProjectFileInAncestor(worktree),
+    false,
+    "grandparent package.json above the .git boundary must be ignored",
+  );
+});
+
+test("#2347: returns false when no ancestor has a marker", (t) => {
+  const root = makeTempRoot(t);
+  const worktree = join(root, "empty", "nested", "deep");
+  mkdirSync(worktree, { recursive: true });
+
+  assert.equal(hasProjectFileInAncestor(worktree), false);
+});
+
+test("#2347: detects marker in immediate parent of the worktree", (t) => {
+  const root = makeTempRoot(t);
+  const parent = join(root, "monorepo");
+  const worktree = join(parent, "svc");
+  mkdirSync(worktree, { recursive: true });
+  writeFileSync(join(parent, "go.mod"), "module x\n");
+
+  assert.equal(hasProjectFileInAncestor(worktree), true);
+});
+
+test("#2347: existsFn injection allows deterministic testing without real FS", () => {
+  // Simulate a layout: /a/b/c (start) → /a/b has pyproject.toml; nothing has .git.
+  const existsFn = (p: string) =>
+    p === "/a/b/pyproject.toml";
+
+  assert.equal(hasProjectFileInAncestor("/a/b/c", existsFn), true);
+});
+
+test("#2347: existsFn injection — .git stops the walk before a marker ancestor", () => {
+  // /a has package.json, but /a/b has .git — walk from /a/b/c must stop at /a/b.
+  const existsFn = (p: string) =>
+    p === "/a/package.json" || p === "/a/b/.git";
+
+  assert.equal(
+    hasProjectFileInAncestor("/a/b/c", existsFn),
+    false,
+    "walk must stop at the .git boundary before reaching /a/package.json",
+  );
+});

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

@@ -190,7 +190,12 @@ describe("worktree journal events", () => {
     });
     const resolver = new WorktreeResolver(s, deps);
 
-    resolver.mergeAndExit("M001", makeNotifyCtx());
+    // Since #4380, mergeAndExit re-throws all errors after emitting the journal
+    // event and restoring state — callers must handle the throw.
+    assert.throws(
+      () => resolver.mergeAndExit("M001", makeNotifyCtx()),
+      /conflict in main/,
+    );
 
     const entries = readJournalEntries(tmp);
     const failed = entries.find(e => e.eventType === "worktree-merge-failed");

package/src/resources/extensions/gsd/tests/worktree-nested-git-safety.test.ts

@@ -6,96 +6,98 @@
  * (mode 160000) without a .gitmodules entry, so the worktree cleanup destroys
  * the only copy of those object databases — causing permanent data loss.
  *
- * This test verifies that removeWorktree detects nested .git directories
- * (orphaned gitlinks) and absorbs or removes them before cleanup so files
- * are tracked as regular content instead of unreachable gitlink pointers.
+ * These tests exercise findNestedGitDirs directly against a synthetic
+ * filesystem layout to verify that nested .git *directories* are detected
+ * (while .git *files* — legitimate worktree pointers — are not), and that
+ * non-project directories (node_modules, .gsd, target, etc.) are skipped.
  */
 
-import { readFileSync } from "node:fs";
+import { test } from "node:test";
+import assert from "node:assert/strict";
+import { mkdtempSync, mkdirSync, writeFileSync, rmSync } from "node:fs";
 import { join } from "node:path";
-import { createTestContext } from "./test-helpers.ts";
-
-const { assertTrue, report } = createTestContext();
-
-const srcPath = join(import.meta.dirname, "..", "worktree-manager.ts");
-const src = readFileSync(srcPath, "utf-8");
-
-console.log("\n=== #2616: Worktree cleanup detects nested .git directories ===");
-
-// ── Test 1: removeWorktree scans for nested .git directories ─────────
-
-const removeWorktreeIdx = src.indexOf("export function removeWorktree");
-assertTrue(removeWorktreeIdx > 0, "worktree-manager.ts exports removeWorktree");
-
-const fnBody = src.slice(removeWorktreeIdx, removeWorktreeIdx + 5000);
-
-const detectsNestedGit =
-  fnBody.includes("nested") && fnBody.includes(".git") ||
-  fnBody.includes("gitlink") ||
-  fnBody.includes("160000") ||
-  fnBody.includes("findNestedGitDirs") ||
-  fnBody.includes("nestedGitDirs");
-
-assertTrue(
-  detectsNestedGit,
-  "removeWorktree detects nested .git directories or gitlinks (#2616)",
-);
-
-// ── Test 2: A helper function exists to find nested .git directories ──
-
-const hasNestedGitHelper =
-  src.includes("findNestedGitDirs") ||
-  src.includes("detectNestedGitDirs") ||
-  src.includes("scanNestedGit") ||
-  src.includes("absorbNestedGit") ||
-  src.includes("nestedGitDirs");
-
-assertTrue(
-  hasNestedGitHelper,
-  "worktree-manager has a helper to find nested .git directories (#2616)",
-);
-
-// ── Test 3: Nested .git dirs are absorbed or removed before cleanup ───
-
-const absorbsOrRemoves =
-  fnBody.includes("absorb") ||
-  fnBody.includes("rmSync") && fnBody.includes("nested") ||
-  (fnBody.includes("nestedGitDirs") || fnBody.includes("findNestedGitDirs")) &&
-    (fnBody.includes("rm") || fnBody.includes("absorb") || fnBody.includes("remove"));
-
-assertTrue(
-  absorbsOrRemoves,
-  "removeWorktree absorbs or removes nested .git dirs before cleanup (#2616)",
-);
-
-// ── Test 4: A warning is logged when nested .git dirs are found ───────
-
-const warnsAboutNestedGit =
-  fnBody.includes("nested") && fnBody.includes("logWarning") ||
-  fnBody.includes("gitlink") && fnBody.includes("logWarning") ||
-  fnBody.includes("scaffold") && fnBody.includes("logWarning");
-
-assertTrue(
-  warnsAboutNestedGit,
-  "removeWorktree warns when nested .git directories are detected (#2616)",
-);
-
-// ── Test 5: The findNestedGitDirs helper correctly identifies nested repos ──
-// Verify the helper scans subdirectories but skips .gsd/, node_modules/, .git/
-
-const helperBody = src.includes("findNestedGitDirs")
-  ? src.slice(src.indexOf("findNestedGitDirs"))
-  : "";
-
-const skipsExcludedDirs =
-  helperBody.includes("node_modules") ||
-  helperBody.includes(".gsd") ||
-  helperBody.includes("skip") ||
-  helperBody.includes("exclude");
-
-assertTrue(
-  skipsExcludedDirs,
-  "findNestedGitDirs skips node_modules and other excluded directories (#2616)",
-);
-
-report();
+import { tmpdir } from "node:os";
+
+import { findNestedGitDirs } from "../worktree-manager.ts";
+
+function makeRoot(t: { after: (fn: () => void) => void }): string {
+  const dir = mkdtempSync(join(tmpdir(), "gsd-nested-git-"));
+  t.after(() => rmSync(dir, { recursive: true, force: true }));
+  return dir;
+}
+
+test("#2616: findNestedGitDirs detects a nested repo at the top level", (t) => {
+  const root = makeRoot(t);
+
+  // Simulate a scaffolded project at root/scaffolded with its own .git *directory*.
+  const scaffolded = join(root, "scaffolded");
+  mkdirSync(join(scaffolded, ".git", "objects"), { recursive: true });
+  writeFileSync(join(scaffolded, "package.json"), "{}");
+
+  const found = findNestedGitDirs(root);
+  assert.ok(
+    found.includes(scaffolded),
+    `expected ${scaffolded} in findNestedGitDirs output, got ${JSON.stringify(found)}`,
+  );
+});
+
+test("#2616: findNestedGitDirs ignores .git files (worktree pointers)", (t) => {
+  const root = makeRoot(t);
+
+  // A worktree or submodule has a .git *file*, not a directory. This is legitimate.
+  const sub = join(root, "legit-worktree");
+  mkdirSync(sub, { recursive: true });
+  writeFileSync(join(sub, ".git"), "gitdir: /elsewhere/.git/worktrees/x\n");
+
+  const found = findNestedGitDirs(root);
+  assert.ok(
+    !found.includes(sub),
+    `.git file (worktree pointer) must not be flagged as a nested repo; got ${JSON.stringify(found)}`,
+  );
+});
+
+test("#2616: findNestedGitDirs skips excluded directories (node_modules, .gsd, target)", (t) => {
+  const root = makeRoot(t);
+
+  // All three of these contain a .git *directory*, but the scan must skip them.
+  for (const excluded of ["node_modules", ".gsd", "target"]) {
+    const inside = join(root, excluded, "vendored-pkg");
+    mkdirSync(join(inside, ".git"), { recursive: true });
+  }
+
+  const found = findNestedGitDirs(root);
+  assert.equal(
+    found.length,
+    0,
+    `excluded directories must be skipped, got ${JSON.stringify(found)}`,
+  );
+});
+
+test("#2616: findNestedGitDirs finds deeply nested repos", (t) => {
+  const root = makeRoot(t);
+  const deep = join(root, "a", "b", "c", "scaffolded");
+  mkdirSync(join(deep, ".git"), { recursive: true });
+
+  const found = findNestedGitDirs(root);
+  assert.ok(
+    found.includes(deep),
+    `expected deep path ${deep} in output, got ${JSON.stringify(found)}`,
+  );
+});
+
+test("#2616: findNestedGitDirs does not recurse into a found nested repo", (t) => {
+  const root = makeRoot(t);
+
+  // Outer scaffolded dir has .git; inside, a further sub-repo also has .git.
+  const outer = join(root, "outer");
+  mkdirSync(join(outer, ".git"), { recursive: true });
+  const inner = join(outer, "inner");
+  mkdirSync(join(inner, ".git"), { recursive: true });
+
+  const found = findNestedGitDirs(root);
+  assert.ok(found.includes(outer), "outer repo is detected");
+  assert.ok(
+    !found.includes(inner),
+    "must not recurse into the outer nested repo (stops at first hit)",
+  );
+});

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

@@ -313,6 +313,43 @@ test("enterMilestone uses originalBasePath as base for worktree ops", () => {
   assert.equal(createdFrom, "/project"); // uses originalBasePath, not current basePath
 });
 
+test("enterMilestone does not create double-nested worktree when originalBasePath is empty and basePath is a worktree path", () => {
+  // Regression test for #3729: when s.originalBasePath is "" (falsy) and
+  // s.basePath is already a worktree path, the expression
+  // `this.s.originalBasePath || this.s.basePath` evaluates to the worktree
+  // path. Passing that to createAutoWorktree produces a doubly-nested path
+  // like /project/.gsd/worktrees/M001/.gsd/worktrees/M002.
+  const wtPath = "/project/.gsd/worktrees/M001";
+  const s = makeSession({
+    basePath: wtPath,
+    originalBasePath: "/project", // will be overwritten below to simulate the bug
+  });
+  // Simulate the real bug: originalBasePath is "" (falsy) as it is when AutoSession
+  // is constructed fresh or reset() is called without auto-start re-setting it.
+  s.originalBasePath = "";
+
+  let createdFromPath = "";
+  const deps = makeDeps({
+    getAutoWorktreePath: () => null,
+    createAutoWorktree: (basePath: string, _mid: string) => {
+      createdFromPath = basePath;
+      return `/project/.gsd/worktrees/M002`;
+    },
+  });
+  const ctx = makeNotifyCtx();
+  const resolver = new WorktreeResolver(s, deps);
+
+  resolver.enterMilestone("M002", ctx);
+
+  // The path passed to createAutoWorktree must be the project root, NOT the
+  // worktree path. If it equals wtPath the worktree would be created at
+  // /project/.gsd/worktrees/M001/.gsd/worktrees/M002 (double-nesting).
+  assert.ok(
+    !createdFromPath.includes("/.gsd/worktrees/"),
+    `createAutoWorktree must be called with project root, got: "${createdFromPath}"`,
+  );
+});
+
 // ─── enterMilestone Tests (branch mode) ──────────────────────────────────────
 
 test("enterMilestone in branch mode calls enterBranchModeForMilestone and rebuilds GitService", () => {
@@ -577,9 +614,11 @@ test("mergeAndExit in worktree mode restores to project root on merge failure",
   const ctx = makeNotifyCtx();
   const resolver = new WorktreeResolver(s, deps);
 
-  resolver.mergeAndExit("M001", ctx);
+  // Error propagates (#4380) — callers handle recovery. restoreToProjectRoot()
+  // still runs before re-throw so state is consistent for the caller.
+  assert.throws(() => resolver.mergeAndExit("M001", ctx), /conflict in main/);
 
-  assert.equal(s.basePath, "/project"); // error recovery — restored
+  assert.equal(s.basePath, "/project"); // error recovery — restored before re-throw
   assert.ok(
     ctx.messages.some(
       (m) => m.level === "warning" && m.msg.includes("conflict in main"),
@@ -607,7 +646,8 @@ test("mergeAndExit failure message tells user worktree and branch are preserved
   const ctx = makeNotifyCtx();
   const resolver = new WorktreeResolver(s, deps);
 
-  resolver.mergeAndExit("M001", ctx);
+  // Error propagates (#4380) — notification is still emitted before re-throw
+  assert.throws(() => resolver.mergeAndExit("M001", ctx), /pathspec 'main' did not match/);
 
   const warning = ctx.messages.find((m) => m.level === "warning");
   assert.ok(warning, "a warning message is emitted");
@@ -643,7 +683,8 @@ test("mergeAndExit failure message references /gsd dispatch complete-milestone,
   const ctx = makeNotifyCtx();
   const resolver = new WorktreeResolver(s, deps);
 
-  resolver.mergeAndExit("M001", ctx);
+  // Error propagates (#4380) — notification is still emitted before re-throw
+  assert.throws(() => resolver.mergeAndExit("M001", ctx), /dirty working tree/);
 
   const warning = ctx.messages.find((m) => m.level === "warning");
   assert.ok(warning, "a warning message is emitted");
@@ -709,7 +750,8 @@ test("mergeAndExit in branch mode handles merge failure gracefully", () => {
   const ctx = makeNotifyCtx();
   const resolver = new WorktreeResolver(s, deps);
 
-  resolver.mergeAndExit("M001", ctx);
+  // Error propagates (#4380) — notification is still emitted before re-throw
+  assert.throws(() => resolver.mergeAndExit("M001", ctx), /branch merge conflict/);
 
   assert.ok(
     ctx.messages.some(
@@ -1069,3 +1111,34 @@ test("mergeAndExit in none mode remains a no-op when NOT in a worktree (#2625)",
   assert.equal(findCalls(deps.calls, "mergeMilestoneToMain").length, 0,
     "must NOT merge when not in a worktree and mode is none");
 });
+
+// ─── #4380 — Non-MergeConflictError must not be swallowed ────────────────────
+
+test("mergeAndExit propagates non-MergeConflictError to caller (#4380)", () => {
+  // Regression test: previously the catch block in _mergeWorktreeMode only
+  // re-threw MergeConflictError. Permission errors, filesystem errors, and other
+  // non-conflict failures were swallowed silently, making broken states impossible
+  // to diagnose and preventing callers (phases.ts) from applying their own
+  // error-recovery logic.
+  const permissionError = new Error("EACCES: permission denied, open '/project/.git/SQUASH_MSG'");
+  const s = makeSession({
+    basePath: "/project/.gsd/worktrees/M001",
+    originalBasePath: "/project",
+  });
+  const deps = makeDeps({
+    isInAutoWorktree: () => true,
+    getIsolationMode: () => "worktree",
+    mergeMilestoneToMain: () => {
+      throw permissionError;
+    },
+  });
+  const ctx = makeNotifyCtx();
+  const resolver = new WorktreeResolver(s, deps);
+
+  // The error must propagate — callers need it to apply their own recovery logic
+  assert.throws(
+    () => resolver.mergeAndExit("M001", ctx),
+    (err: unknown) => err === permissionError,
+    "non-MergeConflictError must propagate to the caller, not be swallowed",
+  );
+});