gsd-pi 2.18.0 → 2.19.0

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;
+}

package/src/resources/extensions/gsd/visualizer-data.ts

@@ -0,0 +1,154 @@
+// Data loader for workflow visualizer overlay — aggregates state + metrics.
+
+import { deriveState } from './state.js';
+import { parseRoadmap, parsePlan, loadFile } from './files.js';
+import { findMilestoneIds } from './guided-flow.js';
+import { resolveMilestoneFile, resolveSliceFile } from './paths.js';
+import {
+  getLedger,
+  getProjectTotals,
+  aggregateByPhase,
+  aggregateBySlice,
+  aggregateByModel,
+  loadLedgerFromDisk,
+} from './metrics.js';
+
+import type { Phase } from './types.js';
+import type {
+  ProjectTotals,
+  PhaseAggregate,
+  SliceAggregate,
+  ModelAggregate,
+  UnitMetrics,
+} from './metrics.js';
+
+// ─── Visualizer Types ─────────────────────────────────────────────────────────
+
+export interface VisualizerMilestone {
+  id: string;
+  title: string;
+  status: 'complete' | 'active' | 'pending';
+  dependsOn: string[];
+  slices: VisualizerSlice[];
+}
+
+export interface VisualizerSlice {
+  id: string;
+  title: string;
+  done: boolean;
+  active: boolean;
+  risk: string;
+  depends: string[];
+  tasks: VisualizerTask[];
+}
+
+export interface VisualizerTask {
+  id: string;
+  title: string;
+  done: boolean;
+  active: boolean;
+}
+
+export interface VisualizerData {
+  milestones: VisualizerMilestone[];
+  phase: Phase;
+  totals: ProjectTotals | null;
+  byPhase: PhaseAggregate[];
+  bySlice: SliceAggregate[];
+  byModel: ModelAggregate[];
+  units: UnitMetrics[];
+}
+
+// ─── Loader ───────────────────────────────────────────────────────────────────
+
+export async function loadVisualizerData(basePath: string): Promise<VisualizerData> {
+  const state = await deriveState(basePath);
+  const milestoneIds = findMilestoneIds(basePath);
+
+  const milestones: VisualizerMilestone[] = [];
+
+  for (const mid of milestoneIds) {
+    const entry = state.registry.find(r => r.id === mid);
+    const status = entry?.status ?? 'pending';
+    const dependsOn = entry?.dependsOn ?? [];
+
+    const slices: VisualizerSlice[] = [];
+
+    const roadmapFile = resolveMilestoneFile(basePath, mid, 'ROADMAP');
+    const roadmapContent = roadmapFile ? await loadFile(roadmapFile) : null;
+
+    if (roadmapContent) {
+      const roadmap = parseRoadmap(roadmapContent);
+
+      for (const s of roadmap.slices) {
+        const isActiveSlice =
+          state.activeMilestone?.id === mid &&
+          state.activeSlice?.id === s.id;
+
+        const tasks: VisualizerTask[] = [];
+
+        if (isActiveSlice) {
+          const planFile = resolveSliceFile(basePath, mid, s.id, 'PLAN');
+          const planContent = planFile ? await loadFile(planFile) : null;
+
+          if (planContent) {
+            const plan = parsePlan(planContent);
+            for (const t of plan.tasks) {
+              tasks.push({
+                id: t.id,
+                title: t.title,
+                done: t.done,
+                active: state.activeTask?.id === t.id,
+              });
+            }
+          }
+        }
+
+        slices.push({
+          id: s.id,
+          title: s.title,
+          done: s.done,
+          active: isActiveSlice,
+          risk: s.risk,
+          depends: s.depends,
+          tasks,
+        });
+      }
+    }
+
+    milestones.push({
+      id: mid,
+      title: entry?.title ?? mid,
+      status,
+      dependsOn,
+      slices,
+    });
+  }
+
+  // Metrics
+  let totals: ProjectTotals | null = null;
+  let byPhase: PhaseAggregate[] = [];
+  let bySlice: SliceAggregate[] = [];
+  let byModel: ModelAggregate[] = [];
+  let units: UnitMetrics[] = [];
+
+  const ledger = getLedger() ?? loadLedgerFromDisk(basePath);
+
+  if (ledger && ledger.units.length > 0) {
+    units = [...ledger.units].sort((a, b) => a.startedAt - b.startedAt);
+    totals = getProjectTotals(units);
+    byPhase = aggregateByPhase(units);
+    bySlice = aggregateBySlice(units);
+    byModel = aggregateByModel(units);
+  }
+
+  return {
+    milestones,
+    phase: state.phase,
+    totals,
+    byPhase,
+    bySlice,
+    byModel,
+    units,
+  };
+}