gsd-pi 2.76.0 → 2.77.0-dev.2daa994b6

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

@@ -1,65 +1,244 @@
 /**
  * worktree-submodule-safety.test.ts — #2337
  *
- * Worktree teardown (removeWorktree) uses --force which destroys
- * uncommitted changes in submodule directories. This test verifies
- * that the removal logic detects submodules and preserves their state.
+ * The bug (#2337): `git worktree remove --force` destroys uncommitted
+ * changes in submodule directories. The fix (in
+ * `worktree-manager.removeWorktree`) detects submodules with
+ * uncommitted state via `git submodule status`, auto-stashes the
+ * worktree before teardown, and attempts non-force removal first —
+ * falling back to force only after a stash was taken.
+ *
+ * This test was previously four `src.includes(...)` source-grep checks
+ * that asserted the strings "submodule" / "force" / "--force" appeared
+ * in the function body. Test 4 was tautological — it passed whenever
+ * both "submodule" and "force" were mentioned anywhere in `removeWorktree`
+ * regardless of whether the guard was wired correctly. See #4823 and
+ * parent issue #4784.
+ *
+ * This rewrite builds a real git parent repo + local submodule, creates
+ * a worktree, dirties a tracked file inside the submodule, then invokes
+ * `removeWorktree` and asserts observable behaviour on stderr (where
+ * `logWarning` writes) and on the filesystem (the worktree is gone).
  */
 
