pi-minimal 0.1.0 → 0.2.1

package/dist/git-state.js

@@ -0,0 +1,63 @@
+export function parseBranch(stdout) {
+    const line = stdout.trim().split("\n")[0]?.trim();
+    if (!line || line === "HEAD")
+        return undefined;
+    return line;
+}
+export function parsePorcelain(stdout) {
+    return stdout.split("\n").filter((line) => line.trim().length > 0).length;
+}
+export function formatGitState(state) {
+    if (!state?.branch)
+        return { branch: "", dirty: "" };
+    const dirty = state.dirty && state.dirty > 0 ? `±${state.dirty}` : "";
+    return { branch: state.branch, dirty };
+}
+/**
+ * Polls git for the current branch and dirty count. Call `refresh()` after events that may have
+ * changed the tree (tool results, turn end); `get()` is always synchronous.
+ */
+export function createGitState(pi, cwd, minIntervalMs = 5000) {
+    let state;
+    let lastRun = 0;
+    let inFlight;
+    const listeners = new Set();
+    const refresh = (force = false) => {
+        const now = Date.now();
+        if (inFlight)
+            return inFlight;
+        if (!force && now - lastRun < minIntervalMs)
+            return Promise.resolve();
+        lastRun = now;
+        inFlight = (async () => {
+            try {
+                const branchRun = await pi.exec("git", ["rev-parse", "--abbrev-ref", "HEAD"], { cwd: cwd(), timeout: 2000 });
+                if (branchRun.code !== 0) {
+                    state = undefined;
+                    return;
+                }
+                const branch = parseBranch(branchRun.stdout);
+                const statusRun = await pi.exec("git", ["status", "--porcelain"], { cwd: cwd(), timeout: 3000 });
+                const dirty = statusRun.code === 0 ? parsePorcelain(statusRun.stdout) : undefined;
+                state = { branch, dirty };
+            }
+            catch {
+                state = undefined;
+            }
+            finally {
+                inFlight = undefined;
+                for (const listener of listeners)
+                    listener();
+            }
+        })();
+        return inFlight;
+    };
+    return {
+        get: () => state,
+        refresh,
+        onChange(listener) {
+            listeners.add(listener);
+            return () => listeners.delete(listener);
+        },
+    };
+}

package/dist/index.js

@@ -5,11 +5,17 @@ import { installFooter } from "./footer.js";
 import { installCwd } from "./cwd.js";
 import { listSiblings, parseAgentList, parseTabList } from "./herdr.js";
 import { hideGauntletWidgets } from "./tracker.js";
-import { stopLiveWatch, wrapBuiltinTools } from "./tools.js";
+import { installToolRenderers, stopLiveWatch } from "./tools.js";
 import { applyReclaim, reclaimPolicy } from "./reclaim.js";
 import { installWorkingStatus } from "./working-status.js";
+import { installTurnRule } from "./turn-rule.js";
+import { installTranscript } from "./transcript.js";
+import { createGitState } from "./git-state.js";
 export default function piMinimalExtension(pi) {
     const stopWorkingStatus = installWorkingStatus(pi);
+    const stopTurnRule = installTurnRule(pi);
+    installToolRenderers(pi);
+    installTranscript(pi);
     let fastTimer;
     let slowTimer;
     let stealTimer;
@@ -17,6 +23,9 @@ export default function piMinimalExtension(pi) {
     let siblings;
     let generation = 0;
     let hideWidgets = true;
+    let busy = false;
+    let currentCwd = process.cwd();
+    const gitState = createGitState(pi, () => currentCwd);
     const stopTimers = () => {
         if (fastTimer)
             clearInterval(fastTimer);
@@ -103,16 +112,37 @@ export default function piMinimalExtension(pi) {
             },
             chrome: () => {
                 installHeader(ctx);
-                installFooter(ctx, () => siblings);
+                installChromeFooter(ctx);
             },
         });
     };
