@tuan_son.dinh/gsd 2.6.0

package/src/resources/extensions/gsd/tests/metrics.test.ts

@@ -0,0 +1,217 @@
+/**
+ * Tests for GSD metrics aggregation logic.
+ * Tests the pure functions — no file I/O, no extension context.
+ */
+
+import {
+  type UnitMetrics,
+  type TokenCounts,
+  classifyUnitPhase,
+  aggregateByPhase,
+  aggregateBySlice,
+  aggregateByModel,
+  getProjectTotals,
+  formatCost,
+  formatTokenCount,
+} from "../metrics.js";
+
+// ─── Test helpers ─────────────────────────────────────────────────────────────
+
+function makeUnit(overrides: Partial<UnitMetrics> = {}): UnitMetrics {
+  return {
+    type: "execute-task",
+    id: "M001/S01/T01",
+    model: "claude-sonnet-4-20250514",
+    startedAt: 1000,
+    finishedAt: 2000,
+    tokens: { input: 1000, output: 500, cacheRead: 200, cacheWrite: 100, total: 1800 },
+    cost: 0.05,
+    toolCalls: 3,
+    assistantMessages: 2,
+    userMessages: 1,
+    ...overrides,
+  };
+}
+
+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 (actual === expected) {
+    passed++;
+  } else {
+    failed++;
+    console.error(`  FAIL: ${message} — expected ${JSON.stringify(expected)}, got ${JSON.stringify(actual)}`);
+  }
+}
+
+function assertClose(actual: number, expected: number, tolerance: number, message: string): void {
+  if (Math.abs(actual - expected) <= tolerance) {
+    passed++;
+  } else {
+    failed++;
+    console.error(`  FAIL: ${message} — expected ~${expected}, got ${actual}`);
+  }
+}
+
+// ─── Phase classification ─────────────────────────────────────────────────────
+
+console.log("\n=== classifyUnitPhase ===");
+
+assertEq(classifyUnitPhase("research-milestone"), "research", "research-milestone → research");
+assertEq(classifyUnitPhase("research-slice"), "research", "research-slice → research");
+assertEq(classifyUnitPhase("plan-milestone"), "planning", "plan-milestone → planning");
+assertEq(classifyUnitPhase("plan-slice"), "planning", "plan-slice → planning");
+assertEq(classifyUnitPhase("execute-task"), "execution", "execute-task → execution");
+assertEq(classifyUnitPhase("complete-slice"), "completion", "complete-slice → completion");
+assertEq(classifyUnitPhase("reassess-roadmap"), "reassessment", "reassess-roadmap → reassessment");
+assertEq(classifyUnitPhase("unknown-thing"), "execution", "unknown → execution (fallback)");
+
+// ─── getProjectTotals ─────────────────────────────────────────────────────────
+
+console.log("\n=== getProjectTotals ===");
+
+{
+  const units = [
+    makeUnit({ tokens: { input: 1000, output: 500, cacheRead: 200, cacheWrite: 100, total: 1800 }, cost: 0.05, toolCalls: 3, startedAt: 1000, finishedAt: 2000 }),
+    makeUnit({ tokens: { input: 2000, output: 1000, cacheRead: 400, cacheWrite: 200, total: 3600 }, cost: 0.10, toolCalls: 5, startedAt: 2000, finishedAt: 4000 }),
+  ];
+  const totals = getProjectTotals(units);
+
+  assertEq(totals.units, 2, "total units");
+  assertEq(totals.tokens.input, 3000, "total input tokens");
+  assertEq(totals.tokens.output, 1500, "total output tokens");
+  assertEq(totals.tokens.cacheRead, 600, "total cacheRead");
+  assertEq(totals.tokens.cacheWrite, 300, "total cacheWrite");
+  assertEq(totals.tokens.total, 5400, "total tokens");
+  assertClose(totals.cost, 0.15, 0.001, "total cost");
+  assertEq(totals.toolCalls, 8, "total tool calls");
+  assertEq(totals.duration, 3000, "total duration");
+}
+
+{
+  const totals = getProjectTotals([]);
+  assertEq(totals.units, 0, "empty: zero units");
+  assertEq(totals.cost, 0, "empty: zero cost");
+  assertEq(totals.tokens.total, 0, "empty: zero tokens");
+}
+
+// ─── aggregateByPhase ─────────────────────────────────────────────────────────
+
+console.log("\n=== aggregateByPhase ===");
+
+{
+  const units = [
+    makeUnit({ type: "research-milestone", cost: 0.02 }),
+    makeUnit({ type: "research-slice", cost: 0.03 }),
+    makeUnit({ type: "plan-milestone", cost: 0.01 }),
+    makeUnit({ type: "plan-slice", cost: 0.02 }),
+    makeUnit({ type: "execute-task", cost: 0.10 }),
+    makeUnit({ type: "execute-task", cost: 0.08 }),
+    makeUnit({ type: "complete-slice", cost: 0.01 }),
+    makeUnit({ type: "reassess-roadmap", cost: 0.005 }),
+  ];
+  const phases = aggregateByPhase(units);
+
+  assertEq(phases.length, 5, "5 phases");
+  assertEq(phases[0].phase, "research", "first phase is research");
+  assertEq(phases[0].units, 2, "2 research units");
+  assertClose(phases[0].cost, 0.05, 0.001, "research cost");
+
+  assertEq(phases[1].phase, "planning", "second phase is planning");
+  assertEq(phases[1].units, 2, "2 planning units");
+
+  assertEq(phases[2].phase, "execution", "third phase is execution");
+  assertEq(phases[2].units, 2, "2 execution units");
+  assertClose(phases[2].cost, 0.18, 0.001, "execution cost");
+
+  assertEq(phases[3].phase, "completion", "fourth phase is completion");
+  assertEq(phases[4].phase, "reassessment", "fifth phase is reassessment");
+}
+
+// ─── aggregateBySlice ─────────────────────────────────────────────────────────
+
+console.log("\n=== aggregateBySlice ===");
+
+{
+  const units = [
+    makeUnit({ id: "M001/S01/T01", cost: 0.05 }),
+    makeUnit({ id: "M001/S01/T02", cost: 0.04 }),
+    makeUnit({ id: "M001/S02/T01", cost: 0.10 }),
+    makeUnit({ id: "M001", type: "research-milestone", cost: 0.02 }),
+  ];
+  const slices = aggregateBySlice(units);
+
+  assertEq(slices.length, 3, "3 slice groups");
+
+  const s01 = slices.find(s => s.sliceId === "M001/S01");
+  assert(!!s01, "M001/S01 exists");
+  assertEq(s01!.units, 2, "M001/S01 has 2 units");
+  assertClose(s01!.cost, 0.09, 0.001, "M001/S01 cost");
+
+  const s02 = slices.find(s => s.sliceId === "M001/S02");
+  assert(!!s02, "M001/S02 exists");
+  assertEq(s02!.units, 1, "M001/S02 has 1 unit");
+
+  const mLevel = slices.find(s => s.sliceId === "M001");
+  assert(!!mLevel, "M001 (milestone-level) exists");
+}
+
+// ─── aggregateByModel ─────────────────────────────────────────────────────────
+
+console.log("\n=== aggregateByModel ===");
+
+{
+  const units = [
+    makeUnit({ model: "claude-sonnet-4-20250514", cost: 0.05 }),
+    makeUnit({ model: "claude-sonnet-4-20250514", cost: 0.04 }),
+    makeUnit({ model: "claude-opus-4-20250514", cost: 0.30 }),
+  ];
+  const models = aggregateByModel(units);
+
+  assertEq(models.length, 2, "2 models");
+  // Sorted by cost desc — opus should be first
+  assertEq(models[0].model, "claude-opus-4-20250514", "opus first (higher cost)");
+  assertClose(models[0].cost, 0.30, 0.001, "opus cost");
+  assertEq(models[1].model, "claude-sonnet-4-20250514", "sonnet second");
+  assertEq(models[1].units, 2, "sonnet has 2 units");
+}
+
+// ─── formatCost ───────────────────────────────────────────────────────────────
+
+console.log("\n=== formatCost ===");
+
+assertEq(formatCost(0), "$0.0000", "zero cost");
+assertEq(formatCost(0.001), "$0.0010", "sub-cent cost");
+assertEq(formatCost(0.05), "$0.050", "5 cents");
+assertEq(formatCost(1.50), "$1.50", "dollar+");
+assertEq(formatCost(14.20), "$14.20", "double digits");
+
+// ─── formatTokenCount ─────────────────────────────────────────────────────────
+
+console.log("\n=== formatTokenCount ===");
+
+assertEq(formatTokenCount(0), "0", "zero tokens");
+assertEq(formatTokenCount(500), "500", "sub-k");
+assertEq(formatTokenCount(1500), "1.5k", "1.5k");
+assertEq(formatTokenCount(150000), "150.0k", "150k");
+assertEq(formatTokenCount(1500000), "1.50M", "1.5M");
+
+// ─── Summary ──────────────────────────────────────────────────────────────────
+
+console.log(`\n${"=".repeat(40)}`);
+console.log(`Results: ${passed} passed, ${failed} failed`);
+if (failed > 0) {
+  process.exit(1);
+} else {
+  console.log("All tests passed ✓");
+}

