gsd-pi 2.11.0 → 2.13.0

package/dist/resources/extensions/gsd/tests/auto-worktree.test.ts

@@ -0,0 +1,147 @@
+/**
+ * auto-worktree.test.ts — Tests for auto-worktree lifecycle.
+ *
+ * Covers: create → detect → teardown, re-entry, path helpers.
+ * Runs in a real temp git repo.
+ */
+
+import { mkdtempSync, mkdirSync, writeFileSync, rmSync, existsSync, realpathSync } from "node:fs";
+import { join } from "node:path";
+import { tmpdir } from "node:os";
+import { execSync } from "node:child_process";
+
+import {
+  createAutoWorktree,
+  teardownAutoWorktree,
+  isInAutoWorktree,
+  getAutoWorktreePath,
+  enterAutoWorktree,
+  getAutoWorktreeOriginalBase,
+} from "../auto-worktree.ts";
+
+import { createTestContext } from "./test-helpers.ts";
+
+const { assertEq, assertTrue, report } = createTestContext();
+
+function run(command: string, cwd: string): string {
+  return execSync(command, { cwd, stdio: ["ignore", "pipe", "pipe"], encoding: "utf-8" }).trim();
+}
+
+function createTempRepo(): string {
+  const dir = realpathSync(mkdtempSync(join(tmpdir(), "auto-wt-test-")));
+  run("git init", dir);
+  run("git config user.email test@test.com", dir);
+  run("git config user.name Test", dir);
+  // Create initial commit on main
+  writeFileSync(join(dir, "README.md"), "# test\n");
+  run("git add .", dir);
+  run("git commit -m init", dir);
+  // Ensure branch is called main
+  run("git branch -M main", dir);
+  return dir;
+}
+
+async function main(): Promise<void> {
+  const savedCwd = process.cwd();
+  let tempDir = "";
+
+  try {
+    tempDir = createTempRepo();
+
+    // Create .gsd/milestones/M003 with a dummy file (simulates planning artifacts)
+    const msDir = join(tempDir, ".gsd", "milestones", "M003");
+    mkdirSync(msDir, { recursive: true });
+    writeFileSync(join(msDir, "CONTEXT.md"), "# M003 Context\n");
+    run("git add .", tempDir);
+    run("git commit -m 'add milestone'", tempDir);
+
+    console.log("\n=== auto-worktree lifecycle ===");
+
+    // ─── createAutoWorktree ──────────────────────────────────────────
+    const wtPath = createAutoWorktree(tempDir, "M003");
+
+    assertTrue(existsSync(wtPath), "worktree directory exists after create");
+    assertEq(process.cwd(), wtPath, "process.cwd() is worktree path after create");
+
+    const branch = run("git branch --show-current", wtPath);
+    assertEq(branch, "milestone/M003", "git branch is milestone/M003");
+
+    assertTrue(
+      existsSync(join(wtPath, ".gsd", "milestones", "M003", "CONTEXT.md")),
+      "planning files inherited in worktree",
+    );
+
+    // ─── isInAutoWorktree ────────────────────────────────────────────
+    assertTrue(isInAutoWorktree(tempDir), "isInAutoWorktree returns true when inside");
+
+    // ─── getAutoWorktreeOriginalBase ─────────────────────────────────
+    assertEq(getAutoWorktreeOriginalBase(), tempDir, "originalBase returns temp dir");
+
+    // ─── getAutoWorktreePath ─────────────────────────────────────────
+    assertEq(getAutoWorktreePath(tempDir, "M003"), wtPath, "getAutoWorktreePath returns correct path");
+    assertEq(getAutoWorktreePath(tempDir, "M999"), null, "getAutoWorktreePath returns null for nonexistent");
+
+    // ─── teardownAutoWorktree ────────────────────────────────────────
+    teardownAutoWorktree(tempDir, "M003");
+
+    assertEq(process.cwd(), tempDir, "process.cwd() back to original after teardown");
+    assertTrue(!existsSync(wtPath), "worktree directory removed after teardown");
+    assertTrue(!isInAutoWorktree(tempDir), "isInAutoWorktree returns false after teardown");
+    assertEq(getAutoWorktreeOriginalBase(), null, "originalBase is null after teardown");
+
+    // ─── Re-entry: create again, exit without teardown, re-enter ─────
+    console.log("\n=== re-entry ===");
+
+    const wtPath2 = createAutoWorktree(tempDir, "M003");
+    assertTrue(existsSync(wtPath2), "worktree re-created");
+
+    // Manually chdir out (simulates pause/crash)
+    process.chdir(tempDir);
+
+    // enterAutoWorktree should re-enter
+    const entered = enterAutoWorktree(tempDir, "M003");
+    assertEq(process.cwd(), entered, "re-entered worktree via enterAutoWorktree");
+    assertEq(getAutoWorktreeOriginalBase(), tempDir, "originalBase restored on re-entry");
+    assertTrue(isInAutoWorktree(tempDir), "isInAutoWorktree true after re-entry");
+
+    // Cleanup
+    teardownAutoWorktree(tempDir, "M003");
+
+    // ─── Coexistence with manual worktree ─────────────────────────────
+    console.log("\n=== coexistence ===");
+
+    // Import createWorktree directly for manual worktree
+    const { createWorktree } = await import("../worktree-manager.ts");
+
+    // Create manual worktree (uses worktree/<name> branch)
+    const manualWt = createWorktree(tempDir, "feature-x");
+    assertTrue(existsSync(manualWt.path), "manual worktree exists");
+    assertEq(manualWt.branch, "worktree/feature-x", "manual worktree uses worktree/ prefix");
+
+    // Create auto-worktree alongside
+    const autoWtPath = createAutoWorktree(tempDir, "M003");
+    assertTrue(existsSync(autoWtPath), "auto-worktree coexists with manual");
+    assertTrue(existsSync(manualWt.path), "manual worktree still exists");
+
+    // Cleanup both
+    teardownAutoWorktree(tempDir, "M003");
+    const { removeWorktree } = await import("../worktree-manager.ts");
+    removeWorktree(tempDir, "feature-x");
+
+    // ─── Failure: split-brain prevention ──────────────────────────────
+    console.log("\n=== split-brain prevention ===");
+    // After teardown, originalBase should be null
+    assertEq(getAutoWorktreeOriginalBase(), null, "no split-brain: originalBase cleared");
+
+  } finally {
+    // Always restore cwd and clean up
+    process.chdir(savedCwd);
+    if (tempDir && existsSync(tempDir)) {
+      rmSync(tempDir, { recursive: true, force: true });
+    }
+  }
+
+  report("auto-worktree");
+}
+
+main();

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

