gsd-pi 2.19.0 → 2.20.0

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

@@ -1,7 +1,7 @@
 // Data loader for workflow visualizer overlay — aggregates state + metrics.
 
 import { deriveState } from './state.js';
-import { parseRoadmap, parsePlan, loadFile } from './files.js';
+import { parseRoadmap, parsePlan, parseSummary, loadFile } from './files.js';
 import { findMilestoneIds } from './guided-flow.js';
 import { resolveMilestoneFile, resolveSliceFile } from './paths.js';
 import {
@@ -11,6 +11,7 @@ import {
   aggregateBySlice,
   aggregateByModel,
   loadLedgerFromDisk,
+  classifyUnitPhase,
 } from './metrics.js';
 
 import type { Phase } from './types.js';
@@ -49,6 +50,37 @@ export interface VisualizerTask {
   active: boolean;
 }
 
+export interface CriticalPathInfo {
+  milestonePath: string[];
+  slicePath: string[];
+  milestoneSlack: Map<string, number>;
+  sliceSlack: Map<string, number>;
+}
+
+export interface AgentActivityInfo {
+  currentUnit: { type: string; id: string; startedAt: number } | null;
+  elapsed: number;
+  completedUnits: number;
+  totalSlices: number;
+  completionRate: number;
+  active: boolean;
+  sessionCost: number;
+  sessionTokens: number;
+}
+
+export interface ChangelogEntry {
+  milestoneId: string;
+  sliceId: string;
+  title: string;
+  oneLiner: string;
+  filesModified: { path: string; description: string }[];
+  completedAt: string;
+}
+
+export interface ChangelogInfo {
+  entries: ChangelogEntry[];
+}
+
 export interface VisualizerData {
   milestones: VisualizerMilestone[];
   phase: Phase;
@@ -57,6 +89,308 @@ export interface VisualizerData {
   bySlice: SliceAggregate[];
   byModel: ModelAggregate[];
   units: UnitMetrics[];
+  criticalPath: CriticalPathInfo;
+  remainingSliceCount: number;
+  agentActivity: AgentActivityInfo | null;
+  changelog: ChangelogInfo;
+}
+
+// ─── Critical Path ────────────────────────────────────────────────────────────
+
+export function computeCriticalPath(milestones: VisualizerMilestone[]): CriticalPathInfo {
+  const empty: CriticalPathInfo = {
+    milestonePath: [],
+    slicePath: [],
+    milestoneSlack: new Map(),
+    sliceSlack: new Map(),
+  };
+
+  if (milestones.length === 0) return empty;
+
+  // Milestone-level critical path (weight = number of incomplete slices)
+  const msMap = new Map(milestones.map(m => [m.id, m]));
+  const msIds = milestones.map(m => m.id);
+  const msAdj = new Map<string, string[]>();
+  const msWeight = new Map<string, number>();
+
+  for (const ms of milestones) {
+    msAdj.set(ms.id, []);
+    const incomplete = ms.slices.filter(s => !s.done).length;
+    msWeight.set(ms.id, ms.status === 'complete' ? 0 : Math.max(1, incomplete));
+  }
+
+  for (const ms of milestones) {
+    for (const dep of ms.dependsOn) {
+      if (msMap.has(dep)) {
+        const adj = msAdj.get(dep);
+        if (adj) adj.push(ms.id);
+      }
+    }
+  }
+
+  // Topological sort (Kahn's algorithm)
+  const inDegree = new Map<string, number>();
+  for (const id of msIds) inDegree.set(id, 0);
+  for (const ms of milestones) {
+    for (const dep of ms.dependsOn) {
+      if (msMap.has(dep)) inDegree.set(ms.id, (inDegree.get(ms.id) ?? 0) + 1);
+    }
+  }
+
+  const queue: string[] = [];
+  for (const [id, deg] of inDegree) {
+    if (deg === 0) queue.push(id);
+  }
+
+  const topoOrder: string[] = [];
+  while (queue.length > 0) {
+    const node = queue.shift()!;
+    topoOrder.push(node);
+    for (const next of (msAdj.get(node) ?? [])) {
+      const d = (inDegree.get(next) ?? 1) - 1;
+      inDegree.set(next, d);
+      if (d === 0) queue.push(next);
+    }
+  }
+
+  // Longest path from each root
+  const dist = new Map<string, number>();
+  const prev = new Map<string, string | null>();
+  for (const id of msIds) {
+    dist.set(id, 0);
+    prev.set(id, null);
+  }
+
+  for (const node of topoOrder) {
+    const w = msWeight.get(node) ?? 1;
+    const nodeDist = dist.get(node)! + w;
+    for (const next of (msAdj.get(node) ?? [])) {
+      if (nodeDist > dist.get(next)!) {
+        dist.set(next, nodeDist);
+        prev.set(next, node);
+      }
+    }
+  }
+
+  // Find the end of the critical path (node with max dist + own weight)
+  let maxDist = 0;
+  let endNode = msIds[0];
+  for (const id of msIds) {
+    const totalDist = dist.get(id)! + (msWeight.get(id) ?? 1);
+    if (totalDist > maxDist) {
+      maxDist = totalDist;
+      endNode = id;
+    }
+  }
+
+  // Trace back
+  const milestonePath: string[] = [];
+  let cur: string | null = endNode;
+  while (cur !== null) {
+    milestonePath.unshift(cur);
+    cur = prev.get(cur) ?? null;
+  }
+
+  // Compute milestone slack
+  const milestoneSlack = new Map<string, number>();
+  const criticalSet = new Set(milestonePath);
+  for (const id of msIds) {
+    if (criticalSet.has(id)) {
+      milestoneSlack.set(id, 0);
+    } else {
+      const nodeTotal = dist.get(id)! + (msWeight.get(id) ?? 1);
+      milestoneSlack.set(id, Math.max(0, maxDist - nodeTotal));
+    }
+  }
+
+  // Slice-level critical path within active milestone
+  const activeMs = milestones.find(m => m.status === 'active');
+  let slicePath: string[] = [];
+  const sliceSlack = new Map<string, number>();
+
+  if (activeMs && activeMs.slices.length > 0) {
+    const slMap = new Map(activeMs.slices.map(s => [s.id, s]));
+    const slAdj = new Map<string, string[]>();
+    for (const s of activeMs.slices) slAdj.set(s.id, []);
+    for (const s of activeMs.slices) {
+      for (const dep of s.depends) {
+        if (slMap.has(dep)) {
+          const adj = slAdj.get(dep);
+          if (adj) adj.push(s.id);
+        }
+      }
+    }
+
+    // Topo sort slices
+    const slIn = new Map<string, number>();
+    for (const s of activeMs.slices) slIn.set(s.id, 0);
+    for (const s of activeMs.slices) {
+      for (const dep of s.depends) {
+        if (slMap.has(dep)) slIn.set(s.id, (slIn.get(s.id) ?? 0) + 1);
+      }
+    }
+
+    const slQueue: string[] = [];
+    for (const [id, d] of slIn) {
+      if (d === 0) slQueue.push(id);
+    }
+
+    const slTopo: string[] = [];
+    while (slQueue.length > 0) {
+      const n = slQueue.shift()!;
+      slTopo.push(n);
+      for (const next of (slAdj.get(n) ?? [])) {
+        const d = (slIn.get(next) ?? 1) - 1;
+        slIn.set(next, d);
+        if (d === 0) slQueue.push(next);
+      }
+    }
+
+    const slDist = new Map<string, number>();
+    const slPrev = new Map<string, string | null>();
+    for (const s of activeMs.slices) {
+      const w = s.done ? 0 : 1;
+      slDist.set(s.id, 0);
+      slPrev.set(s.id, null);
+    }
+
+    for (const n of slTopo) {
+      const w = (slMap.get(n)?.done ? 0 : 1);
+      const nd = slDist.get(n)! + w;
+      for (const next of (slAdj.get(n) ?? [])) {
+        if (nd > slDist.get(next)!) {
+          slDist.set(next, nd);
+          slPrev.set(next, n);
+        }
+      }
+    }
+
+    let slMax = 0;
+    let slEnd = activeMs.slices[0].id;
+    for (const s of activeMs.slices) {
+      const totalDist = slDist.get(s.id)! + (s.done ? 0 : 1);
+      if (totalDist > slMax) {
+        slMax = totalDist;
+        slEnd = s.id;
+      }
+    }
+
+    let slCur: string | null = slEnd;
+    while (slCur !== null) {
+      slicePath.unshift(slCur);
+      slCur = slPrev.get(slCur) ?? null;
+    }
+
+    const slCritSet = new Set(slicePath);
+    for (const s of activeMs.slices) {
+      if (slCritSet.has(s.id)) {
+        sliceSlack.set(s.id, 0);
+      } else {
+        const nodeTotal = slDist.get(s.id)! + (s.done ? 0 : 1);
+        sliceSlack.set(s.id, Math.max(0, slMax - nodeTotal));
+      }
+    }
+  }
+
+  return { milestonePath, slicePath, milestoneSlack, sliceSlack };
+}
+
+// ─── Agent Activity ──────────────────────────────────────────────────────────
+
+function loadAgentActivity(units: UnitMetrics[], milestones: VisualizerMilestone[]): AgentActivityInfo | null {
+  if (units.length === 0) return null;
+
+  // Find currently running unit (finishedAt === 0)
+  const running = units.find(u => u.finishedAt === 0);
+  const now = Date.now();
+
+  const completedUnits = units.filter(u => u.finishedAt > 0).length;
+  const totalSlices = milestones.reduce((sum, m) => sum + m.slices.length, 0);
+
+  // Completion rate from finished units
+  const finished = units.filter(u => u.finishedAt > 0);
+  let completionRate = 0;
+  if (finished.length >= 2) {
+    const earliest = Math.min(...finished.map(u => u.startedAt));
+    const latest = Math.max(...finished.map(u => u.finishedAt));
+    const totalHours = (latest - earliest) / 3_600_000;
+    completionRate = totalHours > 0 ? finished.length / totalHours : 0;
+  }
+
+  const sessionCost = units.reduce((sum, u) => sum + u.cost, 0);
+  const sessionTokens = units.reduce((sum, u) => sum + u.tokens.total, 0);
+
+  return {
+    currentUnit: running
+      ? { type: running.type, id: running.id, startedAt: running.startedAt }
+      : null,
+    elapsed: running ? now - running.startedAt : 0,
+    completedUnits,
+    totalSlices,
+    completionRate,
+    active: !!running,
+    sessionCost,
+    sessionTokens,
+  };
+}
+
+// ─── Changelog ───────────────────────────────────────────────────────────────
+
+const changelogCache = new Map<string, { mtime: number; entry: ChangelogEntry }>();
+
+async function loadChangelog(basePath: string, milestones: VisualizerMilestone[]): Promise<ChangelogInfo> {
+  const entries: ChangelogEntry[] = [];
+
+  for (const ms of milestones) {
+    for (const sl of ms.slices) {
+      if (!sl.done) continue;
+
+      const summaryFile = resolveSliceFile(basePath, ms.id, sl.id, 'SUMMARY');
+      if (!summaryFile) continue;
+
+      // Check cache by file path
+      const cacheKey = `${ms.id}/${sl.id}`;
+      const cached = changelogCache.get(cacheKey);
+
+      // Check mtime for cache invalidation
+      let mtime = 0;
+      try {
+        const { statSync } = await import('node:fs');
+        mtime = statSync(summaryFile).mtimeMs;
+      } catch {
+        continue;
+      }
+
+      if (cached && cached.mtime === mtime) {
+        entries.push(cached.entry);
+        continue;
+      }
+
+      const content = await loadFile(summaryFile);
+      if (!content) continue;
+
+      const summary = parseSummary(content);
+      const entry: ChangelogEntry = {
+        milestoneId: ms.id,
+        sliceId: sl.id,
+        title: sl.title,
+        oneLiner: summary.oneLiner,
+        filesModified: summary.filesModified.map(f => ({
+          path: f.path,
+          description: f.description,
+        })),
+        completedAt: summary.frontmatter.completed_at ?? '',
+      };
+
+      changelogCache.set(cacheKey, { mtime, entry });
+      entries.push(entry);
+    }
+  }
+
+  // Sort by completedAt descending
+  entries.sort((a, b) => (b.completedAt || '').localeCompare(a.completedAt || ''));
+
+  return { entries };
 }
 
 // ─── Loader ───────────────────────────────────────────────────────────────────
@@ -142,6 +476,19 @@ export async function loadVisualizerData(basePath: string): Promise<VisualizerDa
     byModel = aggregateByModel(units);
   }
 
+  // Compute new fields
+  const criticalPath = computeCriticalPath(milestones);
+
+  let remainingSliceCount = 0;
+  for (const ms of milestones) {
+    for (const sl of ms.slices) {
+      if (!sl.done) remainingSliceCount++;
+    }
+  }
+
+  const agentActivity = loadAgentActivity(units, milestones);
+  const changelog = await loadChangelog(basePath, milestones);
+
   return {
     milestones,
     phase: state.phase,
@@ -150,5 +497,9 @@ export async function loadVisualizerData(basePath: string): Promise<VisualizerDa
     bySlice,
     byModel,
     units,
+    criticalPath,
+    remainingSliceCount,
+    agentActivity,
+    changelog,
   };
 }

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

