gsd-pi 2.58.0-dev.778d6ac → 2.58.0-dev.e002a57

package/src/resources/extensions/gsd/tests/codebase-generator.test.ts

@@ -0,0 +1,488 @@
+import test from "node:test";
+import assert from "node:assert/strict";
+import { mkdirSync, writeFileSync, readFileSync, existsSync, rmSync } from "node:fs";
+import { join } from "node:path";
+import { tmpdir } from "node:os";
+import { randomUUID } from "node:crypto";
+import { execSync } from "node:child_process";
+
+import {
+  parseCodebaseMap,
+  generateCodebaseMap,
+  updateCodebaseMap,
+  writeCodebaseMap,
+  readCodebaseMap,
+  getCodebaseMapStats,
+} from "../codebase-generator.ts";
+
+// ─── Helpers ──────────────────────────────────────────────────────────────
+
+function makeTmpRepo(): string {
+  const base = join(tmpdir(), `gsd-codebase-test-${randomUUID()}`);
+  mkdirSync(join(base, ".gsd"), { recursive: true });
+  execSync("git init", { cwd: base, stdio: "ignore" });
+  return base;
+}
+
+function addFile(base: string, path: string, content = ""): void {
+  const fullPath = join(base, path);
+  mkdirSync(join(fullPath, ".."), { recursive: true });
+  writeFileSync(fullPath, content || `// ${path}\n`, "utf-8");
+  execSync(`git add "${path}"`, { cwd: base, stdio: "ignore" });
+}
+
+function cleanup(base: string): void {
+  try { rmSync(base, { recursive: true, force: true }); } catch { /* */ }
+}
+
+// ─── parseCodebaseMap ────────────────────────────────────────────────────
+
+test("parseCodebaseMap: parses file with description", () => {
+  const content = `# Codebase Map
+
+### src/
+- \`main.ts\` — Application entry point
+- \`utils.ts\` — Shared utilities
+`;
+
+  const map = parseCodebaseMap(content);
+  assert.equal(map.size, 2);
+  assert.equal(map.get("main.ts"), "Application entry point");
+  assert.equal(map.get("utils.ts"), "Shared utilities");
+});
+
+test("parseCodebaseMap: parses file without description", () => {
+  const content = `- \`config.ts\`\n- \`index.ts\` — Entry\n`;
+  const map = parseCodebaseMap(content);
+  assert.equal(map.size, 2);
+  assert.equal(map.get("config.ts"), "");
+  assert.equal(map.get("index.ts"), "Entry");
+});
+
+test("parseCodebaseMap: empty content returns empty map", () => {
+  const map = parseCodebaseMap("");
+  assert.equal(map.size, 0);
+});
+
+test("parseCodebaseMap: ignores non-matching lines", () => {
+  const content = `# Codebase Map\n\nGenerated: 2026-03-23\n\n### src/\n- \`file.ts\` — desc\n`;
+  const map = parseCodebaseMap(content);
+  assert.equal(map.size, 1);
+});
+
+test("parseCodebaseMap: recovers descriptions from collapsed-description comments", () => {
+  const content = `# Codebase Map
+
+### src/components/
+- *(25 files: 25 .ts)*
+<!-- gsd:collapsed-descriptions
+- \`src/components/Foo.ts\` — The Foo component
+- \`src/components/Bar.ts\` — The Bar component
+-->
+`;
+  const map = parseCodebaseMap(content);
+  assert.equal(map.get("src/components/Foo.ts"), "The Foo component");
+  assert.equal(map.get("src/components/Bar.ts"), "The Bar component");
+  // The collapsed summary line itself should not be parsed as a file
+  assert.ok(!map.has("*(25 files: 25 .ts)*"));
+});
+
+test("parseCodebaseMap: handles corrupted/malformed input gracefully", () => {
+  const content = [
+    "- `unclosed backtick",
+    "- `` — empty filename",
+    "- `valid.ts` — ok",
+    "random garbage line",
+    "- `a.ts` — desc with other text",
+  ].join("\n");
+  const map = parseCodebaseMap(content);
+  assert.ok(map.has("valid.ts"));
+  assert.ok(map.has("a.ts"));
+  // Malformed lines should be silently skipped
+  assert.equal(map.size, 2);
+});
+
+// ─── generateCodebaseMap ─────────────────────────────────────────────────
+
+test("generateCodebaseMap: generates from git ls-files", () => {
+  const base = makeTmpRepo();
+  try {
+    addFile(base, "src/main.ts");
+    addFile(base, "src/utils.ts");
+    addFile(base, "README.md");
+
+    const result = generateCodebaseMap(base);
+    assert.ok(result.content.includes("# Codebase Map"));
+    assert.ok(result.content.includes("`src/main.ts`"));
+    assert.ok(result.content.includes("`src/utils.ts`"));
+    assert.ok(result.content.includes("README.md"));
+    assert.equal(result.fileCount, 3);
+    assert.equal(result.truncated, false);
+    assert.equal(result.files.length, 3);
+  } finally {
+    cleanup(base);
+  }
+});
+
+test("generateCodebaseMap: excludes .gsd/ files", () => {
+  const base = makeTmpRepo();
+  try {
+    addFile(base, "src/main.ts");
+    addFile(base, ".gsd/PROJECT.md");
+
+    const result = generateCodebaseMap(base);
+    assert.ok(result.content.includes("`src/main.ts`"));
+    assert.ok(!result.content.includes("PROJECT.md"));
+  } finally {
+    cleanup(base);
+  }
+});
+
+test("generateCodebaseMap: excludes binary and lock files", () => {
+  const base = makeTmpRepo();
+  try {
+    addFile(base, "src/main.ts");
+    addFile(base, "package-lock.json"); // .json not excluded
+    addFile(base, "yarn.lock");         // .lock excluded
+    addFile(base, "assets/logo.png");   // .png excluded
+
+    const result = generateCodebaseMap(base);
+    assert.ok(result.content.includes("`src/main.ts`"));
+    assert.ok(result.content.includes("package-lock.json"));
+    assert.ok(!result.content.includes("yarn.lock"));
+    assert.ok(!result.content.includes("logo.png"));
+  } finally {
+    cleanup(base);
+  }
+});
+
+test("generateCodebaseMap: respects custom excludePatterns", () => {
+  const base = makeTmpRepo();
+  try {
+    addFile(base, "src/main.ts");
+    addFile(base, "docs/guide.md");
+    addFile(base, "docs/api.md");
+
+    const result = generateCodebaseMap(base, { excludePatterns: ["docs/"] });
+    assert.ok(result.content.includes("`src/main.ts`"));
+    assert.ok(!result.content.includes("guide.md"));
+    assert.ok(!result.content.includes("api.md"));
+    assert.equal(result.fileCount, 1);
+  } finally {
+    cleanup(base);
+  }
+});
+
+test("generateCodebaseMap: preserves existing descriptions", () => {
+  const base = makeTmpRepo();
+  try {
+    addFile(base, "src/main.ts");
+    addFile(base, "src/utils.ts");
+
+    const descriptions = new Map<string, string>();
+    descriptions.set("src/main.ts", "App entry point");
+
+    const result = generateCodebaseMap(base, undefined, descriptions);
+    assert.ok(result.content.includes("`src/main.ts` — App entry point"));
+    assert.ok(result.content.includes("`src/utils.ts`"));
+  } finally {
+    cleanup(base);
+  }
+});
+
+test("generateCodebaseMap: collapses large directories", () => {
+  const base = makeTmpRepo();
+  try {
+    for (let i = 0; i < 25; i++) {
+      addFile(base, `src/components/comp${String(i).padStart(2, "0")}.ts`);
+    }
+
+    const result = generateCodebaseMap(base);
+    // Collapsed summary should appear
+    assert.ok(result.content.includes("*(25 files: 25 .ts)*"));
+    // Individual file entries should NOT appear in main body
+    assert.ok(!result.content.includes("`src/components/comp00.ts`\n"));
+  } finally {
+    cleanup(base);
+  }
+});
+
+test("generateCodebaseMap: respects custom collapseThreshold", () => {
+  const base = makeTmpRepo();
+  try {
+    for (let i = 0; i < 5; i++) addFile(base, `src/comp${i}.ts`);
+
+    // Low threshold: 5 files should collapse
+    const collapsed = generateCodebaseMap(base, { collapseThreshold: 3 });
+    assert.ok(collapsed.content.includes("5 files"));
+
+    // High threshold: 5 files should expand
+    const expanded = generateCodebaseMap(base, { collapseThreshold: 10 });
+    assert.ok(expanded.content.includes("`src/comp0.ts`"));
+  } finally {
+    cleanup(base);
+  }
+});
+
+test("generateCodebaseMap: truncated=false when file count is below maxFiles", () => {
+  const base = makeTmpRepo();
+  try {
+    for (let i = 0; i < 4; i++) addFile(base, `file${i}.ts`);
+    const result = generateCodebaseMap(base, { maxFiles: 5 });
+    assert.equal(result.fileCount, 4);
+    assert.equal(result.truncated, false);
+  } finally {
+    cleanup(base);
+  }
+});
+
+test("generateCodebaseMap: truncated=false when file count equals maxFiles exactly", () => {
+  const base = makeTmpRepo();
+  try {
+    for (let i = 0; i < 5; i++) addFile(base, `file${i}.ts`);
+    const result = generateCodebaseMap(base, { maxFiles: 5 });
+    assert.equal(result.fileCount, 5);
+    assert.equal(result.truncated, false); // exactly at limit — nothing was truncated
+  } finally {
+    cleanup(base);
+  }
+});
+
+test("generateCodebaseMap: truncated=true when file count exceeds maxFiles", () => {
+  const base = makeTmpRepo();
+  try {
+    for (let i = 0; i < 10; i++) addFile(base, `file${i}.ts`);
+    const result = generateCodebaseMap(base, { maxFiles: 5 });
+    assert.equal(result.fileCount, 5);
+    assert.equal(result.truncated, true);
+    assert.ok(result.content.includes("Truncated"));
+  } finally {
+    cleanup(base);
+  }
+});
+
+test("generateCodebaseMap: returns empty map for non-git directory", () => {
+  const base = join(tmpdir(), `gsd-codebase-test-${randomUUID()}`);
+  mkdirSync(join(base, ".gsd"), { recursive: true });
+  // No git init
+  try {
+    const result = generateCodebaseMap(base);
+    assert.equal(result.fileCount, 0);
+    assert.equal(result.truncated, false);
+    assert.ok(result.content.includes("# Codebase Map"));
+    assert.equal(result.files.length, 0);
+  } finally {
+    cleanup(base);
+  }
+});
+
+test("generateCodebaseMap: handles empty repository (no committed files)", () => {
+  const base = makeTmpRepo();
+  try {
+    const result = generateCodebaseMap(base);
+    assert.equal(result.fileCount, 0);
+    assert.equal(result.truncated, false);
+    assert.ok(result.content.includes("Files: 0"));
+  } finally {
+    cleanup(base);
+  }
+});
+
+test("generateCodebaseMap: collapsed directories preserve descriptions in hidden comment", () => {
+  const base = makeTmpRepo();
+  try {
+    for (let i = 0; i < 25; i++) {
+      addFile(base, `src/components/comp${String(i).padStart(2, "0")}.ts`);
+    }
+
+    // Generate with a description for one file in the collapsed dir
+    const descriptions = new Map([["src/components/comp00.ts", "The first component"]]);
+    const result = generateCodebaseMap(base, undefined, descriptions);
+
+    // The description should be in the hidden comment block
+    assert.ok(result.content.includes("<!-- gsd:collapsed-descriptions"));
+    assert.ok(result.content.includes("`src/components/comp00.ts` — The first component"));
+
+    // Re-parsing should recover the description
+    const recovered = parseCodebaseMap(result.content);
+    assert.equal(recovered.get("src/components/comp00.ts"), "The first component");
+  } finally {
+    cleanup(base);
+  }
+});
+
+// ─── updateCodebaseMap ───────────────────────────────────────────────────
+
+test("updateCodebaseMap: preserves descriptions on update", () => {
+  const base = makeTmpRepo();
+  try {
+    addFile(base, "src/main.ts");
+    addFile(base, "src/utils.ts");
+
+    const initial = generateCodebaseMap(base, undefined, new Map([["src/main.ts", "Entry point"]]));
+    writeCodebaseMap(base, initial.content);
+
+    addFile(base, "src/new.ts");
+
+    const result = updateCodebaseMap(base);
+    assert.ok(result.content.includes("`src/main.ts` — Entry point"));
+    assert.equal(result.added, 1);
+    assert.equal(result.fileCount, 3);
+  } finally {
+    cleanup(base);
+  }
+});
+
+test("updateCodebaseMap: tracks removed files", () => {
+  const base = makeTmpRepo();
+  try {
+    addFile(base, "src/keep.ts");
+    addFile(base, "src/remove.ts");
+    // Commit so git rm can operate
+    execSync("git -c user.email=t@t.com -c user.name=T commit -m init", { cwd: base, stdio: "ignore" });
+
+    const initial = generateCodebaseMap(base);
+    writeCodebaseMap(base, initial.content);
+
+    execSync("git rm src/remove.ts", { cwd: base, stdio: "ignore" });
+
+    const result = updateCodebaseMap(base);
+    assert.equal(result.removed, 1);
+    assert.equal(result.unchanged, 1);
+    assert.equal(result.fileCount, 1);
+    assert.ok(!result.content.includes("remove.ts"));
+  } finally {
+    cleanup(base);
+  }
+});
+
+test("updateCodebaseMap: propagates truncated flag", () => {
+  const base = makeTmpRepo();
+  try {
+    for (let i = 0; i < 10; i++) addFile(base, `file${i}.ts`);
+
+    const initial = generateCodebaseMap(base, { maxFiles: 5 });
+    writeCodebaseMap(base, initial.content);
+
+    const result = updateCodebaseMap(base, { maxFiles: 5 });
+    assert.equal(result.truncated, true);
+  } finally {
+    cleanup(base);
+  }
+});
+
+test("updateCodebaseMap: preserves descriptions from collapsed directories", () => {
+  const base = makeTmpRepo();
+  try {
+    for (let i = 0; i < 25; i++) {
+      addFile(base, `src/components/comp${String(i).padStart(2, "0")}.ts`);
+    }
+
+    // Generate with a description in the (collapsed) components dir
+    const descriptions = new Map([["src/components/comp00.ts", "The first component"]]);
+    const initial = generateCodebaseMap(base, undefined, descriptions);
+    writeCodebaseMap(base, initial.content);
+
+    // Update should recover description from the hidden comment
+    const result = updateCodebaseMap(base);
+    const recovered = parseCodebaseMap(result.content);
+    assert.equal(recovered.get("src/components/comp00.ts"), "The first component");
+  } finally {
+    cleanup(base);
+  }
+});
+
+// ─── writeCodebaseMap / readCodebaseMap ──────────────────────────────────
+
+test("writeCodebaseMap + readCodebaseMap roundtrip", () => {
+  const base = makeTmpRepo();
+  try {
+    const content = "# Codebase Map\n\n- `test.ts` — A test file\n";
+    const outPath = writeCodebaseMap(base, content);
+    assert.ok(existsSync(outPath));
+
+    const read = readCodebaseMap(base);
+    assert.equal(read, content);
+  } finally {
+    cleanup(base);
+  }
+});
+
+test("readCodebaseMap: returns null when file missing", () => {
+  const base = makeTmpRepo();
+  try {
+    const result = readCodebaseMap(base);
+    assert.equal(result, null);
+  } finally {
+    cleanup(base);
+  }
+});
+
+test("writeCodebaseMap: creates .gsd/ directory if missing", () => {
+  const base = join(tmpdir(), `gsd-codebase-test-${randomUUID()}`);
+  mkdirSync(base, { recursive: true });
+  // Intentionally do NOT pre-create .gsd/
+  try {
+    const outPath = writeCodebaseMap(base, "# Codebase Map\n");
+    assert.ok(existsSync(outPath));
+  } finally {
+    cleanup(base);
+  }
+});
+
+// ─── getCodebaseMapStats ─────────────────────────────────────────────────
+
+test("getCodebaseMapStats: no map returns exists=false", () => {
+  const base = makeTmpRepo();
+  try {
+    const stats = getCodebaseMapStats(base);
+    assert.equal(stats.exists, false);
+    assert.equal(stats.fileCount, 0);
+  } finally {
+    cleanup(base);
+  }
+});
+
+test("getCodebaseMapStats: reports coverage", () => {
+  const base = makeTmpRepo();
+  try {
+    const content = `# Codebase Map\n\nGenerated: 2026-03-23T14:00:00Z | Files: 3 | Described: 2/3\n\n- \`a.ts\` — Has desc\n- \`b.ts\`\n- \`c.ts\` — Also has\n`;
+    writeCodebaseMap(base, content);
+
+    const stats = getCodebaseMapStats(base);
+    assert.equal(stats.exists, true);
+    assert.equal(stats.fileCount, 3); // from header, not parse count
+    assert.equal(stats.describedCount, 2);
+    assert.equal(stats.undescribedCount, 1);
+    assert.equal(stats.generatedAt, "2026-03-23T14:00:00Z");
+  } finally {
+    cleanup(base);
+  }
+});
+
+test("getCodebaseMapStats: reads total file count from header for accuracy with collapsed dirs", () => {
+  const base = makeTmpRepo();
+  try {
+    // Simulate a map with a collapsed dir: header says 30 files but parser only sees 2
+    const content = [
+      "# Codebase Map",
+      "",
+      "Generated: 2026-03-23T14:00:00Z | Files: 30 | Described: 2/30",
+      "",
+      "### src/components/",
+      "- *(28 files: 28 .ts)*",
+      "",
+      "### src/",
+      "- `main.ts` — Entry point",
+      "- `utils.ts` — Utilities",
+    ].join("\n");
+    writeCodebaseMap(base, content);
+
+    const stats = getCodebaseMapStats(base);
+    assert.equal(stats.fileCount, 30); // from header, not from parseCodebaseMap
+    assert.equal(stats.describedCount, 2);
+    assert.equal(stats.undescribedCount, 28);
+  } finally {
+    cleanup(base);
+  }
+});

