gsd-pi 2.28.0 → 2.29.0-dev.2ccf3fb

package/src/resources/extensions/gsd/tests/next-milestone-id.test.ts

@@ -1,66 +1,23 @@
-// Tests for nextMilestoneId and maxMilestoneNum — milestone ID generation
-// using max-based approach to avoid collisions after deletions.
-//
-// Sections:
-//   (a) Empty array returns M001
-//   (b) Sequential IDs return next in sequence
-//   (c) IDs with gaps (deletion) use max, not fill
-//   (d) Non-numeric directory names mixed in are ignored
+import test from "node:test";
+import assert from "node:assert/strict";
+import { nextMilestoneId, maxMilestoneNum } from "../guided-flow.ts";
 
-import { nextMilestoneId, maxMilestoneNum } from '../guided-flow.ts';
-import { createTestContext } from './test-helpers.ts';
-
-
-const { assertEq, report } = createTestContext();
-// ─── Tests ─────────────────────────────────────────────────────────────────
-
-async function main(): Promise<void> {
-  console.log('nextMilestoneId / maxMilestoneNum tests');
-
-  // (a) Empty array → M001
-  {
-    assertEq(maxMilestoneNum([]), 0, 'maxMilestoneNum([]) === 0');
-    assertEq(nextMilestoneId([]), 'M001', 'nextMilestoneId([]) === "M001"');
-  }
-
-  // (b) Sequential IDs → next in sequence
-  {
-    assertEq(
-      nextMilestoneId(['M001', 'M002', 'M003']),
-      'M004',
-      'sequential IDs return M004',
-    );
-    assertEq(maxMilestoneNum(['M001', 'M002', 'M003']), 3, 'max of sequential is 3');
-  }
-
-  // (c) IDs with gaps (deletion scenario) → uses max, not fill
-  {
-    assertEq(
-      nextMilestoneId(['M001', 'M003']),
-      'M004',
-      'gap scenario returns M004, not M002',
-    );
-    assertEq(maxMilestoneNum(['M001', 'M003']), 3, 'max with gap is 3');
-  }
+test("nextMilestoneId: empty array returns M001", () => {
+  assert.equal(maxMilestoneNum([]), 0);
+  assert.equal(nextMilestoneId([]), "M001");
+});
 
-  // (d) Non-numeric directory names mixed in are ignored
-  {
-    assertEq(
-      nextMilestoneId(['M001', 'notes', '.DS_Store', 'M003']),
-      'M004',
-      'non-numeric names ignored, returns M004',
-    );
-    assertEq(
-      maxMilestoneNum(['M001', 'notes', '.DS_Store', 'M003']),
-      3,
-      'max ignores non-numeric entries',
-    );
-  }
+test("nextMilestoneId: sequential IDs return next in sequence", () => {
+  assert.equal(nextMilestoneId(["M001", "M002", "M003"]), "M004");
+  assert.equal(maxMilestoneNum(["M001", "M002", "M003"]), 3);
+});
 
-  report();
-}
+test("nextMilestoneId: gaps use max, not fill", () => {
+  assert.equal(nextMilestoneId(["M001", "M003"]), "M004");
+  assert.equal(maxMilestoneNum(["M001", "M003"]), 3);
+});
 