+    const contextPct = (ctx) => {
+        const usage = ctx.getContextUsage?.();
+        const window = usage?.contextWindow || ctx.model?.contextWindow;
+        if (typeof usage?.tokens !== "number" || !window)
+            return undefined;
+        return Math.max(0, Math.min(100, Math.round((usage.tokens / window) * 100)));
+    };
+    const installChromeFooter = (ctx) => {
+        installFooter(ctx, {
+            busy: () => busy,
+            editorText: () => (typeof ctx.ui.getEditorText === "function" ? ctx.ui.getEditorText() : ""),
+            contextPct: () => contextPct(ctx),
+        });
+    };
+    const installStatusLine = (ctx) => {
+        installCwd(ctx, {
+            gitState: gitState.get,
+            siblings: () => siblings,
+            onGitChange: gitState.onChange,
+        });
+    };
     const pinChrome = (ctx, reason) => {
         hideForeignChrome(ctx, reason);
         if (ctx.mode !== "tui" || !reclaimPolicy(reason).reinstallChrome)
             return;
         ctx.ui.setWidget("tw-cwd", undefined);
-        installCwd(ctx);
+        installStatusLine(ctx);
     };
     pi.on("session_start", async (_event, ctx) => {
         if (ctx.mode !== "tui")
@@ -123,10 +153,11 @@ export default function piMinimalExtension(pi) {
             projectTrusted: ctx.isProjectTrusted(),
         });
         hideWidgets = config.hideGauntletWidgets;
+        currentCwd = ctx.cwd;
         installHeader(ctx);
-        installFooter(ctx, () => siblings);
-        installCwd(ctx);
-        wrapBuiltinTools(pi, ctx);
+        installChromeFooter(ctx);
+        installStatusLine(ctx);
+        void gitState.refresh(true);
         pinChrome(ctx, "session_start");
         ctx.ui.setHiddenThinkingLabel("◆ Thought");
         ctx.ui.setWorkingIndicator();
@@ -139,15 +170,26 @@ export default function piMinimalExtension(pi) {
             await probe(ctx);
         }
     });
