gsd-pi 2.33.1-dev.235d83a → 2.33.1-dev.29a8268

package/dist/resources/extensions/gsd/health-widget.ts

@@ -0,0 +1,167 @@
+/**
+ * GSD Health Widget — always-on ambient health signal rendered belowEditor.
+ *
+ * Shows a compact 1-2 line summary: progress score, budget, provider key
+ * status, and doctor/environment issue count. Refreshes every 60 seconds.
+ * Quiet when everything is healthy; turns amber/red when issues arise.
+ *
+ * Widget key: "gsd-health", placement: "belowEditor"
+ */
+
+import type { ExtensionContext } from "@gsd/pi-coding-agent";
+import { runProviderChecks, summariseProviderIssues } from "./doctor-providers.js";
+import { runEnvironmentChecks } from "./doctor-environment.js";
+import { loadEffectiveGSDPreferences } from "./preferences.js";
+import { loadLedgerFromDisk, getProjectTotals } from "./metrics.js";
+import { projectRoot } from "./commands.js";
+
+// ── Types ──────────────────────────────────────────────────────────────────────
+
+interface HealthWidgetData {
+  hasProject: boolean;
+  budgetCeiling: number | undefined;
+  budgetSpent: number;
+  providerIssue: string | null;      // compact summary from summariseProviderIssues()
+  environmentErrorCount: number;
+  environmentWarningCount: number;
+  lastRefreshed: number;
+}
+
+// ── Data loader ────────────────────────────────────────────────────────────────
+
+function loadHealthWidgetData(basePath: string): HealthWidgetData {
+  let hasProject = false;
+  let budgetCeiling: number | undefined;
+  let budgetSpent = 0;
+  let providerIssue: string | null = null;
+  let environmentErrorCount = 0;
+  let environmentWarningCount = 0;
+
+  try {
+    const prefs = loadEffectiveGSDPreferences();
+    budgetCeiling = prefs?.preferences?.budget_ceiling;
+
+    const ledger = loadLedgerFromDisk(basePath);
+    if (ledger) {
+      hasProject = true;
+      const totals = getProjectTotals(ledger.units ?? []);
+      budgetSpent = totals.cost;
+    }
+  } catch { /* non-fatal */ }
+
+  try {
+    const providerResults = runProviderChecks();
+    providerIssue = summariseProviderIssues(providerResults);
+  } catch { /* non-fatal */ }
+
+  try {
+    const envResults = runEnvironmentChecks(basePath);
+    for (const r of envResults) {
+      if (r.status === "error") environmentErrorCount++;
+      else if (r.status === "warning") environmentWarningCount++;
+    }
+  } catch { /* non-fatal */ }
+
+  return {
+    hasProject,
+    budgetCeiling,
+    budgetSpent,
+    providerIssue,
+    environmentErrorCount,
+    environmentWarningCount,
+    lastRefreshed: Date.now(),
+  };
+}
+
+// ── Rendering ──────────────────────────────────────────────────────────────────
+
+function formatCost(n: number): string {
+  return n >= 1 ? `$${n.toFixed(2)}` : `${(n * 100).toFixed(1)}¢`;
+}
+
+/**
+ * Build compact health lines for the widget.
+ * Returns a string array suitable for setWidget().
+ */
+export function buildHealthLines(data: HealthWidgetData): string[] {
+  if (!data.hasProject) {
+    return ["  GSD  No project loaded — run /gsd to start"];
+  }
+
+  const parts: string[] = [];
+
+  // System status signal
+  const totalIssues = data.environmentErrorCount + data.environmentWarningCount + (data.providerIssue ? 1 : 0);
+  if (totalIssues === 0) {
+    parts.push("● System OK");
+  } else if (data.environmentErrorCount > 0 || data.providerIssue?.includes("✗")) {
+    parts.push(`✗ ${totalIssues} issue${totalIssues > 1 ? "s" : ""}`);
+  } else {
+    parts.push(`⚠ ${totalIssues} warning${totalIssues > 1 ? "s" : ""}`);
+  }
+
+  // Budget
+  if (data.budgetCeiling !== undefined && data.budgetCeiling > 0) {
+    const pct = Math.min(100, (data.budgetSpent / data.budgetCeiling) * 100);
+    parts.push(`Budget: ${formatCost(data.budgetSpent)}/${formatCost(data.budgetCeiling)} (${pct.toFixed(0)}%)`);
+  } else if (data.budgetSpent > 0) {
+    parts.push(`Spent: ${formatCost(data.budgetSpent)}`);
+  }
+
+  // Provider issue (if any)
+  if (data.providerIssue) {
+    parts.push(data.providerIssue);
+  }
+
+  // Environment issues
+  if (data.environmentErrorCount > 0) {
+    parts.push(`Env: ${data.environmentErrorCount} error${data.environmentErrorCount > 1 ? "s" : ""}`);
+  } else if (data.environmentWarningCount > 0) {
+    parts.push(`Env: ${data.environmentWarningCount} warning${data.environmentWarningCount > 1 ? "s" : ""}`);
+  }
+
+  return [`  ${parts.join("  │  ")}`];
+}
+
+// ── Widget init ────────────────────────────────────────────────────────────────
+
+const REFRESH_INTERVAL_MS = 60_000;
+
+/**
+ * Initialize the always-on gsd-health widget (belowEditor).
+ * Call once from the extension entry point after context is available.
+ */
+export function initHealthWidget(ctx: ExtensionContext): void {
+  if (!ctx.hasUI) return;
+
+  const basePath = projectRoot();
+
+  // String-array fallback — used in RPC mode (factory is a no-op there)
+  const initialData = loadHealthWidgetData(basePath);
+  ctx.ui.setWidget("gsd-health", buildHealthLines(initialData), { placement: "belowEditor" });
+
+  // Factory-based widget for TUI mode — replaces the string-array above
+  ctx.ui.setWidget("gsd-health", (_tui, _theme) => {
+    let data = initialData;
+    let cachedLines: string[] | undefined;
+
+    const refreshTimer = setInterval(() => {
+      try {
+        data = loadHealthWidgetData(basePath);
+        cachedLines = undefined;
+        _tui.requestRender();
+      } catch { /* non-fatal */ }
+    }, REFRESH_INTERVAL_MS);
+
+    return {
+      render(_width: number): string[] {
+        if (!cachedLines) cachedLines = buildHealthLines(data);
+        return cachedLines;
+      },
+      invalidate(): void { cachedLines = undefined; },
+      dispose(): void {
+        clearInterval(refreshTimer);
+      },
+    };
+  }, { placement: "belowEditor" });
+}