package/src/resources/extensions/gsd/tests/migrate-command.test.ts

@@ -0,0 +1,390 @@
+// Migration command integration test
+// Tests the pipeline functions as the command handler uses them:
+// path resolution, validation gating, full parse→transform→preview→write→deriveState round-trip.
+// Exercises pipeline modules directly — no TUI context dependency.
+
+import { mkdtempSync, mkdirSync, rmSync, writeFileSync, existsSync } from 'node:fs';
+import { join, resolve } from 'node:path';
+import { tmpdir } from 'node:os';
+
+import {
+  validatePlanningDirectory,
+  parsePlanningDirectory,
+  transformToGSD,
+  generatePreview,
+  writeGSDDirectory,
+} from '../migrate/index.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)}`);
+  }
+}
+
+// ─── Fixture Helpers ───────────────────────────────────────────────────────
+
+const SAMPLE_PROJECT = `# Integration Test Project
+
+A project used for command pipeline integration testing.
+
+## Goals
+
+- Test the full migration pipeline
+`;
+
+const SAMPLE_ROADMAP = `# Project Roadmap
+
+## Phases
+
+- [x] 10 — Foundation
+- [ ] 20 — Features
+`;
+
+const SAMPLE_REQUIREMENTS = `# Requirements
+
+## Active
+
+### R001 — Core Pipeline
+- Status: active
+- Description: Pipeline must work end-to-end.
+
+## Validated
+
+### R002 — Output Format
+- Status: validated
+- Description: Output matches GSD format.
+`;
+
+const SAMPLE_STATE = `# State
+
+**Current Phase:** 20-features
+**Status:** in-progress
+`;
+
+const SAMPLE_CONFIG = JSON.stringify({
+  projectName: 'pipeline-test',
+  version: '1.0',
+});
+
+const SAMPLE_PLAN_10_01 = `---
+phase: "10-foundation"
+plan: "01"
+type: "implementation"
+wave: 1
+depends_on: []
+files_modified: [src/core.ts]
+autonomous: true
+must_haves:
+  truths:
+    - Core module works
+  artifacts:
+    - src/core.ts
+  key_links: []
+---
+
+# 10-01: Build Foundation
+
+<objective>
+Set up the project foundation and core module.
+</objective>
+
+<tasks>
+<task>Create core module</task>
+<task>Add configuration loader</task>
+</tasks>
+
+<context>
+Foundation work needed before features.
+</context>
+
+<verification>
+- Core module loads
+- Config is parsed
+</verification>
+
+<success_criteria>
+Core is operational.
+</success_criteria>
+`;
+
+const SAMPLE_SUMMARY_10_01 = `---
+phase: "10-foundation"
+plan: "01"
+subsystem: "core"
+tags:
+  - foundation
+requires: []
+provides:
+  - core-module
+affects:
+  - features
+tech-stack:
+  - typescript
+key-files:
+  - src/core.ts
+key-decisions:
+  - Use TypeScript strict mode
+patterns-established:
+  - Module pattern
+duration: "1h"
+completed: "2026-01-10"
+---
+
+# 10-01: Foundation Summary
+
+Core module built and operational.
+
+## What Happened
+
+Created core module and configuration loader.
+
+## Files Modified
+
+- \`src/core.ts\` — Core module
+`;
+
+const SAMPLE_PLAN_20_01 = `---
+phase: "20-features"
+plan: "01"
+type: "implementation"
+wave: 1
+depends_on: [10-01]
+files_modified: []
+autonomous: false
+---
+
+# 20-01: Build Feature A
+
+<objective>
+Implement the first feature.
+</objective>
+
+<tasks>
+<task>Design feature API</task>
+<task>Implement feature logic</task>
+</tasks>
+
+<context>
+Depends on foundation work.
+</context>
+`;
+
+function createCompleteFixture(): string {
+  const base = mkdtempSync(join(tmpdir(), 'gsd-cmd-test-'));
+  const planning = join(base, '.planning');
+  mkdirSync(planning, { recursive: true });
+
+  writeFileSync(join(planning, 'PROJECT.md'), SAMPLE_PROJECT);
+  writeFileSync(join(planning, 'ROADMAP.md'), SAMPLE_ROADMAP);
+  writeFileSync(join(planning, 'REQUIREMENTS.md'), SAMPLE_REQUIREMENTS);
+  writeFileSync(join(planning, 'STATE.md'), SAMPLE_STATE);
+  writeFileSync(join(planning, 'config.json'), SAMPLE_CONFIG);
+
+  // Phase 10: done — has plan + summary
+  const phase10 = join(planning, 'phases', '10-foundation');
+  mkdirSync(phase10, { recursive: true });
+  writeFileSync(join(phase10, '10-01-PLAN.md'), SAMPLE_PLAN_10_01);
+  writeFileSync(join(phase10, '10-01-SUMMARY.md'), SAMPLE_SUMMARY_10_01);
+
+  // Phase 20: in-progress — has plan, no summary
+  const phase20 = join(planning, 'phases', '20-features');
+  mkdirSync(phase20, { recursive: true });
+  writeFileSync(join(phase20, '20-01-PLAN.md'), SAMPLE_PLAN_20_01);
+
+  return base;
+}
+
+// ═══════════════════════════════════════════════════════════════════════════
+// Tests
+// ═══════════════════════════════════════════════════════════════════════════
+
+async function main(): Promise<void> {
+
+  // ─── Test 1: Path resolution — .planning appended when missing ─────────
+  console.log('\n=== Path resolution: .planning appended when source path lacks it ===');
+  {
+    const base = createCompleteFixture();
+    try {
+      // Simulate the command's path resolution logic
+      let sourcePath = resolve(base); // no .planning suffix
+      if (!sourcePath.endsWith('.planning')) {
+        sourcePath = join(sourcePath, '.planning');
+      }
+      assert(sourcePath.endsWith('.planning'), 'path-resolution: .planning appended');
+      assert(existsSync(sourcePath), 'path-resolution: appended path exists');
+    } finally {
+      rmSync(base, { recursive: true, force: true });
+    }
+  }
+
+  // ─── Test 2: Path resolution — .planning used as-is ────────────────────
+  console.log('\n=== Path resolution: .planning used as-is when already present ===');
+  {
+    const base = createCompleteFixture();
+    try {
+      const planningPath = join(base, '.planning');
+      let sourcePath = resolve(planningPath);
+      if (!sourcePath.endsWith('.planning')) {
+        sourcePath = join(sourcePath, '.planning');
+      }
+      assertEq(sourcePath, resolve(planningPath), 'path-resolution: .planning not double-appended');
+      assert(existsSync(sourcePath), 'path-resolution: direct path exists');
+    } finally {
+      rmSync(base, { recursive: true, force: true });
+    }
+  }
+
+  // ─── Test 3: Validation gating — non-existent path ─────────────────────
+  console.log('\n=== Validation gating: non-existent path returns invalid ===');
+  {
+    const fakePath = join(tmpdir(), 'gsd-cmd-nonexistent-' + Date.now(), '.planning');
+    const result = await validatePlanningDirectory(fakePath);
+    assertEq(result.valid, false, 'validation: non-existent path is invalid');
+    assert(result.issues.length > 0, 'validation: has issues for non-existent path');
+    const hasFatal = result.issues.some(i => i.severity === 'fatal');
+    assert(hasFatal, 'validation: non-existent path has fatal issue');
+  }
+
+  // ─── Test 4: Validation gating — valid fixture passes ──────────────────
+  console.log('\n=== Validation gating: valid fixture passes validation ===');
+  {
+    const base = createCompleteFixture();
+    try {
+      const result = await validatePlanningDirectory(join(base, '.planning'));
+      assert(result.valid === true, 'validation: valid fixture passes');
+    } finally {
+      rmSync(base, { recursive: true, force: true });
+    }
+  }
+
+  // ─── Test 5: Full pipeline round-trip ──────────────────────────────────
+  console.log('\n=== Full pipeline: parse → transform → preview → write → deriveState ===');
+  {
+    const base = createCompleteFixture();
+    const writeTarget = mkdtempSync(join(tmpdir(), 'gsd-cmd-write-'));
+    try {
+      const planningPath = join(base, '.planning');
+
+      // (a) Validate
+      const validation = await validatePlanningDirectory(planningPath);
+      assert(validation.valid === true, 'pipeline: validation passes');
+
+      // (b) Parse
+      const parsed = await parsePlanningDirectory(planningPath);
+      assert(parsed.roadmap !== null, 'pipeline: roadmap parsed');
+      assert(Object.keys(parsed.phases).length >= 2, 'pipeline: phases parsed');
+
+      // (c) Transform
+      const project = transformToGSD(parsed);
+      assert(project.milestones.length >= 1, 'pipeline: has milestones');
+      assert(project.milestones[0].slices.length >= 1, 'pipeline: has slices');
+
+      // Count totals for preview verification
+      let totalTasks = 0;
+      let doneTasks = 0;
+      let totalSlices = 0;
+      let doneSlices = 0;
+      for (const m of project.milestones) {
+        for (const s of m.slices) {
+          totalSlices++;
+          if (s.done) doneSlices++;
+          for (const t of s.tasks) {
+            totalTasks++;
+            if (t.done) doneTasks++;
+          }
+        }
+      }
+
+      // (d) Preview — verify counts match project data
+      const preview = generatePreview(project);
+      assertEq(preview.milestoneCount, project.milestones.length, 'pipeline: preview milestoneCount');
+      assertEq(preview.totalSlices, totalSlices, 'pipeline: preview totalSlices');
+      assertEq(preview.totalTasks, totalTasks, 'pipeline: preview totalTasks');
+      assertEq(preview.doneSlices, doneSlices, 'pipeline: preview doneSlices');
+      assertEq(preview.doneTasks, doneTasks, 'pipeline: preview doneTasks');
+
+      // Completion percentages
+      const expectedSlicePct = totalSlices > 0 ? Math.round((doneSlices / totalSlices) * 100) : 0;
+      const expectedTaskPct = totalTasks > 0 ? Math.round((doneTasks / totalTasks) * 100) : 0;
+      assertEq(preview.sliceCompletionPct, expectedSlicePct, 'pipeline: preview sliceCompletionPct');
+      assertEq(preview.taskCompletionPct, expectedTaskPct, 'pipeline: preview taskCompletionPct');
+
+      // Requirements in preview
+      assertEq(preview.requirements.active, 1, 'pipeline: preview requirements active');
+      assertEq(preview.requirements.validated, 1, 'pipeline: preview requirements validated');
+      assertEq(preview.requirements.total, 2, 'pipeline: preview requirements total');
+
+      // (e) Write
+      const result = await writeGSDDirectory(project, writeTarget);
+      assert(result.paths.length > 0, 'pipeline: files written');
+
+      // Key files exist
+      const gsd = join(writeTarget, '.gsd');
+      assert(existsSync(join(gsd, 'PROJECT.md')), 'pipeline: PROJECT.md written');
+      assert(existsSync(join(gsd, 'STATE.md')), 'pipeline: STATE.md written');
+      assert(existsSync(join(gsd, 'REQUIREMENTS.md')), 'pipeline: REQUIREMENTS.md written');
+
+      const m001 = join(gsd, 'milestones', 'M001');
+      assert(existsSync(join(m001, 'M001-ROADMAP.md')), 'pipeline: M001-ROADMAP.md written');
+      assert(existsSync(join(m001, 'M001-CONTEXT.md')), 'pipeline: M001-CONTEXT.md written');
+
+      // At least one slice plan exists
+      const s01Plan = join(m001, 'slices', 'S01', 'S01-PLAN.md');
+      assert(existsSync(s01Plan), 'pipeline: S01-PLAN.md written');
+
+      // (f) deriveState — coherent state from written output
+      console.log('  --- deriveState ---');
+      const state = await deriveState(writeTarget);
+      assert(state.phase !== undefined, 'pipeline: deriveState returns phase');
+      assert(state.activeMilestone !== null, 'pipeline: deriveState has activeMilestone');
+      assertEq(state.activeMilestone!.id, 'M001', 'pipeline: deriveState activeMilestone is M001');
+      assert(state.progress.slices !== undefined, 'pipeline: deriveState has slices progress');
+      assert(state.progress.tasks !== undefined, 'pipeline: deriveState has tasks progress');
+
+    } finally {
+      rmSync(base, { recursive: true, force: true });
+      rmSync(writeTarget, { recursive: true, force: true });
+    }
+  }
+
+  // ─── Test 6: .gsd/ exists detection ────────────────────────────────────
+  console.log('\n=== .gsd/ exists detection ===');
+  {
+    const base = mkdtempSync(join(tmpdir(), 'gsd-cmd-exists-'));
+    try {
+      // No .gsd/ yet
+      assert(!existsSync(join(base, '.gsd')), 'exists-detection: .gsd absent initially');
+
+      // Create .gsd/
+      mkdirSync(join(base, '.gsd'), { recursive: true });
+      assert(existsSync(join(base, '.gsd')), 'exists-detection: .gsd detected after creation');
+    } finally {
+      rmSync(base, { recursive: true, force: true });
+    }
+  }
+
+  // ─── Results ─────────────────────────────────────────────────────────────
+  console.log(`\n${passed + failed} assertions: ${passed} passed, ${failed} failed`);
+  if (failed > 0) process.exit(1);
+}
+
+main().catch((err) => {
+  console.error('Unhandled error:', err);
+  process.exit(1);
+});