gsd-pi 2.10.12 → 2.12.0

package/dist/resources/extensions/gsd/tests/cost-projection.test.ts

@@ -0,0 +1,134 @@
+/**
+ * Contract tests for `formatCostProjection`.
+ * Tests the pure function — no file I/O, no extension context.
+ *
+ * This test intentionally fails at import time (or on first assertion)
+ * because `formatCostProjection` does not yet exist in metrics.ts.
+ * That failure confirms the test runs against real code. (T01 state)
+ */
+
+import {
+  type SliceAggregate,
+  formatCostProjection,
+} from "../metrics.js";
+import { createTestContext } from './test-helpers.ts';
+
+// ─── Test helpers ─────────────────────────────────────────────────────────────
+
+function makeSliceAggregate(sliceId: string, cost: number): SliceAggregate {
+  return {
+    sliceId,
+    units: 1,
+    tokens: { input: 0, output: 0, cacheRead: 0, cacheWrite: 0, total: 0 },
+    cost,
+    duration: 1000,
+  };
+}
+
+const { assertEq, assertTrue, report } = createTestContext();
+// ─── formatCostProjection ─────────────────────────────────────────────────────
+
+console.log("\n=== formatCostProjection ===");
+
+// 1. Zero completed slices → empty result
+{
+  const result = formatCostProjection([], 3);
+  assertEq(result.length, 0, "zero slices → empty array");
+}
+
+// 2. One slice → suppressed (need ≥2 to project reliably)
+{
+  const result = formatCostProjection([makeSliceAggregate("M001/S01", 0.10)], 3);
+  assertEq(result.length, 0, "one slice → suppressed (no projection shown)");
+}
+
+// 3. Two slices → projection shown (result.length > 0)
+{
+  const slices = [
+    makeSliceAggregate("M001/S01", 0.10),
+    makeSliceAggregate("M001/S02", 0.10),
+  ];
+  const result = formatCostProjection(slices, 5);
+  assertTrue(result.length > 0, "two slices → projection shown");
+}
+
+// 4. Two-slice result: result[0] contains "$" (cost is formatted)
+{
+  const slices = [
+    makeSliceAggregate("M001/S01", 0.10),
+    makeSliceAggregate("M001/S02", 0.10),
+  ];
+  const result = formatCostProjection(slices, 5);
+  assertTrue(result.length > 0 && result[0].includes("$"), "projection line contains \"$\"");
+}
+
+// 5. Budget ceiling hit: total $0.20 >= ceiling $0.05 → line contains "ceiling"
+{
+  const slices = [
+    makeSliceAggregate("M001/S01", 0.10),
+    makeSliceAggregate("M001/S02", 0.10),
+  ];
+  const result = formatCostProjection(slices, 5, 0.05);
+  const hasCeilingLine = result.some(
+    line => line.toLowerCase().includes("ceiling")
+  );
+  assertTrue(hasCeilingLine, "ceiling warning appears when total ($0.20) >= ceiling ($0.05)");
+}
+
+// 6. Budget ceiling not hit: total $0.20 < ceiling $100.00 → no ceiling line
+{
+  const slices = [
+    makeSliceAggregate("M001/S01", 0.10),
+    makeSliceAggregate("M001/S02", 0.10),
+  ];
+  const result = formatCostProjection(slices, 5, 100.00);
+  const hasCeilingLine = result.some(
+    line => line.toLowerCase().includes("ceiling")
+  );
+  assertTrue(!hasCeilingLine, "no ceiling warning when total ($0.20) < ceiling ($100.00)");
+}
+
+// 7. No ceiling arg → no ceiling line
+{
+  const slices = [
+    makeSliceAggregate("M001/S01", 0.10),
+    makeSliceAggregate("M001/S02", 0.10),
+  ];
+  const result = formatCostProjection(slices, 5);
+  const hasCeilingLine = result.some(
+    line => line.toLowerCase().includes("ceiling")
+  );
+  assertTrue(!hasCeilingLine, "no ceiling warning when no ceiling is set");
+}
+
+// 8. Rounding: avg $0.10 × 5 remaining = $0.50 → result[0] contains "$0.50"
+{
+  const slices = [
+    makeSliceAggregate("M001/S01", 0.10),
+    makeSliceAggregate("M001/S02", 0.10),
+  ];
+  const result = formatCostProjection(slices, 5);
+  const hasRoundedCost = result.some(line => line.includes("$0.50"));
+  assertTrue(hasRoundedCost, "projected cost $0.50 (avg $0.10 × 5 remaining) appears in output");
+}
+
+// 9. Bare milestone entries excluded from average:
+//    makeSliceAggregate('M001', 5.00) has no "/" in sliceId → excluded from avg calc.
+//    Only M001/S01 ($0.10) and M001/S02 ($0.10) count → avg $0.10 × 3 remaining = $0.30
+{
+  const slices = [
+    makeSliceAggregate("M001", 5.00),        // bare milestone — must be excluded
+    makeSliceAggregate("M001/S01", 0.10),
+    makeSliceAggregate("M001/S02", 0.10),
+  ];
+  const result = formatCostProjection(slices, 3);
+  const hasCorrectProjection = result.some(line => line.includes("$0.30"));
+  assertTrue(
+    hasCorrectProjection,
+    "bare milestone entry excluded from avg: projection shows $0.30 (avg $0.10 × 3), not $1.83 (including $5.00 entry)"
+  );
+}
+
+// ─── Summary ──────────────────────────────────────────────────────────────────
+
+report();

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

@@ -0,0 +1,312 @@
+import { mkdtempSync, mkdirSync, rmSync, writeFileSync } from 'node:fs';
+import { join } from 'node:path';
+import { tmpdir } from 'node:os';
+
+import { deriveState } from '../state.ts';
+import { createTestContext } from './test-helpers.ts';
+
+const { assertEq, assertTrue, report } = createTestContext();
+// ─── 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');
+      assertTrue(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');
+      assertTrue(state.activeMilestone === null || state.activeMilestone !== null, 'all-blocked: state is consistent');
+      assertTrue(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');
+      assertTrue(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');
+      assertTrue(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)');
+      assertTrue(state.phase !== 'blocked', 'empty-deps-list: phase is not blocked');
+    } finally {
+      cleanup(base);
+    }
+  }
+
+  report();
+}
+
+main().catch((error) => {
+  console.error(error);
+  process.exit(1);
+});