@tuan_son.dinh/gsd 2.6.0

package/src/resources/extensions/gsd/tests/workspace-index.test.ts

@@ -0,0 +1,94 @@
+import { mkdtempSync, mkdirSync, rmSync, writeFileSync } from "node:fs";
+import { join } from "node:path";
+import { tmpdir } from "node:os";
+
+import { getSuggestedNextCommands, indexWorkspace, listDoctorScopeSuggestions } from "../workspace-index.ts";
+
+let passed = 0;
+let failed = 0;
+
+function assert(condition: boolean, message: string): void {
+  if (condition) passed++;
+  else {
+    failed++;
+    console.error(`  FAIL: ${message}`);
+  }
+}
+
+function assertEq<T>(actual: T, expected: T, message: string): void {
+  if (JSON.stringify(actual) === JSON.stringify(expected)) passed++;
+  else {
+    failed++;
+    console.error(`  FAIL: ${message} — expected ${JSON.stringify(expected)}, got ${JSON.stringify(actual)}`);
+  }
+}
+
+const base = mkdtempSync(join(tmpdir(), "gsd-workspace-index-test-"));
+const gsd = join(base, ".gsd");
+const mDir = join(gsd, "milestones", "M001");
+const sDir = join(mDir, "slices", "S01");
+const tDir = join(sDir, "tasks");
+mkdirSync(tDir, { recursive: true });
+
+writeFileSync(join(mDir, "M001-ROADMAP.md"), `# M001: Demo Milestone
+
+## Slices
+- [ ] **S01: Demo Slice** \`risk:low\` \`depends:[]\`
+  > After this: demo works
+`);
+
+writeFileSync(join(sDir, "S01-PLAN.md"), `# S01: Demo Slice
+
+**Goal:** Demo
+**Demo:** Demo
+
+## Must-Haves
+- done
+
+## Tasks
+- [ ] **T01: Implement thing** \`est:10m\`
+  Task is in progress.
+`);
+
+writeFileSync(join(tDir, "T01-PLAN.md"), `# T01: Implement thing
+
+## Steps
+- do it
+`);
+
+async function main(): Promise<void> {
+  console.log("\n=== workspace index ===");
+  {
+    const index = await indexWorkspace(base);
+    assertEq(index.active.milestoneId, "M001", "active milestone indexed");
+    assertEq(index.active.sliceId, "S01", "active slice indexed");
+    assertEq(index.active.taskId, "T01", "active task indexed");
+    assert(index.scopes.some(scope => scope.scope === "M001/S01"), "slice scope listed");
+    assert(index.scopes.some(scope => scope.scope === "M001/S01/T01"), "task scope listed");
+  }
+
+  console.log("\n=== doctor scope suggestions ===");
+  {
+    const suggestions = await listDoctorScopeSuggestions(base);
+    assertEq(suggestions[0].value, "M001/S01", "active slice suggested first");
+    assert(suggestions.some(item => item.value === "M001/S01/T01"), "task scope suggested");
+  }
+
+  console.log("\n=== next command suggestions ===");
+  {
+    const commands = await getSuggestedNextCommands(base);
+    assert(commands.includes("/gsd auto"), "suggests auto during execution");
+    assert(commands.includes("/gsd doctor M001/S01"), "suggests scoped doctor");
+    assert(commands.includes("/gsd status"), "suggests status");
+  }
+
+  rmSync(base, { recursive: true, force: true });
+  console.log(`\nResults: ${passed} passed, ${failed} failed`);
+  if (failed > 0) process.exit(1);
+  console.log("All tests passed ✓");
+}
+
+main().catch((error) => {
+  console.error(error);
+  process.exit(1);
+});

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

