pi-minimal 0.1.0 → 0.2.2

package/dist/tools.js

@@ -1,103 +1,172 @@
-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 * as chrome from "./chrome.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";
+/** Tolerates a stale chrome module after /reload, where only CHROME_MARGIN may exist. */
+const margin = () => (typeof chrome.chromeMargin === "function" ? chrome.chromeMargin() : (chrome.CHROME_MARGIN ?? 1));
 const live = createLiveWatch(400);
+/** Left indent of every tool row: chrome margin plus one cell so rows sit inside message text. */
+const rowIndent = () => margin() + 1;
+/** 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(rowIndent() + 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(rowIndent() + 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 - rowIndent());
+            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(rowIndent()) +
+                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);
+    });
+}

package/dist/turn-rule.js

@@ -0,0 +1,121 @@
+import { truncateToWidth, visibleWidth } from "@earendil-works/pi-tui";
+import * as chrome from "./chrome.js";
+import { formatElapsed } from "./working-status.js";
+/** Tolerates a stale chrome module after /reload, where only CHROME_MARGIN may exist. */
+const margin = () => (typeof chrome.chromeMargin === "function" ? chrome.chromeMargin() : (chrome.CHROME_MARGIN ?? 1));
+export const TURN_ENTRY_TYPE = "pi-minimal.turn";
+export function formatClock(epochMs) {
+    const d = new Date(epochMs);
+    const hh = String(d.getHours()).padStart(2, "0");
+    const mm = String(d.getMinutes()).padStart(2, "0");
+    return `${hh}:${mm}`;
+}
+export function turnLabel(summary) {
+    const parts = [formatClock(summary.endedAt), formatElapsed(summary.elapsedMs)];
+    if (summary.tools > 0)
+        parts.push(`${summary.tools} tool${summary.tools === 1 ? "" : "s"}`);
+    if (summary.outcome === "aborted")
+        parts.push("aborted");
+    if (summary.outcome === "error")
+        parts.push("error");
+    return parts.join(" · ");
+}
+/** `── label ─────────` filling `width`; label is dropped when the row is too narrow. */
+export function ruleLine(width, label) {
+    const lead = "── ";
+    const tail = " ";
+    const minRule = 4;
+    if (width <= 0)
+        return "";
+    if (visibleWidth(lead) + visibleWidth(label) + visibleWidth(tail) + minRule > width) {
+        return "─".repeat(width);
+    }
+    const shown = truncateToWidth(label, width - lead.length - tail.length - minRule, "…");
+    const rest = Math.max(minRule, width - visibleWidth(lead) - visibleWidth(shown) - visibleWidth(tail));
+    return `${lead}${shown}${tail}${"─".repeat(rest)}`;
+}
+export function runOutcome(messages) {
+    if (!Array.isArray(messages))
+        return "completed";
+    for (let i = messages.length - 1; i >= 0; i -= 1) {
+        const message = messages[i];
+        if (message?.role !== "assistant")
+            continue;
+        if (message.stopReason === "aborted")
+            return "aborted";
+        if (message.stopReason === "error")
+            return "error";
+        return "completed";
+    }
+    return "completed";
+}
+export function isTurnSummary(data) {
+    if (!data || typeof data !== "object")
+        return false;
+    const d = data;
+    return (typeof d.endedAt === "number" &&
+        typeof d.elapsedMs === "number" &&
+        typeof d.tools === "number" &&
+        (d.outcome === "completed" || d.outcome === "aborted" || d.outcome === "error"));
+}
+export function installTurnRule(pi) {
+    let ctx;
+    let startedAt = 0;
+    let tools = 0;
+    if (typeof pi.registerEntryRenderer !== "function" || typeof pi.appendEntry !== "function") {
+        return () => { };
+    }
+    pi.registerEntryRenderer(TURN_ENTRY_TYPE, (entry, _options, theme) => {
+        if (!isTurnSummary(entry.data))
+            return undefined;
+        const label = turnLabel(entry.data);
+        const color = entry.data.outcome === "completed" ? "borderMuted" : entry.data.outcome === "aborted" ? "warning" : "error";
+        return {
+            render(width) {
+                const inner = Math.max(0, width - margin() * 2);
+                const rule = ruleLine(inner, label);
+                const colored = rule.replace(label, theme.fg("dim", label));
+                return ["", `${" ".repeat(margin())}${theme.fg(color, colored)}`];
+            },
+            invalidate() { },
+        };
+    });
+    pi.on("session_start", (_event, next) => {
+        if (next.mode !== "tui")
+            return;
+        ctx = next;
+    });
+    pi.on("agent_start", () => {
+        startedAt = Date.now();
+        tools = 0;
+    });
+    pi.on("tool_execution_end", () => {
+        tools += 1;
+    });
+    pi.on("agent_end", (event) => {
+        if (!ctx || ctx.mode !== "tui" || !startedAt)
+            return;
+        const ev = event;
+        const summary = {
+            endedAt: Date.now(),
+            elapsedMs: Date.now() - startedAt,
+            tools,
+            outcome: runOutcome(ev.messages),
+        };
+        startedAt = 0;
+        try {
+            pi.appendEntry(TURN_ENTRY_TYPE, summary);
+        }
+        catch {
+            // A session that cannot accept entries just goes without the separator.
+        }
+    });
+    pi.on("session_shutdown", () => {
+        ctx = undefined;
+        startedAt = 0;
+    });
+    return () => {
+        ctx = undefined;
+        startedAt = 0;
+    };
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "pi-minimal",
-  "version": "0.1.0",
+  "version": "0.2.2",
   "license": "MIT",
   "type": "module",
   "private": false,
@@ -10,9 +10,20 @@
   "keywords": [
     "pi-package"
   ],
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/raviy06/pi-minimal.git"
+  },
+  "homepage": "https://github.com/raviy06/pi-minimal#readme",
+  "bugs": {
+    "url": "https://github.com/raviy06/pi-minimal/issues"
+  },
   "pi": {
     "extensions": [
       "./dist/index.js"
+    ],
+    "themes": [
+      "./themes/minimal-dark.json"
     ]
   },
   "peerDependencies": {
@@ -20,8 +31,8 @@
     "@earendil-works/pi-tui": "*"
   },
   "devDependencies": {
-    "@earendil-works/pi-coding-agent": "*",
-    "@earendil-works/pi-tui": "*",
+    "@earendil-works/pi-coding-agent": "^1.4.0",
+    "@earendil-works/pi-tui": "^1.4.0",
     "@eslint/js": "^10.0.1",
     "@types/node": "*",
     "eslint": "^10.11.0",

package/release-notes.md

@@ -0,0 +1,32 @@
+### Added
+- Fenced code renders as a closed box (`╭─ lang ─╮` / `│ code │` / `╰───╯`)
+  instead of literal ``` lines, keeping syntax highlighting; long lines wrap
+  inside the box. pi-tui exposes no hook for this, so pi-minimal post-processes
+  the code token's rendered lines.
+
+### Changed
+- Chrome margin (status line, footer, turn rule, tool rows) follows pi's
+  `outputPad` setting so it lines up with transcript text. Set
+  `editorPaddingX` to the same value for a flush left edge.
+- Chrome modules tolerate a stale `chrome` module after `/reload`, which
+  previously could crash the renderer when the package was updated in place.
+- `mdCodeBlockBorder` in `minimal-dark` is a faint grey again (it frames the
+  box now) instead of background-coloured.
+
+## What's Changed
+* Fix trusted publishing: upgrade npm, make Publish re-runnable by @raviy06 in https://github.com/raviy06/pi-minimal/pull/7
+* Add Dependabot configuration file by @raviy06 in https://github.com/raviy06/pi-minimal/pull/9
+* Create SECURITY.md for security policy by @raviy06 in https://github.com/raviy06/pi-minimal/pull/10
+* Pin npm 11 for trusted publishing by @raviy06 in https://github.com/raviy06/pi-minimal/pull/8
+* Drop registry-url so npm uses OIDC instead of a placeholder token by @raviy06 in https://github.com/raviy06/pi-minimal/pull/11
+* Add repository metadata required for npm provenance by @raviy06 in https://github.com/raviy06/pi-minimal/pull/12
+* Frame fenced code, align chrome with outputPad (0.2.2) by @raviy06 in https://github.com/raviy06/pi-minimal/pull/13
+
+
+**Full Changelog**: https://github.com/raviy06/pi-minimal/compare/v0.2.1...v0.2.2
+
+---
+**Install / upgrade**
+```bash
+pi install npm:pi-minimal@0.2.2   # or: pi update --extensions
+```

package/src/activity.ts

@@ -10,7 +10,3 @@ export function rowIsRunning(context: ActivityContext): boolean {
   if (context.isPartial === false) return false
   return true
 }
-
-export function activityBullet(running: boolean, frame: 0 | 1): "◆" | "◇" {
-  return running && frame === 1 ? "◇" : "◆"
-}

package/src/chrome.ts

@@ -1 +1,19 @@
+/**
+ * Horizontal margin for pi-minimal's chrome (status line, footer, turn rule, tool rows).
+ * Follows pi's `outputPad` setting so chrome lines up with transcript text. Pi's editor uses
+ * the separate `editorPaddingX` setting (default 0); set it to the same value for a flush
+ * left edge.
+ */
+const KEY = Symbol.for("pi-minimal.chrome-margin")
+const store = globalThis as unknown as Record<symbol, number | undefined>
+
+/** Kept for modules linked against an older copy of this file across a hot reload. */
 export const CHROME_MARGIN = 1
+
+export function chromeMargin(): number {
+  return store[KEY] ?? CHROME_MARGIN
+}
+
+export function setChromeMargin(value: number): void {
+  store[KEY] = value === 0 ? 0 : 1
+}

package/src/code-box.ts

@@ -0,0 +1,86 @@
+import { Markdown, visibleWidth, wrapTextWithAnsi } from "@earendil-works/pi-tui"
+
+/**
+ * pi-tui renders fenced code as literal ``` lines. Pi exposes no hook for the code token, so
+ * pi-minimal post-processes the rendered lines of every `code` token into a closed box:
+ *
+ *   ╭─ json ──────────────╮
+ *   │ { "a": 1 }          │
+ *   ╰─────────────────────╯
+ *
+ * Code lines longer than the box are wrapped inside it so the right edge stays intact.
+ */
+
+type CodeToken = { type?: string; lang?: string; text?: string }
+type MarkdownThemeLike = {
+  codeBlockBorder: (text: string) => string
+  codeBlockIndent?: string
+}
+
+const PATCHED = Symbol.for("pi-minimal.code-box")
+/** Current framing implementation. Lives on globalThis so a /reload swaps the behaviour of the
+ *  wrapper that an earlier load already installed on pi-tui's shared Markdown prototype. */
+const FRAME_SLOT = Symbol.for("pi-minimal.code-box.frame")
+
+type Framer = (lines: string[], lang: string | undefined, width: number, theme: MarkdownThemeLike) => string[]
+const slots = globalThis as unknown as Record<symbol, Framer | undefined>
+
+export function frameCodeLines(lines: string[], lang: string | undefined, width: number, theme: MarkdownThemeLike): string[] {
+  if (lines.length < 2) return lines
+  // Trailing spacer ("" after the closing fence) is preserved as-is.
+  let end = lines.length
+  while (end > 0 && lines[end - 1] === "") end -= 1
+  if (end < 2) return lines
+  const trailer = lines.slice(end)
+  const body = lines.slice(1, end - 1)
+  const indent = theme.codeBlockIndent ?? "  "
+  const outer = Math.max(6, width)
+  // "│ " + content + " │"
+  const innerWidth = outer - 4
+
+  const label = lang ? ` ${lang} ` : ""
+  const topRule = "─".repeat(Math.max(1, outer - 3 - visibleWidth(label)))
+  const top = theme.codeBlockBorder(`╭─${label}${topRule}╮`)
+  const bottom = theme.codeBlockBorder(`╰${"─".repeat(outer - 2)}╯`)
+  const edge = theme.codeBlockBorder("│")
+
+  const framed: string[] = []
+  for (const line of body) {
+    const content = line.startsWith(indent) ? line.slice(indent.length) : line
+    for (const piece of wrapTextWithAnsi(content, innerWidth)) {
+      const pad = Math.max(0, innerWidth - visibleWidth(piece))
+      framed.push(`${edge} ${piece}${" ".repeat(pad)} ${edge}`)
+    }
+  }
+  if (framed.length === 0) framed.push(`${edge} ${" ".repeat(innerWidth)} ${edge}`)
+  return [top, ...framed, bottom, ...trailer]
+}
+
+type RenderToken = (this: { theme: MarkdownThemeLike }, token: CodeToken, width: number, next?: string, style?: unknown) => string[]
+
+/**
+ * Patch pi-tui's Markdown renderer. The prototype wrapper is installed once per process; every
+ * call (including after /reload) points it at this module's `frameCodeLines`.
+ * Returns false when the renderer is not patchable.
+ */
+export function installCodeBox(): boolean {
+  slots[FRAME_SLOT] = frameCodeLines
+  const proto = Markdown.prototype as unknown as Record<string | symbol, unknown>
+  if (proto[PATCHED]) return true
+  const original = proto.renderToken
+  if (typeof original !== "function") return false
+  const originalRender = original as RenderToken
+  proto.renderToken = function (this: { theme: MarkdownThemeLike }, token: CodeToken, width: number, next?: string, style?: unknown) {
+    const lines = originalRender.call(this, token, width, next, style)
+    if (token?.type !== "code" || !this.theme?.codeBlockBorder) return lines
+    const frame = slots[FRAME_SLOT]
+    if (!frame) return lines
+    try {
+      return frame(lines, token.lang, width, this.theme)
+    } catch {
+      return lines
+    }
+  }
+  proto[PATCHED] = true
+  return true
+}