gsd-pi 2.18.0 → 2.19.0

package/dist/resources/extensions/gsd/tests/triage-resolution.test.ts

@@ -0,0 +1,215 @@
+/**
+ * Unit tests for GSD Triage Resolution — resolution execution and file overlap detection.
+ */
+
+import test from "node:test";
+import assert from "node:assert/strict";
+import { mkdirSync, readFileSync, writeFileSync, rmSync, existsSync } from "node:fs";
+import { join } from "node:path";
+import { tmpdir } from "node:os";
+import { appendCapture, markCaptureResolved, loadAllCaptures } from "../captures.ts";
+// Import only the functions that don't depend on @gsd/pi-coding-agent
+// (triage-ui.ts imports next-action-ui.ts which imports the unavailable package)
+import { executeInject, executeReplan, detectFileOverlap, loadDeferredCaptures, loadReplanCaptures, buildQuickTaskPrompt } from "../triage-resolution.ts";
+
+function makeTempDir(prefix: string): string {
+  const dir = join(
+    tmpdir(),
+    `${prefix}-${Date.now()}-${Math.random().toString(36).slice(2)}`,
+  );
+  mkdirSync(dir, { recursive: true });
+  return dir;
+}
+
+function setupPlanFile(tmp: string, mid: string, sid: string, content: string): string {
+  const planDir = join(tmp, ".gsd", "milestones", mid, "slices", sid);
+  mkdirSync(planDir, { recursive: true });
+  const planPath = join(planDir, `${sid}-PLAN.md`);
+  writeFileSync(planPath, content, "utf-8");
+  return planPath;
+}
+
+const SAMPLE_PLAN = `# S01: Test Slice
+
+**Goal:** Test
+**Demo:** Test
+
+## Must-Haves
+
+- Something works
+
+## Tasks
+
+- [x] **T01: First task** \`est:1h\`
+  - Why: Setup
+  - Files: \`src/foo.ts\`, \`src/bar.ts\`
+  - Do: Build it
+  - Done when: Tests pass
+
+- [ ] **T02: Second task** \`est:1h\`
+  - Why: Feature
+  - Files: \`src/baz.ts\`, \`src/qux.ts\`
+  - Do: Build it
+  - Done when: Tests pass
+
+- [ ] **T03: Third task** \`est:30m\`
+  - Why: Polish
+  - Files: \`src/qux.ts\`, \`src/config.ts\`
+  - Do: Build it
+  - Done when: Tests pass
+
+## Files Likely Touched
+
+- \`src/foo.ts\`
+- \`src/bar.ts\`
+`;
+
+// ─── executeInject ────────────────────────────────────────────────────────────
+
+test("resolution: executeInject appends a new task to the plan", () => {
+  const tmp = makeTempDir("res-inject");
+  try {
+    const planPath = setupPlanFile(tmp, "M001", "S01", SAMPLE_PLAN);
+    const captureId = appendCapture(tmp, "add retry logic");
+    const captures = loadAllCaptures(tmp);
+    const capture = captures[0];
+
+    const newId = executeInject(tmp, "M001", "S01", capture);
+
+    assert.strictEqual(newId, "T04", "should be T04 (next after T03)");
+
+    const updated = readFileSync(planPath, "utf-8");
+    assert.ok(updated.includes("**T04:"), "should have T04 in plan");
+    assert.ok(updated.includes(capture.text), "should include capture text");
+    assert.ok(updated.includes("## Files Likely Touched"), "should preserve files section");
+
+    // T04 should appear before Files Likely Touched
+    const t04Pos = updated.indexOf("**T04:");
+    const filesPos = updated.indexOf("## Files Likely Touched");
+    assert.ok(t04Pos < filesPos, "T04 should be before Files section");
+  } finally {
+    rmSync(tmp, { recursive: true, force: true });
+  }
+});
+
+test("resolution: executeInject returns null when plan doesn't exist", () => {
+  const tmp = makeTempDir("res-inject-noplan");
+  try {
+    const captureId = appendCapture(tmp, "some task");
+    const captures = loadAllCaptures(tmp);
+    const result = executeInject(tmp, "M001", "S01", captures[0]);
+    assert.strictEqual(result, null);
+  } finally {
+    rmSync(tmp, { recursive: true, force: true });
+  }
+});
+
+// ─── executeReplan ────────────────────────────────────────────────────────────
+
+test("resolution: executeReplan writes REPLAN-TRIGGER.md", () => {
+  const tmp = makeTempDir("res-replan");
+  try {
+    setupPlanFile(tmp, "M001", "S01", SAMPLE_PLAN);
+    const captureId = appendCapture(tmp, "approach is wrong, need different strategy");
+    const captures = loadAllCaptures(tmp);
+    const capture = captures[0];
+
+    const result = executeReplan(tmp, "M001", "S01", capture);
+    assert.strictEqual(result, true);
+
+    const triggerPath = join(
+      tmp, ".gsd", "milestones", "M001", "slices", "S01", "S01-REPLAN-TRIGGER.md",
+    );
+    assert.ok(existsSync(triggerPath), "trigger file should exist");
+
+    const content = readFileSync(triggerPath, "utf-8");
+    assert.ok(content.includes(capture.id), "should include capture ID");
+    assert.ok(content.includes(capture.text), "should include capture text");
+    assert.ok(content.includes("# Replan Trigger"), "should have header");
+  } finally {
+    rmSync(tmp, { recursive: true, force: true });
+  }
+});
+
+// ─── detectFileOverlap ───────────────────────────────────────────────────────
+
+test("resolution: detectFileOverlap finds overlapping incomplete tasks", () => {
+  const overlaps = detectFileOverlap(["src/qux.ts"], SAMPLE_PLAN);
+  assert.deepStrictEqual(overlaps, ["T02", "T03"]);
+});
+
+test("resolution: detectFileOverlap ignores completed tasks", () => {
+  // T01 is [x] and uses src/foo.ts — should NOT be returned
+  const overlaps = detectFileOverlap(["src/foo.ts"], SAMPLE_PLAN);
+  assert.deepStrictEqual(overlaps, []);
+});
+
+test("resolution: detectFileOverlap returns empty when no overlap", () => {
+  const overlaps = detectFileOverlap(["src/unrelated.ts"], SAMPLE_PLAN);
+  assert.deepStrictEqual(overlaps, []);
+});
+
+test("resolution: detectFileOverlap returns empty for empty affected files", () => {
+  assert.deepStrictEqual(detectFileOverlap([], SAMPLE_PLAN), []);
+});
+
+test("resolution: detectFileOverlap is case-insensitive", () => {
+  const overlaps = detectFileOverlap(["SRC/QUX.TS"], SAMPLE_PLAN);
+  assert.deepStrictEqual(overlaps, ["T02", "T03"]);
+});
+
+// ─── loadDeferredCaptures / loadReplanCaptures ───────────────────────────────
+
+test("resolution: loadDeferredCaptures returns only deferred captures", () => {
+  const tmp = makeTempDir("res-deferred");
+  try {
+    const id1 = appendCapture(tmp, "deferred one");
+    const id2 = appendCapture(tmp, "note one");
+    const id3 = appendCapture(tmp, "deferred two");
+
+    markCaptureResolved(tmp, id1, "defer", "deferred to S03", "future work");
+    markCaptureResolved(tmp, id2, "note", "acknowledged", "just a note");
+    markCaptureResolved(tmp, id3, "defer", "deferred to S04", "later");
+
+    const deferred = loadDeferredCaptures(tmp);
+    assert.strictEqual(deferred.length, 2);
+    assert.strictEqual(deferred[0].id, id1);
+    assert.strictEqual(deferred[1].id, id3);
+  } finally {
+    rmSync(tmp, { recursive: true, force: true });
+  }
+});
+
+test("resolution: loadReplanCaptures returns only replan captures", () => {
+  const tmp = makeTempDir("res-replan-load");
+  try {
+    const id1 = appendCapture(tmp, "needs replan");
+    const id2 = appendCapture(tmp, "just a note");
+
+    markCaptureResolved(tmp, id1, "replan", "replan triggered", "approach changed");
+    markCaptureResolved(tmp, id2, "note", "acknowledged", "info only");
+
+    const replans = loadReplanCaptures(tmp);
+    assert.strictEqual(replans.length, 1);
+    assert.strictEqual(replans[0].id, id1);
+  } finally {
+    rmSync(tmp, { recursive: true, force: true });
+  }
+});
+
+// ─── buildQuickTaskPrompt ────────────────────────────────────────────────────
+
+test("resolution: buildQuickTaskPrompt includes capture text and ID", () => {
+  const prompt = buildQuickTaskPrompt({
+    id: "CAP-abc123",
+    text: "add retry logic to OAuth",
+    timestamp: "2026-03-15T20:00:00Z",
+    status: "resolved",
+    classification: "quick-task",
+  });
+
+  assert.ok(prompt.includes("CAP-abc123"), "should include capture ID");
+  assert.ok(prompt.includes("add retry logic to OAuth"), "should include capture text");
+  assert.ok(prompt.includes("Quick Task"), "should have Quick Task header");
+  assert.ok(prompt.includes("Do NOT modify"), "should warn about plan files");
+});