-main().catch((error) => {
-  console.error(error);
-  process.exit(1);
+test("nextMilestoneId: non-numeric directory names ignored", () => {
+  assert.equal(nextMilestoneId(["M001", "notes", ".DS_Store", "M003"]), "M004");
+  assert.equal(maxMilestoneNum(["M001", "notes", ".DS_Store", "M003"]), 3);
 });

package/src/resources/extensions/gsd/tests/none-mode-gates.test.ts

@@ -11,8 +11,9 @@
  * prefs to the runner's cwd .gsd/preferences.md and clean up in finally.
  */
 
-import { mkdirSync, writeFileSync, rmSync } from "node:fs";
+import { mkdirSync, writeFileSync, rmSync, existsSync } from "node:fs";
 import { join } from "node:path";
+import { homedir } from "node:os";
 
 import { shouldUseWorktreeIsolation } from "../auto.ts";
 import { getIsolationMode } from "../preferences.ts";
@@ -71,13 +72,21 @@ try {
 }
 
 // Test 4: shouldUseWorktreeIsolation returns true for no prefs (default)
-console.log("Test 4: shouldUseWorktreeIsolation returns true for no prefs (default)");
-try {
-  removeRunnerPreferences(); // ensure no prefs file
-  invalidateAllCaches();
-  assertEq(shouldUseWorktreeIsolation(), true, "shouldUseWorktreeIsolation() with no prefs (default worktree)");
-} finally {
-  invalidateAllCaches();
+// Skip if global prefs exist — they override the default and this test
+// cannot control ~/.gsd/preferences.md.
+const globalPrefsExist = existsSync(join(homedir(), ".gsd", "preferences.md"))
+  || existsSync(join(homedir(), ".gsd", "PREFERENCES.md"));
+if (!globalPrefsExist) {
+  console.log("Test 4: shouldUseWorktreeIsolation returns true for no prefs (default)");
+  try {
+    removeRunnerPreferences(); // ensure no prefs file
+    invalidateAllCaches();
+    assertEq(shouldUseWorktreeIsolation(), true, "shouldUseWorktreeIsolation() with no prefs (default worktree)");
+  } finally {
+    invalidateAllCaches();
+  }
+} else {
+  console.log("Test 4: SKIPPED — global prefs file exists, cannot test bare default");
 }
 
 // Test 5: getIsolationMode returns "none" with none prefs

package/src/resources/extensions/gsd/tests/parallel-merge.test.ts

@@ -51,6 +51,9 @@ function createTempRepo(): string {
   run("git config user.email test@test.com", dir);
   run("git config user.name Test", dir);
   writeFileSync(join(dir, "README.md"), "# test\n");
+  // Mirror production: .gsd/worktrees/ is gitignored so autoCommitDirtyState
+  // doesn't pick up the worktrees directory as dirty state (#1127 fix).
+  writeFileSync(join(dir, ".gitignore"), ".gsd/worktrees/\n");
   mkdirSync(join(dir, ".gsd"), { recursive: true });
   writeFileSync(join(dir, ".gsd", "STATE.md"), "# State\n");
   run("git add .", dir);

package/src/resources/extensions/gsd/tests/parallel-workers-multi-milestone-e2e.test.ts

@@ -30,7 +30,7 @@ import {
   getBudgetAlertLevel,
   getNewBudgetAlertLevel,
   getBudgetEnforcementAction,
-} from '../auto.ts';
+} from '../auto-budget.ts';
 import {
   type UnitMetrics,
   type MetricsLedger,

package/src/resources/extensions/gsd/tests/park-edge-cases.test.ts

@@ -0,0 +1,276 @@
+/**
+ * Edge Case Tests for Park/Discard Milestone Feature
+ *
+ * Tests critical edge cases:
+ * 1. Discard breaks depends_on chain → permanent block
+ * 2. Park blocks depends_on chain
+ * 3. Discard active, next (no deps) activates
+ * 4. Park all + discard all → clean state
+ * 5. Discard non-existent → graceful failure
+ * 6. Queue order survives discards
+ * 7. Circular deps + park interaction
+ * 8. Discard milestone that has depends_on on others
+ */
+
+import { mkdtempSync, mkdirSync, rmSync, writeFileSync, readFileSync } from 'node:fs';
+import { join } from 'node:path';
+import { tmpdir } from 'node:os';
+
+import { deriveState, invalidateStateCache } from '../state.ts';
+import { clearPathCache } from '../paths.ts';
+import { parkMilestone, unparkMilestone, discardMilestone } from '../milestone-actions.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 createFixture(): string {
+  const b = mkdtempSync(join(tmpdir(), 'gsd-edge-'));
+  mkdirSync(join(b, '.gsd', 'milestones'), { recursive: true });
+  return b;
+}
+
+function createM(b: string, mid: string, opts?: { roadmap?: boolean; summary?: boolean; dependsOn?: string[] }): void {
+  const d = join(b, '.gsd', 'milestones', mid);
+  mkdirSync(d, { recursive: true });
+  if (opts?.dependsOn) {
+    writeFileSync(join(d, `${mid}-CONTEXT.md`), `---\ndepends_on: [${opts.dependsOn.join(', ')}]\n---\n# ${mid}`, 'utf-8');
+  }
+  if (opts?.roadmap) {
+    writeFileSync(join(d, `${mid}-ROADMAP.md`), [
+      `# ${mid}: Test`,
+      '', '## Vision', 'Test',
+      '', '## Success Criteria', '- [ ] ok',
+      '', '## Slices',
+      `- [${opts?.summary ? 'x' : ' '}] **S01: Setup** \`risk:low\` \`depends:[]\``,
+      '  - After this: done',
+    ].join('\n'), 'utf-8');
+  }
+  if (opts?.summary) {
+    writeFileSync(join(d, `${mid}-SUMMARY.md`), `---\nid: ${mid}\n---\n# Done`, 'utf-8');
+  }
+}
+
+function clear(): void { clearPathCache(); invalidateStateCache(); }
+function cleanup(b: string): void { rmSync(b, { recursive: true, force: true }); }
+
+async function main(): Promise<void> {
+
+  // ─── EDGE 1: Discard breaks depends_on → downstream is BLOCKED ────────
+  console.log('\n=== EDGE 1: Discard breaks depends_on chain ===');
+  {
+    const b = createFixture();
+    try {
+      createM(b, 'M001', { roadmap: true, summary: true }); // complete
+      createM(b, 'M002', { roadmap: true });                 // active
+      createM(b, 'M003', { roadmap: true, dependsOn: ['M002'] }); // depends on M002
+      clear();
+
+      discardMilestone(b, 'M002');
+      const s = await deriveState(b);
+
+      // M003 depends on M002 which no longer exists.
+      // M002 is not in completeMilestoneIds → dep is unmet → M003 stays pending
+      assertEq(s.registry.find(e => e.id === 'M003')?.status, 'pending', 'M003 stays pending after dep discarded');
+      assertEq(s.phase, 'blocked', 'system is blocked (unmet dep on deleted milestone)');
+      assert(s.blockers.length > 0, 'blockers list is not empty');
+    } finally {
+      cleanup(b);
+    }
+  }
+
+  // ─── EDGE 2: Park blocks depends_on chain ────────────────────────────
+  console.log('\n=== EDGE 2: Park blocks depends_on chain ===');
+  {
+    const b = createFixture();
+    try {
+      createM(b, 'M001', { roadmap: true, summary: true });
+      createM(b, 'M002', { roadmap: true });
+      createM(b, 'M003', { roadmap: true, dependsOn: ['M002'] });
+      clear();
+
+      parkMilestone(b, 'M002', 'testing');
+      const s = await deriveState(b);
+      assertEq(s.registry.find(e => e.id === 'M003')?.status, 'pending', 'M003 pending when M002 parked');
+      // System should be blocked since M003 deps unmet and M002 is parked
+      assert(s.activeMilestone === null, 'no active milestone (M002 parked, M003 dep-blocked)');
+    } finally {
+      cleanup(b);
+    }
+  }
+
+  // ─── EDGE 3: Discard active, next (no deps) activates ────────────────
+  console.log('\n=== EDGE 3: Discard active → next activates ===');
+  {
+    const b = createFixture();
+    try {
+      createM(b, 'M001', { roadmap: true });
+      createM(b, 'M002', { roadmap: true }); // no depends_on
+      clear();
+
+      discardMilestone(b, 'M001');
+      const s = await deriveState(b);
+      assertEq(s.activeMilestone?.id, 'M002', 'M002 becomes active');
+      assert(s.phase !== 'blocked', 'not blocked');
+    } finally {
+      cleanup(b);
+    }
+  }
+
+  // ─── EDGE 4: Park all + discard all → clean pre-planning ─────────────
+  console.log('\n=== EDGE 4: Park all → discard all → clean state ===');
+  {
+    const b = createFixture();
+    try {
+      createM(b, 'M001', { roadmap: true });
+      createM(b, 'M002', { roadmap: true });
+      clear();
+
+      parkMilestone(b, 'M001', 'test');
+      parkMilestone(b, 'M002', 'test');
+      discardMilestone(b, 'M001');
+      discardMilestone(b, 'M002');
+      const s = await deriveState(b);
+      assertEq(s.activeMilestone, null, 'no active milestone');
+      assertEq(s.phase, 'pre-planning', 'phase is pre-planning');
+      assertEq(s.registry.length, 0, 'empty registry');
+      assert(s.nextAction.includes('No milestones'), 'nextAction mentions no milestones');
+    } finally {
+      cleanup(b);
+    }
+  }
+
+  // ─── EDGE 5: Discard non-existent → graceful false ───────────────────
+  console.log('\n=== EDGE 5: Discard non-existent ===');
+  {
+    const b = createFixture();
+    try {
+      const result = discardMilestone(b, 'M999');
+      assert(!result, 'returns false for non-existent');
+    } finally {
+      cleanup(b);
+    }
+  }
+
+  // ─── EDGE 6: Queue order survives discards ───────────────────────────
+  console.log('\n=== EDGE 6: Queue order after discard ===');
+  {
+    const b = createFixture();
+    try {
+      createM(b, 'M001', { roadmap: true });
+      createM(b, 'M002', { roadmap: true });
+      createM(b, 'M003', { roadmap: true });
+      writeFileSync(
+        join(b, '.gsd', 'QUEUE-ORDER.json'),
+        JSON.stringify({ order: ['M003', 'M001', 'M002'], updatedAt: new Date().toISOString() }),
+        'utf-8',
+      );
+      clear();
+
+      // With custom queue order, M003 should be active first
+      let s = await deriveState(b);
+      assertEq(s.activeMilestone?.id, 'M003', 'M003 active (custom queue order)');
+
+      // Discard M003 → M001 should be next per queue order
+      discardMilestone(b, 'M003');
+      s = await deriveState(b);
+      assertEq(s.activeMilestone?.id, 'M001', 'M001 active after M003 discarded');
+
+      // Verify queue order file was updated
+      const order = JSON.parse(readFileSync(join(b, '.gsd', 'QUEUE-ORDER.json'), 'utf-8'));
+      assert(!order.order.includes('M003'), 'M003 removed from QUEUE-ORDER.json');
+    } finally {
+      cleanup(b);
+    }
+  }
+
+  // ─── EDGE 7: Discard milestone that has deps on others ───────────────
+  console.log('\n=== EDGE 7: Discard a milestone that depends on others ===');
+  {
+    const b = createFixture();
+    try {
+      createM(b, 'M001', { roadmap: true });
+      createM(b, 'M002', { roadmap: true, dependsOn: ['M001'] });
+      createM(b, 'M003', { roadmap: true }); // no deps
+      clear();
+
+      // M002 depends on M001, so M001 is active, M002 is pending
+      let s = await deriveState(b);
+      assertEq(s.activeMilestone?.id, 'M001', 'M001 is active');
+      assertEq(s.registry.find(e => e.id === 'M002')?.status, 'pending', 'M002 pending (dep on M001)');
+
+      // Discard M002 (the one WITH deps) — should be fine, M003 becomes pending
+      discardMilestone(b, 'M002');
+      s = await deriveState(b);
+      assertEq(s.activeMilestone?.id, 'M001', 'M001 still active');
+      assert(!s.registry.some(e => e.id === 'M002'), 'M002 gone from registry');
+      assertEq(s.registry.find(e => e.id === 'M003')?.status, 'pending', 'M003 is pending (after M001)');
+    } finally {
+      cleanup(b);
+    }
+  }
+
+  // ─── EDGE 8: Park → Discard → state transitions ─────────────────────
+  console.log('\n=== EDGE 8: Park then discard same milestone ===');
+  {
+    const b = createFixture();
+    try {
+      createM(b, 'M001', { roadmap: true });
+      createM(b, 'M002', { roadmap: true });
+      clear();
+
+      parkMilestone(b, 'M001', 'temp');
+      let s = await deriveState(b);
+      assertEq(s.activeMilestone?.id, 'M002', 'M002 active while M001 parked');
+
+      // Now discard the parked milestone
+      discardMilestone(b, 'M001');
+      s = await deriveState(b);
+      assertEq(s.activeMilestone?.id, 'M002', 'M002 still active');
+      assert(!s.registry.some(e => e.id === 'M001'), 'M001 gone completely');
+      assertEq(s.registry.length, 1, 'only M002 in registry');
+    } finally {
+      cleanup(b);
+    }
+  }
+
+  // ─── EDGE 9: Complete + parked + pending coexist ─────────────────────
+  console.log('\n=== EDGE 9: Mixed states — complete + parked + active ===');
+  {
+    const b = createFixture();
+    try {
+      createM(b, 'M001', { roadmap: true, summary: true }); // complete
+      createM(b, 'M002', { roadmap: true });                 // will park
+      createM(b, 'M003', { roadmap: true });                 // will be active
+      createM(b, 'M004', { roadmap: true });                 // will be pending
+      clear();
+
+      parkMilestone(b, 'M002', 'parked');
+      const s = await deriveState(b);
+      assertEq(s.registry.find(e => e.id === 'M001')?.status, 'complete', 'M001 complete');
+      assertEq(s.registry.find(e => e.id === 'M002')?.status, 'parked', 'M002 parked');
+      assertEq(s.registry.find(e => e.id === 'M003')?.status, 'active', 'M003 active');
+      assertEq(s.registry.find(e => e.id === 'M004')?.status, 'pending', 'M004 pending');
+      assertEq(s.activeMilestone?.id, 'M003', 'M003 is the active milestone');
+      assertEq(s.progress?.milestones.done, 1, '1 done');
+      assertEq(s.progress?.milestones.total, 4, '4 total');
+    } finally {
+      cleanup(b);
+    }
+  }
+
+  // ═══════════════════════════════════════════════════════════════════════
+  console.log(`\n${'='.repeat(50)}`);
+  console.log(`Results: ${passed} passed, ${failed} failed`);
+  if (failed > 0) process.exit(1);
+  else console.log('All edge cases passed!');
+}
+
+main().catch(e => { console.error(e); process.exit(1); });