@tuan_son.dinh/gsd 2.6.0

package/src/resources/extensions/gsd/tests/idle-recovery.test.ts

@@ -0,0 +1,308 @@
+import { mkdtempSync, mkdirSync, readFileSync, rmSync, writeFileSync, existsSync } from "node:fs";
+import { join } from "node:path";
+import { tmpdir } from "node:os";
+import {
+  resolveExpectedArtifactPath,
+  writeBlockerPlaceholder,
+  skipExecuteTask,
+} from "../auto.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 createFixtureBase(): string {
+  const base = mkdtempSync(join(tmpdir(), "gsd-idle-recovery-test-"));
+  mkdirSync(join(base, ".gsd", "milestones", "M001", "slices", "S01", "tasks"), { recursive: true });
+  return base;
+}
+
+function cleanup(base: string): void {
+  rmSync(base, { recursive: true, force: true });
+}
+
+// ═══ resolveExpectedArtifactPath ═════════════════════════════════════════════
+
+{
+  console.log("\n=== resolveExpectedArtifactPath: research-milestone ===");
+  const base = createFixtureBase();
+  try {
+    const result = resolveExpectedArtifactPath("research-milestone", "M001", base);
+    assert(result !== null, "should resolve a path");
+    assert(result!.endsWith("M001-RESEARCH.md"), `path should end with M001-RESEARCH.md, got ${result}`);
+  } finally {
+    cleanup(base);
+  }
+}
+
+{
+  console.log("\n=== resolveExpectedArtifactPath: plan-milestone ===");
+  const base = createFixtureBase();
+  try {
+    const result = resolveExpectedArtifactPath("plan-milestone", "M001", base);
+    assert(result !== null, "should resolve a path");
+    assert(result!.endsWith("M001-ROADMAP.md"), `path should end with M001-ROADMAP.md, got ${result}`);
+  } finally {
+    cleanup(base);
+  }
+}
+
+{
+  console.log("\n=== resolveExpectedArtifactPath: research-slice ===");
+  const base = createFixtureBase();
+  try {
+    const result = resolveExpectedArtifactPath("research-slice", "M001/S01", base);
+    assert(result !== null, "should resolve a path");
+    assert(result!.endsWith("S01-RESEARCH.md"), `path should end with S01-RESEARCH.md, got ${result}`);
+  } finally {
+    cleanup(base);
+  }
+}
+
+{
+  console.log("\n=== resolveExpectedArtifactPath: plan-slice ===");
+  const base = createFixtureBase();
+  try {
+    const result = resolveExpectedArtifactPath("plan-slice", "M001/S01", base);
+    assert(result !== null, "should resolve a path");
+    assert(result!.endsWith("S01-PLAN.md"), `path should end with S01-PLAN.md, got ${result}`);
+  } finally {
+    cleanup(base);
+  }
+}
+
+{
+  console.log("\n=== resolveExpectedArtifactPath: complete-milestone ===");
+  const base = createFixtureBase();
+  try {
+    const result = resolveExpectedArtifactPath("complete-milestone", "M001", base);
+    assert(result !== null, "should resolve a path");
+    assert(result!.endsWith("M001-SUMMARY.md"), `path should end with M001-SUMMARY.md, got ${result}`);
+  } finally {
+    cleanup(base);
+  }
+}
+
+{
+  console.log("\n=== resolveExpectedArtifactPath: unknown unit type → null ===");
+  const base = createFixtureBase();
+  try {
+    const result = resolveExpectedArtifactPath("unknown-type", "M001/S01", base);
+    assertEq(result, null, "unknown type returns null");
+  } finally {
+    cleanup(base);
+  }
+}
+
+// ═══ writeBlockerPlaceholder ═════════════════════════════════════════════════
+
+{
+  console.log("\n=== writeBlockerPlaceholder: writes file for research-slice ===");
+  const base = createFixtureBase();
+  try {
+    const result = writeBlockerPlaceholder("research-slice", "M001/S01", base, "idle recovery exhausted 2 attempts");
+    assert(result !== null, "should return relative path");
+    const absPath = resolveExpectedArtifactPath("research-slice", "M001/S01", base)!;
+    assert(existsSync(absPath), "file should exist on disk");
+    const content = readFileSync(absPath, "utf-8");
+    assert(content.includes("BLOCKER"), "should contain BLOCKER heading");
+    assert(content.includes("idle recovery exhausted 2 attempts"), "should contain the reason");
+    assert(content.includes("research-slice"), "should mention the unit type");
+    assert(content.includes("M001/S01"), "should mention the unit ID");
+  } finally {
+    cleanup(base);
+  }
+}
+
+{
+  console.log("\n=== writeBlockerPlaceholder: creates directory if missing ===");
+  const base = mkdtempSync(join(tmpdir(), "gsd-idle-recovery-test-"));
+  try {
+    // Only create milestone dir, not slice dir
+    mkdirSync(join(base, ".gsd", "milestones", "M001"), { recursive: true });
+    // resolveSlicePath needs the slice dir to exist to resolve, so this should return null
+    const result = writeBlockerPlaceholder("research-slice", "M001/S01", base, "test reason");
+    // Since the slice dir doesn't exist, resolveExpectedArtifactPath returns null
+    assertEq(result, null, "returns null when directory structure doesn't exist");
+  } finally {
+    cleanup(base);
+  }
+}
+
+{
+  console.log("\n=== writeBlockerPlaceholder: writes file for research-milestone ===");
+  const base = createFixtureBase();
+  try {
+    const result = writeBlockerPlaceholder("research-milestone", "M001", base, "hard timeout");
+    assert(result !== null, "should return relative path");
+    const absPath = resolveExpectedArtifactPath("research-milestone", "M001", base)!;
+    assert(existsSync(absPath), "file should exist on disk");
+    const content = readFileSync(absPath, "utf-8");
+    assert(content.includes("BLOCKER"), "should contain BLOCKER heading");
+    assert(content.includes("hard timeout"), "should contain the reason");
+  } finally {
+    cleanup(base);
+  }
+}
+
+{
+  console.log("\n=== writeBlockerPlaceholder: unknown type → null ===");
+  const base = createFixtureBase();
+  try {
+    const result = writeBlockerPlaceholder("execute-task", "M001/S01/T01", base, "test");
+    assertEq(result, null, "execute-task has no single artifact path, returns null");
+  } finally {
+    cleanup(base);
+  }
+}
+
+// ═══ skipExecuteTask ═════════════════════════════════════════════════════════
+
+{
+  console.log("\n=== skipExecuteTask: writes summary and checks plan checkbox ===");
+  const base = createFixtureBase();
+  try {
+    const planPath = join(base, ".gsd", "milestones", "M001", "slices", "S01", "S01-PLAN.md");
+    writeFileSync(planPath, [
+      "# S01: Test Slice",
+      "",
+      "## Tasks",
+      "",
+      "- [ ] **T01: First task** `est:10m`",
+      "  Do the first thing.",
+      "- [ ] **T02: Second task** `est:15m`",
+      "  Do the second thing.",
+    ].join("\n"), "utf-8");
+
+    const result = skipExecuteTask(
+      base, "M001", "S01", "T01",
+      { summaryExists: false, taskChecked: false },
+      "idle", 2,
+    );
+
+    assert(result === true, "should return true");
+
+    // Check summary was written
+    const summaryPath = join(base, ".gsd", "milestones", "M001", "slices", "S01", "tasks", "T01-SUMMARY.md");
+    assert(existsSync(summaryPath), "task summary should exist");
+    const summaryContent = readFileSync(summaryPath, "utf-8");
+    assert(summaryContent.includes("BLOCKER"), "summary should contain BLOCKER");
+    assert(summaryContent.includes("T01"), "summary should mention task ID");
+
+    // Check plan checkbox was marked
+    const planContent = readFileSync(planPath, "utf-8");
+    assert(planContent.includes("- [x] **T01:"), "T01 should be checked");
+    assert(planContent.includes("- [ ] **T02:"), "T02 should remain unchecked");
+  } finally {
+    cleanup(base);
+  }
+}
+
+{
+  console.log("\n=== skipExecuteTask: skips summary if already exists ===");
+  const base = createFixtureBase();
+  try {
+    const planPath = join(base, ".gsd", "milestones", "M001", "slices", "S01", "S01-PLAN.md");
+    writeFileSync(planPath, "- [ ] **T01: Task** `est:10m`\n", "utf-8");
+
+    // Pre-write a summary
+    const summaryPath = join(base, ".gsd", "milestones", "M001", "slices", "S01", "tasks", "T01-SUMMARY.md");
+    writeFileSync(summaryPath, "# Real summary\nActual work done.", "utf-8");
+
+    const result = skipExecuteTask(
+      base, "M001", "S01", "T01",
+      { summaryExists: true, taskChecked: false },
+      "idle", 2,
+    );
+
+    assert(result === true, "should return true");
+
+    // Summary should be untouched (not overwritten with blocker)
+    const content = readFileSync(summaryPath, "utf-8");
+    assert(content.includes("Real summary"), "original summary should be preserved");
+    assert(!content.includes("BLOCKER"), "should not contain BLOCKER");
+
+    // Plan checkbox should still be marked
+    const planContent = readFileSync(planPath, "utf-8");
+    assert(planContent.includes("- [x] **T01:"), "T01 should be checked");
+  } finally {
+    cleanup(base);
+  }
+}
+
+{
+  console.log("\n=== skipExecuteTask: skips checkbox if already checked ===");
+  const base = createFixtureBase();
+  try {
+    const planPath = join(base, ".gsd", "milestones", "M001", "slices", "S01", "S01-PLAN.md");
+    writeFileSync(planPath, "- [x] **T01: Task** `est:10m`\n", "utf-8");
+
+    const result = skipExecuteTask(
+      base, "M001", "S01", "T01",
+      { summaryExists: false, taskChecked: true },
+      "idle", 2,
+    );
+
+    assert(result === true, "should return true");
+
+    // Summary should be written (since summaryExists was false)
+    const summaryPath = join(base, ".gsd", "milestones", "M001", "slices", "S01", "tasks", "T01-SUMMARY.md");
+    assert(existsSync(summaryPath), "task summary should exist");
+
+    // Plan checkbox should be untouched
+    const planContent = readFileSync(planPath, "utf-8");
+    assert(planContent.includes("- [x] **T01:"), "T01 should remain checked");
+  } finally {
+    cleanup(base);
+  }
+}
+
+{
+  console.log("\n=== skipExecuteTask: handles special regex chars in task ID ===");
+  const base = createFixtureBase();
+  try {
+    const planPath = join(base, ".gsd", "milestones", "M001", "slices", "S01", "S01-PLAN.md");
+    writeFileSync(planPath, "- [ ] **T01.1: Sub-task** `est:10m`\n", "utf-8");
+
+    const result = skipExecuteTask(
+      base, "M001", "S01", "T01.1",
+      { summaryExists: false, taskChecked: false },
+      "idle", 2,
+    );
+
+    assert(result === true, "should return true");
+
+    const planContent = readFileSync(planPath, "utf-8");
+    assert(planContent.includes("- [x] **T01.1:"), "T01.1 should be checked (regex chars escaped)");
+  } finally {
+    cleanup(base);
+  }
+}
+
+// ═════════════════════════════════════════════════════════════════════════════
+// Results
+// ═════════════════════════════════════════════════════════════════════════════
+
+console.log(`\n${"=".repeat(40)}`);
+if (failed > 0) {
+  console.log(`Results: ${passed} passed, ${failed} failed`);
+  process.exit(1);
+} else {
+  console.log(`Results: ${passed} passed, ${failed} failed`);
+  console.log("All tests passed ✓");
+}

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