package/dist/resources/extensions/gsd/tests/visualizer-data.test.ts

@@ -0,0 +1,198 @@
+// Tests for GSD visualizer data loader.
+// Verifies the VisualizerData interface shape and source-file contracts.
+
+import { readFileSync } from "node:fs";
+import { join, dirname } from "node:path";
+import { fileURLToPath } from "node:url";
+import { createTestContext } from "./test-helpers.ts";
+
+const __dirname = dirname(fileURLToPath(import.meta.url));
+const { assertTrue, report } = createTestContext();
+
+const dataPath = join(__dirname, "..", "visualizer-data.ts");
+const dataSrc = readFileSync(dataPath, "utf-8");
+
+console.log("\n=== visualizer-data.ts source contracts ===");
+
+// Interface exports
+assertTrue(
+  dataSrc.includes("export interface VisualizerData"),
+  "exports VisualizerData interface",
+);
+
+assertTrue(
+  dataSrc.includes("export interface VisualizerMilestone"),
+  "exports VisualizerMilestone interface",
+);
+
+assertTrue(
+  dataSrc.includes("export interface VisualizerSlice"),
+  "exports VisualizerSlice interface",
+);
+
+assertTrue(
+  dataSrc.includes("export interface VisualizerTask"),
+  "exports VisualizerTask interface",
+);
+
+// Function export
+assertTrue(
+  dataSrc.includes("export async function loadVisualizerData"),
+  "exports loadVisualizerData function",
+);
+
+// Data source usage
+assertTrue(
+  dataSrc.includes("deriveState"),
+  "uses deriveState for state derivation",
+);
+
+assertTrue(
+  dataSrc.includes("findMilestoneIds"),
+  "uses findMilestoneIds to enumerate milestones",
+);
+
+assertTrue(
+  dataSrc.includes("parseRoadmap"),
+  "uses parseRoadmap for roadmap parsing",
+);
+
+assertTrue(
+  dataSrc.includes("parsePlan"),
+  "uses parsePlan for plan parsing",
+);
+
+assertTrue(
+  dataSrc.includes("getLedger"),
+  "uses getLedger for in-memory metrics",
+);
+
+assertTrue(
+  dataSrc.includes("loadLedgerFromDisk"),
+  "uses loadLedgerFromDisk as fallback",
+);
+
+assertTrue(
+  dataSrc.includes("getProjectTotals"),
+  "uses getProjectTotals for aggregation",
+);
+
+assertTrue(
+  dataSrc.includes("aggregateByPhase"),
+  "uses aggregateByPhase",
+);
+
+assertTrue(
+  dataSrc.includes("aggregateBySlice"),
+  "uses aggregateBySlice",
+);
+
+assertTrue(
+  dataSrc.includes("aggregateByModel"),
+  "uses aggregateByModel",
+);
+
+// Interface fields
+assertTrue(
+  dataSrc.includes("dependsOn: string[]"),
+  "VisualizerMilestone has dependsOn field",
+);
+
+assertTrue(
+  dataSrc.includes("depends: string[]"),
+  "VisualizerSlice has depends field",
+);
+
+assertTrue(
+  dataSrc.includes("totals: ProjectTotals | null"),
+  "VisualizerData has nullable totals",
+);
+
+assertTrue(
+  dataSrc.includes("units: UnitMetrics[]"),
+  "VisualizerData has units array",
+);
+
+// Verify overlay source exists and imports data module
+const overlayPath = join(__dirname, "..", "visualizer-overlay.ts");
+const overlaySrc = readFileSync(overlayPath, "utf-8");
+
+console.log("\n=== visualizer-overlay.ts source contracts ===");
+
+assertTrue(
+  overlaySrc.includes("export class GSDVisualizerOverlay"),
+  "exports GSDVisualizerOverlay class",
+);
+
+assertTrue(
+  overlaySrc.includes("loadVisualizerData"),
+  "overlay uses loadVisualizerData",
+);
+
+assertTrue(
+  overlaySrc.includes("renderProgressView"),
+  "overlay delegates to renderProgressView",
+);
+
+assertTrue(
+  overlaySrc.includes("renderDepsView"),
+  "overlay delegates to renderDepsView",
+);
+
+assertTrue(
+  overlaySrc.includes("renderMetricsView"),
+  "overlay delegates to renderMetricsView",
+);
+
+assertTrue(
+  overlaySrc.includes("renderTimelineView"),
+  "overlay delegates to renderTimelineView",
+);
+
+assertTrue(
+  overlaySrc.includes("handleInput"),
+  "overlay has handleInput method",
+);
+
+assertTrue(
+  overlaySrc.includes("dispose"),
+  "overlay has dispose method",
+);
+
+assertTrue(
+  overlaySrc.includes("wrapInBox"),
+  "overlay has wrapInBox helper",
+);
+
+assertTrue(
+  overlaySrc.includes("activeTab"),
+  "overlay tracks active tab",
+);
+
+assertTrue(
+  overlaySrc.includes("scrollOffsets"),
+  "overlay tracks per-tab scroll offsets",
+);
+
+// Verify commands.ts integration
+const commandsPath = join(__dirname, "..", "commands.ts");
+const commandsSrc = readFileSync(commandsPath, "utf-8");
+
+console.log("\n=== commands.ts integration ===");
+
+assertTrue(
+  commandsSrc.includes('"visualize"'),
+  "commands.ts has visualize in subcommands array",
+);
+
+assertTrue(
+  commandsSrc.includes("GSDVisualizerOverlay"),
+  "commands.ts imports GSDVisualizerOverlay",
+);
+
+assertTrue(
+  commandsSrc.includes("handleVisualize"),
+  "commands.ts has handleVisualize handler",
+);
+
+report();