-import { readFileSync } from "node:fs";
+import { describe, test, beforeEach, afterEach } from "node:test";
+import assert from "node:assert/strict";
+import { execFileSync } from "node:child_process";
+import {
+  mkdtempSync,
+  renameSync,
+  rmSync,
+  writeFileSync,
+  existsSync,
+} 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=== #2337: Worktree teardown preserves submodule state ===");
-
-// ── Test 1: removeWorktree function exists ──────────────────────────────
-
-const removeWorktreeIdx = src.indexOf("export function removeWorktree");
-assertTrue(removeWorktreeIdx > 0, "worktree-manager.ts exports removeWorktree");
-
-const fnBody = src.slice(removeWorktreeIdx, removeWorktreeIdx + 6000);
-
-// ── Test 2: The function checks for submodules before force removal ─────
-
-const checksSubmodules =
-  fnBody.includes("submodule") ||
-  fnBody.includes(".gitmodules");
-
-assertTrue(
-  checksSubmodules,
-  "removeWorktree checks for submodules before force removal (#2337)",
-);
-
-// ── Test 3: Submodule changes are stashed or warned about ───────────────
-
-const preservesSubmoduleState =
-  fnBody.includes("stash") ||
-  fnBody.includes("uncommitted") ||
-  fnBody.includes("dirty") ||
-  fnBody.includes("submodule") && (fnBody.includes("warn") || fnBody.includes("preserv"));
-
-assertTrue(
-  preservesSubmoduleState,
-  "removeWorktree preserves or warns about submodule uncommitted changes (#2337)",
-);
-
-// ── Test 4: Force removal is skipped when submodules have changes ───────
-
-// The key fix: when submodules have dirty state, we should NOT use force
-// removal. Instead, use non-force first and fall back to force only after
-// submodule state is preserved.
-const hasConditionalForce =
-  fnBody.includes("submodule") &&
-  (fnBody.includes("force") || fnBody.includes("--force"));
-
-assertTrue(
-  hasConditionalForce,
-  "removeWorktree has conditional force logic around submodules (#2337)",
-);
-
-report();
+import { tmpdir } from "node:os";
+
+import { createWorktree, removeWorktree } from "../worktree-manager.ts";
+
+interface Harness {
+  parent: string;
+  subSrc: string;
+  cleanup: () => void;
+}
+
+function runGit(cwd: string, args: string[]): string {
+  return execFileSync("git", args, {
+    cwd,
+    stdio: ["ignore", "pipe", "pipe"],
+    encoding: "utf-8",
+    env: {
+      ...process.env,
+      // Disable user config from polluting the test environment.
+      GIT_CONFIG_GLOBAL: "/dev/null",
+      GIT_CONFIG_SYSTEM: "/dev/null",
+      GIT_AUTHOR_NAME: "gsd-test",
+      GIT_AUTHOR_EMAIL: "gsd-test@example.com",
+      GIT_COMMITTER_NAME: "gsd-test",
+      GIT_COMMITTER_EMAIL: "gsd-test@example.com",
+      // Allow local-path submodule URLs. Git 2.38.1+ blocks the `file` transport
+      // in `submodule add` by default (CVE-2022-39253). The config also has to
+      // propagate to git subprocess env for submodule cloning.
+      GIT_ALLOW_PROTOCOL: "file",
+    },
+  }).trim();
+}
+
+function makeHarness(): Harness {
+  // Two real git repos: the parent that we will create worktrees of, and
+  // the `subSrc` repo that we will add as a submodule.
+  const parent = mkdtempSync(join(tmpdir(), "worktree-submodule-parent-"));
+  const subSrc = mkdtempSync(join(tmpdir(), "worktree-submodule-source-"));
+
+  // Bootstrap the submodule source with one committed file.
+  runGit(subSrc, ["init", "-b", "main"]);
+  writeFileSync(join(subSrc, "tracked.txt"), "initial\n", "utf-8");
+  runGit(subSrc, ["add", "."]);
+  runGit(subSrc, ["commit", "-m", "initial"]);
+
+  // Bootstrap the parent with one commit so it has a HEAD for worktrees.
+  runGit(parent, ["init", "-b", "main"]);
+  // Allow local file:// URLs for submodule add (git 2.38+ blocks by default).
+  runGit(parent, ["config", "protocol.file.allow", "always"]);
+  writeFileSync(join(parent, "README.md"), "parent\n", "utf-8");
+  runGit(parent, ["add", "."]);
+  runGit(parent, ["commit", "-m", "initial"]);
+
+  // Register the subSrc as a submodule named "sub" inside the parent.
+  // Use `file://` URL so `protocol.file.allow` governs access; plain path
+  // would be blocked by git's local-filesystem safety checks regardless.
+  runGit(parent, [
+    "-c",
+    "protocol.file.allow=always",
+    "submodule",
+    "add",
+    `file://${subSrc}`,
+    "sub",
+  ]);
+  runGit(parent, ["commit", "-m", "add submodule"]);
+
+  return {
+    parent,
+    subSrc,
+    cleanup: () => {
+      for (const dir of [parent, subSrc]) {
+        try {
+          rmSync(dir, { recursive: true, force: true });
+        } catch {
+          // Best-effort cleanup.
+        }
+      }
+    },
+  };
+}
+
+/** Capture stderr writes during `fn`. `logWarning` writes to stderr, so
+ * this reveals warnings emitted by the worktree-manager. */
+function captureStderr(fn: () => void): string {
+  const streamAny = process.stderr as unknown as {
+    write: (chunk: string | Uint8Array, ...rest: unknown[]) => boolean;
+  };
+  const original = streamAny.write.bind(streamAny);
+  const chunks: string[] = [];
+  streamAny.write = (chunk: string | Uint8Array): boolean => {
+    chunks.push(typeof chunk === "string" ? chunk : Buffer.from(chunk).toString("utf-8"));
+    return true;
+  };
+  try {
+    fn();
+  } finally {
+    streamAny.write = original;
+  }
+  return chunks.join("");
+}
+
+describe("removeWorktree preserves submodule uncommitted state (#2337)", () => {
+  let h: Harness;
+
+  beforeEach(() => {
+    h = makeHarness();
+  });
+
+  afterEach(() => {
+    h.cleanup();
+  });
+
+  test("clean submodules: worktree removes without stashing or submodule warnings", () => {
+    const wt = createWorktree(h.parent, "cleanwt");
+    runGit(wt.path, ["submodule", "update", "--init", "--recursive"]);
+
+    const stderr = captureStderr(() => {
+      removeWorktree(h.parent, "cleanwt");
+    });
+
+    assert.ok(!existsSync(wt.path), "worktree directory should be gone");
+    assert.doesNotMatch(
+      stderr,
+      /Stashed uncommitted submodule changes/,
+      "clean submodule must not trigger stash-before-teardown",
+    );
+    assert.doesNotMatch(
+      stderr,
+      /stash failed, changes may be lost/,
+      "clean submodule must not trigger stash-failure warning",
+    );
+  });
+
+  test("diverged submodule HEAD: removeWorktree detects and warns before tearing down", () => {
+    // The code's detection key is `git submodule status` output lines
+    // starting with `+` (HEAD diverged from parent's recorded SHA) or
+    // `-` (not initialised). Note this is NARROWER than #2337's
+    // description ("uncommitted changes") — a plain working-tree edit
+    // inside the submodule does NOT trigger the detection. That gap is
+    // tracked separately; this test exercises the code path that the
+    // current implementation actually guards.
+    const wt = createWorktree(h.parent, "dirtywt");
+    runGit(wt.path, ["submodule", "update", "--init", "--recursive"]);
+
+    // Write a new file, commit it inside the submodule — this moves the
+    // submodule's HEAD ahead of the parent's recorded SHA, yielding a
+    // `+` prefix in `git submodule status`.
+    const subPath = join(wt.path, "sub");
+    writeFileSync(join(subPath, "new-file.txt"), "divergence\n", "utf-8");
+    runGit(subPath, ["add", "."]);
+    runGit(subPath, ["commit", "-m", "divergence commit"]);
+
+    // Sanity: submodule status in the parent worktree must now show `+`.
+    const subStatus = runGit(wt.path, ["submodule", "status"]);
+    assert.match(
+      subStatus,
+      /^\+/,
+      `precondition: submodule must be diverged, got: "${subStatus}"`,
+    );
+
+    const stderr = captureStderr(() => {
+      removeWorktree(h.parent, "dirtywt");
+    });
+
+    // Worktree is gone: force fallback succeeded.
+    assert.ok(!existsSync(wt.path), "worktree directory should be removed");
+
+    // The code path that fires on dirty submodules emits one of these
+    // two warnings. Either indicates the detection ran — the ONLY
+    // observable that would fail if someone removed the
+    // `if (hasSubmoduleChanges)` branch and went straight to force
+    // removal. This is the assertion that #4823 demanded in place of
+    // the tautological `src.includes("submodule") && src.includes("force")`.
+    assert.match(
+      stderr,
+      /Stashed uncommitted submodule changes|Submodule changes detected/,
+      "dirty submodule must trigger detection-and-warning path",
+    );
+  });
+
+  test("missing .gitmodules: detection short-circuits even when submodule content is dirty", () => {
+    // Prove the detection is file-based, not identifier-based. If the
+    // .gitmodules file is absent, the detection branch must NOT fire
+    // regardless of whether "submodule" appears elsewhere in the source.
+    const wt = createWorktree(h.parent, "no-gitmodules");
+    runGit(wt.path, ["submodule", "update", "--init", "--recursive"]);
+
+    writeFileSync(
+      join(wt.path, "sub", "tracked.txt"),
+      "modified\n",
+      "utf-8",
+    );
+
+    // Hide .gitmodules so existsSync(gitmodulesPath) returns false.
+    const modPath = join(wt.path, ".gitmodules");
+    const hiddenPath = join(wt.path, ".gitmodules.hidden");
+    if (existsSync(modPath)) {
+      renameSync(modPath, hiddenPath);
+    }
+
+    const stderr = captureStderr(() => {
+      removeWorktree(h.parent, "no-gitmodules");
+    });
+
+    assert.doesNotMatch(
+      stderr,
+      /Stashed uncommitted submodule changes/,
+      "missing .gitmodules should skip submodule detection entirely",
+    );
+  });
+});