@@ -0,0 +1,201 @@
+/**
+ * Tests for GSD metrics disk I/O — init, snapshot, load/save cycle.
+ * Uses a temp directory to avoid touching real .gsd/ state.
+ */
+
+import { mkdtempSync, mkdirSync, readFileSync, rmSync } from "node:fs";
+import { join } from "node:path";
+import { tmpdir } from "node:os";
+import {
+  initMetrics,
+  resetMetrics,
+  getLedger,
+  snapshotUnitMetrics,
+  type MetricsLedger,
+} from "../metrics.js";
+
+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)}`);
+  }
+}
+
+// ─── Setup ────────────────────────────────────────────────────────────────────
+
+const tmpBase = mkdtempSync(join(tmpdir(), "gsd-metrics-test-"));
+mkdirSync(join(tmpBase, ".gsd"), { recursive: true });
+
+// Mock ExtensionContext with session entries
+function mockCtx(messages: any[] = []): any {
+  const entries = messages.map((msg, i) => ({
+    type: "message",
+    id: `entry-${i}`,
+    parentId: i > 0 ? `entry-${i - 1}` : null,
+    timestamp: new Date().toISOString(),
+    message: msg,
+  }));
+  return {
+    sessionManager: {
+      getEntries: () => entries,
+    },
+    model: { id: "claude-sonnet-4-20250514" },
+  };
+}
+
+// ─── Tests ────────────────────────────────────────────────────────────────────
+
+console.log("\n=== initMetrics / getLedger ===");
+
+{
+  resetMetrics();
+  assert(getLedger() === null, "ledger null before init");
+
+  initMetrics(tmpBase);
+  const ledger = getLedger();
+  assert(ledger !== null, "ledger not null after init");
+  assertEq(ledger!.version, 1, "version is 1");
+  assertEq(ledger!.units.length, 0, "no units initially");
+}
+
+console.log("\n=== snapshotUnitMetrics ===");
+
+{
+  resetMetrics();
+  initMetrics(tmpBase);
+
+  // Simulate a session with assistant messages containing usage data
+  const ctx = mockCtx([
+    { role: "user", content: "Do the thing" },
+    {
+      role: "assistant",
+      content: [
+        { type: "text", text: "I'll do the thing" },
+        { type: "tool_call", id: "tc1", name: "bash", input: {} },
+      ],
+      usage: {
+        input: 5000,
+        output: 2000,
+        cacheRead: 3000,
+        cacheWrite: 500,
+        totalTokens: 10500,
+        cost: { input: 0.015, output: 0.03, cacheRead: 0.003, cacheWrite: 0.002, total: 0.05 },
+      },
+    },
+    { role: "toolResult", toolCallId: "tc1", content: [{ type: "text", text: "ok" }] },
+    {
+      role: "assistant",
+      content: [{ type: "text", text: "Done!" }],
+      usage: {
+        input: 8000,
+        output: 1000,
+        cacheRead: 6000,
+        cacheWrite: 200,
+        totalTokens: 15200,
+        cost: { input: 0.024, output: 0.015, cacheRead: 0.006, cacheWrite: 0.001, total: 0.046 },
+      },
+    },
+  ]);
+
+  const unit = snapshotUnitMetrics(ctx, "execute-task", "M001/S01/T01", Date.now() - 5000, "claude-sonnet-4-20250514");
+
+  assert(unit !== null, "unit returned");
+  assertEq(unit!.type, "execute-task", "type");
+  assertEq(unit!.id, "M001/S01/T01", "id");
+  assertEq(unit!.tokens.input, 13000, "input tokens (5000+8000)");
+  assertEq(unit!.tokens.output, 3000, "output tokens (2000+1000)");
+  assertEq(unit!.tokens.cacheRead, 9000, "cacheRead (3000+6000)");
+  assertEq(unit!.tokens.total, 25700, "total tokens (10500+15200)");
+  assert(Math.abs(unit!.cost - 0.096) < 0.001, `cost ~0.096 (got ${unit!.cost})`);
+  assertEq(unit!.toolCalls, 1, "1 tool call");
+  assertEq(unit!.assistantMessages, 2, "2 assistant messages");
+  assertEq(unit!.userMessages, 1, "1 user message");
+
+  // Verify ledger persisted
+  const ledger = getLedger()!;
+  assertEq(ledger.units.length, 1, "1 unit in ledger");
+}
+
+console.log("\n=== Persistence across init/reset cycles ===");
+
+{
+  // Reset and re-init — should load from disk
+  resetMetrics();
+  initMetrics(tmpBase);
+
+  const ledger = getLedger()!;
+  assertEq(ledger.units.length, 1, "unit survived reset+init");
+  assertEq(ledger.units[0].id, "M001/S01/T01", "correct unit ID");
+
+  // Add another unit
+  const ctx = mockCtx([
+    {
+      role: "assistant",
+      content: [{ type: "text", text: "Research complete" }],
+      usage: {
+        input: 3000, output: 1500, cacheRead: 1000, cacheWrite: 300, totalTokens: 5800,
+        cost: { input: 0.009, output: 0.023, cacheRead: 0.001, cacheWrite: 0.001, total: 0.034 },
+      },
+    },
+  ]);
+
+  snapshotUnitMetrics(ctx, "research-slice", "M001/S02", Date.now() - 3000, "claude-sonnet-4-20250514");
+
+  // Verify both units persisted
+  resetMetrics();
+  initMetrics(tmpBase);
+  const final = getLedger()!;
+  assertEq(final.units.length, 2, "2 units after second snapshot");
+}
+
+console.log("\n=== File content verification ===");
+
+{
+  const raw = readFileSync(join(tmpBase, ".gsd", "metrics.json"), "utf-8");
+  const parsed: MetricsLedger = JSON.parse(raw);
+  assertEq(parsed.version, 1, "file version is 1");
+  assertEq(parsed.units.length, 2, "file has 2 units");
+  assert(parsed.projectStartedAt > 0, "projectStartedAt is set");
+}
+
+console.log("\n=== Empty session handling ===");
+
+{
+  resetMetrics();
+  initMetrics(tmpBase);
+
+  // Empty session — no messages
+  const ctx = mockCtx([]);
+  const unit = snapshotUnitMetrics(ctx, "plan-slice", "M001/S01", Date.now(), "test-model");
+  assert(unit === null, "returns null for empty session");
+
+  // Ledger shouldn't have grown
+  assertEq(getLedger()!.units.length, 2, "still 2 units (empty session not added)");
+}
+
+// ─── Cleanup ──────────────────────────────────────────────────────────────────
+
+resetMetrics();
+rmSync(tmpBase, { recursive: true, force: true });
+
+console.log(`\n${"=".repeat(40)}`);
+console.log(`Results: ${passed} passed, ${failed} failed`);
+if (failed > 0) {
+  process.exit(1);
+} else {
+  console.log("All tests passed ✓");
+}