package/dist/resources/extensions/gsd/tests/visualizer-views.test.ts

@@ -0,0 +1,255 @@
+// Tests for GSD visualizer view renderers.
+// Tests the pure view functions with mock data — no file I/O.
+
+import {
+  renderProgressView,
+  renderDepsView,
+  renderMetricsView,
+  renderTimelineView,
+} from "../visualizer-views.js";
+import type { VisualizerData } from "../visualizer-data.js";
+import { createTestContext } from "./test-helpers.ts";
+
+const { assertEq, assertTrue, report } = createTestContext();
+
+// ─── Mock theme ─────────────────────────────────────────────────────────────
+
+const mockTheme = {
+  fg: (_color: string, text: string) => text,
+  bold: (text: string) => text,
+} as any;
+
+// ─── Test data factories ────────────────────────────────────────────────────
+
+function makeVisualizerData(overrides: Partial<VisualizerData> = {}): VisualizerData {
+  return {
+    milestones: [],
+    phase: "executing",
+    totals: null,
+    byPhase: [],
+    bySlice: [],
+    byModel: [],
+    units: [],
+    ...overrides,
+  };
+}
+
+// ─── renderProgressView ─────────────────────────────────────────────────────
+
+console.log("\n=== renderProgressView ===");
+
+{
+  const data = makeVisualizerData({
+    milestones: [
+      {
+        id: "M001",
+        title: "First Milestone",
+        status: "active",
+        dependsOn: [],
+        slices: [
+          {
+            id: "S01",
+            title: "Core Types",
+            done: true,
+            active: false,
+            risk: "low",
+            depends: [],
+            tasks: [],
+          },
+          {
+            id: "S02",
+            title: "State Engine",
+            done: false,
+            active: true,
+            risk: "high",
+            depends: ["S01"],
+            tasks: [
+              { id: "T01", title: "Dispatch Loop", done: false, active: true },
+              { id: "T02", title: "Session Mgmt", done: true, active: false },
+            ],
+          },
+          {
+            id: "S03",
+            title: "Dashboard",
+            done: false,
+            active: false,
+            risk: "medium",
+            depends: ["S02"],
+            tasks: [],
+          },
+        ],
+      },
+      {
+        id: "M002",
+        title: "Plugin Arch",
+        status: "pending",
+        dependsOn: ["M001"],
+        slices: [],
+      },
+    ],
+  });
+
+  const lines = renderProgressView(data, mockTheme, 80);
+  assertTrue(lines.length > 0, "progress view produces output");
+  assertTrue(lines.some(l => l.includes("M001")), "shows milestone M001");
+  assertTrue(lines.some(l => l.includes("S01")), "shows slice S01");
+  assertTrue(lines.some(l => l.includes("T01")), "shows task T01 for active slice");
+  assertTrue(lines.some(l => l.includes("M002")), "shows milestone M002");
+  assertTrue(lines.some(l => l.includes("depends on M001")), "shows dependency note");
+}
+
+{
+  const data = makeVisualizerData({ milestones: [] });
+  const lines = renderProgressView(data, mockTheme, 80);
+  assertEq(lines.length, 0, "empty milestones produce no lines");
+}
+
+// ─── renderDepsView ─────────────────────────────────────────────────────────
+
+console.log("\n=== renderDepsView ===");
+
+{
+  const data = makeVisualizerData({
+    milestones: [
+      {
+        id: "M001",
+        title: "First",
+        status: "active",
+        dependsOn: [],
+        slices: [
+          { id: "S01", title: "A", done: false, active: true, risk: "low", depends: [], tasks: [] },
+          { id: "S02", title: "B", done: false, active: false, risk: "low", depends: ["S01"], tasks: [] },
+        ],
+      },
+      {
+        id: "M002",
+        title: "Second",
+        status: "pending",
+        dependsOn: ["M001"],
+        slices: [],
+      },
+    ],
+  });
+
+  const lines = renderDepsView(data, mockTheme, 80);
+  assertTrue(lines.length > 0, "deps view produces output");
+  assertTrue(lines.some(l => l.includes("M001") && l.includes("M002")), "shows milestone dep edge");
+  assertTrue(lines.some(l => l.includes("S01") && l.includes("S02")), "shows slice dep edge");
+}
+
+{
+  const data = makeVisualizerData({
+    milestones: [
+      { id: "M001", title: "Only", status: "active", dependsOn: [], slices: [] },
+    ],
+  });
+
+  const lines = renderDepsView(data, mockTheme, 80);
+  assertTrue(lines.some(l => l.includes("No milestone dependencies")), "shows no-deps message");
+}
+
+// ─── renderMetricsView ──────────────────────────────────────────────────────
+
+console.log("\n=== renderMetricsView ===");
+
+{
+  const data = makeVisualizerData({
+    totals: {
+      units: 5,
+      tokens: { input: 1000, output: 500, cacheRead: 200, cacheWrite: 100, total: 1800 },
+      cost: 2.50,
+      duration: 60000,
+      toolCalls: 15,
+      assistantMessages: 10,
+      userMessages: 5,
+    },
+    byPhase: [
+      {
+        phase: "execution",
+        units: 3,
+        tokens: { input: 600, output: 300, cacheRead: 100, cacheWrite: 50, total: 1050 },
+        cost: 1.50,
+        duration: 40000,
+      },
+      {
+        phase: "planning",
+        units: 2,
+        tokens: { input: 400, output: 200, cacheRead: 100, cacheWrite: 50, total: 750 },
+        cost: 1.00,
+        duration: 20000,
+      },
+    ],
+    byModel: [
+      {
+        model: "claude-opus-4-6",
+        units: 5,
+        tokens: { input: 1000, output: 500, cacheRead: 200, cacheWrite: 100, total: 1800 },
+        cost: 2.50,
+      },
+    ],
+  });
+
+  const lines = renderMetricsView(data, mockTheme, 80);
+  assertTrue(lines.length > 0, "metrics view produces output");
+  assertTrue(lines.some(l => l.includes("$2.50")), "shows total cost");
+  assertTrue(lines.some(l => l.includes("execution")), "shows phase name");
+  assertTrue(lines.some(l => l.includes("claude-opus-4-6")), "shows model name");
+}
+
+{
+  const data = makeVisualizerData({ totals: null });
+  const lines = renderMetricsView(data, mockTheme, 80);
+  assertTrue(lines.some(l => l.includes("No metrics data")), "shows no-data message");
+}
+
+// ─── renderTimelineView ─────────────────────────────────────────────────────
+
+console.log("\n=== renderTimelineView ===");
+
+{
+  const now = Date.now();
+  const data = makeVisualizerData({
+    units: [
+      {
+        type: "execute-task",
+        id: "M001/S01/T01",
+        model: "claude-opus-4-6",
+        startedAt: now - 120000,
+        finishedAt: now - 60000,
+        tokens: { input: 500, output: 200, cacheRead: 100, cacheWrite: 50, total: 850 },
+        cost: 0.42,
+        toolCalls: 5,
+        assistantMessages: 3,
+        userMessages: 1,
+      },
+      {
+        type: "plan-slice",
+        id: "M001/S02",
+        model: "claude-opus-4-6",
+        startedAt: now - 60000,
+        finishedAt: now - 30000,
+        tokens: { input: 300, output: 150, cacheRead: 50, cacheWrite: 25, total: 525 },
+        cost: 0.18,
+        toolCalls: 2,
+        assistantMessages: 2,
+        userMessages: 1,
+      },
+    ],
+  });
+
+  const lines = renderTimelineView(data, mockTheme, 80);
+  assertTrue(lines.length >= 2, "timeline view produces lines for each unit");
+  assertTrue(lines.some(l => l.includes("execute-task")), "shows unit type");
+  assertTrue(lines.some(l => l.includes("M001/S01/T01")), "shows unit id");
+  assertTrue(lines.some(l => l.includes("$0.42")), "shows unit cost");
+}
+
+{
+  const data = makeVisualizerData({ units: [] });
+  const lines = renderTimelineView(data, mockTheme, 80);
+  assertTrue(lines.some(l => l.includes("No execution history")), "shows empty message");
+}
+
+// ─── Report ─────────────────────────────────────────────────────────────────
+
+report();