+    pi.on("agent_start", () => {
+        busy = true;
+    });
+    pi.on("agent_end", () => {
+        busy = false;
+        void gitState.refresh();
+    });
     pi.on("turn_end", (_event, ctx) => {
         pinChrome(ctx, "turn_end");
+        void gitState.refresh();
     });
     pi.on("tool_execution_end", (_event, ctx) => {
         pinChrome(ctx, "tool_execution_end");
+        void gitState.refresh();
     });
     pi.on("session_shutdown", async () => {
+        busy = false;
         stopTimers();
         stopWorkingStatus();
+        stopTurnRule();
         stopLiveWatch();
         generation += 1;
         siblings = undefined;

package/dist/tool-rows.js

@@ -1,7 +1,7 @@
-let activityGroup;
-export function resetActivityGroup() {
-    activityGroup = undefined;
-}
+import { truncateToWidth, visibleWidth } from "@earendil-works/pi-tui";
+/** Width of the verb column so items align across rows. */
+export const VERB_WIDTH = 5;
+const BASH_STATUS = /^Command (?:exited with code (\d+)|terminated without an exit code)$/;
 export function shortName(path) {
     const parts = path.split("/").filter(Boolean);
     if (parts.length <= 1)
@@ -22,13 +22,144 @@ export function toolItem(kind, args) {
         "";
     return path ? shortName(path) : kind;
 }
-export function nextGroupedRow(verb, item, id) {
-    if (activityGroup && activityGroup.verb === verb) {
-        activityGroup.seen.add(id);
-        if (id === activityGroup.leadId)
-            return { header: verb, item };
-        return { header: undefined, item };
+export function resultText(result) {
+    if (!result?.content)
+        return "";
+    return result.content
+        .filter((part) => part.type === "text" && typeof part.text === "string")
+        .map((part) => part.text)
+        .join("\n");
+}
+export function rowGlyph(status, frame) {
+    if (status === "running")
+        return frame === 1 ? "◓" : "◐";
+    return status === "error" ? "✗" : "✓";
+}
+export function formatDuration(ms) {
+    if (ms === undefined || !Number.isFinite(ms))
+        return "";
+    if (ms < 1000)
+        return `${Math.round(ms / 100) / 10}s`;
+    if (ms < 60_000)
+        return `${Math.round(ms / 100) / 10}s`;
+    const minutes = Math.floor(ms / 60_000);
+    const seconds = Math.round((ms % 60_000) / 1000);
+    return `${minutes}m ${seconds}s`;
+}
+function plural(n, word, pluralWord = `${word}s`) {
+    return `${n} ${n === 1 ? word : pluralWord}`;
+}
+function countLines(text) {
+    if (!text)
+        return 0;
+    return text.split("\n").filter((line) => line.length > 0).length;
+}
+/** Strip pi's bash status trailer and truncation note from output text. */
+export function bashBody(text) {
+    const lines = text.split("\n");
+    let exitCode;
+    while (lines.length > 0) {
+        const last = lines[lines.length - 1].trim();
+        const match = BASH_STATUS.exec(last);
+        if (match) {
+            exitCode = match[1] !== undefined ? Number(match[1]) : undefined;
+            lines.pop();
+            continue;
+        }
+        if (last.startsWith("[Showing ") && last.endsWith("]")) {
+            lines.pop();
+            continue;
+        }
+        if (last === "") {
+            lines.pop();
+            continue;
+        }
+        break;
+    }
+    return { body: lines.join("\n"), exitCode };
+}
+export function diffStats(diff) {
+    let added = 0;
+    let removed = 0;
+    for (const line of diff.split("\n")) {
+        if (line.startsWith("+++") || line.startsWith("---"))
+            continue;
+        if (line.startsWith("+"))
+            added += 1;
+        else if (line.startsWith("-"))
+            removed += 1;
+    }
+    return { added, removed };
+}
+export function formatOutcome(kind, args, result, isError, durationMs) {
+    const text = resultText(result);
+    const dur = formatDuration(durationMs);
+    const join = (...parts) => parts.filter(Boolean).join(" · ");
+    if (kind === "bash") {
+        const { body, exitCode } = bashBody(text);
+        if (isError || (exitCode !== undefined && exitCode !== 0)) {
+            const code = exitCode !== undefined ? `exit ${exitCode}` : "failed";
+            return { text: join(code, dur), errorLine: firstLine(body) };
+        }
+        const lines = countLines(body);
+        const summary = lines === 0 || body === "(no output)" ? "ok" : plural(lines, "line");
+        return { text: join(summary, dur) };
+    }
+    if (isError)
+        return { text: join("failed", dur), errorLine: firstLine(text) };
+    if (kind === "edit") {
+        const details = result?.details;
+        const diff = typeof details?.diff === "string" ? diffStats(details.diff) : undefined;
+        return diff ? { text: dur, diff } : { text: join("edited", dur) };
+    }
+    if (kind === "write") {
+        const bytes = typeof args?.content === "string" ? Buffer.byteLength(args.content, "utf8") : undefined;
+        return { text: join(bytes === undefined ? "written" : formatBytes(bytes), dur) };
+    }
+    if (kind === "read") {
+        return { text: join(plural(countLines(text), "line"), dur) };
+    }
+    if (kind === "grep") {
+        if (/^No matches found/m.test(text))
+            return { text: join("0 matches", dur) };
+        return { text: join(plural(countLines(text), "match"), dur) };
+    }
+    // find / ls
+    return { text: join(plural(countLines(text), "entry", "entries"), dur) };
+}
+export function firstLine(text) {
+    for (const line of text.split("\n")) {
+        const trimmed = line.trim();
+        if (trimmed && trimmed !== "(no output)")
+            return trimmed;
+    }
+    return undefined;
+}
+export function formatBytes(n) {
+    if (n < 1024)
+        return `${n} B`;
+    if (n < 1024 * 1024)
+        return `${Math.round(n / 102.4) / 10} KB`;
+    return `${Math.round(n / (1024 * 102.4)) / 10} MB`;
+}
+/**
+ * Lay out one row: `<glyph> <verb> <item> ... <outcome>`. The item is truncated so the outcome
+ * stays visible; the outcome is dropped only when the row is too narrow to show both.
+ */
+export function layoutRow(width, verb, item, outcome) {
+    const verbCol = verb.padEnd(VERB_WIDTH);
+    // glyph + space + verb column + space
+    const prefixWidth = 2 + VERB_WIDTH + 1;
+    const outcomeWidth = visibleWidth(outcome);
+    const minGap = 2;
+    let shownOutcome = outcome;
+    let itemRoom = width - prefixWidth - (outcomeWidth ? outcomeWidth + minGap : 0);
+    if (itemRoom < 12 && outcomeWidth) {
+        shownOutcome = "";
+        itemRoom = width - prefixWidth;
     }
-    activityGroup = { verb, leadId: id, seen: new Set([id]) };
-    return { header: verb, item };
+    const shownItem = truncateToWidth(item, Math.max(0, itemRoom), "…");
+    const used = prefixWidth + visibleWidth(shownItem) + visibleWidth(shownOutcome);
+    const gap = shownOutcome ? Math.max(minGap, width - used) : 0;
+    return { verb: verbCol, item: shownItem, gap, outcome: shownOutcome };
 }

package/dist/tools.js

@@ -1,103 +1,169 @@
-import { createBashToolDefinition, createEditToolDefinition, createFindToolDefinition, createGrepToolDefinition, createLsToolDefinition, createReadToolDefinition, createWriteToolDefinition, SettingsManager, } from "@earendil-works/pi-coding-agent";
-import { Container, Text, truncateToWidth } from "@earendil-works/pi-tui";
-import { activityBullet, rowIsRunning } from "./activity.js";
+import { Container, truncateToWidth } from "@earendil-works/pi-tui";
+import { rowIsRunning } from "./activity.js";
 import { createLiveWatch } from "./live-watch.js";
-import { nextGroupedRow, toolItem } from "./tool-rows.js";
+import { bashBody, formatDuration, formatOutcome, layoutRow, resultText, rowGlyph, toolItem, } from "./tool-rows.js";
 const live = createLiveWatch(400);
+/** Left indent of every tool row, in cells. */
+const ROW_INDENT = 2;
+/** Max lines of output shown when a row is expanded. */
+const EXPANDED_MAX_LINES = 400;
 export function stopLiveWatch() {
     live.stop();
 }
 function liveId(context, item) {
     return context.toolCallId || item;
 }
-function contentText(result) {
-    if (!result?.content)
-        return "";
-    return result.content
-        .filter((part) => part.type === "text" && typeof part.text === "string")
-        .map((part) => part.text)
-        .join("\n");
+function rowStatus(context) {
+    if (context.isError)
+        return "error";
+    if (context.state.outcome?.errorLine)
+        return "error";
+    return rowIsRunning(context) ? "running" : "ok";
 }
-function collapsedResult() {
-    return new Container();
+function statusColor(status) {
+    if (status === "error")
+        return "error";
+    if (status === "running")
+        return "warning";
+    return "success";
 }
-function expandedContent(result, options) {
-    if (!options.expanded)
-        return collapsedResult();
-    const text = contentText(result);
-    return text ? new Text(text, 0, 0) : collapsedResult();
+function expandedLines(kind, result) {
+    let text = resultText(result);
+    if (kind === "bash")
+        text = bashBody(text).body;
+    if (!text)
+        return [];
+    const lines = text.split("\n");
+    if (lines.length > EXPANDED_MAX_LINES) {
+        const hidden = lines.length - EXPANDED_MAX_LINES;
+        return [...lines.slice(0, EXPANDED_MAX_LINES), `… ${hidden} more lines`];
+    }
+    return lines;
+}
+function outputBlock(kind, result, theme) {
+    const lines = expandedLines(kind, result);
+    if (lines.length === 0)
+        return new Container();
+    const indent = " ".repeat(ROW_INDENT + 2);
+    const rule = theme.fg("borderMuted", "│");
+    return {
+        render(width) {
+            const inner = Math.max(0, width - indent.length - 2);
+            return lines.map((line) => `${indent}${rule} ${theme.fg("dim", truncateToWidth(line, inner))}`);
+        },
+        invalidate() { },
+    };
 }
-function activityBlock(kind, args, theme, context) {
+function errorLineBlock(line, theme) {
+    if (!line)
+        return undefined;
+    const indent = " ".repeat(ROW_INDENT + 2);
+    const rule = theme.fg("error", "│");
+    return {
+        render(width) {
+            const inner = Math.max(0, width - indent.length - 2);
+            return [`${indent}${rule} ${theme.fg("error", truncateToWidth(line, inner))}`];
+        },
+        invalidate() { },
+    };
+}
+function activityRow(kind, args, theme, context) {
     const item = toolItem(kind, args);
     const id = liveId(context, item);
-    const row = nextGroupedRow(kind, item, id);
     const running = rowIsRunning(context);
     context.state.running = running;
-    if (running)
+    if (running) {
+        context.state.startedAt ??= Date.now();
         live.watch(id, context.invalidate);
-    else
+    }
+    else {
         live.unwatch(id);
-    const color = context.isError ? "error" : running ? "warning" : "dim";
+    }
     return {
         render(width) {
-            const pad = 1;
-            const inner = Math.max(0, width - pad);
-            const lines = [];
-            if (row.header) {
-                const blink = Boolean(context.state.running) && live.has(id);
-                const bullet = activityBullet(blink, live.frame);
-                lines.push(" ".repeat(pad) + theme.fg(color, truncateToWidth(`${bullet} ${row.header}`, inner)));
+            const status = rowStatus(context);
+            const blink = status === "running" && live.has(id);
+            const glyph = rowGlyph(status, blink ? live.frame : 0);
+            const outcome = context.state.outcome;
+            const diff = status !== "running" ? outcome?.diff : undefined;
+            let right = "";
+            if (status === "running") {
+                const started = context.state.startedAt;
+                right = started ? formatDuration(Date.now() - started) : "";
             }
-            lines.push(" ".repeat(pad) + "  " + theme.fg(color, truncateToWidth(row.item, Math.max(0, inner - 2))));
-            return lines;
+            else if (outcome) {
+                right = outcome.text;
+                if (diff) {
+                    const stats = `+${diff.added} −${diff.removed}`;
+                    right = right ? `${stats} · ${right}` : stats;
+                }
+            }
+            const inner = Math.max(8, width - ROW_INDENT);
+            const row = layoutRow(inner, kind, item, right);
+            let coloredRight;
+            if (status === "running")
+                coloredRight = theme.fg("warning", row.outcome);
+            else if (status === "error")
+                coloredRight = theme.fg("error", row.outcome);
+            else if (diff && row.outcome) {
+                const rest = row.outcome.slice(`+${diff.added} −${diff.removed}`.length);
+                coloredRight =
+                    theme.fg("success", `+${diff.added}`) + " " + theme.fg("error", `−${diff.removed}`) + theme.fg("dim", rest);
+            }
+            else
+                coloredRight = theme.fg("dim", row.outcome);
+            const line = " ".repeat(ROW_INDENT) +
+                theme.fg(statusColor(status), glyph) +
+                " " +
+                theme.fg("dim", row.verb) +
+                " " +
+                theme.fg(status === "error" ? "text" : "muted", row.item) +
+                " ".repeat(row.gap) +
+                coloredRight;
+            return [line];
         },
         invalidate() { },
     };
 }
-function wrapOne(pi, kind, factory) {
-    try {
-        const tool = factory();
-        pi.registerTool({
-            ...tool,
-            renderShell: "self",
-            renderCall(args, theme, context) {
-                return activityBlock(kind, args, theme, context);
-            },
-            renderResult(result, options, _theme, context) {
-                const renderContext = context;
-                if (!renderContext.isPartial) {
-                    renderContext.state.done = true;
-                    renderContext.state.running = false;
-                    live.unwatch(liveId(renderContext, toolItem(kind, renderContext.args)));
-                }
-                return expandedContent(result, options);
-            },
-        });
-    }
-    catch {
-        // A missing built-in tool leaves the rest of the compact renderers available.
-    }
+const TOOL_KINDS = new Set(["bash", "read", "edit", "write", "grep", "find", "ls"]);
+export function isToolKind(name) {
+    return TOOL_KINDS.has(name);
 }
-export function wrapBuiltinTools(pi, ctx) {
-    let commandPrefix;
-    let shellPath;
-    let autoResizeImages;
-    try {
-        const settings = SettingsManager.create(ctx.cwd, undefined, {
-            projectTrusted: ctx.isProjectTrusted(),
-        });
-        commandPrefix = settings.getShellCommandPrefix();
-        shellPath = settings.getShellPath();
-        autoResizeImages = settings.getImageAutoResize();
-    }
-    catch {
-        // Tool wrapping still works when optional shell or image settings are unavailable.
-    }
-    wrapOne(pi, "bash", () => createBashToolDefinition(ctx.cwd, { commandPrefix, shellPath }));
-    wrapOne(pi, "read", () => createReadToolDefinition(ctx.cwd, { autoResizeImages }));
-    wrapOne(pi, "edit", () => createEditToolDefinition(ctx.cwd));
-    wrapOne(pi, "write", () => createWriteToolDefinition(ctx.cwd));
-    wrapOne(pi, "grep", () => createGrepToolDefinition(ctx.cwd));
-    wrapOne(pi, "find", () => createFindToolDefinition(ctx.cwd));
-    wrapOne(pi, "ls", () => createLsToolDefinition(ctx.cwd));
+export function compactRenderers(kind) {
+    return {
+        renderShell: "self",
+        renderCall(args, theme, context) {
+            return activityRow(kind, args, theme, context);
+        },
+        renderResult(result, options, theme, context) {
+            const renderContext = context;
+            const typedResult = result;
+            if (!renderContext.isPartial) {
+                renderContext.state.done = true;
+                renderContext.state.running = false;
+                renderContext.state.outcome = formatOutcome(kind, renderContext.args, typedResult, Boolean(renderContext.isError), renderContext.durationMs);
+                live.unwatch(liveId(renderContext, toolItem(kind, renderContext.args)));
+            }
+            const container = new Container();
+            const errorLine = errorLineBlock(renderContext.state.outcome?.errorLine, theme);
+            if (errorLine && !options.expanded)
+                container.addChild(errorLine);
+            if (options.expanded)
+                container.addChild(outputBlock(kind, typedResult, theme));
+            return container;
+        },
+    };
+}
+/**
+ * Attach the compact renderers to the built-in tools without re-registering them. Registered at
+ * extension load so a resumed transcript draws its earlier tool calls the same way as new ones.
+ */
+export function installToolRenderers(pi) {
+    if (typeof pi.registerToolRenderer !== "function")
+        return;
+    pi.registerToolRenderer((toolName, next) => {
+        if (!isToolKind(toolName))
+            return next();
+        return compactRenderers(toolName);
+    });
 }

package/dist/transcript.js

@@ -0,0 +1,50 @@
+export const THINKING_GUTTER = "┊ ";
+const FENCE = /^\s*(```|~~~)/;
+const BLOCK_START = /^\s*(#{1,6}\s|[-*+]\s|\d+[.)]\s|>|\||```|~~~|---\s*$|\*\*\*\s*$|___\s*$)/;
+/**
+ * Prefix the first line of every plain paragraph in thinking Markdown with a gutter glyph.
+ * Lines that start a Markdown block (heading, list, quote, table, fence, rule) are left alone so
+ * they keep parsing, and nothing inside a fenced code block is touched.
+ */
+export function gutterThinking(markdown) {
+    if (!markdown)
+        return markdown;
+    const lines = markdown.split("\n");
+    const out = [];
+    let inFence = false;
+    let atParagraphStart = true;
+    for (const line of lines) {
+        if (FENCE.test(line)) {
+            inFence = !inFence;
+            out.push(line);
+            atParagraphStart = !inFence;
+            continue;
+        }
+        if (inFence) {
+            out.push(line);
+            continue;
+        }
+        if (line.trim() === "") {
+            out.push(line);
+            atParagraphStart = true;
+            continue;
+        }
+        if (atParagraphStart && !BLOCK_START.test(line) && !line.startsWith(THINKING_GUTTER)) {
+            out.push(`${THINKING_GUTTER}${line}`);
+        }
+        else {
+            out.push(line);
+        }
+        atParagraphStart = false;
+    }
+    return out.join("\n");
+}
+export function installTranscript(pi) {
+    if (typeof pi.registerMarkdownTransformer !== "function")
+        return;
+    pi.registerMarkdownTransformer((markdown, context) => {
+        if (context.messageType !== "assistant-thinking")
+            return markdown;
+        return gutterThinking(markdown);
+    });
+}