@@ -0,0 +1,246 @@
+/**
+ * doctor-git.test.ts — Integration tests for doctor git health checks.
+ *
+ * Creates real temp git repos with deliberate broken state, runs runGSDDoctor,
+ * and asserts correct detection and fixing of all 4 git issue codes:
+ *   orphaned_auto_worktree, stale_milestone_branch,
+ *   corrupt_merge_state, tracked_runtime_files
+ */
+
+import { mkdtempSync, mkdirSync, writeFileSync, rmSync, existsSync, realpathSync } from "node:fs";
+import { join } from "node:path";
+import { tmpdir } from "node:os";
+import { execSync } from "node:child_process";
+
+import { runGSDDoctor } from "../doctor.ts";
+import { createTestContext } from "./test-helpers.ts";
+
+const { assertEq, assertTrue, report } = createTestContext();
+
+function run(cmd: string, cwd: string): string {
+  return execSync(cmd, { cwd, stdio: ["ignore", "pipe", "pipe"], encoding: "utf-8" }).trim();
+}
+
+/** Create a temp git repo with a completed milestone M001 in roadmap. */
+function createRepoWithCompletedMilestone(): string {
+  const dir = realpathSync(mkdtempSync(join(tmpdir(), "doc-git-test-")));
+  run("git init", dir);
+  run("git config user.email test@test.com", dir);
+  run("git config user.name Test", dir);
+
+  // Initial commit
+  writeFileSync(join(dir, "README.md"), "# test\n");
+  run("git add .", dir);
+  run("git commit -m init", dir);
+  run("git branch -M main", dir);
+
+  // Create .gsd structure with milestone M001 — all slices done → complete
+  const msDir = join(dir, ".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_
+`);
+
+  // Commit .gsd files
+  run("git add -A", dir);
+  run("git commit -m 'add milestone'", dir);
+
+  return dir;
+}
+
+/** Create a repo with an in-progress milestone. */
+function createRepoWithActiveMilestone(): string {
+  const dir = realpathSync(mkdtempSync(join(tmpdir(), "doc-git-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");
+  run("git add .", dir);
+  run("git commit -m init", dir);
+  run("git branch -M main", dir);
+
+  const msDir = join(dir, ".gsd", "milestones", "M001");
+  mkdirSync(msDir, { recursive: true });
+  writeFileSync(join(msDir, "ROADMAP.md"), `---
+id: M001
+title: "Active Milestone"
+---
+
+# M001: Active Milestone
+
+## Vision
+Test
+
+## Success Criteria
+- Done
+
+## Slices
+- [ ] **S01: Test slice** \`risk:low\` \`depends:[]\`
+  > After this: done
+
+## Boundary Map
+_None_
+`);
+
+  run("git add -A", dir);
+  run("git commit -m 'add milestone'", dir);
+
+  return dir;
+}
+
+async function main(): Promise<void> {
+  const cleanups: string[] = [];
+
+  try {
+    // ─── Test 1: Orphaned worktree detection & fix ─────────────────────
+    console.log("\n=== orphaned_auto_worktree ===");
+    {
+      const dir = createRepoWithCompletedMilestone();
+      cleanups.push(dir);
+
+      // Create worktree with milestone/M001 branch under .gsd/worktrees/
+      mkdirSync(join(dir, ".gsd", "worktrees"), { recursive: true });
+      run("git worktree add -b milestone/M001 .gsd/worktrees/M001", dir);
+
+      const detect = await runGSDDoctor(dir);
+      const orphanIssues = detect.issues.filter(i => i.code === "orphaned_auto_worktree");
+      assertTrue(orphanIssues.length > 0, "detects orphaned worktree");
+      assertEq(orphanIssues[0]?.unitId, "M001", "orphaned worktree unitId is M001");
+
+      const fixed = await runGSDDoctor(dir, { fix: true });
+      assertTrue(fixed.fixesApplied.some(f => f.includes("removed orphaned worktree")), "fix removes orphaned worktree");
+
+      // Verify worktree is gone
+      const wtList = run("git worktree list", dir);
+      assertTrue(!wtList.includes("milestone/M001"), "worktree no longer listed after fix");
+    }
+
+    // ─── Test 2: Stale milestone branch detection & fix ────────────────
+    console.log("\n=== stale_milestone_branch ===");
+    {
+      const dir = createRepoWithCompletedMilestone();
+      cleanups.push(dir);
+
+      // Create a milestone/M001 branch (no worktree)
+      run("git branch milestone/M001", dir);
+
+      const detect = await runGSDDoctor(dir);
+      const staleIssues = detect.issues.filter(i => i.code === "stale_milestone_branch");
+      assertTrue(staleIssues.length > 0, "detects stale milestone branch");
+      assertEq(staleIssues[0]?.unitId, "M001", "stale branch unitId is M001");
+
+      const fixed = await runGSDDoctor(dir, { fix: true });
+      assertTrue(fixed.fixesApplied.some(f => f.includes("deleted stale branch")), "fix deletes stale branch");
+
+      // Verify branch is gone
+      const branches = run("git branch --list 'milestone/*'", dir);
+      assertTrue(!branches.includes("milestone/M001"), "branch gone after fix");
+    }
+
+    // ─── Test 3: Corrupt merge state detection & fix ───────────────────
+    console.log("\n=== corrupt_merge_state ===");
+    {
+      const dir = createRepoWithCompletedMilestone();
+      cleanups.push(dir);
+
+      // Inject MERGE_HEAD into .git
+      const headHash = run("git rev-parse HEAD", dir);
+      writeFileSync(join(dir, ".git", "MERGE_HEAD"), headHash + "\n");
+
+      const detect = await runGSDDoctor(dir);
+      const mergeIssues = detect.issues.filter(i => i.code === "corrupt_merge_state");
+      assertTrue(mergeIssues.length > 0, "detects corrupt merge state");
+
+      const fixed = await runGSDDoctor(dir, { fix: true });
+      assertTrue(fixed.fixesApplied.some(f => f.includes("cleaned merge state")), "fix cleans merge state");
+
+      // Verify MERGE_HEAD is gone
+      assertTrue(!existsSync(join(dir, ".git", "MERGE_HEAD")), "MERGE_HEAD removed after fix");
+    }
+
+    // ─── Test 4: Tracked runtime files detection & fix ─────────────────
+    console.log("\n=== tracked_runtime_files ===");
+    {
+      const dir = createRepoWithCompletedMilestone();
+      cleanups.push(dir);
+
+      // Force-add a runtime file
+      const activityDir = join(dir, ".gsd", "activity");
+      mkdirSync(activityDir, { recursive: true });
+      writeFileSync(join(activityDir, "test.log"), "log data\n");
+      run("git add -f .gsd/activity/test.log", dir);
+      run("git commit -m 'track runtime file'", dir);
+
+      const detect = await runGSDDoctor(dir);
+      const trackedIssues = detect.issues.filter(i => i.code === "tracked_runtime_files");
+      assertTrue(trackedIssues.length > 0, "detects tracked runtime files");
+
+      const fixed = await runGSDDoctor(dir, { fix: true });
+      assertTrue(fixed.fixesApplied.some(f => f.includes("untracked")), "fix untracks runtime files");
+
+      // Verify file is no longer tracked
+      const tracked = run("git ls-files .gsd/activity/", dir);
+      assertEq(tracked, "", "runtime file untracked after fix");
+    }
+
+    // ─── Test 5: Non-git directory — graceful degradation ──────────────
+    console.log("\n=== non-git directory ===");
+    {
+      const dir = realpathSync(mkdtempSync(join(tmpdir(), "doc-git-test-")));
+      cleanups.push(dir);
+
+      // Create minimal .gsd structure (no git)
+      mkdirSync(join(dir, ".gsd"), { recursive: true });
+
+      const result = await runGSDDoctor(dir);
+      const gitIssues = result.issues.filter(i =>
+        ["orphaned_auto_worktree", "stale_milestone_branch", "corrupt_merge_state", "tracked_runtime_files"].includes(i.code)
+      );
+      assertEq(gitIssues.length, 0, "no git issues in non-git directory");
+      // Should not throw — reaching here means no crash
+      assertTrue(true, "non-git directory does not crash");
+    }
+
+    // ─── Test 6: Active worktree NOT flagged (false positive prevention) ─
+    console.log("\n=== active worktree safety ===");
+    {
+      const dir = createRepoWithActiveMilestone();
+      cleanups.push(dir);
+
+      // Create worktree for in-progress milestone under .gsd/worktrees/
+      mkdirSync(join(dir, ".gsd", "worktrees"), { recursive: true });
+      run("git worktree add -b milestone/M001 .gsd/worktrees/M001", dir);
+
+      const detect = await runGSDDoctor(dir);
+      const orphanIssues = detect.issues.filter(i => i.code === "orphaned_auto_worktree");
+      assertEq(orphanIssues.length, 0, "active worktree NOT flagged as orphaned");
+    }
+
+  } finally {
+    for (const dir of cleanups) {
+      try { rmSync(dir, { recursive: true, force: true }); } catch { /* ignore */ }
+    }
+  }
+
+  report();
+}
+
+main();

