@pi-unipi/unipi 3.0.0-alpha.2 → 3.0.0-alpha.21

package/packages/utility/src/render/parse.ts

@@ -0,0 +1,156 @@
+/**
+ * @pi-unipi/utility — response formatting helpers (pure)
+ *
+ * Splits a shell command into shell text and embedded code (heredoc bodies,
+ * `python -c "…"`, `node -e '…'`) with the embedded language, parses pi's
+ * display diff, and pulls exit codes and test summaries out of tool output.
+ */
+
+export interface Segment {
+  kind: "shell" | "code";
+  text: string;
+  lang: string;
+}
+
+const RUNTIME_LANG: Array<[RegExp, string]> = [
+  [/\b(?:python3?|uv run python|ipython)\b/, "python"],
+  [/\b(?:node|deno|bun|tsx|ts-node)\b/, "javascript"],
+  [/\b(?:psql|sqlite3|mysql|duckdb|clickhouse-client)\b/, "sql"],
+  [/\b(?:ruby|irb)\b/, "ruby"],
+  [/\b(?:php)\b/, "php"],
+  [/\b(?:perl)\b/, "perl"],
+  [/\b(?:lua|luajit)\b/, "lua"],
+  [/\b(?:bash|sh|zsh|ssh\s+\S+)\b/, "bash"],
+  [/\bjq\b/, "json"],
+];
+
+const EXT_LANG: Record<string, string> = {
+  py: "python", js: "javascript", mjs: "javascript", cjs: "javascript", ts: "typescript", mts: "typescript", tsx: "tsx", jsx: "jsx",
+  json: "json", yaml: "yaml", yml: "yaml", toml: "toml", sql: "sql", sh: "bash", bash: "bash", rs: "rust", go: "go",
+  rb: "ruby", md: "markdown", html: "html", css: "css", xml: "xml", ini: "ini", conf: "ini", dockerfile: "dockerfile",
+};
+
+/** Language of code fed to the command before the heredoc marker. */
+export function langForPrefix(prefix: string): string {
+  const line = prefix.split("\n").pop() ?? prefix;
+  const target = line.match(/(?:>|tee\s+(?:-a\s+)?)\s*["']?([^\s"'|;&]+)["']?\s*(?:<<|$)/)?.[1];
+  const ext = target?.split(".").pop()?.toLowerCase();
+  if (ext && EXT_LANG[ext]) return EXT_LANG[ext]!;
+  for (const [re, lang] of RUNTIME_LANG) if (re.test(line)) return lang;
+  return "text";
+}
+
+/**
+ * Shell text and embedded code, in order. Heredocs (`<<EOF`, `<<'EOF'`,
+ * `<<-"EOF"`) take the language of their command; `-c/-e` string arguments
+ * of known runtimes are highlighted as that runtime's language.
+ */
+export function splitCommand(command: string): Segment[] {
+  const out: Segment[] = [];
+  const push = (kind: Segment["kind"], text: string, lang: string) => {
+    if (!text) return;
+    const last = out.at(-1);
+    if (last && last.kind === kind && last.lang === lang) last.text += text;
+    else out.push({ kind, text, lang });
+  };
+  const heredoc = /<<-?\s*(['"]?)([A-Za-z_][A-Za-z0-9_]*)\1[^\n]*\n/g;
+  let at = 0;
+  for (let m = heredoc.exec(command); m; m = heredoc.exec(command)) {
+    const tag = m[2]!;
+    const bodyStart = m.index + m[0].length;
+    const end = new RegExp(`^[\\t ]*${tag}[\\t ]*$`, "m");
+    const rest = command.slice(bodyStart);
+    const close = end.exec(rest);
+    if (!close) continue;
+    pushInline(command.slice(at, bodyStart), push);
+    push("code", rest.slice(0, close.index), langForPrefix(command.slice(0, m.index)));
+    at = bodyStart + close.index;
+    heredoc.lastIndex = at;
+  }
+  pushInline(command.slice(at), push);
+  return out;
+}
+
+/** `python -c "…"` / `node -e '…'` → code segment; the rest stays shell. */
+function pushInline(text: string, push: (kind: Segment["kind"], text: string, lang: string) => void): void {
+  const inline = /\b(python3?|node|deno|bun|ruby|perl|psql|sqlite3)\b([^\n'"]*?\s-(?:c|e|-eval|-command)\s+)(["'])([\s\S]*?)\3/g;
+  let at = 0;
+  for (let m = inline.exec(text); m; m = inline.exec(text)) {
+    const quoteStart = m.index + m[1]!.length + m[2]!.length;
+    push("shell", text.slice(at, quoteStart + 1), "bash");
+    push("code", m[4]!, langForPrefix(m[1]!));
+    push("shell", m[3]!, "bash");
+    at = m.index + m[0].length;
+  }
+  push("shell", text.slice(at), "bash");
+}
+
+export interface DiffRow {
+  kind: "add" | "del" | "ctx" | "gap";
+  line?: number;
+  text: string;
+}
+
+/** pi's display diff (`+12 text`, `-12 text`, ` 12 text`, `...`) → rows. */
+export function parseDiff(diff: string): DiffRow[] {
+  const rows: DiffRow[] = [];
+  for (const raw of diff.split("\n")) {
+    const m = raw.match(/^([+\- ])(\s*\d+) (.*)$/);
+    if (m) {
+      rows.push({ kind: m[1] === "+" ? "add" : m[1] === "-" ? "del" : "ctx", line: Number(m[2]), text: m[3]! });
+    } else if (/^\s*\.\.\.\s*$/.test(raw) || /^[+\- ]\s*\.\.\.$/.test(raw)) {
+      rows.push({ kind: "gap", text: "" });
+    } else if (raw.length) {
+      rows.push({ kind: "ctx", text: raw });
+    }
+  }
+  return rows;
+}
+
+export function diffStats(rows: readonly DiffRow[]): { added: number; removed: number } {
+  return { added: rows.filter((r) => r.kind === "add").length, removed: rows.filter((r) => r.kind === "del").length };
+}
+
+/** Exit code from pi's bash error text; 0 for a successful result. */
+export function exitCode(text: string, isError: boolean): number | undefined {
+  const m = text.match(/Command exited with code (\d+)\s*$/);
+  if (m) return Number(m[1]);
+  if (/Command (?:aborted|terminated without an exit code)\s*$/.test(text)) return undefined;
+  return isError ? 1 : 0;
+}
+
+/** Output without pi's trailing status line. */
+export function stripStatus(text: string): string {
+  return text.replace(/\n*(?:Command exited with code \d+|Command aborted|Command terminated without an exit code)\s*$/, "");
+}
+
+/** "83 passed · 0 failed" from common test runners' summary lines. */
+export function testSummary(output: string): { passed: number; failed: number } | undefined {
+  let passed: number | undefined;
+  let failed: number | undefined;
+  const set = (p?: string, f?: string) => {
+    if (p !== undefined) passed = (passed ?? 0) + Number(p);
+    if (f !== undefined) failed = (failed ?? 0) + Number(f);
+  };
+  for (const line of output.split("\n")) {
+    const clean = line.replace(/\x1b\[[0-9;]*m/g, "");
+    let m: RegExpMatchArray | null;
+    if ((m = clean.match(/^ℹ pass (\d+)/))) set(m[1]);
+    else if ((m = clean.match(/^ℹ fail (\d+)/))) set(undefined, m[1]);
+    else if ((m = clean.match(/Tests?:?\s+(?:(\d+) failed[,|\s]+)?(\d+) passed/i))) set(m[2], m[1] ?? "0");
+    else if ((m = clean.match(/test result: \w+\. (\d+) passed; (\d+) failed/))) set(m[1], m[2]);
+    else if ((m = clean.match(/^=+ (?:(\d+) failed, )?(\d+) passed/))) set(m[2], m[1] ?? "0");
+  }
+  return passed === undefined && failed === undefined ? undefined : { passed: passed ?? 0, failed: failed ?? 0 };
+}
+
+/** Pretty JSON when the whole output is one JSON value; else undefined. */
+export function asJson(output: string): string | undefined {
+  const t = output.trim();
+  if (!/^[[{]/.test(t) || t.length > 200_000) return undefined;
+  try {
+    return JSON.stringify(JSON.parse(t), null, 2);
+  } catch {
+    return undefined;
+  }
+}

package/packages/utility/src/render/pi-settings.ts

@@ -0,0 +1,38 @@
+/**
+ * @pi-unipi/utility — the pi settings that shape the built-in tools
+ *
+ * pi builds read/bash with `images.autoResize`, `shellCommandPrefix` and
+ * `shellPath`. Re-registered tools must behave identically, so the same
+ * values are read here (global ~/.pi/agent/settings.json, then the project's
+ * .pi/settings.json on top).
+ */
+
+import { readFileSync } from "node:fs";
+import { homedir } from "node:os";
+import { join } from "node:path";
+
+function readJson(file: string): Record<string, unknown> {
+  try {
+    return JSON.parse(readFileSync(file, "utf-8")) as Record<string, unknown>;
+  } catch {
+    return {};
+  }
+}
+
+export interface PiToolOptions {
+  read: { autoResizeImages?: boolean };
+  bash: { commandPrefix?: string; shellPath?: string };
+}
+
+export function readPiToolOptions(cwd: string, agentDir = process.env.PI_AGENT_DIR || join(homedir(), ".pi", "agent")): PiToolOptions {
+  const merged = { ...readJson(join(agentDir, "settings.json")), ...readJson(join(cwd, ".pi", "settings.json")) };
+  const images = merged.images as { autoResize?: unknown } | undefined;
+  const shellPath = typeof merged.shellPath === "string" ? merged.shellPath.replace(/^~(?=\/|$)/, homedir()) : undefined;
+  return {
+    read: typeof images?.autoResize === "boolean" ? { autoResizeImages: images.autoResize } : {},
+    bash: {
+      ...(typeof merged.shellCommandPrefix === "string" ? { commandPrefix: merged.shellCommandPrefix } : {}),
+      ...(shellPath ? { shellPath } : {}),
+    },
+  };
+}

package/packages/utility/src/render/reply-bg.ts

@@ -0,0 +1,307 @@
+/**
+ * @pi-unipi/utility — "simple" style: the final reply gets a soft background.
+ *
+ * In a long transcript of collapsed tool rows the actual answer is easy to
+ * miss. An assistant message with no tool calls (the turn's reply) is painted
+ * on the darkest possible panel (true black), framed by an orange heavy rule
+ * labelled "summary" above and a matching unlabelled rule below, with one blank
+ * row of breathing space before the top rule. On light themes the text is lifted to
+ * bright white so it stays readable on the black panel.
+ *
+ * pi has no hook for assistant-message rendering, and extensions get a
+ * different module instance of AssistantMessageComponent than the one pi
+ * renders, so the class is found in the live TUI tree (duck-typed) and its
+ * render is wrapped once. Output is cached per component by width + message +
+ * colour, so a keystroke re-render is a lookup, not a repaint.
+ */
+
+import { visibleWidth } from "@earendil-works/pi-tui";
+
+const PROBE_WIDGET = "unipi-reply-bg-probe";
+const PATCHED = Symbol.for("unipi.replyBg.patched");
+
+interface AssistantLike {
+  hasToolCalls: boolean;
+  isStreaming: boolean;
+  lastMessage?: unknown;
+  contentContainer: unknown;
+  updateContent: (...args: unknown[]) => void;
+  render: (width: number) => string[];
+}
+
+interface TreeNode {
+  children?: unknown[];
+}
+
+export function isAssistant(c: unknown): c is AssistantLike {
+  const a = c as Partial<AssistantLike> | null;
+  return !!a && typeof a === "object" && "contentContainer" in a && "hasToolCalls" in a && typeof a.updateContent === "function";
+}
+
+/** Depth-first search of the TUI tree for pi's assistant message component. */
+export function findAssistant(root: unknown, depth = 0): AssistantLike | undefined {
+  if (!root || typeof root !== "object" || depth > 12) return undefined;
+  if (isAssistant(root)) return root;
+  for (const child of (root as TreeNode).children ?? []) {
+    const hit = findAssistant(child, depth + 1);
+    if (hit) return hit;
+  }
+  return undefined;
+}
+
+/** Relative luminance 0..1 of an ANSI background escape (truecolor or 256). */
+export function bgLuminance(ansi: string): number | undefined {
+  const tc = /48;2;(\d+);(\d+);(\d+)/.exec(ansi);
+  if (tc) return (0.2126 * +tc[1]! + 0.7152 * +tc[2]! + 0.0722 * +tc[3]!) / 255;
+  const c256 = /48;5;(\d+)/.exec(ansi);
+  if (c256) {
+    const n = +c256[1]!;
+    if (n >= 232) return (8 + (n - 232) * 10) / 255;
+    if (n >= 16) {
+      const i = n - 16;
+      const v = (x: number) => (x === 0 ? 0 : 55 + x * 40);
+      return (0.2126 * v(Math.floor(i / 36)) + 0.7152 * v(Math.floor(i / 6) % 6) + 0.0722 * v(i % 6)) / 255;
+    }
+  }
+  return undefined;
+}
+
+/** The reply background: the darkest possible (true black). */
+export function replyBg(_theme?: unknown): string {
+  return "\x1b[48;2;0;0;0m";
+}
+
+/** Bright white fg re-opened after resets when the theme is light (black panel). */
+export function replyFg(theme: { getBgAnsi?: (k: string) => string } | undefined): string | null {
+  try {
+    const lum = bgLuminance(theme?.getBgAnsi?.("userMessageBg") ?? "");
+    return lum !== undefined && lum > 0.5 ? "\x1b[97m" : null;
+  } catch {
+    return null;
+  }
+}
+
+/** The rule colour: orange, truecolor on capable terminals, 256-colour fallback. */
+export function ruleFg(theme: { getColorMode?: () => string } | undefined): string {
+  let mode = "truecolor";
+  try {
+    mode = theme?.getColorMode?.() ?? "truecolor";
+  } catch {}
+  return mode === "truecolor" ? "\x1b[38;2;255;135;0m" : "\x1b[38;5;208m";
+}
+
+/**
+ * The heavy rule that frames the panel. With a label the word sits centred
+ * between two runs of rule ("━━━━━ summary ━━━━━"); without one the rule
+ * spans the full width (the closing edge under the panel). Painted in orange
+ * with a bold label.
+ */
+export function dividerLine(
+  theme: { getColorMode?: () => string; bold?: (t: string) => string } | undefined,
+  label: string,
+  width: number,
+): string {
+  const w = Math.max(0, width);
+  const rule = "━";
+  const color = (t: string) => `${ruleFg(theme)}${t}\x1b[39m`;
+  const bold = (t: string) => {
+    try {
+      return theme?.bold?.(t) ?? `\x1b[1m${t}\x1b[22m`;
+    } catch {
+      return `\x1b[1m${t}\x1b[22m`;
+    }
+  };
+  if (!label) return color(rule.repeat(w));
+  const text = ` ${label} `;
+  const inner = visibleWidth(text);
+  if (inner >= w) return color(text.slice(0, w));
+  const left = Math.floor((w - inner) / 2);
+  return color(rule.repeat(left)) + bold(color(text)) + color(rule.repeat(w - inner - left));
+}
+
+/**
+ * Paint one line on `bg`, padded to `width`. Inner resets (`\x1b[0m`,
+ * `\x1b[49m`) would end the background mid-line, so the background is
+ * re-opened right after each of them.
+ */
+export function paintLine(line: string, width: number, bg: string, fg: string | null = null): string {
+  const pad = Math.max(0, width - visibleWidth(line));
+  const reopen = (m: string) => m + bg + (fg ?? "");
+  const body = line.replace(/\x1b\[(?:0|39|49)m/g, reopen);
+  return `${bg}${fg ?? ""}${body}${" ".repeat(pad)}\x1b[49m${fg ? "\x1b[39m" : ""}`;
+}
+
+/** A step with no visible text (thinking and/or tool calls only) that ended normally. */
+export function isBlankStep(msg: unknown): boolean {
+  const m = msg as { content?: unknown; stopReason?: string } | undefined;
+  if (!m || !Array.isArray(m.content)) return false;
+  if (m.stopReason === "error" || m.stopReason === "aborted" || m.stopReason === "length") return false;
+  return !m.content.some((c: any) => c?.type === "text" && typeof c.text === "string" && c.text.trim());
+}
+
+/** A rendered row that paints nothing: whitespace + SGR/OSC sequences only. */
+const OSC_SEQ = /\x1b\][^\x07\x1b]*(?:\x07|\x1b\\)/g;
+const SGR_SEQ = /\x1b\[[0-9;]*m/g;
+
+export function isBlankRendered(line: string): boolean {
+  return line.replace(OSC_SEQ, "").replace(SGR_SEQ, "").trim() === "";
+}
+
+/**
+ * Drop rendered blank rows at both edges of a component's output. pi parks a
+ * Spacer(1) as the first child of every content-bearing assistant message —
+ * rendered, it's a stray blank row below custom badges and above mid-turn
+ * text, and a pad row under the summary rule inside the reply panel. Dropped
+ * edge lines keep their OSC-133 zone markers (pi prepends `\x1b]133;A\x07` to
+ * the first line of a tool-free message): they're moved onto the surviving
+ * edge lines so prompt-zone navigation isn't lost.
+ */
+export function trimEdgeBlankLines(lines: string[]): string[] {
+  let start = 0;
+  let end = lines.length;
+  while (start < end && isBlankRendered(lines[start]!)) start++;
+  while (end > start && isBlankRendered(lines[end - 1]!)) end--;
+  const kept = lines.slice(start, end);
+  if (kept.length === 0) return kept;
+  const zones = (ls: string[]) => ls.join("").match(OSC_SEQ)?.join("") ?? "";
+  // Tail first, then head: a single surviving line ends up head+tail+text,
+  // matching pi's A…B C order (zone start precedes zone end).
+  const tail = zones(lines.slice(end));
+  if (tail) kept[kept.length - 1] = tail + kept[kept.length - 1];
+  const head = zones(lines.slice(0, start));
+  if (head) kept[0] = head + kept[0];
+  return kept;
+}
+
+/**
+ * Drop children of a message's content container that render only blank rows.
+ * In simple mode that's each hidden-thinking run: pi wraps the label Text in a
+ * MouseRegion, and theme.italic(theme.fg(key, "")) is ANSI escapes around an
+ * empty string — it survives Text's empty check (`trim()` keeps escapes) and
+ * paints a full blank row — plus the Spacer pi parks after a thinking run. A
+ * thinking+text step would otherwise show ~3 blank rows above the text. A
+ * region with real content (non-empty label) is kept.
+ */
+export function stripBlankRuns(container: unknown, width: number): void {
+  const kids = (container as TreeNode | undefined)?.children;
+  if (!Array.isArray(kids)) return;
+  const blank = (l: string) => l.replace(/\x1b\[[0-9;]*m/g, "").trim() === "";
+  for (let i = kids.length - 1; i >= 0; i--) {
+    const child = kids[i] as { child?: unknown; render?: (w: number) => string[] } | null;
+    if (!child || typeof child !== "object" || !("child" in child) || typeof child.render !== "function") continue;
+    let empty = false;
+    try {
+      empty = child.render(width).every(blank);
+    } catch {}
+    if (!empty) continue;
+    kids.splice(i, 1);
+    const next = kids[i] as { lines?: unknown } | null | undefined;
+    if (next && typeof next === "object" && typeof next.lines === "number") kids.splice(i, 1);
+  }
+}
+
+/**
+ * Wrap the component class's render once. `getBg` is read per render so a
+ * theme switch takes effect; `enabled` lets the caller turn it off.
+ */
+export function patchAssistantRender(
+  proto: AssistantLike,
+  getPanel: () => { bg: string; fg: string | null; dividerFor: (width: number, label?: string) => string },
+): void {
+  const p = proto as unknown as Record<PropertyKey, unknown>;
+  if (p[PATCHED]) return;
+  const original = proto.render;
+  const cache = new WeakMap<object, { width: number; msg: unknown; bg: string; streaming: boolean; lines: string[] }>();
+  proto.render = function (this: AssistantLike, width: number): string[] {
+    // Simple mode hides thinking, but pi still adds a leading Spacer for a
+    // thinking-only step (and a hidden label line), so every tool step left
+    // blank rows — a growing gap above tool groups. No visible text → no rows.
+    if (isBlankStep(this.lastMessage)) return [];
+    stripBlankRuns(this.contentContainer, width);
+    const lines = trimEdgeBlankLines(original.call(this, width));
+    // Only the reply: finished, no tool calls, something visible — and the
+    // message must have ended cleanly. An error/abort/length/deferred tail
+    // isn't the turn's reply and doesn't get the summary frame.
+    if (this.hasToolCalls || this.isStreaming || lines.length === 0) return lines;
+    const stop = (this.lastMessage as { stopReason?: string } | undefined)?.stopReason;
+    if (stop === "pending" || stop === "error" || stop === "aborted" || stop === "length" || stop === "deferred") return lines;
+    const { bg, fg, dividerFor } = getPanel();
+    const hit = cache.get(this);
+    if (hit && hit.width === width && hit.msg === this.lastMessage && hit.bg === bg && hit.streaming === this.isStreaming) return hit.lines;
+    const painted = [
+      "", // breathing space above the section rule
+      dividerFor(width),
+      // Exactly one pad row below the rule, mirroring the bottom pad: the
+      // reply (its `●` anchor) starts one blank row under "─ summary ─" —
+      // never flush, never two.
+      paintLine("", width, bg),
+      ...lines.map((l) => paintLine(l, width, bg, fg)),
+      // A bottom pad row so the panel doesn't end flush on the last text line.
+      paintLine("", width, bg),
+      dividerFor(width, ""), // closing edge under the panel
+    ];
+    cache.set(this, { width, msg: this.lastMessage, bg, streaming: this.isStreaming, lines: painted });
+    return painted;
+  };
+  p[PATCHED] = true;
+}
+
+/**
+ * Install for the session: grab the TUI via an empty widget, and after each
+ * agent turn look for an assistant component until one is found and patched.
+ * `onTick` runs on every attempt once the TUI is known — it gets the tree root,
+ * which the simple renderer uses to reconcile tool-call grouping after a
+ * resumed-session history render (replay fires no message_* events, so the
+ * event-driven group breaks never happen and every call lands in one group).
+ */
+export function installReplyBackground(pi: {
+  on: (event: any, handler: (event: any, ctx?: any) => void) => void;
+}, onTick?: (tui: unknown) => void): void {
+  let tui: unknown;
+  let theme: any;
+  let done = false;
+  const tryPatch = () => {
+    if (tui) {
+      try {
+        onTick?.(tui);
+      } catch {}
+    }
+    if (done || !tui) return;
+    const hit = findAssistant(tui);
+    if (!hit) return;
+    patchAssistantRender(Object.getPrototypeOf(hit) as AssistantLike, () => ({
+      bg: replyBg(),
+      fg: replyFg(theme),
+      dividerFor: (width: number, label = "summary") => dividerLine(theme, label, width),
+    }));
+    done = true;
+    try {
+      (tui as { requestRender?: (force?: boolean) => void }).requestRender?.(true);
+    } catch {}
+  };
+  try {
+    pi.on("session_start", (_e: any, ctx: any) => {
+      if (!ctx?.hasUI) return;
+      try {
+        ctx.ui.setWidget(
+          PROBE_WIDGET,
+          (t: unknown, th: unknown) => {
+            tui = t;
+            theme = th;
+            return { invalidate() {}, render: () => [] };
+          },
+          { placement: "belowEditor" },
+        );
+        // Resumed sessions already have replies on screen; history renders
+        // right after extension init, so probe a few times until the tree is
+        // populated even if the user never sends another message.
+        for (const ms of [0, 400, 2000]) setTimeout(tryPatch, ms);
+      } catch {}
+    });
+    pi.on("message_start", () => setTimeout(tryPatch, 0));
+    pi.on("message_end", () => setTimeout(tryPatch, 0));
+    pi.on("agent_end", () => setTimeout(tryPatch, 0));
+  } catch {
+    // cosmetic; never block load
+  }
+}