package/src/resources/extensions/gsd/tests/complexity-classifier.test.ts

@@ -41,14 +41,14 @@ test("research-slice classifies as standard", () => {
   assert.equal(result.tier, "standard");
 });
 
-test("plan-milestone classifies as standard", () => {
+test("plan-milestone classifies as heavy", () => {
   const result = classifyUnitComplexity("plan-milestone", "M001", "/tmp/fake");
-  assert.equal(result.tier, "standard");
+  assert.equal(result.tier, "heavy");
 });
 
-test("plan-slice classifies as standard", () => {
+test("plan-slice classifies as heavy", () => {
   const result = classifyUnitComplexity("plan-slice", "M001/S01", "/tmp/fake");
-  assert.equal(result.tier, "standard");
+  assert.equal(result.tier, "heavy");
 });
 
 test("replan-slice classifies as heavy", () => {

package/src/resources/extensions/gsd/tests/integration/auto-worktree-milestone-merge.test.ts

@@ -739,6 +739,39 @@ describe("auto-worktree-milestone-merge", { timeout: 300_000 }, () => {
     );
   });
 
+  test("#2912: stale SQUASH_MSG and MERGE_MSG are cleaned before squash merge", () => {
+    // Verifies that the pre-merge cleanup (step 7b) removes all three merge
+    // artifacts — not just MERGE_HEAD — so that `git merge --squash` never
+    // encounters leftover state from a prior interrupted operation.
+    const repo = freshRepo();
+    const wtPath = createAutoWorktree(repo, "M294");
+
+    addSliceToMilestone(repo, wtPath, "M294", "S01", "Feature C", [
+      { file: "feature-c.ts", content: "export const c = true;\n", message: "add feature c" },
+    ]);
+
+    const roadmap = makeRoadmap("M294", "Stale merge artifacts", [
+      { id: "S01", title: "Feature C" },
+    ]);
+
+    // Plant stale merge artifacts in the git dir to simulate a prior
+    // interrupted merge.  The pre-merge cleanup must remove all of them.
+    const gitDir = join(repo, ".git");
+    writeFileSync(join(gitDir, "SQUASH_MSG"), "stale squash message\n");
+    writeFileSync(join(gitDir, "MERGE_MSG"), "stale merge message\n");
+
+    mergeMilestoneToMain(repo, "M294", roadmap);
+
+    assert.ok(
+      !existsSync(join(gitDir, "SQUASH_MSG")),
+      "#2912: stale SQUASH_MSG must be removed by pre-merge cleanup",
+    );
+    assert.ok(
+      !existsSync(join(gitDir, "MERGE_MSG")),
+      "#2912: stale MERGE_MSG must be removed by pre-merge cleanup",
+    );
+  });
+
   test("#1906: codeFilesChanged=true when real code is merged", () => {
     const repo = freshRepo();
     const wtPath = createAutoWorktree(repo, "M190");

package/src/resources/extensions/gsd/tests/integration/doctor-git.test.ts

@@ -645,6 +645,78 @@ describe('doctor-git', async () => {
     } else {
     }
 
+    // ─── Test: stale_uncommitted_changes detection & auto-snapshot ──────
+    test('stale_uncommitted_changes (detected and auto-committed)', async () => {
+      const dir = createRepoWithActiveMilestone();
+      cleanups.push(dir);
+
+      // Make the last commit appear old by amending its date to 45 min ago
+      const pastDate = new Date(Date.now() - 45 * 60 * 1000).toISOString();
+      run(`git commit --amend --no-edit --date="${pastDate}"`, dir);
+      // Also set committer date so git log %ct reflects it
+      execSync(`git commit --amend --no-edit`, {
+        cwd: dir,
+        stdio: ["ignore", "pipe", "pipe"],
+        encoding: "utf-8",
+        env: { ...process.env, GIT_COMMITTER_DATE: pastDate },
+      });
+
+      // Modify an already-tracked file (nativeAddTracked uses git add -u,
+      // which only stages tracked files — new untracked files are not staged)
+      writeFileSync(join(dir, "README.md"), "# test\nmodified content\n");
+
+      const detect = await runGSDDoctor(dir);
+      const staleIssues = detect.issues.filter(i => i.code === "stale_uncommitted_changes");
+      assert.ok(staleIssues.length > 0, "detects stale uncommitted changes");
+      assert.ok(staleIssues[0]?.message.includes("minute"), "message mentions minutes");
+      assert.ok(staleIssues[0]?.fixable === true, "stale uncommitted changes is fixable");
+
+      // Fix should create a gsd snapshot commit
+      const fixed = await runGSDDoctor(dir, { fix: true });
+      assert.ok(
+        fixed.fixesApplied.some(f => f.includes("gsd snapshot")),
+        "fix creates a gsd snapshot commit",
+      );
+
+      // Verify the snapshot commit was created with the gsd snapshot tag
+      const log = run("git log -1 --oneline", dir);
+      assert.ok(log.includes("gsd snapshot"), "commit is tagged with gsd snapshot");
+    });
+
+    // ─── Test: stale_uncommitted_changes NOT flagged when recent commit ──
+    test('stale_uncommitted_changes (no false positive on recent commit)', async () => {
+      const dir = createRepoWithActiveMilestone();
+      cleanups.push(dir);
+
+      // Create uncommitted changes (but last commit is fresh — just created)
+      writeFileSync(join(dir, "fresh-dirty.txt"), "recent changes\n");
+
+      const detect = await runGSDDoctor(dir);
+      const staleIssues = detect.issues.filter(i => i.code === "stale_uncommitted_changes");
+      assert.deepStrictEqual(staleIssues.length, 0, "recent commit with dirty tree NOT flagged as stale");
+    });
+
+    // ─── Test: stale_uncommitted_changes NOT flagged when tree is clean ──
+    test('stale_uncommitted_changes (no false positive on clean tree)', async () => {
+      const dir = createRepoWithActiveMilestone();
+      cleanups.push(dir);
+
+      // Make the last commit appear old
+      const pastDate = new Date(Date.now() - 45 * 60 * 1000).toISOString();
+      run(`git commit --amend --no-edit --date="${pastDate}"`, dir);
+      execSync(`git commit --amend --no-edit`, {
+        cwd: dir,
+        stdio: ["ignore", "pipe", "pipe"],
+        encoding: "utf-8",
+        env: { ...process.env, GIT_COMMITTER_DATE: pastDate },
+      });
+
+      // No uncommitted changes — tree is clean
+      const detect = await runGSDDoctor(dir);
+      const staleIssues = detect.issues.filter(i => i.code === "stale_uncommitted_changes");
+      assert.deepStrictEqual(staleIssues.length, 0, "old commit with clean tree NOT flagged as stale");
+    });
+
   } finally {
     for (const dir of cleanups) {
       try { rmSync(dir, { recursive: true, force: true }); } catch { /* ignore */ }