@@ -6,9 +6,23 @@ import {
   renderDepsView,
   renderMetricsView,
   renderTimelineView,
+  renderAgentView,
+  renderChangelogView,
+  renderExportView,
+  type ProgressFilter,
 } from "./visualizer-views.js";
+import { writeExportFile } from "./export.js";
 
-const TAB_LABELS = ["1 Progress", "2 Deps", "3 Metrics", "4 Timeline"];
+const TAB_COUNT = 7;
+const TAB_LABELS = [
+  "1 Progress",
+  "2 Deps",
+  "3 Metrics",
+  "4 Timeline",
+  "5 Agent",
+  "6 Changes",
+  "7 Export",
+];
 
 export class GSDVisualizerOverlay {
   private tui: { requestRender: () => void };
@@ -16,7 +30,7 @@ export class GSDVisualizerOverlay {
   private onClose: () => void;
 
   activeTab = 0;
-  scrollOffsets: number[] = [0, 0, 0, 0];
+  scrollOffsets: number[] = new Array(TAB_COUNT).fill(0);
   loading = true;
   disposed = false;
   cachedWidth?: number;
@@ -25,6 +39,15 @@ export class GSDVisualizerOverlay {
   data: VisualizerData | null = null;
   basePath: string;
 
+  // Filter state (Progress tab)
+  filterMode = false;
+  filterText = "";
+  filterField: "all" | "status" | "risk" | "keyword" = "all";
+
+  // Export state
+  lastExportPath?: string;
+  exportStatus?: string;
+
   constructor(
     tui: { requestRender: () => void },
     theme: Theme,
@@ -52,6 +75,37 @@ export class GSDVisualizerOverlay {
   }
 
   handleInput(data: string): void {
+    // Filter mode input routing
+    if (this.filterMode) {
+      if (matchesKey(data, Key.escape)) {
+        this.filterMode = false;
+        this.filterText = "";
+        this.invalidate();
+        this.tui.requestRender();
+        return;
+      }
+      if (matchesKey(data, Key.enter)) {
+        this.filterMode = false;
+        this.invalidate();
+        this.tui.requestRender();
+        return;
+      }
+      if (matchesKey(data, Key.backspace)) {
+        this.filterText = this.filterText.slice(0, -1);
+        this.invalidate();
+        this.tui.requestRender();
+        return;
+      }
+      // Append printable characters
+      if (data.length === 1 && data.charCodeAt(0) >= 32) {
+        this.filterText += data;
+        this.invalidate();
+        this.tui.requestRender();
+        return;
+      }
+      return;
+    }
+
     if (matchesKey(data, Key.escape) || matchesKey(data, Key.ctrl("c"))) {
       this.dispose();
       this.onClose();
@@ -59,19 +113,46 @@ export class GSDVisualizerOverlay {
     }
 
     if (matchesKey(data, Key.tab)) {
-      this.activeTab = (this.activeTab + 1) % 4;
+      this.activeTab = (this.activeTab + 1) % TAB_COUNT;
       this.invalidate();
       this.tui.requestRender();
       return;
     }
 
-    if (data === "1" || data === "2" || data === "3" || data === "4") {
+    if ("1234567".includes(data) && data.length === 1) {
       this.activeTab = parseInt(data, 10) - 1;
       this.invalidate();
       this.tui.requestRender();
       return;
     }
 
+    // "/" enters filter mode on Progress tab
+    if (data === "/" && this.activeTab === 0) {
+      this.filterMode = true;
+      this.filterText = "";
+      this.invalidate();
+      this.tui.requestRender();
+      return;
+    }
+
+    // "f" cycles filter field on Progress tab (when not in filter mode)
+    if (data === "f" && this.activeTab === 0) {
+      const fields: Array<"all" | "status" | "risk" | "keyword"> = ["all", "status", "risk", "keyword"];
+      const idx = fields.indexOf(this.filterField);
+      this.filterField = fields[(idx + 1) % fields.length];
+      this.invalidate();
+      this.tui.requestRender();
+      return;
+    }
+
+    // Export tab key handling
+    if (this.activeTab === 6 && this.data) {
+      if (data === "m" || data === "j" || data === "s") {
+        this.handleExportKey(data);
+        return;
+      }
+    }
+
     if (matchesKey(data, Key.down) || matchesKey(data, "j")) {
       this.scrollOffsets[this.activeTab]++;
       this.invalidate();
@@ -101,6 +182,62 @@ export class GSDVisualizerOverlay {
     }
   }
 
+  private handleExportKey(key: "m" | "j" | "s"): void {
+    if (!this.data) return;
+
+    const format = key === "m" ? "markdown" : key === "j" ? "json" : "snapshot";
+
+    if (format === "snapshot") {
+      // Capture current active tab's rendered lines as snapshot
+      const snapshotLines = this.renderTabContent(this.activeTab, 80);
+      const timestamp = new Date().toISOString().replace(/[:.]/g, "-").slice(0, 19);
+      const { writeFileSync, mkdirSync } = require("node:fs");
+      const { join } = require("node:path");
+      const { gsdRoot } = require("./paths.js");
+      const exportDir = gsdRoot(this.basePath);
+      mkdirSync(exportDir, { recursive: true });
+      const outPath = join(exportDir, `snapshot-${timestamp}.txt`);
+      writeFileSync(outPath, snapshotLines.join("\n") + "\n", "utf-8");
+      this.lastExportPath = outPath;
+      this.exportStatus = "Snapshot saved";
+    } else {
+      const result = writeExportFile(this.basePath, format, this.data);
+      if (result) {
+        this.lastExportPath = result;
+        this.exportStatus = `${format} export saved`;
+      }
+    }
+
+    this.invalidate();
+    this.tui.requestRender();
+  }
+
+  private renderTabContent(tab: number, width: number): string[] {
+    if (!this.data) return [];
+    const th = this.theme;
+    switch (tab) {
+      case 0: {
+        const filter: ProgressFilter | undefined =
+          this.filterText ? { text: this.filterText, field: this.filterField } : undefined;
+        return renderProgressView(this.data, th, width, filter);
+      }
+      case 1:
+        return renderDepsView(this.data, th, width);
+      case 2:
+        return renderMetricsView(this.data, th, width);
+      case 3:
+        return renderTimelineView(this.data, th, width);
+      case 4:
+        return renderAgentView(this.data, th, width);
+      case 5:
+        return renderChangelogView(this.data, th, width);
+      case 6:
+        return renderExportView(this.data, th, width, this.lastExportPath);
+      default:
+        return [];
+    }
+  }
+
   render(width: number): string[] {
     if (this.cachedLines && this.cachedWidth === width) {
       return this.cachedLines;
@@ -112,35 +249,42 @@ export class GSDVisualizerOverlay {
 
     // Tab bar
     const tabs = TAB_LABELS.map((label, i) => {
+      let displayLabel = label;
+      // Show filter indicator on Progress tab
+      if (i === 0 && this.filterText) {
+        displayLabel += " ✱";
+      }
       if (i === this.activeTab) {
-        return th.fg("accent", `[${label}]`);
+        return th.fg("accent", `[${displayLabel}]`);
       }
-      return th.fg("dim", `[${label}]`);
+      return th.fg("dim", `[${displayLabel}]`);
     });
-    content.push(" " + tabs.join("  "));
+    content.push(" " + tabs.join(" "));
     content.push("");
 
+    // Filter bar (when in filter mode)
+    if (this.filterMode && this.activeTab === 0) {
+      content.push(
+        th.fg("accent", `Filter (${this.filterField}): ${this.filterText}█`),
+      );
+      content.push("");
+    }
+
     if (this.loading) {
       const loadingText = "Loading…";
       const vis = visibleWidth(loadingText);
       const leftPad = Math.max(0, Math.floor((innerWidth - vis) / 2));
       content.push(" ".repeat(leftPad) + loadingText);
     } else if (this.data) {
-      let viewLines: string[] = [];
-      switch (this.activeTab) {
-        case 0:
-          viewLines = renderProgressView(this.data, th, innerWidth);
-          break;
-        case 1:
-          viewLines = renderDepsView(this.data, th, innerWidth);
-          break;
-        case 2:
-          viewLines = renderMetricsView(this.data, th, innerWidth);
-          break;
-        case 3:
-          viewLines = renderTimelineView(this.data, th, innerWidth);
-          break;
+      const viewLines = this.renderTabContent(this.activeTab, innerWidth);
+
+      // Show export status message if present
+      if (this.exportStatus && this.activeTab === 6) {
+        content.push(th.fg("success", this.exportStatus));
+        content.push("");
+        this.exportStatus = undefined;
       }
+
       content.push(...viewLines);
     }
 
@@ -156,7 +300,7 @@ export class GSDVisualizerOverlay {
     const lines = this.wrapInBox(visibleContent, width);
 
     // Footer hint
-    const hint = th.fg("dim", "Tab/1-4 switch · ↑↓ scroll · g/G top/end · esc close");
+    const hint = th.fg("dim", "Tab/1-7 switch · / filter · ↑↓ scroll · g/G top/end · esc close");
     const hintVis = visibleWidth(hint);
     const hintPad = Math.max(0, Math.floor((width - hintVis) / 2));
     lines.push(" ".repeat(hintPad) + hint);