@@ -0,0 +1,253 @@
+/**
+ * Worktree Integration Tests
+ *
+ * Tests the full lifecycle of GSD operations inside a worktree:
+ * - Branch namespacing (gsd/<wt>/<M>/<S> instead of gsd/<M>/<S>)
+ * - getMainBranch returns worktree/<name> inside a worktree
+ * - switchToMain goes to worktree/<name>, not main
+ * - mergeSliceToMain merges into worktree/<name>
+ * - Parallel worktrees don't conflict on branch names
+ * - State derivation works correctly inside worktrees
+ */
+
+import { mkdtempSync, mkdirSync, rmSync, writeFileSync, readFileSync, existsSync } from "node:fs";
+import { join } from "node:path";
+import { tmpdir } from "node:os";
+import { execSync } from "node:child_process";
+
+import {
+  createWorktree,
+  listWorktrees,
+  removeWorktree,
+  worktreePath,
+  worktreeBranchName,
+} from "../worktree-manager.ts";
+
+import {
+  detectWorktreeName,
+  ensureSliceBranch,
+  getActiveSliceBranch,
+  getCurrentBranch,
+  getMainBranch,
+  getSliceBranchName,
+  isOnSliceBranch,
+  mergeSliceToMain,
+  switchToMain,
+  autoCommitCurrentBranch,
+} from "../worktree.ts";
+
+import { deriveState } from "../state.ts";
+
+let passed = 0;
+let failed = 0;
+
+function assert(condition: boolean, message: string): void {
+  if (condition) passed++;
+  else {
+    failed++;
+    console.error(`  FAIL: ${message}`);
+  }
+}
+
+function assertEq<T>(actual: T, expected: T, message: string): void {
+  if (JSON.stringify(actual) === JSON.stringify(expected)) passed++;
+  else {
+    failed++;
+    console.error(`  FAIL: ${message} — expected ${JSON.stringify(expected)}, got ${JSON.stringify(actual)}`);
+  }
+}
+
+function run(command: string, cwd: string): string {
+  return execSync(command, { cwd, stdio: ["ignore", "pipe", "pipe"], encoding: "utf-8" }).trim();
+}
+
+// ─── Test repo setup ──────────────────────────────────────────────────────────
+
+const base = mkdtempSync(join(tmpdir(), "gsd-wt-integration-"));
+run("git init -b main", base);
+run("git config user.name 'Pi Test'", base);
+run("git config user.email 'pi@example.com'", base);
+
+// Create a project with one milestone and two slices
+mkdirSync(join(base, ".gsd", "milestones", "M001", "slices", "S01", "tasks"), { recursive: true });
+mkdirSync(join(base, ".gsd", "milestones", "M001", "slices", "S02", "tasks"), { recursive: true });
+writeFileSync(join(base, "README.md"), "# Test Project\n", "utf-8");
+writeFileSync(
+  join(base, ".gsd", "milestones", "M001", "M001-ROADMAP.md"),
+  [
+    "# M001: Demo",
+    "",
+    "## Slices",
+    "- [ ] **S01: First** `risk:low` `depends:[]`",
+    "  > After this: part one works",
+    "- [ ] **S02: Second** `risk:low` `depends:[]`",
+    "  > After this: part two works",
+  ].join("\n") + "\n",
+  "utf-8",
+);
+writeFileSync(
+  join(base, ".gsd", "milestones", "M001", "slices", "S01", "S01-PLAN.md"),
+  "# S01: First\n\n**Goal:** Demo\n**Demo:** Demo\n\n## Must-Haves\n- done\n\n## Tasks\n- [ ] **T01: Implement** `est:10m`\n  do it\n",
+  "utf-8",
+);
+writeFileSync(
+  join(base, ".gsd", "milestones", "M001", "slices", "S02", "S02-PLAN.md"),
+  "# S02: Second\n\n**Goal:** Demo\n**Demo:** Demo\n\n## Must-Haves\n- done\n\n## Tasks\n- [ ] **T01: Implement** `est:10m`\n  do it\n",
+  "utf-8",
+);
+run("git add .", base);
+run("git commit -m 'chore: init'", base);
+
+async function main(): Promise<void> {
+  // ── Verify main tree baseline ──────────────────────────────────────────────
+
+  console.log("\n=== Main tree baseline ===");
+  assertEq(getMainBranch(base), "main", "main tree getMainBranch returns main");
+  assertEq(detectWorktreeName(base), null, "main tree not detected as worktree");
+
+  // ── Create worktree and verify detection ───────────────────────────────────
+
+  console.log("\n=== Create worktree ===");
+  const wt = createWorktree(base, "alpha");
+  assert(existsSync(wt.path), "worktree created on disk");
+  assertEq(wt.branch, "worktree/alpha", "worktree branch name");
+
+  console.log("\n=== Worktree detection ===");
+  assertEq(detectWorktreeName(wt.path), "alpha", "detectWorktreeName inside worktree");
+  assertEq(getMainBranch(wt.path), "worktree/alpha", "getMainBranch returns worktree branch inside worktree");
+
+  // ── Verify current branch inside worktree ──────────────────────────────────
+
+  console.log("\n=== Worktree initial branch ===");
+  assertEq(getCurrentBranch(wt.path), "worktree/alpha", "worktree starts on its own branch");
+
+  // ── ensureSliceBranch inside worktree ──────────────────────────────────────
+
+  console.log("\n=== ensureSliceBranch in worktree ===");
+  const created = ensureSliceBranch(wt.path, "M001", "S01");
+  assert(created, "slice branch created");
+  assertEq(getCurrentBranch(wt.path), "gsd/alpha/M001/S01", "worktree-namespaced slice branch");
+  assert(isOnSliceBranch(wt.path), "isOnSliceBranch returns true");
+  assertEq(getActiveSliceBranch(wt.path), "gsd/alpha/M001/S01", "getActiveSliceBranch returns namespaced branch");
+
+  // ── Verify branch name helper ──────────────────────────────────────────────
+
+  console.log("\n=== getSliceBranchName with worktree ===");
+  assertEq(getSliceBranchName("M001", "S01", "alpha"), "gsd/alpha/M001/S01", "explicit worktree param");
+  assertEq(getSliceBranchName("M001", "S01"), "gsd/M001/S01", "no worktree param = plain branch");
+
+  // ── Do work on slice branch, then merge to worktree branch ─────────────────
+
+  console.log("\n=== Work and merge slice in worktree ===");
+  writeFileSync(join(wt.path, "feature.txt"), "new feature\n", "utf-8");
+  run("git add .", wt.path);
+  run("git commit -m 'feat: add feature'", wt.path);
+
+  // switchToMain should go to worktree/alpha, NOT main
+  switchToMain(wt.path);
+  assertEq(getCurrentBranch(wt.path), "worktree/alpha", "switchToMain goes to worktree branch, not main");
+
+  // mergeSliceToMain should merge into worktree/alpha
+  const merge = mergeSliceToMain(wt.path, "M001", "S01", "First");
+  assertEq(merge.branch, "gsd/alpha/M001/S01", "merged the namespaced branch");
+  assert(merge.deletedBranch, "slice branch deleted after merge");
+  assertEq(getCurrentBranch(wt.path), "worktree/alpha", "still on worktree branch after merge");
+  assert(readFileSync(join(wt.path, "feature.txt"), "utf-8").includes("new feature"), "merge brought feature to worktree branch");
+
+  // Verify slice branch is gone
+  const branches = run("git branch", base);
+  assert(!branches.includes("gsd/alpha/M001/S01"), "slice branch cleaned up");
+
+  // ── Second slice in same worktree ──────────────────────────────────────────
+
+  console.log("\n=== Second slice in worktree ===");
+  const created2 = ensureSliceBranch(wt.path, "M001", "S02");
+  assert(created2, "S02 branch created");
+  assertEq(getCurrentBranch(wt.path), "gsd/alpha/M001/S02", "on S02 namespaced branch");
+
+  writeFileSync(join(wt.path, "feature2.txt"), "second feature\n", "utf-8");
+  run("git add .", wt.path);
+  run("git commit -m 'feat: add feature 2'", wt.path);
+
+  switchToMain(wt.path);
+  const merge2 = mergeSliceToMain(wt.path, "M001", "S02", "Second");
+  assertEq(merge2.branch, "gsd/alpha/M001/S02", "S02 merge correct");
+  assertEq(getCurrentBranch(wt.path), "worktree/alpha", "back on worktree branch");
+
+  // ── Main tree can still do its own slice work independently ────────────────
+
+  console.log("\n=== Main tree independent slice work ===");
+  assertEq(getCurrentBranch(base), "main", "main tree still on main");
+  const mainCreated = ensureSliceBranch(base, "M001", "S01");
+  assert(mainCreated, "main tree can create S01 branch (no conflict with worktree)");
+  assertEq(getCurrentBranch(base), "gsd/M001/S01", "main tree on plain branch name");
+
+  writeFileSync(join(base, "main-feature.txt"), "main work\n", "utf-8");
+  run("git add .", base);
+  run("git commit -m 'feat: main work'", base);
+
+  switchToMain(base);
+  assertEq(getCurrentBranch(base), "main", "main tree switchToMain goes to main");
+  const mainMerge = mergeSliceToMain(base, "M001", "S01", "First");
+  assertEq(mainMerge.branch, "gsd/M001/S01", "main tree merge uses plain branch");
+
+  // ── Parallel worktrees don't conflict ──────────────────────────────────────
+
+  console.log("\n=== Parallel worktrees ===");
+  const wt2 = createWorktree(base, "beta");
+  assertEq(getMainBranch(wt2.path), "worktree/beta", "second worktree has its own base branch");
+
+  // Both worktrees can create S01 branches without conflict
+  const betaCreated = ensureSliceBranch(wt2.path, "M001", "S01");
+  assert(betaCreated, "beta worktree can create S01");
+  assertEq(getCurrentBranch(wt2.path), "gsd/beta/M001/S01", "beta has its own namespaced branch");
+
+  // Alpha worktree can re-create S01 too (it was already merged+deleted earlier)
+  const alphaReCreated = ensureSliceBranch(wt.path, "M001", "S01");
+  assert(alphaReCreated, "alpha worktree can re-create S01");
+  assertEq(getCurrentBranch(wt.path), "gsd/alpha/M001/S01", "alpha re-created S01");
+
+  // Both exist simultaneously
+  const allBranches = run("git branch", base);
+  assert(allBranches.includes("gsd/alpha/M001/S01"), "alpha S01 branch exists");
+  assert(allBranches.includes("gsd/beta/M001/S01"), "beta S01 branch exists");
+
+  // ── State derivation in worktree ───────────────────────────────────────────
+
+  console.log("\n=== State derivation in worktree ===");
+  // Switch alpha back to its base so deriveState sees milestone files
+  switchToMain(wt.path);
+  const state = await deriveState(wt.path);
+  assert(state.activeMilestone !== null, "worktree has active milestone");
+  assertEq(state.activeMilestone?.id, "M001", "correct milestone");
+
+  // ── autoCommitCurrentBranch in worktree ────────────────────────────────────
+
+  console.log("\n=== autoCommitCurrentBranch in worktree ===");
+  ensureSliceBranch(wt2.path, "M001", "S01"); // re-checkout if needed
+  writeFileSync(join(wt2.path, "dirty.txt"), "uncommitted\n", "utf-8");
+  const commitMsg = autoCommitCurrentBranch(wt2.path, "execute-task", "M001/S01/T01");
+  assert(commitMsg !== null, "auto-commit works in worktree");
+  assertEq(run("git status --short", wt2.path), "", "worktree clean after auto-commit");
+
+  // ── Cleanup ────────────────────────────────────────────────────────────────
+
+  console.log("\n=== Cleanup ===");
+  // Switch worktrees back to their base branches before removal
+  switchToMain(wt.path);
+  switchToMain(wt2.path);
+  removeWorktree(base, "alpha", { deleteBranch: true });
+  removeWorktree(base, "beta", { deleteBranch: true });
+  assertEq(listWorktrees(base).length, 0, "all worktrees removed");
+
+  rmSync(base, { recursive: true, force: true });
+
+  console.log(`\nResults: ${passed} passed, ${failed} failed`);
+  if (failed > 0) process.exit(1);
+  console.log("All tests passed ✓");
+}
+
+main().catch((error) => {
+  console.error(error);
+  process.exit(1);
+});

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