package/src/resources/extensions/gsd/tests/worktree-sync-overwrite-loop.test.ts

@@ -10,14 +10,10 @@
  *
  * 2. completed-units.json is not forward-synced from project root to
  *    worktree, so the worktree never learns about already-completed units.
- *
- * Covers:
- *   - syncProjectRootToWorktree does NOT overwrite existing worktree files
- *   - syncProjectRootToWorktree copies files missing from the worktree
- *   - completed-units.json is forward-synced from project root to worktree
- *   - completed-units.json sync uses force:true (project root is authoritative)
  */
 
+import { test } from "node:test";
+import assert from "node:assert/strict";
 import {
   mkdtempSync,
   mkdirSync,
@@ -30,9 +26,6 @@ import { join } from "node:path";
 import { tmpdir } from "node:os";
 
 import { syncProjectRootToWorktree } from "../auto-worktree.ts";
-import { createTestContext } from "./test-helpers.ts";
-
-const { assertTrue, assertEq, report } = createTestContext();
 
 function createBase(name: string): string {
   const base = mkdtempSync(join(tmpdir(), `gsd-wt-1886-${name}-`));
@@ -40,165 +33,124 @@ function createBase(name: string): string {
   return base;
 }
 
-function cleanup(base: string): void {
-  rmSync(base, { recursive: true, force: true });
+function registerBases(
+  t: { after: (fn: () => void) => void },
+  ...dirs: string[]
+): void {
+  t.after(() => {
+    for (const d of dirs) {
+      rmSync(d, { recursive: true, force: true });
+    }
+  });
 }
 
-async function main(): Promise<void> {
-  // ─── 1. Worktree VALIDATION.md must NOT be overwritten by project root ──
-  console.log(
-    "\n=== 1. #1886: worktree VALIDATION.md preserved (not overwritten) ===",
+test("#1886: worktree VALIDATION.md is not overwritten by project root sync", (t) => {
+  const mainBase = createBase("main");
+  const wtBase = createBase("wt");
+  registerBases(t, mainBase, wtBase);
+
+  // Project root has an older CONTEXT but no VALIDATION
+  const prM004 = join(mainBase, ".gsd", "milestones", "M004");
+  mkdirSync(prM004, { recursive: true });
+  writeFileSync(join(prM004, "M004-CONTEXT.md"), "# old context");
+
+  // Worktree has CONTEXT + VALIDATION (written by validate-milestone)
+  const wtM004 = join(wtBase, ".gsd", "milestones", "M004");
+  mkdirSync(wtM004, { recursive: true });
+  writeFileSync(join(wtM004, "M004-CONTEXT.md"), "# worktree context");
+  writeFileSync(
+    join(wtM004, "M004-VALIDATION.md"),
+    "verdict: pass\nremediation_round: 1",
   );
-  {
-    const mainBase = createBase("main");
-    const wtBase = createBase("wt");
-
-    try {
-      // Project root has an older CONTEXT but no VALIDATION
-      const prM004 = join(mainBase, ".gsd", "milestones", "M004");
-      mkdirSync(prM004, { recursive: true });
-      writeFileSync(join(prM004, "M004-CONTEXT.md"), "# old context");
-
-      // Worktree has CONTEXT + VALIDATION (written by validate-milestone)
-      const wtM004 = join(wtBase, ".gsd", "milestones", "M004");
-      mkdirSync(wtM004, { recursive: true });
-      writeFileSync(join(wtM004, "M004-CONTEXT.md"), "# worktree context");
-      writeFileSync(
-        join(wtM004, "M004-VALIDATION.md"),
-        "verdict: pass\nremediation_round: 1",
-      );
-
-      syncProjectRootToWorktree(mainBase, wtBase, "M004");
-
-      // VALIDATION.md must still exist in worktree
-      assertTrue(
-        existsSync(join(wtM004, "M004-VALIDATION.md")),
-        "#1886: VALIDATION.md still exists after sync",
-      );
-      assertEq(
-        readFileSync(join(wtM004, "M004-VALIDATION.md"), "utf-8"),
-        "verdict: pass\nremediation_round: 1",
-        "#1886: VALIDATION.md content preserved",
-      );
-
-      // CONTEXT.md should NOT be overwritten — worktree version is authoritative
-      assertEq(
-        readFileSync(join(wtM004, "M004-CONTEXT.md"), "utf-8"),
-        "# worktree context",
-        "#1886: existing worktree CONTEXT.md not overwritten",
-      );
-    } finally {
-      cleanup(mainBase);
-      cleanup(wtBase);
-    }
-  }
-
-  // ─── 2. Missing files ARE still copied from project root ────────────────
-  console.log("\n=== 2. #1886: missing worktree files still copied ===");
-  {
-    const mainBase = createBase("main");
-    const wtBase = createBase("wt");
-
-    try {
-      const prM004 = join(mainBase, ".gsd", "milestones", "M004");
-      mkdirSync(prM004, { recursive: true });
-      writeFileSync(join(prM004, "M004-CONTEXT.md"), "# from project root");
-      writeFileSync(join(prM004, "M004-ROADMAP.md"), "# roadmap");
-
-      // Worktree has no M004 directory at all
-      syncProjectRootToWorktree(mainBase, wtBase, "M004");
-
-      assertTrue(
-        existsSync(join(wtBase, ".gsd", "milestones", "M004", "M004-CONTEXT.md")),
-        "#1886: missing CONTEXT.md copied from project root",
-      );
-      assertTrue(
-        existsSync(join(wtBase, ".gsd", "milestones", "M004", "M004-ROADMAP.md")),
-        "#1886: missing ROADMAP.md copied from project root",
-      );
-    } finally {
-      cleanup(mainBase);
-      cleanup(wtBase);
-    }
-  }
 
-  // ─── 3. completed-units.json forward-synced from project root ───────────
-  console.log(
-    "\n=== 3. #1886: completed-units.json forward-synced to worktree ===",
+  syncProjectRootToWorktree(mainBase, wtBase, "M004");
+
+  assert.ok(
+    existsSync(join(wtM004, "M004-VALIDATION.md")),
+    "VALIDATION.md still exists after sync",
   );
-  {
-    const mainBase = createBase("main");
-    const wtBase = createBase("wt");
-
-    try {
-      // Project root has completed units (authoritative after crash recovery)
-      writeFileSync(
-        join(mainBase, ".gsd", "completed-units.json"),
-        JSON.stringify(["validate-milestone/M004"]),
-      );
-
-      // Worktree has empty completed-units
-      writeFileSync(
-        join(wtBase, ".gsd", "completed-units.json"),
-        JSON.stringify([]),
-      );
-
-      syncProjectRootToWorktree(mainBase, wtBase, "M004");
-
-      const wtCompleted = JSON.parse(
-        readFileSync(join(wtBase, ".gsd", "completed-units.json"), "utf-8"),
-      );
-      assertEq(
-        wtCompleted,
-        ["validate-milestone/M004"],
-        "#1886: completed-units.json synced from project root (force:true)",
-      );
-    } finally {
-      cleanup(mainBase);
-      cleanup(wtBase);
-    }
-  }
+  assert.equal(
+    readFileSync(join(wtM004, "M004-VALIDATION.md"), "utf-8"),
+    "verdict: pass\nremediation_round: 1",
+    "VALIDATION.md content preserved",
+  );
+  assert.equal(
+    readFileSync(join(wtM004, "M004-CONTEXT.md"), "utf-8"),
+    "# worktree context",
+    "existing worktree CONTEXT.md not overwritten",
+  );
+});
+
+test("#1886: missing worktree files are still copied from project root", (t) => {
+  const mainBase = createBase("main");
+  const wtBase = createBase("wt");
+  registerBases(t, mainBase, wtBase);
+
+  const prM004 = join(mainBase, ".gsd", "milestones", "M004");
+  mkdirSync(prM004, { recursive: true });
+  writeFileSync(join(prM004, "M004-CONTEXT.md"), "# from project root");
+  writeFileSync(join(prM004, "M004-ROADMAP.md"), "# roadmap");
 
-  // ─── 4. completed-units.json: no-op when project root has no file ───────
-  console.log(
-    "\n=== 4. #1886: completed-units.json no-op when missing in project root ===",
+  syncProjectRootToWorktree(mainBase, wtBase, "M004");
+
+  assert.ok(
+    existsSync(join(wtBase, ".gsd", "milestones", "M004", "M004-CONTEXT.md")),
+    "missing CONTEXT.md copied from project root",
   );
-  {
-    const mainBase = createBase("main");
-    const wtBase = createBase("wt");
-
-    try {
-      // Project root milestone dir must exist for sync to run
-      const prM004 = join(mainBase, ".gsd", "milestones", "M004");
-      mkdirSync(prM004, { recursive: true });
-
-      // No completed-units.json in project root
-      // Worktree has its own
-      writeFileSync(
-        join(wtBase, ".gsd", "completed-units.json"),
-        JSON.stringify(["some-unit/M001"]),
-      );
-
-      syncProjectRootToWorktree(mainBase, wtBase, "M004");
-
-      const wtCompleted = JSON.parse(
-        readFileSync(join(wtBase, ".gsd", "completed-units.json"), "utf-8"),
-      );
-      assertEq(
-        wtCompleted,
-        ["some-unit/M001"],
-        "#1886: worktree completed-units.json untouched when project root has none",
-      );
-    } finally {
-      cleanup(mainBase);
-      cleanup(wtBase);
-    }
-  }
+  assert.ok(
+    existsSync(join(wtBase, ".gsd", "milestones", "M004", "M004-ROADMAP.md")),
+    "missing ROADMAP.md copied from project root",
+  );
+});
 
-  report();
-}
+test("#1886: completed-units.json is forward-synced to worktree", (t) => {
+  const mainBase = createBase("main");
+  const wtBase = createBase("wt");
+  registerBases(t, mainBase, wtBase);
+
+  writeFileSync(
+    join(mainBase, ".gsd", "completed-units.json"),
+    JSON.stringify(["validate-milestone/M004"]),
+  );
+  writeFileSync(
+    join(wtBase, ".gsd", "completed-units.json"),
+    JSON.stringify([]),
+  );
+
+  syncProjectRootToWorktree(mainBase, wtBase, "M004");
+
+  const wtCompleted = JSON.parse(
+    readFileSync(join(wtBase, ".gsd", "completed-units.json"), "utf-8"),
+  );
+  assert.deepEqual(
+    wtCompleted,
+    ["validate-milestone/M004"],
+    "completed-units.json synced from project root (force:true)",
+  );
+});
+
+test("#1886: worktree completed-units.json untouched when project root has none", (t) => {
+  const mainBase = createBase("main");
+  const wtBase = createBase("wt");
+  registerBases(t, mainBase, wtBase);
+
+  // Project root milestone dir must exist for sync to run
+  const prM004 = join(mainBase, ".gsd", "milestones", "M004");
+  mkdirSync(prM004, { recursive: true });
+
+  writeFileSync(
+    join(wtBase, ".gsd", "completed-units.json"),
+    JSON.stringify(["some-unit/M001"]),
+  );
+
+  syncProjectRootToWorktree(mainBase, wtBase, "M004");
 
-main().catch((error) => {
-  console.error(error);
-  process.exit(1);
+  const wtCompleted = JSON.parse(
+    readFileSync(join(wtBase, ".gsd", "completed-units.json"), "utf-8"),
+  );
+  assert.deepEqual(
+    wtCompleted,
+    ["some-unit/M001"],
+    "worktree completed-units.json untouched when project root has none",
+  );
 });