@tuan_son.dinh/gsd 2.6.0

package/src/resources/extensions/gsd/tests/derive-state-deps.test.ts

@@ -0,0 +1,341 @@
+import { mkdtempSync, mkdirSync, rmSync, writeFileSync } from 'node:fs';
+import { join } from 'node:path';
+import { tmpdir } from 'node:os';
+
+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)}`);
+  }
+}
+
+// ─── Fixture Helpers ───────────────────────────────────────────────────────
+
+function createFixtureBase(): string {
+  const base = mkdtempSync(join(tmpdir(), 'gsd-deps-test-'));
+  mkdirSync(join(base, '.gsd', 'milestones'), { recursive: true });
+  return base;
+}
+
+function writeRoadmap(base: string, mid: string, content: string): void {
+  const dir = join(base, '.gsd', 'milestones', mid);
+  mkdirSync(dir, { recursive: true });
+  writeFileSync(join(dir, `${mid}-ROADMAP.md`), content);
+}
+
+function writeMilestoneSummary(base: string, mid: string, content: string): void {
+  const dir = join(base, '.gsd', 'milestones', mid);
+  mkdirSync(dir, { recursive: true });
+  writeFileSync(join(dir, `${mid}-SUMMARY.md`), content);
+}
+
+/**
+ * Creates M00x-CONTEXT.md with a valid YAML frontmatter block.
+ * frontmatter is the raw YAML lines between the --- delimiters.
+ */
+function writeContext(base: string, mid: string, frontmatter: string): void {
+  const dir = join(base, '.gsd', 'milestones', mid);
+  mkdirSync(dir, { recursive: true });
+  writeFileSync(join(dir, `${mid}-CONTEXT.md`), `---\n${frontmatter}\n---\n`);
+}
+
+function writeSlicePlan(base: string, mid: string, sid: string, content: string): void {
+  const dir = join(base, '.gsd', 'milestones', mid, 'slices', sid);
+  mkdirSync(join(dir, 'tasks'), { recursive: true });
+  writeFileSync(join(dir, `${sid}-PLAN.md`), content);
+}
+
+function cleanup(base: string): void {
+  rmSync(base, { recursive: true, force: true });
+}
+
+// ═══════════════════════════════════════════════════════════════════════════
+// Test Groups
+// ═══════════════════════════════════════════════════════════════════════════
+
+async function main(): Promise<void> {
+
+  // ─── Test Group 1: blocked-deps ────────────────────────────────────────
+  // M001 is incomplete (no SUMMARY), M002 depends_on M001 → M002 is pending
+  console.log('\n=== blocked-deps ===');
+  {
+    const base = createFixtureBase();
+    try {
+      // M001: incomplete (one slice, no SUMMARY)
+      writeRoadmap(base, 'M001', `# M001: First Milestone
+
+**Vision:** First milestone still in progress.
+
+## Slices
+
+- [ ] **S01: Incomplete Slice** \`risk:low\` \`depends:[]\`
+  > After this: Done.
+`);
+
+      // M001: add a slice plan with an active task so phase is 'executing'
+      writeSlicePlan(base, 'M001', 'S01', `# S01: Incomplete Slice
+
+**Goal:** Verify dep-blocked milestone behavior.
+**Demo:** Tests pass.
+
+## Tasks
+
+- [ ] **T01: Do work** \`est:15m\`
+  First task still in progress.
+`);
+
+      // M002: depends on M001, also incomplete
+      writeRoadmap(base, 'M002', `# M002: Second Milestone
+
+**Vision:** Second milestone blocked by M001.
+
+## Slices
+
+- [ ] **S01: Blocked Slice** \`risk:low\` \`depends:[]\`
+  > After this: Done.
+`);
+      writeContext(base, 'M002', 'depends_on: [M001]');
+
+      const state = await deriveState(base);
+
+      assertEq(state.registry[0]?.status, 'active', 'blocked-deps: M001 is active');
+      assertEq(state.registry[1]?.status, 'pending', 'blocked-deps: M002 is pending (dep-blocked)');
+      assertEq(state.phase, 'executing', 'blocked-deps: phase is executing (M001 is active)');
+      assertEq(state.activeMilestone?.id, 'M001', 'blocked-deps: activeMilestone is M001');
+    } finally {
+      cleanup(base);
+    }
+  }
+
+  // ─── Test Group 2: unblocked-deps ──────────────────────────────────────
+  // M001 is complete (all slices [x] + SUMMARY), M002 depends_on M001 → M002 becomes active
+  console.log('\n=== unblocked-deps ===');
+  {
+    const base = createFixtureBase();
+    try {
+      // M001: complete (all slices done + SUMMARY present)
+      writeRoadmap(base, 'M001', `# M001: First Milestone
+
+**Vision:** First milestone complete.
+
+## Slices
+
+- [x] **S01: Done** \`risk:low\` \`depends:[]\`
+  > After this: Done.
+`);
+      writeMilestoneSummary(base, 'M001', '# M001 Summary\n\nFirst milestone is complete.');
+
+      // M002: depends on M001, now unblocked
+      writeRoadmap(base, 'M002', `# M002: Second Milestone
+
+**Vision:** Second milestone now active.
+
+## Slices
+
+- [ ] **S01: Active Slice** \`risk:low\` \`depends:[]\`
+  > After this: Done.
+`);
+      writeContext(base, 'M002', 'depends_on: [M001]');
+
+      const state = await deriveState(base);
+
+      assertEq(state.registry[0]?.status, 'complete', 'unblocked-deps: M001 is complete');
+      assertEq(state.registry[1]?.status, 'active', 'unblocked-deps: M002 is active');
+      assertEq(state.activeMilestone?.id, 'M002', 'unblocked-deps: activeMilestone is M002');
+      assert(state.phase !== 'blocked', 'unblocked-deps: phase is not blocked');
+    } finally {
+      cleanup(base);
+    }
+  }
+
+  // ─── Test Group 3: all-blocked ─────────────────────────────────────────
+  // M001 depends_on M002, M002 depends_on M001 — circular dep, neither can activate
+  console.log('\n=== all-blocked ===');
+  {
+    const base = createFixtureBase();
+    try {
+      // M001: depends on M002
+      writeRoadmap(base, 'M001', `# M001: First Milestone
+
+**Vision:** Circular dependency.
+
+## Slices
+
+- [ ] **S01: Waiting** \`risk:low\` \`depends:[]\`
+  > After this: Done.
+`);
+      writeContext(base, 'M001', 'depends_on: [M002]');
+
+      // M002: depends on M001
+      writeRoadmap(base, 'M002', `# M002: Second Milestone
+
+**Vision:** Also in circular dependency.
+
+## Slices
+
+- [ ] **S01: Also Waiting** \`risk:low\` \`depends:[]\`
+  > After this: Done.
+`);
+      writeContext(base, 'M002', 'depends_on: [M001]');
+
+      const state = await deriveState(base);
+
+      assertEq(state.phase, 'blocked', 'all-blocked: phase is blocked');
+      assert(state.activeMilestone === null || state.activeMilestone !== null, 'all-blocked: state is consistent');
+      assert(state.blockers.length > 0, 'all-blocked: blockers array is non-empty');
+    } finally {
+      cleanup(base);
+    }
+  }
+
+  // ─── Test Group 4: absent-context ──────────────────────────────────────
+  // Neither M001 nor M002 has a CONTEXT.md → no dep constraints, normal sequential behavior
+  console.log('\n=== absent-context ===');
+  {
+    const base = createFixtureBase();
+    try {
+      // M001: incomplete, no CONTEXT.md
+      writeRoadmap(base, 'M001', `# M001: First Milestone
+
+**Vision:** No context file, no deps.
+
+## Slices
+
+- [ ] **S01: Incomplete** \`risk:low\` \`depends:[]\`
+  > After this: Done.
+`);
+
+      // M002: incomplete, no CONTEXT.md
+      writeRoadmap(base, 'M002', `# M002: Second Milestone
+
+**Vision:** Also no context file.
+
+## Slices
+
+- [ ] **S01: Pending** \`risk:low\` \`depends:[]\`
+  > After this: Done.
+`);
+
+      const state = await deriveState(base);
+
+      assertEq(state.registry[0]?.status, 'active', 'absent-context: M001 is active');
+      assertEq(state.registry[1]?.status, 'pending', 'absent-context: M002 is pending');
+      assertEq(state.activeMilestone?.id, 'M001', 'absent-context: activeMilestone is M001');
+      assert(state.phase !== 'blocked', 'absent-context: phase is not blocked');
+    } finally {
+      cleanup(base);
+    }
+  }
+
+  // ─── Test Group 5: forward-dep ─────────────────────────────────────────
+  // M001 depends_on M002, but M002 is already complete → M001 can activate
+  console.log('\n=== forward-dep ===');
+  {
+    const base = createFixtureBase();
+    try {
+      // M001: depends on M002, but M002 is complete so M001 is unblocked
+      writeRoadmap(base, 'M001', `# M001: First Milestone
+
+**Vision:** Depends on M002 which is already complete.
+
+## Slices
+
+- [ ] **S01: Ready** \`risk:low\` \`depends:[]\`
+  > After this: Done.
+`);
+      writeContext(base, 'M001', 'depends_on: [M002]');
+
+      // M002: complete (all slices [x] + SUMMARY)
+      writeRoadmap(base, 'M002', `# M002: Second Milestone
+
+**Vision:** Already complete.
+
+## Slices
+
+- [x] **S01: Done** \`risk:low\` \`depends:[]\`
+  > After this: Done.
+`);
+      writeMilestoneSummary(base, 'M002', '# M002 Summary\n\nSecond milestone is complete.');
+
+      const state = await deriveState(base);
+
+      assertEq(state.activeMilestone?.id, 'M001', 'forward-dep: activeMilestone is M001');
+      assertEq(state.registry[1]?.status, 'complete', 'forward-dep: M002 is complete');
+      assert(state.phase !== 'blocked', 'forward-dep: phase is not blocked');
+    } finally {
+      cleanup(base);
+    }
+  }
+
+  // ─── Test Group 6: empty-deps-list ─────────────────────────────────────
+  // M002 has `depends_on: []` — empty list means no constraint, normal sequential behavior
+  console.log('\n=== empty-deps-list ===');
+  {
+    const base = createFixtureBase();
+    try {
+      // M001: incomplete, no context
+      writeRoadmap(base, 'M001', `# M001: First Milestone
+
+**Vision:** First milestone still in progress.
+
+## Slices
+
+- [ ] **S01: Incomplete** \`risk:low\` \`depends:[]\`
+  > After this: Done.
+`);
+
+      // M002: empty deps list — no constraint from deps, but still sequential after M001
+      writeRoadmap(base, 'M002', `# M002: Second Milestone
+
+**Vision:** Empty deps list, no blocking constraint.
+
+## Slices
+
+- [ ] **S01: Waiting for M001** \`risk:low\` \`depends:[]\`
+  > After this: Done.
+`);
+      writeContext(base, 'M002', 'depends_on: []');
+
+      const state = await deriveState(base);
+
+      assertEq(state.registry[0]?.status, 'active', 'empty-deps-list: M001 is active');
+      assertEq(state.registry[1]?.status, 'pending', 'empty-deps-list: M002 is pending (M001 not done yet)');
+      assert(state.phase !== 'blocked', 'empty-deps-list: phase is not blocked');
+    } finally {
+      cleanup(base);
+    }
+  }
+
+  // ═════════════════════════════════════════════════════════════════════════
+  // Results
+  // ═════════════════════════════════════════════════════════════════════════
+
+  console.log(`\n${'='.repeat(40)}`);
+  console.log(`Results: ${passed} passed, ${failed} failed`);
+  if (failed > 0) {
+    process.exit(1);
+  } else {
+    console.log('All tests passed ✓');
+  }
+}
+
+main().catch((error) => {
+  console.error(error);
+  process.exit(1);
+});