@@ -0,0 +1,160 @@
+import { mkdtempSync, mkdirSync, rmSync, writeFileSync, existsSync, readFileSync } from "node:fs";
+import { join } from "node:path";
+import { tmpdir } from "node:os";
+import { execSync } from "node:child_process";
+
+import {
+  createWorktree,
+  listWorktrees,
+  removeWorktree,
+  diffWorktreeGSD,
+  getWorktreeGSDDiff,
+  getWorktreeLog,
+  worktreeBranchName,
+  worktreePath,
+} from "../worktree-manager.ts";
+
+let passed = 0;
+let failed = 0;
+
+function assert(condition: boolean, message: string): void {
+  if (condition) passed++;
+  else {
+    failed++;
+    console.error(`  FAIL: ${message}`);
+  }
+}
+
+function assertEq<T>(actual: T, expected: T, message: string): void {
+  if (JSON.stringify(actual) === JSON.stringify(expected)) passed++;
+  else {
+    failed++;
+    console.error(`  FAIL: ${message} — expected ${JSON.stringify(expected)}, got ${JSON.stringify(actual)}`);
+  }
+}
+
+function run(command: string, cwd: string): string {
+  return execSync(command, { cwd, stdio: ["ignore", "pipe", "pipe"], encoding: "utf-8" }).trim();
+}
+
+// Set up a test repo
+const base = mkdtempSync(join(tmpdir(), "gsd-worktree-mgr-test-"));
+run("git init -b main", base);
+run("git config user.name 'Pi Test'", base);
+run("git config user.email 'pi@example.com'", base);
+
+// Create initial project structure
+mkdirSync(join(base, ".gsd", "milestones", "M001"), { recursive: true });
+writeFileSync(join(base, "README.md"), "# Test Project\n", "utf-8");
+writeFileSync(
+  join(base, ".gsd", "milestones", "M001", "M001-ROADMAP.md"),
+  "# M001: Demo\n\n## Slices\n- [ ] **S01: First** `risk:low` `depends:[]`\n  > After this: it works\n",
+  "utf-8",
+);
+run("git add .", base);
+run("git commit -m 'chore: init'", base);
+
+async function main(): Promise<void> {
+  console.log("\n=== worktreeBranchName ===");
+  assertEq(worktreeBranchName("feature-x"), "worktree/feature-x", "branch name format");
+
+  console.log("\n=== createWorktree ===");
+  const info = createWorktree(base, "feature-x");
+  assert(info.name === "feature-x", "name matches");
+  assert(info.branch === "worktree/feature-x", "branch matches");
+  assert(info.exists, "worktree exists");
+  assert(existsSync(info.path), "worktree path exists on disk");
+  assert(existsSync(join(info.path, "README.md")), "README.md copied to worktree");
+  assert(existsSync(join(info.path, ".gsd", "milestones", "M001", "M001-ROADMAP.md")), ".gsd files copied");
+
+  // Branch was created
+  const branches = run("git branch", base);
+  assert(branches.includes("worktree/feature-x"), "branch was created");
+
+  console.log("\n=== createWorktree — duplicate ===");
+  let duplicateError = "";
+  try {
+    createWorktree(base, "feature-x");
+  } catch (e) {
+    duplicateError = (e as Error).message;
+  }
+  assert(duplicateError.includes("already exists"), "duplicate creation fails");
+
+  console.log("\n=== createWorktree — invalid name ===");
+  let invalidError = "";
+  try {
+    createWorktree(base, "bad name!");
+  } catch (e) {
+    invalidError = (e as Error).message;
+  }
+  assert(invalidError.includes("Invalid worktree name"), "invalid name rejected");
+
+  console.log("\n=== listWorktrees ===");
+  const list = listWorktrees(base);
+  assertEq(list.length, 1, "one worktree listed");
+  assertEq(list[0]!.name, "feature-x", "correct name");
+  assertEq(list[0]!.branch, "worktree/feature-x", "correct branch");
+  assert(list[0]!.exists, "exists flag is true");
+
+  console.log("\n=== make changes in worktree ===");
+  const wtPath = worktreePath(base, "feature-x");
+  // Add a new GSD artifact in the worktree
+  mkdirSync(join(wtPath, ".gsd", "milestones", "M002"), { recursive: true });
+  writeFileSync(
+    join(wtPath, ".gsd", "milestones", "M002", "M002-ROADMAP.md"),
+    "# M002: New Feature\n\n## Slices\n- [ ] **S01: Setup** `risk:low` `depends:[]`\n  > After this: new feature ready\n",
+    "utf-8",
+  );
+  // Modify an existing artifact
+  writeFileSync(
+    join(wtPath, ".gsd", "milestones", "M001", "M001-ROADMAP.md"),
+    "# M001: Demo (updated)\n\n## Slices\n- [x] **S01: First** `risk:low` `depends:[]`\n  > Done\n",
+    "utf-8",
+  );
+  run("git add .", wtPath);
+  run("git commit -m 'feat: add M002 and update M001'", wtPath);
+
+  console.log("\n=== diffWorktreeGSD ===");
+  const diff = diffWorktreeGSD(base, "feature-x");
+  assert(diff.added.length > 0, "has added files");
+  assert(diff.added.some(f => f.includes("M002")), "M002 roadmap is in added");
+  assert(diff.modified.length > 0, "has modified files");
+  assert(diff.modified.some(f => f.includes("M001")), "M001 roadmap is in modified");
+  assertEq(diff.removed.length, 0, "no removed files");
+
+  console.log("\n=== getWorktreeGSDDiff ===");
+  const fullDiff = getWorktreeGSDDiff(base, "feature-x");
+  assert(fullDiff.includes("M002"), "full diff mentions M002");
+  assert(fullDiff.includes("updated"), "full diff mentions update");
+
+  console.log("\n=== getWorktreeLog ===");
+  const log = getWorktreeLog(base, "feature-x");
+  assert(log.includes("add M002"), "log shows commit message");
+
+  console.log("\n=== removeWorktree ===");
+  removeWorktree(base, "feature-x", { deleteBranch: true });
+  assert(!existsSync(wtPath), "worktree directory removed");
+  const branchesAfter = run("git branch", base);
+  assert(!branchesAfter.includes("worktree/feature-x"), "branch deleted");
+
+  console.log("\n=== listWorktrees after removal ===");
+  const listAfter = listWorktrees(base);
+  assertEq(listAfter.length, 0, "no worktrees after removal");
+
+  console.log("\n=== removeWorktree — already gone ===");
+  // Should not throw
+  removeWorktree(base, "feature-x", { deleteBranch: true });
+  passed++;
+
+  // Cleanup
+  rmSync(base, { recursive: true, force: true });
+
+  console.log(`\nResults: ${passed} passed, ${failed} failed`);
+  if (failed > 0) process.exit(1);
+  console.log("All tests passed ✓");
+}
+
+main().catch((error) => {
+  console.error(error);
+  process.exit(1);
+});