package/dist/resources/extensions/gsd/tests/doctor.test.ts

@@ -2,7 +2,7 @@ import { mkdtempSync, mkdirSync, readFileSync, rmSync, writeFileSync, existsSync
 import { join } from "node:path";
 import { tmpdir } from "node:os";
 
-import { formatDoctorReport, runGSDDoctor, summarizeDoctorIssues, filterDoctorIssues, selectDoctorScope } from "../doctor.js";
+import { formatDoctorReport, runGSDDoctor, summarizeDoctorIssues, filterDoctorIssues, selectDoctorScope, validateTitle } from "../doctor.js";
 import { createTestContext } from './test-helpers.ts';
 
 const { assertEq, assertTrue, report } = createTestContext();
@@ -471,6 +471,120 @@ Discovered an issue.
     rmSync(mhBase, { recursive: true, force: true });
   }
 
+  // ─── validateTitle: em dash and slash detection ────────────────────────
+  console.log("\n=== validateTitle: returns null for clean titles ===");
+  {
+    assertEq(validateTitle("Foundation"), null, "clean title passes");
+    assertEq(validateTitle("Build Core Systems"), null, "clean title with spaces passes");
+    assertEq(validateTitle("API v2 Integration"), null, "clean title with version passes");
+    assertEq(validateTitle(""), null, "empty title passes");
+  }
+
+  console.log("\n=== validateTitle: detects em dash ===");
+  {
+    const result = validateTitle("Foundation — Build Core");
+    assertTrue(result !== null, "detects em dash in title");
+    assertTrue(result!.includes("em/en dash"), "message mentions em/en dash");
+  }
+
+  console.log("\n=== validateTitle: detects en dash ===");
+  {
+    const result = validateTitle("Phase 1 – Phase 2");
+    assertTrue(result !== null, "detects en dash in title");
+    assertTrue(result!.includes("em/en dash"), "message mentions em/en dash for en dash");
+  }
+
+  console.log("\n=== validateTitle: detects forward slash ===");
+  {
+    const result = validateTitle("Client/Server");
+    assertTrue(result !== null, "detects forward slash in title");
+    assertTrue(result!.includes("forward slash"), "message mentions forward slash");
+  }
+
+  console.log("\n=== validateTitle: detects both em dash and slash ===");
+  {
+    const result = validateTitle("Client — Server/API");
+    assertTrue(result !== null, "detects both delimiters");
+    assertTrue(result!.includes("em/en dash"), "message mentions em/en dash");
+    assertTrue(result!.includes("forward slash"), "message mentions forward slash");
+  }
+
+  // ─── doctor detects delimiter_in_title for milestone ───────────────────
+  console.log("\n=== doctor detects em dash in milestone title ===");
+  {
+    const dtBase = mkdtempSync(join(tmpdir(), "gsd-doctor-dt-test-"));
+    const dtGsd = join(dtBase, ".gsd");
+    const dtMDir = join(dtGsd, "milestones", "M001");
+    const dtSDir = join(dtMDir, "slices", "S01");
+    const dtTDir = join(dtSDir, "tasks");
+    mkdirSync(dtTDir, { recursive: true });
+
+    // Roadmap with em dash in milestone title
+    writeFileSync(join(dtMDir, "M001-ROADMAP.md"), `# M001: Foundation — Build Core\n\n## Slices\n- [ ] **S01: Demo Slice** \`risk:low\` \`depends:[]\`\n  > After this: demo works\n`);
+    writeFileSync(join(dtSDir, "S01-PLAN.md"), `# S01: Demo Slice\n\n**Goal:** Demo\n**Demo:** Demo\n\n## Tasks\n- [ ] **T01: Implement** \`est:10m\`\n  Task.\n`);
+    writeFileSync(join(dtTDir, "T01-PLAN.md"), `# T01: Implement\n\n## Steps\n\n1. Do the thing.\n`);
+
+    const report = await runGSDDoctor(dtBase, { fix: false });
+    const dtIssues = report.issues.filter(i => i.code === "delimiter_in_title");
+    assertTrue(dtIssues.length >= 1, "detects delimiter_in_title for milestone with em dash");
+    const milestoneIssue = dtIssues.find(i => i.scope === "milestone");
+    assertTrue(milestoneIssue !== undefined, "delimiter issue has milestone scope");
+    assertEq(milestoneIssue?.severity, "warning", "delimiter issue has warning severity");
+    assertEq(milestoneIssue?.unitId, "M001", "delimiter issue unitId is M001");
+    assertTrue(milestoneIssue?.message?.includes("em/en dash") ?? false, "issue message mentions em/en dash");
+    assertEq(milestoneIssue?.fixable, false, "delimiter issue is not auto-fixable");
+
+    rmSync(dtBase, { recursive: true, force: true });
+  }
+
+  // ─── doctor detects delimiter_in_title for slice ────────────────────────
+  console.log("\n=== doctor detects em dash in slice title ===");
+  {
+    const dtBase = mkdtempSync(join(tmpdir(), "gsd-doctor-dt-slice-"));
+    const dtGsd = join(dtBase, ".gsd");
+    const dtMDir = join(dtGsd, "milestones", "M001");
+    const dtSDir = join(dtMDir, "slices", "S01");
+    const dtTDir = join(dtSDir, "tasks");
+    mkdirSync(dtTDir, { recursive: true });
+
+    // Roadmap with em dash in slice title (milestone title is clean)
+    writeFileSync(join(dtMDir, "M001-ROADMAP.md"), `# M001: Clean Milestone\n\n## Slices\n- [ ] **S01: Core — Foundation** \`risk:low\` \`depends:[]\`\n  > After this: demo works\n`);
+    writeFileSync(join(dtSDir, "S01-PLAN.md"), `# S01: Core — Foundation\n\n**Goal:** Demo\n**Demo:** Demo\n\n## Tasks\n- [ ] **T01: Implement** \`est:10m\`\n  Task.\n`);
+    writeFileSync(join(dtTDir, "T01-PLAN.md"), `# T01: Implement\n\n## Steps\n\n1. Do the thing.\n`);
+
+    const report = await runGSDDoctor(dtBase, { fix: false });
+    const dtIssues = report.issues.filter(i => i.code === "delimiter_in_title");
+    assertTrue(dtIssues.length >= 1, "detects delimiter_in_title for slice with em dash");
+    const sliceIssue = dtIssues.find(i => i.scope === "slice");
+    assertTrue(sliceIssue !== undefined, "delimiter issue has slice scope");
+    assertEq(sliceIssue?.severity, "warning", "slice delimiter issue has warning severity");
+    assertEq(sliceIssue?.unitId, "M001/S01", "slice delimiter issue unitId is M001/S01");
+
+    rmSync(dtBase, { recursive: true, force: true });
+  }
+
+  // ─── doctor does NOT flag clean titles ──────────────────────────────────
+  console.log("\n=== doctor does NOT flag milestone with clean title ===");
+  {
+    const dtBase = mkdtempSync(join(tmpdir(), "gsd-doctor-dt-clean-"));
+    const dtGsd = join(dtBase, ".gsd");
+    const dtMDir = join(dtGsd, "milestones", "M001");
+    const dtSDir = join(dtMDir, "slices", "S01");
+    const dtTDir = join(dtSDir, "tasks");
+    mkdirSync(dtTDir, { recursive: true });
+
+    // Roadmap with clean titles (no delimiters)
+    writeFileSync(join(dtMDir, "M001-ROADMAP.md"), `# M001: Foundation Build Core\n\n## Slices\n- [ ] **S01: Demo Slice** \`risk:low\` \`depends:[]\`\n  > After this: demo works\n`);
+    writeFileSync(join(dtSDir, "S01-PLAN.md"), `# S01: Demo Slice\n\n**Goal:** Demo\n**Demo:** Demo\n\n## Tasks\n- [ ] **T01: Implement** \`est:10m\`\n  Task.\n`);
+    writeFileSync(join(dtTDir, "T01-PLAN.md"), `# T01: Implement\n\n## Steps\n\n1. Do the thing.\n`);
+
+    const report = await runGSDDoctor(dtBase, { fix: false });
+    const dtIssues = report.issues.filter(i => i.code === "delimiter_in_title");
+    assertEq(dtIssues.length, 0, "no delimiter_in_title issues for clean titles");
+
+    rmSync(dtBase, { recursive: true, force: true });
+  }
+
   report();
 }