gsd-pi 2.77.0 → 2.78.0

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-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)",
+  );
+});