package/dist/resources/extensions/gsd/history.ts

@@ -0,0 +1,143 @@
+// GSD Extension — Session History View
+// Human-readable display of past auto-mode unit executions.
+
+import type { ExtensionCommandContext } from "@gsd/pi-coding-agent";
+import { formatDuration, padRight, truncateWithEllipsis } from "../shared/format-utils.js";
+import {
+  getLedger, getProjectTotals, formatCost, formatTokenCount,
+  aggregateBySlice, aggregateByPhase, aggregateByModel, loadLedgerFromDisk,
+} from "./metrics.js";
+import type { UnitMetrics } from "./metrics.js";
+
+/**
+ * Show recent unit execution history with cost, tokens, and duration.
+ */
+export async function handleHistory(args: string, ctx: ExtensionCommandContext, basePath: string): Promise<void> {
+  const ledger = getLedger();
+
+  // If ledger is null (metrics not initialized from auto-mode), try loading from disk
+  let units: UnitMetrics[];
+  if (ledger && ledger.units.length > 0) {
+    units = ledger.units;
+  } else {
+    const diskLedger = loadLedgerFromDisk(basePath);
+    if (!diskLedger || diskLedger.units.length === 0) {
+      ctx.ui.notify("No history — no units have been executed yet.", "info");
+      return;
+    }
+    units = diskLedger.units;
+  }
+
+  const parsedLimit = parseInt(args.replace(/--\w+/g, "").trim(), 10);
+  const limit = Number.isFinite(parsedLimit) && parsedLimit > 0 ? parsedLimit : 20;
+  const showCost = args.includes("--cost");
+  const showPhase = args.includes("--phase");
+  const showModel = args.includes("--model");
+
+  if (showCost) {
+    return showCostBreakdown(units, ctx);
+  }
+  if (showPhase) {
+    return showPhaseBreakdown(units, ctx);
+  }
+  if (showModel) {
+    return showModelBreakdown(units, ctx);
+  }
+
+  const display = units.slice(-limit).reverse();
+  const totals = getProjectTotals(units);
+
+  const lines: string[] = [
+    `Last ${display.length} of ${units.length} units | Total: ${formatCost(totals.cost)} · ${formatTokenCount(totals.tokens.total)} tokens`,
+    "",
+    padRight("Time", 14) + padRight("Type", 20) + padRight("ID", 16) + padRight("Model", 14) + padRight("Cost", 10) + padRight("Tokens", 10) + "Duration",
+    "─".repeat(98),
+  ];
+
+  for (const u of display) {
+    lines.push(
+      padRight(formatRelativeTime(u.finishedAt), 14) +
+      padRight(u.type, 20) +
+      padRight(truncateWithEllipsis(u.id, 15), 16) +
+      padRight(shortModel(u.model), 14) +
+      padRight(formatCost(u.cost), 10) +
+      padRight(formatTokenCount(u.tokens.total), 10) +
+      formatDuration(u.finishedAt - u.startedAt),
+    );
+  }
+
+  ctx.ui.notify(lines.join("\n"), "info");
+}
+
+function showCostBreakdown(units: UnitMetrics[], ctx: ExtensionCommandContext): void {
+  const slices = aggregateBySlice(units);
+  const lines = [
+    "Cost by slice:",
+    "",
+    padRight("Slice", 16) + padRight("Units", 8) + padRight("Cost", 10) + "Tokens",
+    "─".repeat(50),
+  ];
+  for (const s of slices) {
+    lines.push(
+      padRight(s.sliceId, 16) +
+      padRight(String(s.units), 8) +
+      padRight(formatCost(s.cost), 10) +
+      formatTokenCount(s.tokens.total),
+    );
+  }
+  ctx.ui.notify(lines.join("\n"), "info");
+}
+
+function showPhaseBreakdown(units: UnitMetrics[], ctx: ExtensionCommandContext): void {
+  const phases = aggregateByPhase(units);
+  const lines = [
+    "Cost by phase:",
+    "",
+    padRight("Phase", 16) + padRight("Units", 8) + padRight("Cost", 10) + padRight("Tokens", 10) + "Duration",
+    "─".repeat(60),
+  ];
+  for (const p of phases) {
+    lines.push(
+      padRight(p.phase, 16) +
+      padRight(String(p.units), 8) +
+      padRight(formatCost(p.cost), 10) +
+      padRight(formatTokenCount(p.tokens.total), 10) +
+      formatDuration(p.duration),
+    );
+  }
+  ctx.ui.notify(lines.join("\n"), "info");
+}
+
+function showModelBreakdown(units: UnitMetrics[], ctx: ExtensionCommandContext): void {
+  const models = aggregateByModel(units);
+  const lines = [
+    "Cost by model:",
+    "",
+    padRight("Model", 24) + padRight("Units", 8) + padRight("Cost", 10) + "Tokens",
+    "─".repeat(56),
+  ];
+  for (const m of models) {
+    lines.push(
+      padRight(shortModel(m.model), 24) +
+      padRight(String(m.units), 8) +
+      padRight(formatCost(m.cost), 10) +
+      formatTokenCount(m.tokens.total),
+    );
+  }
+  ctx.ui.notify(lines.join("\n"), "info");
+}
+
+// ─── Formatting helpers ──────────────────────────────────────────────────────
+
+function formatRelativeTime(timestamp: number): string {
+  const diff = Date.now() - timestamp;
+  if (diff < 60_000) return "just now";
+  if (diff < 3_600_000) return `${Math.floor(diff / 60_000)}m ago`;
+  if (diff < 86_400_000) return `${Math.floor(diff / 3_600_000)}h ago`;
+  return `${Math.floor(diff / 86_400_000)}d ago`;
+}
+
+function shortModel(model: string): string {
+  return model.replace(/^claude-/, "").replace(/^anthropic\//, "");
+}
+