gsd-pi 2.17.0 → 2.19.0

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

package/src/resources/extensions/gsd/triage-resolution.ts

@@ -0,0 +1,200 @@
+/**
+ * GSD Triage Resolution — Execute triage classifications
+ *
+ * Provides resolution executors for each capture classification type:
+ *
+ * - inject: appends a new task to the current slice plan
+ * - replan: writes REPLAN-TRIGGER.md so next dispatchNextUnit enters replanning-slice
+ * - defer/note: query helpers for loading deferred/replan captures
+ *
+ * Also provides detectFileOverlap() for surfacing downstream impact on quick tasks.
+ */
+
+import { existsSync, readFileSync, writeFileSync } from "node:fs";
+import { join } from "node:path";
+import type { Classification, CaptureEntry } from "./captures.js";
+import {
+  loadPendingCaptures,
+  loadAllCaptures,
+  markCaptureResolved,
+} from "./captures.js";
+
+// ─── Resolution Executors ─────────────────────────────────────────────────────
+
+/**
+ * Inject a new task into the current slice plan.
+ * Reads the plan, finds the highest task ID, appends a new task entry.
+ * Returns the new task ID, or null if injection failed.
+ */
+export function executeInject(
+  basePath: string,
+  mid: string,
+  sid: string,
+  capture: CaptureEntry,
+): string | null {
+  try {
+    // Resolve the plan file path
+    const planPath = join(basePath, ".gsd", "milestones", mid, "slices", sid, `${sid}-PLAN.md`);
+    if (!existsSync(planPath)) return null;
+
+    const content = readFileSync(planPath, "utf-8");
+
+    // Find the highest existing task ID
+    const taskMatches = [...content.matchAll(/- \[[ x]\] \*\*T(\d+):/g)];
+    if (taskMatches.length === 0) return null;
+
+    const maxId = Math.max(...taskMatches.map(m => parseInt(m[1], 10)));
+    const newId = `T${String(maxId + 1).padStart(2, "0")}`;
+
+    // Build the new task entry
+    const newTask = [
+      `- [ ] **${newId}: ${capture.text}** \`est:30m\``,
+      `  - Why: Injected from capture ${capture.id} during triage`,
+      `  - Do: ${capture.text}`,
+      `  - Done when: Capture intent fulfilled`,
+    ].join("\n");
+
+    // Find the last task entry and append after it
+    // Look for the "## Files Likely Touched" section as the boundary
+    const filesSection = content.indexOf("## Files Likely Touched");
+    if (filesSection !== -1) {
+      const updated = content.slice(0, filesSection) + newTask + "\n\n" + content.slice(filesSection);
+      writeFileSync(planPath, updated, "utf-8");
+    } else {
+      // No Files section — append at end
+      writeFileSync(planPath, content.trimEnd() + "\n\n" + newTask + "\n", "utf-8");
+    }
+
+    return newId;
+  } catch {
+    return null;
+  }
+}
+
+/**
+ * Trigger replanning by writing a REPLAN-TRIGGER.md marker file.
+ * The existing state.ts derivation detects this and sets phase to "replanning-slice".
+ * Returns true if the trigger was written successfully.
+ */
+export function executeReplan(
+  basePath: string,
+  mid: string,
+  sid: string,
+  capture: CaptureEntry,
+): boolean {
+  try {
+    const triggerPath = join(
+      basePath, ".gsd", "milestones", mid, "slices", sid, `${sid}-REPLAN-TRIGGER.md`,
+    );
+    const content = [
+      `# Replan Trigger`,
+      ``,
+      `**Source:** Capture ${capture.id}`,
+      `**Capture:** ${capture.text}`,
+      `**Rationale:** ${capture.rationale ?? "User-initiated replan via capture triage"}`,
+      `**Triggered:** ${new Date().toISOString()}`,
+      ``,
+      `This file was created by the triage pipeline. The next dispatch cycle`,
+      `will detect it and enter the replanning-slice phase.`,
+    ].join("\n");
+
+    writeFileSync(triggerPath, content, "utf-8");
+    return true;
+  } catch {
+    return false;
+  }
+}
+
+// ─── File Overlap Detection ───────────────────────────────────────────────────
+
+/**
+ * Detect file overlap between a capture's affected files and planned tasks.
+ *
+ * Parses the slice plan for task file references and returns task IDs
+ * whose files overlap with the capture's affected files.
+ *
+ * @param affectedFiles - Files the capture would touch
+ * @param planContent - Content of the slice plan.md
+ * @returns Array of task IDs (e.g., ["T03", "T04"]) whose files overlap
+ */
+export function detectFileOverlap(
+  affectedFiles: string[],
+  planContent: string,
+): string[] {
+  if (!affectedFiles || affectedFiles.length === 0) return [];
+
+  const overlappingTasks: string[] = [];
+
+  // Normalize affected files for comparison
+  const normalizedAffected = new Set(
+    affectedFiles.map(f => f.replace(/^\.\//, "").toLowerCase()),
+  );
+
+  // Parse plan for incomplete tasks and their file references
+  const taskPattern = /- \[ \] \*\*(T\d+):[^*]*\*\*/g;
+  const tasks = [...planContent.matchAll(taskPattern)];
+
+  for (const taskMatch of tasks) {
+    const taskId = taskMatch[1];
+    const taskStart = taskMatch.index!;
+
+    // Find the end of this task (next task or end of section)
+    const nextTask = planContent.indexOf("- [", taskStart + 1);
+    const sectionEnd = planContent.indexOf("##", taskStart + 1);
+    const taskEnd = Math.min(
+      nextTask === -1 ? planContent.length : nextTask,
+      sectionEnd === -1 ? planContent.length : sectionEnd,
+    );
+
+    const taskContent = planContent.slice(taskStart, taskEnd);
+
+    // Extract file references — look for backtick-quoted paths
+    const fileRefs = [...taskContent.matchAll(/`([^`]+\.[a-z]+)`/g)]
+      .map(m => m[1].replace(/^\.\//, "").toLowerCase());
+
+    // Check for overlap
+    const hasOverlap = fileRefs.some(f => normalizedAffected.has(f));
+    if (hasOverlap) {
+      overlappingTasks.push(taskId);
+    }
+  }
+
+  return overlappingTasks;
+}
+
+/**
+ * Load deferred captures (classification === "defer") for injection into
+ * reassess-roadmap prompts.
+ */
+export function loadDeferredCaptures(basePath: string): CaptureEntry[] {
+  return loadAllCaptures(basePath).filter(c => c.classification === "defer");
+}
+
+/**
+ * Load replan-triggering captures for injection into replan-slice prompts.
+ */
+export function loadReplanCaptures(basePath: string): CaptureEntry[] {
+  return loadAllCaptures(basePath).filter(c => c.classification === "replan");
+}
+
+/**
+ * Build a quick-task execution prompt from a capture.
+ */
+export function buildQuickTaskPrompt(capture: CaptureEntry): string {
+  return [
+    `You are executing a quick one-off task captured during a GSD auto-mode session.`,
+    ``,
+    `## Quick Task`,
+    ``,
+    `**Capture ID:** ${capture.id}`,
+    `**Task:** ${capture.text}`,
+    ``,
+    `## Instructions`,
+    ``,
+    `1. Execute this task as a small, self-contained change.`,
+    `2. Do NOT modify any \`.gsd/\` plan files — this is a one-off, not a planned task.`,
+    `3. Commit your changes with a descriptive message.`,
+    `4. Keep changes minimal and focused on the capture text.`,
+    `5. When done, say: "Quick task complete."`,
+  ].join("\n");
+}

package/src/resources/extensions/gsd/triage-ui.ts

@@ -0,0 +1,175 @@
+/**
+ * GSD Triage UI — Confirmation flow for programmatic triage results
+ *
+ * Used by auto-mode dispatch (S02) when triage fires between tasks.
+ * For manual `/gsd triage`, the LLM session handles confirmation directly.
+ *
+ * This module provides `showTriageConfirmation` which presents each
+ * triage result to the user via `showNextAction` and returns the
+ * confirmed classifications.
+ */
+
+import type { ExtensionCommandContext } from "@gsd/pi-coding-agent";
+import { showNextAction } from "../shared/next-action-ui.js";
+import type { CaptureEntry, Classification, TriageResult } from "./captures.js";
+import { markCaptureResolved } from "./captures.js";
+
+// ─── Types ────────────────────────────────────────────────────────────────────
+
+export interface ConfirmedTriage {
+  captureId: string;
+  classification: Classification;
+  rationale: string;
+  affectedFiles?: string[];
+  targetSlice?: string;
+  userOverride: boolean;  // true if user changed the proposed classification
+}
+
+// ─── Classification Labels ────────────────────────────────────────────────────
+
+const CLASSIFICATION_LABELS: Record<Classification, { label: string; description: string }> = {
+  "quick-task": {
+    label: "Quick task",
+    description: "Execute as a one-off at the next seam — no plan modification.",
+  },
+  "inject": {
+    label: "Inject into plan",
+    description: "Add a new task to the current slice plan.",
+  },
+  "defer": {
+    label: "Defer",
+    description: "Move to a future slice or milestone — not urgent now.",
+  },
+  "replan": {
+    label: "Replan slice",
+    description: "Remaining tasks need rewriting — triggers slice replan.",
+  },
+  "note": {
+    label: "Note",
+    description: "Informational only — no action needed.",
+  },
+};
+
+const ALL_CLASSIFICATIONS: Classification[] = [
+  "quick-task", "inject", "defer", "replan", "note",
+];
+
+// ─── Public API ───────────────────────────────────────────────────────────────
+
+/**
+ * Present triage results to the user for confirmation.
+ *
+ * For each capture:
+ * - note/defer: auto-confirm (no user interaction needed)
+ * - quick-task/inject/replan: show confirmation UI with proposed + alternatives
+ *
+ * Returns confirmed results with final classifications.
+ * Updates CAPTURES.md with resolved status.
+ *
+ * @param fileOverlaps - Map of captureId → list of planned task IDs whose files overlap
+ */
+export async function showTriageConfirmation(
+  ctx: ExtensionCommandContext,
+  triageResults: TriageResult[],
+  captures: CaptureEntry[],
+  basePath: string,
+  fileOverlaps?: Map<string, string[]>,
+): Promise<ConfirmedTriage[]> {
+  const confirmed: ConfirmedTriage[] = [];
+  const captureMap = new Map(captures.map(c => [c.id, c]));
+
+  for (const result of triageResults) {
+    const capture = captureMap.get(result.captureId);
+    if (!capture) continue;
+
+    // Auto-confirm note and defer — low-impact, no plan modification
+    if (result.classification === "note" || result.classification === "defer") {
+      const resolution = result.classification === "note"
+        ? "acknowledged as note"
+        : `deferred${result.targetSlice ? ` to ${result.targetSlice}` : ""}`;
+
+      markCaptureResolved(
+        basePath,
+        result.captureId,
+        result.classification,
+        resolution,
+        result.rationale,
+      );
+
+      confirmed.push({
+        captureId: result.captureId,
+        classification: result.classification,
+        rationale: result.rationale,
+        affectedFiles: result.affectedFiles,
+        targetSlice: result.targetSlice,
+        userOverride: false,
+      });
+      continue;
+    }
+
+    // Build summary lines for the confirmation UI
+    const summary: string[] = [
+      `"${capture.text}"`,
+      "",
+      `Proposed: **${CLASSIFICATION_LABELS[result.classification].label}** — ${result.rationale}`,
+    ];
+
+    // Add file overlap warning if present
+    const overlaps = fileOverlaps?.get(result.captureId);
+    if (overlaps && overlaps.length > 0) {
+      summary.push("");
+      summary.push(`⚠ Touches files planned for ${overlaps.join(", ")} — consider inject or defer`);
+    }
+
+    if (result.affectedFiles && result.affectedFiles.length > 0) {
+      summary.push("");
+      summary.push(`Files: ${result.affectedFiles.join(", ")}`);
+    }
+
+    // Build action options — proposed first (recommended), then alternatives
+    const proposed = result.classification;
+    const actions = ALL_CLASSIFICATIONS.map(cls => ({
+      id: cls,
+      label: CLASSIFICATION_LABELS[cls].label,
+      description: CLASSIFICATION_LABELS[cls].description,
+      recommended: cls === proposed,
+    }));
+
+    const choice = await showNextAction(ctx as any, {
+      title: `Triage: ${result.captureId}`,
+      summary,
+      actions,
+      notYetMessage: "Capture will remain pending for later triage.",
+    });
+
+    if (choice === "not_yet") {
+      // User skipped — leave capture pending
+      continue;
+    }
+
+    const finalClassification = choice as Classification;
+    const userOverride = finalClassification !== proposed;
+    const resolution = userOverride
+      ? `user chose ${finalClassification} (was ${proposed})`
+      : `confirmed as ${finalClassification}`;
+
+    markCaptureResolved(
+      basePath,
+      result.captureId,
+      finalClassification,
+      resolution,
+      userOverride ? `User override: ${result.rationale}` : result.rationale,
+    );
+
+    confirmed.push({
+      captureId: result.captureId,
+      classification: finalClassification,
+      rationale: result.rationale,
+      affectedFiles: result.affectedFiles,
+      targetSlice: result.targetSlice,
+      userOverride,
+    });
+  }
+
+  return confirmed;
+}