gsd-pi 2.33.1-dev.29a8268 → 2.33.1-dev.bf822e6

package/dist/resources/extensions/gsd/auto-dashboard.js

@@ -0,0 +1,509 @@
+/**
+ * Auto-mode Dashboard — progress widget rendering, elapsed time formatting,
+ * unit description helpers, and slice progress caching.
+ *
+ * Pure functions that accept specific parameters — no module-level globals
+ * or AutoContext dependency. State accessors are passed as callbacks.
+ */
+import { getCurrentBranch } from "./worktree.js";
+import { getActiveHook } from "./post-unit-hooks.js";
+import { getLedger, getProjectTotals, formatCost, formatTierSavings } from "./metrics.js";
+import { getHealthTrend, getConsecutiveErrorUnits } from "./doctor-proactive.js";
+import { resolveMilestoneFile, resolveSliceFile, } from "./paths.js";
+import { parseRoadmap, parsePlan } from "./files.js";
+import { readFileSync, existsSync } from "node:fs";
+import { truncateToWidth, visibleWidth } from "@gsd/pi-tui";
+import { makeUI, GLYPH, INDENT } from "../shared/mod.js";
+import { parseUnitId } from "./unit-id.js";
+// ─── Unit Description Helpers ─────────────────────────────────────────────────
+/** Canonical verb and phase label for each known unit type. */
+const UNIT_TYPE_INFO = {
+    "research-milestone": { verb: "researching", phaseLabel: "RESEARCH" },
+    "research-slice": { verb: "researching", phaseLabel: "RESEARCH" },
+    "plan-milestone": { verb: "planning", phaseLabel: "PLAN" },
+    "plan-slice": { verb: "planning", phaseLabel: "PLAN" },
+    "execute-task": { verb: "executing", phaseLabel: "EXECUTE" },
+    "complete-slice": { verb: "completing", phaseLabel: "COMPLETE" },
+    "replan-slice": { verb: "replanning", phaseLabel: "REPLAN" },
+    "rewrite-docs": { verb: "rewriting", phaseLabel: "REWRITE" },
+    "reassess-roadmap": { verb: "reassessing", phaseLabel: "REASSESS" },
+    "run-uat": { verb: "running UAT", phaseLabel: "UAT" },
+};
+export function unitVerb(unitType) {
+    if (unitType.startsWith("hook/"))
+        return `hook: ${unitType.slice(5)}`;
+    return UNIT_TYPE_INFO[unitType]?.verb ?? unitType;
+}
+export function unitPhaseLabel(unitType) {
+    if (unitType.startsWith("hook/"))
+        return "HOOK";
+    return UNIT_TYPE_INFO[unitType]?.phaseLabel ?? unitType.toUpperCase();
+}
+/**
+ * Describe the expected next step after the current unit completes.
+ * Unit types here mirror the keys in UNIT_TYPE_INFO above.
+ */
+function peekNext(unitType, state) {
+    // Show active hook info in progress display
+    const activeHookState = getActiveHook();
+    if (activeHookState) {
+        return `hook: ${activeHookState.hookName} (cycle ${activeHookState.cycle})`;
+    }
+    const sid = state.activeSlice?.id ?? "";
+    if (unitType.startsWith("hook/"))
+        return `continue ${sid}`;
+    switch (unitType) {
+        case "research-milestone": return "plan milestone roadmap";
+        case "plan-milestone": return "plan or execute first slice";
+        case "research-slice": return `plan ${sid}`;
+        case "plan-slice": return "execute first task";
+        case "execute-task": return `continue ${sid}`;
+        case "complete-slice": return "reassess roadmap";
+        case "replan-slice": return `re-execute ${sid}`;
+        case "rewrite-docs": return "continue execution";
+        case "reassess-roadmap": return "advance to next slice";
+        case "run-uat": return "reassess roadmap";
+        default: return "";
+    }
+}
+/**
+ * Describe what the next unit will be, based on current state.
+ */
+export function describeNextUnit(state) {
+    const sid = state.activeSlice?.id;
+    const sTitle = state.activeSlice?.title;
+    const tid = state.activeTask?.id;
+    const tTitle = state.activeTask?.title;
+    switch (state.phase) {
+        case "needs-discussion":
+            return { label: "Discuss milestone draft", description: "Milestone has a draft context — needs discussion before planning." };
+        case "pre-planning":
+            return { label: "Research & plan milestone", description: "Scout the landscape and create the roadmap." };
+        case "planning":
+            return { label: `Plan ${sid}: ${sTitle}`, description: "Research and decompose into tasks." };
+        case "executing":
+            return { label: `Execute ${tid}: ${tTitle}`, description: "Run the next task in a fresh session." };
+        case "summarizing":
+            return { label: `Complete ${sid}: ${sTitle}`, description: "Write summary, UAT, and merge to main." };
+        case "replanning-slice":
+            return { label: `Replan ${sid}: ${sTitle}`, description: "Blocker found — replan the slice." };
+        case "completing-milestone":
+            return { label: "Complete milestone", description: "Write milestone summary." };
+        default:
+            return { label: "Continue", description: "Execute the next step." };
+    }
+}
+// ─── Elapsed Time Formatting ──────────────────────────────────────────────────
+/** Format elapsed time since auto-mode started */
+export function formatAutoElapsed(autoStartTime) {
+    if (!autoStartTime)
+        return "";
+    const ms = Date.now() - autoStartTime;
+    const s = Math.floor(ms / 1000);
+    if (s < 60)
+        return `${s}s`;
+    const m = Math.floor(s / 60);
+    const rs = s % 60;
+    if (m < 60)
+        return `${m}m${rs > 0 ? ` ${rs}s` : ""}`;
+    const h = Math.floor(m / 60);
+    const rm = m % 60;
+    return `${h}h ${rm}m`;
+}
+/** Format token counts for compact display */
+export function formatWidgetTokens(count) {
+    if (count < 1000)
+        return count.toString();
+    if (count < 10000)
+        return `${(count / 1000).toFixed(1)}k`;
+    if (count < 1000000)
+        return `${Math.round(count / 1000)}k`;
+    if (count < 10000000)
+        return `${(count / 1000000).toFixed(1)}M`;
+    return `${Math.round(count / 1000000)}M`;
+}
+// ─── ETA Estimation ──────────────────────────────────────────────────────────
+/**
+ * Estimate remaining time based on average unit duration from the metrics ledger.
+ * Returns a formatted string like "~12m remaining" or null if insufficient data.
+ */
+export function estimateTimeRemaining() {
+    const ledger = getLedger();
+    if (!ledger || ledger.units.length < 2)
+        return null;
+    const sliceProgress = getRoadmapSlicesSync();
+    if (!sliceProgress || sliceProgress.total === 0)
+        return null;
+    const remainingSlices = sliceProgress.total - sliceProgress.done;
+    if (remainingSlices <= 0)
+        return null;
+    // Compute average duration per completed slice from the ledger
+    const completedSliceUnits = ledger.units.filter(u => u.finishedAt > 0 && u.startedAt > 0);
+    if (completedSliceUnits.length < 2)
+        return null;
+    const totalDuration = completedSliceUnits.reduce((sum, u) => sum + (u.finishedAt - u.startedAt), 0);
+    const avgDuration = totalDuration / completedSliceUnits.length;
+    // Rough estimate: remaining slices × average units per slice × avg duration
+    const completedSlices = sliceProgress.done || 1;
+    const unitsPerSlice = completedSliceUnits.length / completedSlices;
+    const estimatedMs = remainingSlices * unitsPerSlice * avgDuration;
+    if (estimatedMs < 5_000)
+        return null; // Too small to display
+    const s = Math.floor(estimatedMs / 1000);
+    if (s < 60)
+        return `~${s}s remaining`;
+    const m = Math.floor(s / 60);
+    if (m < 60)
+        return `~${m}m remaining`;
+    const h = Math.floor(m / 60);
+    const rm = m % 60;
+    return rm > 0 ? `~${h}h ${rm}m remaining` : `~${h}h remaining`;
+}
+// ─── Slice Progress Cache ─────────────────────────────────────────────────────
+/** Cached slice progress for the widget — avoid async in render */
+let cachedSliceProgress = null;
+export function updateSliceProgressCache(base, mid, activeSid) {
+    try {
+        const roadmapFile = resolveMilestoneFile(base, mid, "ROADMAP");
+        if (!roadmapFile)
+            return;
+        const content = readFileSync(roadmapFile, "utf-8");
+        const roadmap = parseRoadmap(content);
+        let activeSliceTasks = null;
+        if (activeSid) {
+            try {
+                const planFile = resolveSliceFile(base, mid, activeSid, "PLAN");
+                if (planFile && existsSync(planFile)) {
+                    const planContent = readFileSync(planFile, "utf-8");
+                    const plan = parsePlan(planContent);
+                    activeSliceTasks = {
+                        done: plan.tasks.filter(t => t.done).length,
+                        total: plan.tasks.length,
+                    };
+                }
+            }
+            catch {
+                // Non-fatal — just omit task count
+            }
+        }
+        cachedSliceProgress = {
+            done: roadmap.slices.filter(s => s.done).length,
+            total: roadmap.slices.length,
+            milestoneId: mid,
+            activeSliceTasks,
+        };
+    }
+    catch {
+        // Non-fatal — widget just won't show progress bar
+    }
+}
+export function getRoadmapSlicesSync() {
+    return cachedSliceProgress;
+}
+export function clearSliceProgressCache() {
+    cachedSliceProgress = null;
+}
+// ─── Footer Factory ───────────────────────────────────────────────────────────
+/**
+ * Footer factory that renders zero lines — hides the built-in footer entirely.
+ * All footer info (pwd, branch, tokens, cost, model) is shown inside the
+ * progress widget instead, so there's no gap or redundancy.
+ */
+export const hideFooter = () => ({
+    render(_width) { return []; },
+    invalidate() { },
+    dispose() { },
+});
+export function updateProgressWidget(ctx, unitType, unitId, state, accessors, tierBadge) {
+    if (!ctx.hasUI)
+        return;
+    const verb = unitVerb(unitType);
+    const phaseLabel = unitPhaseLabel(unitType);
+    const mid = state.activeMilestone;
+    const slice = state.activeSlice;
+    const task = state.activeTask;
+    const next = peekNext(unitType, state);
+    // Cache git branch at widget creation time (not per render)
+    let cachedBranch = null;
+    try {
+        cachedBranch = getCurrentBranch(accessors.getBasePath());
+    }
+    catch { /* not in git repo */ }
+    // Cache pwd with ~ substitution
+    let widgetPwd = process.cwd();
+    const widgetHome = process.env.HOME || process.env.USERPROFILE;
+    if (widgetHome && widgetPwd.startsWith(widgetHome)) {
+        widgetPwd = `~${widgetPwd.slice(widgetHome.length)}`;
+    }
+    if (cachedBranch)
+        widgetPwd = `${widgetPwd} (${cachedBranch})`;
+    // Set a string-array fallback first — this is the only version RPC mode will
+    // see, since the factory widget set below is not supported in RPC mode.
+    const progressText = buildProgressTextLines(verb, phaseLabel, unitId, mid, slice, task, next, accessors, tierBadge, widgetPwd);
+    ctx.ui.setWidget("gsd-progress", progressText);
+    // Set the factory-based widget — in TUI mode this replaces the string-array
+    // version with a dynamic, animated widget. In RPC mode this call is a no-op.
+    ctx.ui.setWidget("gsd-progress", (tui, theme) => {
+        let pulseBright = true;
+        let cachedLines;
+        let cachedWidth;
+        const pulseTimer = setInterval(() => {
+            pulseBright = !pulseBright;
+            cachedLines = undefined;
+            tui.requestRender();
+        }, 800);
+        // Refresh progress cache from disk every 15s so the widget reflects
+        // task/slice completion mid-unit. Without this, the progress bar only
+        // updates at dispatch time, appearing frozen during long-running units.
+        // 15s (vs 5s) reduces synchronous file I/O on the hot path.
+        const progressRefreshTimer = mid ? setInterval(() => {
+            try {
+                updateSliceProgressCache(accessors.getBasePath(), mid.id, slice?.id);
+                cachedLines = undefined;
+            }
+            catch { /* non-fatal */ }
+        }, 15_000) : null;
+        return {
+            render(width) {
+                if (cachedLines && cachedWidth === width)
+                    return cachedLines;
+                const ui = makeUI(theme, width);
+                const lines = [];
+                const pad = INDENT.base;
+                // ── Line 1: Top bar ───────────────────────────────────────────────
+                lines.push(...ui.bar());
+                const dot = pulseBright
+                    ? theme.fg("accent", GLYPH.statusActive)
+                    : theme.fg("dim", GLYPH.statusPending);
+                const elapsed = formatAutoElapsed(accessors.getAutoStartTime());
+                const modeTag = accessors.isStepMode() ? "NEXT" : "AUTO";
+                const headerLeft = `${pad}${dot} ${theme.fg("accent", theme.bold("GSD"))}  ${theme.fg("success", modeTag)}`;
+                const headerRight = elapsed ? theme.fg("dim", elapsed) : "";
+                lines.push(rightAlign(headerLeft, headerRight, width));
+                lines.push("");
+                if (mid) {
+                    lines.push(truncateToWidth(`${pad}${theme.fg("dim", mid.title)}`, width));
+                }
+                if (slice && unitType !== "research-milestone" && unitType !== "plan-milestone") {
+                    lines.push(truncateToWidth(`${pad}${theme.fg("text", theme.bold(`${slice.id}: ${slice.title}`))}`, width));
+                }
+                lines.push("");
+                const isHook = unitType.startsWith("hook/");
+                const hookParsed = isHook ? parseUnitId(unitId) : undefined;
+                const target = isHook
+                    ? (hookParsed.task ?? hookParsed.slice ?? unitId)
+                    : (task ? `${task.id}: ${task.title}` : unitId);
+                const actionLeft = `${pad}${theme.fg("accent", "▸")} ${theme.fg("accent", verb)}  ${theme.fg("text", target)}`;
+                const tierTag = tierBadge ? theme.fg("dim", `[${tierBadge}] `) : "";
+                const phaseBadge = `${tierTag}${theme.fg("dim", phaseLabel)}`;
+                lines.push(rightAlign(actionLeft, phaseBadge, width));
+                lines.push("");
+                if (mid) {
+                    const roadmapSlices = getRoadmapSlicesSync();
+                    if (roadmapSlices) {
+                        const { done, total, activeSliceTasks } = roadmapSlices;
+                        const barWidth = Math.max(8, Math.min(24, Math.floor(width * 0.3)));
+                        const pct = total > 0 ? done / total : 0;
+                        const filled = Math.round(pct * barWidth);
+                        const bar = theme.fg("success", "█".repeat(filled))
+                            + theme.fg("dim", "░".repeat(barWidth - filled));
+                        let meta = theme.fg("dim", `${done}/${total} slices`);
+                        if (activeSliceTasks && activeSliceTasks.total > 0) {
+                            // For hooks, show the trigger task number (done), not the next task (done + 1)
+                            const taskNum = isHook
+                                ? Math.max(activeSliceTasks.done, 1)
+                                : Math.min(activeSliceTasks.done + 1, activeSliceTasks.total);
+                            meta += theme.fg("dim", `  ·  task ${taskNum}/${activeSliceTasks.total}`);
+                        }
+                        // ETA estimate
+                        const eta = estimateTimeRemaining();
+                        if (eta) {
+                            meta += theme.fg("dim", `  ·  ${eta}`);
+                        }
+                        lines.push(truncateToWidth(`${pad}${bar}  ${meta}`, width));
+                    }
+                }
+                lines.push("");
+                if (next) {
+                    lines.push(truncateToWidth(`${pad}${theme.fg("dim", "→")} ${theme.fg("dim", `then ${next}`)}`, width));
+                }
+                // ── Footer info (pwd, tokens, cost, context, model) ──────────────
+                lines.push("");
+                lines.push(truncateToWidth(theme.fg("dim", `${pad}${widgetPwd}`), width, theme.fg("dim", "…")));
+                // Token stats from current unit session + cumulative cost from metrics
+                {
+                    const cmdCtx = accessors.getCmdCtx();
+                    let totalInput = 0, totalOutput = 0;
+                    let totalCacheRead = 0, totalCacheWrite = 0;
+                    if (cmdCtx) {
+                        for (const entry of cmdCtx.sessionManager.getEntries()) {
+                            if (entry.type === "message") {
+                                const msgEntry = entry;
+                                if (msgEntry.message?.role === "assistant") {
+                                    const u = msgEntry.message.usage;
+                                    if (u) {
+                                        totalInput += u.input || 0;
+                                        totalOutput += u.output || 0;
+                                        totalCacheRead += u.cacheRead || 0;
+                                        totalCacheWrite += u.cacheWrite || 0;
+                                    }
+                                }
+                            }
+                        }
+                    }
+                    const mLedger = getLedger();
+                    const autoTotals = mLedger ? getProjectTotals(mLedger.units) : null;
+                    const cumulativeCost = autoTotals?.cost ?? 0;
+                    const cxUsage = cmdCtx?.getContextUsage?.();
+                    const cxWindow = cxUsage?.contextWindow ?? cmdCtx?.model?.contextWindow ?? 0;
+                    const cxPctVal = cxUsage?.percent ?? 0;
+                    const cxPct = cxUsage?.percent !== null ? cxPctVal.toFixed(1) : "?";
+                    const sp = [];
+                    if (totalInput)
+                        sp.push(`↑${formatWidgetTokens(totalInput)}`);
+                    if (totalOutput)
+                        sp.push(`↓${formatWidgetTokens(totalOutput)}`);
+                    if (totalCacheRead)
+                        sp.push(`R${formatWidgetTokens(totalCacheRead)}`);
+                    if (totalCacheWrite)
+                        sp.push(`W${formatWidgetTokens(totalCacheWrite)}`);
+                    // Cache hit rate for current unit
+                    if (totalCacheRead + totalInput > 0) {
+                        const hitRate = Math.round((totalCacheRead / (totalCacheRead + totalInput)) * 100);
+                        sp.push(`\u26A1${hitRate}%`);
+                    }
+                    if (cumulativeCost)
+                        sp.push(`$${cumulativeCost.toFixed(3)}`);
+                    else if (autoTotals?.apiRequests)
+                        sp.push(`${autoTotals.apiRequests} reqs`);
+                    const cxDisplay = cxPct === "?"
+                        ? `?/${formatWidgetTokens(cxWindow)}`
+                        : `${cxPct}%/${formatWidgetTokens(cxWindow)}`;
+                    if (cxPctVal > 90) {
+                        sp.push(theme.fg("error", cxDisplay));
+                    }
+                    else if (cxPctVal > 70) {
+                        sp.push(theme.fg("warning", cxDisplay));
+                    }
+                    else {
+                        sp.push(cxDisplay);
+                    }
+                    const sLeft = sp.map(p => p.includes("\x1b[") ? p : theme.fg("dim", p))
+                        .join(theme.fg("dim", " "));
+                    const modelId = cmdCtx?.model?.id ?? "";
+                    const modelProvider = cmdCtx?.model?.provider ?? "";
+                    const modelPhase = phaseLabel ? theme.fg("dim", `[${phaseLabel}] `) : "";
+                    const modelDisplay = modelProvider && modelId
+                        ? `${modelProvider}/${modelId}`
+                        : modelId;
+                    const sRight = modelDisplay
+                        ? `${modelPhase}${theme.fg("dim", modelDisplay)}`
+                        : "";
+                    lines.push(rightAlign(`${pad}${sLeft}`, sRight, width));
+                    // Dynamic routing savings summary
+                    if (mLedger && mLedger.units.some(u => u.tier)) {
+                        const savings = formatTierSavings(mLedger.units);
+                        if (savings) {
+                            lines.push(truncateToWidth(theme.fg("dim", `${pad}${savings}`), width));
+                        }
+                    }
+                }
+                const hintParts = [];
+                hintParts.push("esc pause");
+                hintParts.push(process.platform === "darwin" ? "⌃⌥G dashboard" : "Ctrl+Alt+G dashboard");
+                lines.push(...ui.hints(hintParts));
+                lines.push(...ui.bar());
+                cachedLines = lines;
+                cachedWidth = width;
+                return lines;
+            },
+            invalidate() {
+                cachedLines = undefined;
+                cachedWidth = undefined;
+            },
+            dispose() {
+                clearInterval(pulseTimer);
+                if (progressRefreshTimer)
+                    clearInterval(progressRefreshTimer);
+            },
+        };
+    });
+}
+// ─── Text Fallback for RPC Mode ───────────────────────────────────────────
+/**
+ * Build a compact string-array representation of the progress widget.
+ * Used as a fallback when the factory-based widget cannot render (RPC mode).
+ */
+// ─── Model Health Indicator ───────────────────────────────────────────────────
+/**
+ * Compute a traffic-light health indicator from observable signals.
+ * 🟢 progressing well — no errors, trend stable/improving
+ * 🟡 struggling — some errors or degrading trend
+ * 🔴 stuck — consecutive errors, likely needs attention
+ */
+export function getModelHealthIndicator() {
+    const trend = getHealthTrend();
+    const consecutiveErrors = getConsecutiveErrorUnits();
+    if (consecutiveErrors >= 3) {
+        return { emoji: "🔴", label: "stuck" };
+    }
+    if (consecutiveErrors >= 1 || trend === "degrading") {
+        return { emoji: "🟡", label: "struggling" };
+    }
+    if (trend === "improving") {
+        return { emoji: "🟢", label: "progressing well" };
+    }
+    // stable or unknown
+    return { emoji: "🟢", label: "progressing" };
+}
+function buildProgressTextLines(verb, phaseLabel, unitId, mid, slice, task, next, accessors, tierBadge, widgetPwd) {
+    const mode = accessors.isStepMode() ? "step" : "auto";
+    const elapsed = formatAutoElapsed(accessors.getAutoStartTime());
+    const tierStr = tierBadge ? ` [${tierBadge}]` : "";
+    const lines = [];
+    lines.push(`[GSD ${mode}] ${verb} ${unitId}${tierStr}${elapsed ? ` — ${elapsed}` : ""}`);
+    if (mid)
+        lines.push(`  Milestone: ${mid.id} — ${mid.title}`);
+    if (slice)
+        lines.push(`  Slice: ${slice.id} — ${slice.title}`);
+    if (task)
+        lines.push(`  Task: ${task.id} — ${task.title}`);
+    // Progress bar
+    const sp = cachedSliceProgress;
+    if (sp && sp.total > 0) {
+        const pct = Math.round((sp.done / sp.total) * 100);
+        const taskInfo = sp.activeSliceTasks
+            ? ` (tasks: ${sp.activeSliceTasks.done}/${sp.activeSliceTasks.total})`
+            : "";
+        lines.push(`  Progress: ${sp.done}/${sp.total} slices (${pct}%)${taskInfo}`);
+    }
+    // Cost / tokens
+    const ledger = getLedger();
+    const totals = ledger ? getProjectTotals(ledger.units) : null;
+    if (totals) {
+        const parts = [];
+        if (totals.tokens.input || totals.tokens.output) {
+            parts.push(`tokens: ${formatWidgetTokens(totals.tokens.input)}↑ ${formatWidgetTokens(totals.tokens.output)}↓`);
+        }
+        if (totals.cost > 0) {
+            parts.push(`cost: ${formatCost(totals.cost)}`);
+        }
+        if (parts.length > 0)
+            lines.push(`  ${parts.join(" — ")}`);
+    }
+    if (next)
+        lines.push(`  Next: ${next}`);
+    // Model health indicator
+    const health = getModelHealthIndicator();
+    lines.push(`  Health: ${health.emoji} ${health.label}`);
+    lines.push(`  ${widgetPwd}`);
+    return lines;
+}
+// ─── Right-align Helper ───────────────────────────────────────────────────────
+/** Right-align helper: build a line with left content and right content. */
+function rightAlign(left, right, width) {
+    const leftVis = visibleWidth(left);
+    const rightVis = visibleWidth(right);
+    const gap = Math.max(1, width - leftVis - rightVis);
+    return truncateToWidth(left + " ".repeat(gap) + right, width);
+}