gsd-pi 2.17.0 → 2.19.0

package/src/resources/extensions/gsd/tests/triage-dispatch.test.ts

@@ -0,0 +1,224 @@
+/**
+ * Triage dispatch ordering contract tests.
+ *
+ * These tests verify structural invariants of the triage integration
+ * by inspecting the actual source code of auto.ts and post-unit-hooks.ts.
+ * Full behavioral testing requires the @gsd/pi-coding-agent runtime.
+ */
+
+import test from "node:test";
+import assert from "node:assert/strict";
+import { readFileSync } from "node:fs";
+import { join, dirname } from "node:path";
+import { fileURLToPath } from "node:url";
+
+const __dirname = dirname(fileURLToPath(import.meta.url));
+const autoPath = join(__dirname, "..", "auto.ts");
+const hooksPath = join(__dirname, "..", "post-unit-hooks.ts");
+const autoPromptsPath = join(__dirname, "..", "auto-prompts.ts");
+
+const autoSrc = readFileSync(autoPath, "utf-8");
+const hooksSrc = readFileSync(hooksPath, "utf-8");
+const autoPromptsSrc = (() => { try { return readFileSync(autoPromptsPath, "utf-8"); } catch { return autoSrc; } })();
+
+// ─── Hook exclusion ──────────────────────────────────────────────────────────
+
+test("dispatch: triage-captures excluded from post-unit hook triggering", () => {
+  // post-unit-hooks.ts must return null for triage-captures unit type
+  assert.ok(
+    hooksSrc.includes('"triage-captures"'),
+    "post-unit-hooks.ts should reference triage-captures",
+  );
+  assert.ok(
+    hooksSrc.includes('completedUnitType === "triage-captures"'),
+    "should check for triage-captures in the hook exclusion guard",
+  );
+});
+
+// ─── Triage check placement ──────────────────────────────────────────────────
+
+test("dispatch: triage check appears after hook section and before stepMode check", () => {
+  const hookRetryIndex = autoSrc.indexOf("isRetryPending()");
+  // Find the triage check in handleAgentEnd (not in getAutoDashboardData)
+  const triageCheckIndex = autoSrc.indexOf("Triage check: dispatch triage unit");
+  const stepModeIndex = autoSrc.indexOf("In step mode, pause and show a wizard");
+
+  assert.ok(hookRetryIndex > 0, "hook retry check should exist");
+  assert.ok(triageCheckIndex > 0, "triage check block should exist");
+  assert.ok(stepModeIndex > 0, "step mode check should exist");
+
+  assert.ok(
+    triageCheckIndex > hookRetryIndex,
+    "triage check should come after hook retry check",
+  );
+  assert.ok(
+    triageCheckIndex < stepModeIndex,
+    "triage check should come before stepMode check",
+  );
+});
+
+// ─── Guard conditions ────────────────────────────────────────────────────────
+
+test("dispatch: triage check guards against step mode", () => {
+  // The triage block should check !stepMode
+  const triageBlock = autoSrc.slice(
+    autoSrc.indexOf("Triage check: dispatch triage unit"),
+    autoSrc.indexOf("In step mode, pause and show a wizard"),
+  );
+  assert.ok(
+    triageBlock.includes("!stepMode"),
+    "triage block should guard against step mode",
+  );
+});
+
+test("dispatch: triage check guards against hook unit types", () => {
+  const triageBlock = autoSrc.slice(
+    autoSrc.indexOf("Triage check: dispatch triage unit"),
+    autoSrc.indexOf("In step mode, pause and show a wizard"),
+  );
+  assert.ok(
+    triageBlock.includes('!currentUnit.type.startsWith("hook/")'),
+    "triage block should not fire for hook units",
+  );
+});
+
+test("dispatch: triage check guards against triage-on-triage", () => {
+  const triageBlock = autoSrc.slice(
+    autoSrc.indexOf("Triage check: dispatch triage unit"),
+    autoSrc.indexOf("In step mode, pause and show a wizard"),
+  );
+  assert.ok(
+    triageBlock.includes('currentUnit.type !== "triage-captures"'),
+    "triage block should not fire for triage units",
+  );
+});
+
+test("dispatch: triage check guards against quick-task triggering triage", () => {
+  const triageBlock = autoSrc.slice(
+    autoSrc.indexOf("Triage check: dispatch triage unit"),
+    autoSrc.indexOf("In step mode, pause and show a wizard"),
+  );
+  assert.ok(
+    triageBlock.includes('currentUnit.type !== "quick-task"'),
+    "triage block should not fire for quick-task units",
+  );
+});
+
+test("dispatch: triage dispatch uses early-return pattern", () => {
+  const triageBlock = autoSrc.slice(
+    autoSrc.indexOf("Triage check: dispatch triage unit"),
+    autoSrc.indexOf("In step mode, pause and show a wizard"),
+  );
+  assert.ok(
+    triageBlock.includes("return; // handleAgentEnd will fire again"),
+    "triage dispatch should return after sending message",
+  );
+});
+
+test("dispatch: triage imports hasPendingCaptures and loadPendingCaptures", () => {
+  assert.ok(
+    autoSrc.includes('hasPendingCaptures, loadPendingCaptures, countPendingCaptures') &&
+    autoSrc.includes('from "./captures.js"'),
+    "auto.ts should import capture functions including countPendingCaptures",
+  );
+});
+
+// ─── Prompt integration ──────────────────────────────────────────────────────
+
+test("dispatch: replan prompt builder loads capture context", () => {
+  const src = autoPromptsSrc;
+  assert.ok(
+    src.includes("loadReplanCaptures"),
+    "buildReplanSlicePrompt should load replan captures",
+  );
+  assert.ok(
+    src.includes("captureContext"),
+    "buildReplanSlicePrompt should pass captureContext to template",
+  );
+});
+
+test("dispatch: reassess prompt builder loads deferred captures", () => {
+  const src = autoPromptsSrc;
+  assert.ok(
+    src.includes("loadDeferredCaptures"),
+    "buildReassessRoadmapPrompt should load deferred captures",
+  );
+  assert.ok(
+    src.includes("deferredCaptures"),
+    "buildReassessRoadmapPrompt should pass deferredCaptures to template",
+  );
+});
+
+// ─── Prompt templates ────────────────────────────────────────────────────────
+
+test("dispatch: replan prompt template includes captureContext variable", () => {
+  const promptPath = join(__dirname, "..", "prompts", "replan-slice.md");
+  const prompt = readFileSync(promptPath, "utf-8");
+  assert.ok(
+    prompt.includes("{{captureContext}}"),
+    "replan-slice.md should include {{captureContext}}",
+  );
+});
+
+test("dispatch: reassess prompt template includes deferredCaptures variable", () => {
+  const promptPath = join(__dirname, "..", "prompts", "reassess-roadmap.md");
+  const prompt = readFileSync(promptPath, "utf-8");
+  assert.ok(
+    prompt.includes("{{deferredCaptures}}"),
+    "reassess-roadmap.md should include {{deferredCaptures}}",
+  );
+});
+
+test("dispatch: triage prompt template exists and has classification criteria", () => {
+  const promptPath = join(__dirname, "..", "prompts", "triage-captures.md");
+  const prompt = readFileSync(promptPath, "utf-8");
+  assert.ok(prompt.includes("quick-task"), "should have quick-task classification");
+  assert.ok(prompt.includes("inject"), "should have inject classification");
+  assert.ok(prompt.includes("defer"), "should have defer classification");
+  assert.ok(prompt.includes("replan"), "should have replan classification");
+  assert.ok(prompt.includes("note"), "should have note classification");
+  assert.ok(prompt.includes("{{pendingCaptures}}"), "should have pending captures variable");
+});
+
+// ─── Dashboard integration ───────────────────────────────────────────────────
+
+test("dashboard: AutoDashboardData includes pendingCaptureCount field", () => {
+  assert.ok(
+    autoSrc.includes("pendingCaptureCount"),
+    "auto.ts should have pendingCaptureCount in AutoDashboardData",
+  );
+});
+
+test("dashboard: getAutoDashboardData computes pendingCaptureCount", () => {
+  assert.ok(
+    autoSrc.includes("pendingCaptureCount = countPendingCaptures") ||
+    autoSrc.includes("pendingCaptureCount = countPendingCaptures(basePath)"),
+    "getAutoDashboardData should compute pendingCaptureCount from countPendingCaptures (single-read)",
+  );
+});
+
+test("dashboard: overlay renders pending captures badge", () => {
+  const overlayPath = join(__dirname, "..", "dashboard-overlay.ts");
+  const overlaySrc = readFileSync(overlayPath, "utf-8");
+  assert.ok(
+    overlaySrc.includes("pendingCaptureCount"),
+    "dashboard-overlay.ts should reference pendingCaptureCount",
+  );
+  assert.ok(
+    overlaySrc.includes("pending capture"),
+    "dashboard-overlay.ts should show pending captures text",
+  );
+});
+
+test("dashboard: overlay labels triage-captures and quick-task unit types", () => {
+  const overlayPath = join(__dirname, "..", "dashboard-overlay.ts");
+  const overlaySrc = readFileSync(overlayPath, "utf-8");
+  assert.ok(
+    overlaySrc.includes('"triage-captures"'),
+    "unitLabel should handle triage-captures",
+  );
+  assert.ok(
+    overlaySrc.includes('"quick-task"'),
+    "unitLabel should handle quick-task",
+  );
+});

package/src/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/src/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();