@ocis/myagent-cli 0.2.0

package/dist/ui/diff.d.ts

@@ -0,0 +1,37 @@
+export type DiffLineKind = "meta" | "hunk" | "add" | "del" | "context";
+export interface DiffLine {
+    kind: DiffLineKind;
+    text: string;
+    /** 1-based line number in the pre-image (deletions and context). */
+    oldLine?: number;
+    /** 1-based line number in the post-image (additions and context). */
+    newLine?: number;
+}
+/** A pair row: `full` spans both columns; otherwise left/right cells align. */
+export type DiffRow = {
+    full: DiffLine;
+} | {
+    left: DiffLine | null;
+    right: DiffLine | null;
+};
+/**
+ * Classify the lines of a unified diff (blank/trailing lines are dropped) and
+ * track the pre/post-image line numbers from the hunk headers.
+ */
+export declare function parseDiffLines(raw: string): DiffLine[];
+/**
+ * Pack a parsed diff into rows: a run of deletions is paired with the
+ * following run of additions (the shorter side pads with empty cells); meta,
+ * hunk and context lines span the full row.
+ */
+export declare function toPairRows(lines: readonly DiffLine[]): DiffRow[];
+/** Width of the line-number gutter for a set of diff lines. */
+export declare function diffNumberWidth(lines: readonly DiffLine[]): number;
+/** Pad a line number to the gutter width (dim; blank when absent). */
+export declare function diffNumber(value: number | undefined, width: number): string;
+/**
+ * Lay a parsed diff out as side-by-side rows: each side gets its own number
+ * gutter and text column, and full-span rows (context/meta) keep the gutters
+ * blank for alignment. `paint` styles one line for the caller's palette.
+ */
+export declare function renderPairRows(lines: readonly DiffLine[], width: number, paint: (line: DiffLine) => string): string[];

package/dist/ui/diff.js

@@ -0,0 +1,143 @@
+// ---------------------------------------------------------------------------
+// Unified-diff parsing and side-by-side row rendering.
+//
+// Pure and synchronous: classify each line of a unified diff, pack the
+// removed/added runs into aligned side-by-side rows, and lay those rows out
+// with old/new line-number gutters. Callers supply the per-line paint function
+// (the transcript and the popup viewer use different palettes).
+// ---------------------------------------------------------------------------
+import { truncateToWidth } from "@earendil-works/pi-tui";
+import { style } from "./colors.js";
+const HUNK_PATTERN = /^@@ -(\d+)(?:,\d+)? \+(\d+)(?:,\d+)? @@/;
+/**
+ * Classify the lines of a unified diff (blank/trailing lines are dropped) and
+ * track the pre/post-image line numbers from the hunk headers.
+ */
+export function parseDiffLines(raw) {
+    const lines = [];
+    let oldLine;
+    let newLine;
+    for (const text of raw.split("\n")) {
+        if (text.length === 0)
+            continue;
+        let kind;
+        let oldNumber;
+        let newNumber;
+        if (text.startsWith("@@")) {
+            kind = "hunk";
+            const match = HUNK_PATTERN.exec(text);
+            if (match) {
+                oldLine = Number(match[1]);
+                newLine = Number(match[2]);
+            }
+        }
+        else if (text.startsWith("+++") || text.startsWith("---")) {
+            kind = "meta";
+        }
+        else if (text.startsWith("+")) {
+            kind = "add";
+            newNumber = newLine;
+            if (newLine !== undefined)
+                newLine += 1;
+        }
+        else if (text.startsWith("-")) {
+            kind = "del";
+            oldNumber = oldLine;
+            if (oldLine !== undefined)
+                oldLine += 1;
+        }
+        else if (text.startsWith(" ")) {
+            kind = "context";
+            oldNumber = oldLine;
+            newNumber = newLine;
+            if (oldLine !== undefined)
+                oldLine += 1;
+            if (newLine !== undefined)
+                newLine += 1;
+        }
+        else {
+            kind = "meta";
+        }
+        const line = { kind, text };
+        if (oldNumber !== undefined)
+            line.oldLine = oldNumber;
+        if (newNumber !== undefined)
+            line.newLine = newNumber;
+        lines.push(line);
+    }
+    return lines;
+}
+/**
+ * Pack a parsed diff into rows: a run of deletions is paired with the
+ * following run of additions (the shorter side pads with empty cells); meta,
+ * hunk and context lines span the full row.
+ */
+export function toPairRows(lines) {
+    const rows = [];
+    let dels = [];
+    let adds = [];
+    const flush = () => {
+        const count = Math.max(dels.length, adds.length);
+        for (let i = 0; i < count; i++) {
+            rows.push({ left: dels[i] ?? null, right: adds[i] ?? null });
+        }
+        dels = [];
+        adds = [];
+    };
+    for (const line of lines) {
+        if (line.kind === "del") {
+            dels.push(line);
+        }
+        else if (line.kind === "add") {
+            adds.push(line);
+        }
+        else {
+            flush();
+            rows.push({ full: line });
+        }
+    }
+    flush();
+    return rows;
+}
+/** Width of the line-number gutter for a set of diff lines. */
+export function diffNumberWidth(lines) {
+    let max = 0;
+    for (const line of lines) {
+        max = Math.max(max, line.oldLine ?? 0, line.newLine ?? 0);
+    }
+    return Math.min(6, Math.max(2, String(max).length));
+}
+/** Pad a line number to the gutter width (dim; blank when absent). */
+export function diffNumber(value, width) {
+    return style.dim((value === undefined ? "" : String(value)).padStart(width));
+}
+/**
+ * Lay a parsed diff out as side-by-side rows: each side gets its own number
+ * gutter and text column, and full-span rows (context/meta) keep the gutters
+ * blank for alignment. `paint` styles one line for the caller's palette.
+ */
+export function renderPairRows(lines, width, paint) {
+    const nums = diffNumberWidth(lines);
+    const gutter = 3; // " │ "
+    const minCell = nums + 4;
+    let leftWidth = Math.max(minCell, Math.floor((width - gutter) / 2));
+    let rightWidth = Math.max(minCell, width - gutter - leftWidth);
+    if (leftWidth + gutter + rightWidth > width) {
+        // Narrow terminal: the comfortable minimum would overflow the popup's
+        // width budget — shrink below it (cells degrade to heavy truncation)
+        // rather than render rows wider than the caller asked for.
+        const available = Math.max(2, width - gutter);
+        leftWidth = Math.floor(available / 2);
+        rightWidth = available - leftWidth;
+    }
+    const cell = (line, number, cellWidth) => {
+        const text = line ? paint(line) : "";
+        return `${diffNumber(number, nums)} ${style.dim("│")} ${truncateToWidth(text, Math.max(1, cellWidth - nums - 3), "…", true)}`;
+    };
+    return toPairRows(lines).map((row) => {
+        if ("full" in row) {
+            return truncateToWidth(`${" ".repeat(nums)} ${style.dim("│")} ${paint(row.full)}`, width, "…", true);
+        }
+        return `${cell(row.left, row.left?.oldLine, leftWidth)}${style.dim(" │ ")}${cell(row.right, row.right?.newLine, rightWidth)}`;
+    });
+}

package/dist/ui/format.d.ts

@@ -0,0 +1,28 @@
+import type { AgentUsage } from "../protocol/types.js";
+import type { TodoStatus } from "../agent/todo.js";
+/** 999 → "999", 12345 → "12.3k", 1234567 → "1.2M". */
+export declare function formatTokens(n: number): string;
+/** Cost with adaptive precision; empty string when no cost data. */
+export declare function formatCost(usage: AgentUsage | null): string;
+/**
+ * Share of input tokens served from the prompt cache ("87%"), or "—" when no
+ * input has been reported yet. `input` counts non-cached tokens only, so the
+ * total input is `input + cacheRead + cacheWrite`.
+ */
+export declare function formatCacheHit(usage: AgentUsage | null): string;
+/** Percentage of the context window in use ("42%"), or "—" when unknown. */
+export declare function formatContextPercent(used: number, window: number): string;
+/** "84.0k / 200k" style context numbers. */
+export declare function formatContextNumbers(used: number, window: number): string;
+/** Clamp a line to `width` visible cells (never exceeds it). */
+export declare function fit(line: string, width: number): string;
+/** Remove ANSI SGR sequences — content matching on styled lines. */
+export declare function stripAnsi(line: string): string;
+/** Plain-text checkbox for a todo status. */
+export declare function todoMark(status: TodoStatus): string;
+/**
+ * Render a `local_update_todo` request's args as display lines — the task
+ * list lives in the tool request, not in the system prompt. Empty for
+ * malformed args (the tool call itself surfaces the validation error).
+ */
+export declare function formatTodoArgs(args: Record<string, unknown>): string[];

package/dist/ui/format.js

@@ -0,0 +1,76 @@
+// ---------------------------------------------------------------------------
+// Pure formatting helpers shared by the sidebar, footer and transcript.
+// ---------------------------------------------------------------------------
+import { truncateToWidth, visibleWidth } from "@earendil-works/pi-tui";
+import { parseTodoItems } from "../agent/todo.js";
+/** 999 → "999", 12345 → "12.3k", 1234567 → "1.2M". */
+export function formatTokens(n) {
+    if (!Number.isFinite(n))
+        return "0";
+    const abs = Math.abs(n);
+    if (abs < 1000)
+        return String(Math.round(n));
+    if (abs < 10_000)
+        return `${(n / 1000).toFixed(1)}k`;
+    if (abs < 1_000_000)
+        return `${Math.round(n / 1000)}k`;
+    return `${(n / 1_000_000).toFixed(1)}M`;
+}
+/** Cost with adaptive precision; empty string when no cost data. */
+export function formatCost(usage) {
+    const total = usage?.cost?.total;
+    if (total === undefined || Number.isNaN(total))
+        return "";
+    return `$${total >= 1 ? total.toFixed(2) : total.toFixed(4)}`;
+}
+/**
+ * Share of input tokens served from the prompt cache ("87%"), or "—" when no
+ * input has been reported yet. `input` counts non-cached tokens only, so the
+ * total input is `input + cacheRead + cacheWrite`.
+ */
+export function formatCacheHit(usage) {
+    const read = usage?.cacheRead ?? 0;
+    const totalInput = (usage?.input ?? 0) + read + (usage?.cacheWrite ?? 0);
+    if (totalInput <= 0)
+        return "—";
+    return `${Math.round((read / totalInput) * 100)}%`;
+}
+/** Percentage of the context window in use ("42%"), or "—" when unknown. */
+export function formatContextPercent(used, window) {
+    if (!window || window <= 0)
+        return "—";
+    return `${Math.round(Math.max(0, Math.min(1, used / window)) * 100)}%`;
+}
+/** "84.0k / 200k" style context numbers. */
+export function formatContextNumbers(used, window) {
+    if (!window || window <= 0)
+        return formatTokens(used);
+    return `${formatTokens(used)} / ${formatTokens(window)}`;
+}
+/** Clamp a line to `width` visible cells (never exceeds it). */
+export function fit(line, width) {
+    return visibleWidth(line) > width ? truncateToWidth(line, width) : line;
+}
+/** Remove ANSI SGR sequences — content matching on styled lines. */
+export function stripAnsi(line) {
+    return line.replace(/\x1b\[[0-9;]*m/g, "");
+}
+/** Plain-text checkbox for a todo status. */
+export function todoMark(status) {
+    return status === "completed" ? "[x]" : status === "in_progress" ? "[>]" : "[ ]";
+}
+/**
+ * Render a `local_update_todo` request's args as display lines — the task
+ * list lives in the tool request, not in the system prompt. Empty for
+ * malformed args (the tool call itself surfaces the validation error).
+ */
+export function formatTodoArgs(args) {
+    let items;
+    try {
+        items = parseTodoItems(args.todos);
+    }
+    catch {
+        return [];
+    }
+    return items.map((t) => `${todoMark(t.status)} ${t.content}`);
+}

package/dist/ui/help.d.ts

@@ -0,0 +1,6 @@
+/** [leftLabel, leftDescription, rightLabel, rightDescription]. */
+export type HelpPair = [string, string, string, string];
+/** One section table: bold title, then aligned cyan labels + gray descriptions. */
+export declare function helpTable(title: string, rows: readonly HelpPair[]): string[];
+/** Body lines for the /help popup. */
+export declare function helpLines(): string[];

package/dist/ui/help.js

@@ -0,0 +1,45 @@
+// -------------------------------------------------------------------
+// /help content: compact two-pair tables (label + description, twice per
+// row) sized to fit an 80-column terminal inside the info popup.
+// -------------------------------------------------------------------
+import { visibleWidth } from "@earendil-works/pi-tui";
+import { GRAY_COLOR, style } from "./colors.js";
+function pad(text, width) {
+    return text + " ".repeat(Math.max(0, width - visibleWidth(text)));
+}
+/** One section table: bold title, then aligned cyan labels + gray descriptions. */
+export function helpTable(title, rows) {
+    const leftLabel = rows.reduce((widest, row) => Math.max(widest, visibleWidth(row[0])), 0);
+    const leftDescription = rows.reduce((widest, row) => Math.max(widest, visibleWidth(row[1])), 0);
+    const rightLabel = rows.reduce((widest, row) => Math.max(widest, visibleWidth(row[2])), 0);
+    const lines = [style.bold(title)];
+    for (const [leftKey, leftText, rightKey, rightText] of rows) {
+        lines.push(`  ${style.cyan(pad(leftKey, leftLabel))}  ${GRAY_COLOR(pad(leftText, leftDescription))}  ` +
+            `${style.cyan(pad(rightKey, rightLabel))}  ${GRAY_COLOR(rightText)}`);
+    }
+    return lines;
+}
+const COMMANDS = [
+    ["/plan /coding", "modes", "/mode", "cycle"],
+    ["/cowork", "general tasks", "/edit", "AUTO/ASK"],
+    ["/new", "new session", "/session [all]", "list · switch"],
+    ["/thinking /model", "level · model", "/compact /stop", "compact · stop"],
+    ["/reload /export", "reload · export", "/config /quit", "info · exit"],
+];
+const KEYS = [
+    ["Tab", "plan/coding/cowork", "Shift+Tab", "AUTO/ASK"],
+    ["Enter", "send · steer", "Ctrl+P", "sidebar"],
+    ["Shift+Enter", "newline (also Alt+Enter)", "Ctrl+E", "changed files"],
+    ["Ctrl+Y / Ctrl+N", "approve · deny", "Ctrl+O", "tool output"],
+    ["Esc", "force-stop", "Ctrl+T", "thinking"],
+    ["Ctrl+C", "twice quits (idle)", "Alt+↑/↓", "panel scroll"],
+    ["@ /", "mention · commands", "", ""],
+];
+const MOUSE = [
+    ["Click", "mode/model/thinking chips", "Click", "ASK/AUTO badge"],
+    ["Click", "picker rows", "Wheel", "scroll"],
+];
+/** Body lines for the /help popup. */
+export function helpLines() {
+    return [...helpTable("Commands", COMMANDS), "", ...helpTable("Keys", KEYS), "", ...helpTable("Mouse", MOUSE)];
+}

package/dist/ui/highlight.d.ts

@@ -0,0 +1,20 @@
+type TokenKind = "plain" | "comment" | "string" | "number" | "keyword";
+interface Token {
+    kind: TokenKind;
+    text: string;
+}
+/** Language id for a file path, or undefined when it has no known extension. */
+export declare function languageForPath(path: string): string | undefined;
+/** Language id for a fenced code block's info string (e.g. "ts title=x"). */
+export declare function languageForFence(language: string | undefined): string | undefined;
+/**
+ * Split one line into highlightable tokens: comments, strings, numbers and
+ * keywords, with everything else left plain. Line-oriented — an unterminated
+ * block comment colors to the end of the line.
+ */
+export declare function tokenizeLine(language: string | undefined, line: string): Token[];
+/** Apply the syntax palette to one line, optionally tinting the plain runs. */
+export declare function highlightLine(language: string | undefined, line: string, base?: (text: string) => string): string;
+/** Markdown `highlightCode` hook: one highlighted line per source line. */
+export declare function highlightCodeBlock(code: string, language?: string): string[];
+export {};

package/dist/ui/highlight.js

@@ -0,0 +1,210 @@
+// -------------------------------------------------------------------
+// Regex syntax highlighting for tool output (file reads).
+//
+// Line-oriented and dependency-free: enough color for common source files
+// without pulling in a parser. Tokenization is pure and separate from color
+// application, so it stays testable without a TTY.
+// -------------------------------------------------------------------
+import { syntaxComment, syntaxKeyword, syntaxNumber, syntaxString } from "./colors.js";
+const JS_KEYWORDS = [
+    "await", "async", "break", "case", "catch", "class", "const", "continue", "debugger", "default",
+    "delete", "do", "else", "export", "extends", "false", "finally", "for", "from", "function", "get",
+    "if", "import", "in", "instanceof", "let", "new", "null", "of", "return", "set", "static", "super",
+    "switch", "this", "throw", "true", "try", "typeof", "undefined", "var", "void", "while", "with", "yield",
+];
+const TS_KEYWORDS = [
+    ...JS_KEYWORDS,
+    "abstract", "any", "as", "bigint", "boolean", "declare", "enum", "implements", "infer", "interface",
+    "is", "keyof", "namespace", "never", "number", "object", "private", "protected", "public", "readonly",
+    "satisfies", "string", "symbol", "type", "unique", "unknown",
+];
+const PYTHON_KEYWORDS = [
+    "and", "as", "assert", "async", "await", "break", "class", "continue", "def", "del", "elif", "else",
+    "except", "False", "finally", "for", "from", "global", "if", "import", "in", "is", "lambda", "None",
+    "nonlocal", "not", "or", "pass", "raise", "return", "True", "try", "while", "with", "yield",
+];
+const RUST_KEYWORDS = [
+    "as", "async", "await", "break", "const", "continue", "crate", "dyn", "else", "enum", "extern",
+    "false", "fn", "for", "if", "impl", "in", "let", "loop", "match", "mod", "move", "mut", "pub", "ref",
+    "return", "self", "Self", "static", "struct", "super", "trait", "true", "type", "unsafe", "use",
+    "where", "while",
+];
+const GO_KEYWORDS = [
+    "break", "case", "chan", "const", "continue", "default", "defer", "else", "fallthrough", "false",
+    "for", "func", "go", "goto", "if", "import", "interface", "iota", "map", "nil", "package", "range",
+    "return", "select", "struct", "switch", "true", "type", "var",
+];
+const SH_KEYWORDS = [
+    "case", "do", "done", "elif", "else", "esac", "export", "fi", "for", "function", "if", "in",
+    "local", "readonly", "return", "set", "shift", "then", "trap", "unset", "until", "while",
+];
+/** SQL keywords in both cases — queries are written upper- or lowercase. */
+const SQL_KEYWORDS = [
+    "add", "alter", "and", "as", "asc", "begin", "between", "by", "case", "commit", "constraint",
+    "create", "cross", "default", "delete", "desc", "distinct", "drop", "else", "end", "exists",
+    "foreign", "from", "full", "group", "having", "if", "in", "index", "inner", "insert", "into",
+    "is", "join", "key", "left", "like", "limit", "not", "null", "offset", "on", "or", "order",
+    "outer", "primary", "references", "right", "rollback", "select", "set", "table", "then",
+    "transaction", "union", "unique", "update", "values", "when", "where", "with",
+].flatMap((k) => [k, k.toUpperCase()]);
+/** Dockerfile instructions — conventionally uppercase, lowercase accepted. */
+const DOCKERFILE_KEYWORDS = [
+    "add", "arg", "cmd", "copy", "entrypoint", "env", "expose", "from", "healthcheck", "label",
+    "onbuild", "run", "shell", "stopsignal", "user", "volume", "workdir",
+].flatMap((k) => [k, k.toUpperCase()]);
+const JAVA_KEYWORDS = [
+    "abstract", "assert", "boolean", "break", "byte", "case", "catch", "char", "class", "const",
+    "continue", "default", "do", "double", "else", "enum", "extends", "false", "final", "finally",
+    "float", "for", "goto", "if", "implements", "import", "instanceof", "int", "interface", "long",
+    "native", "new", "null", "package", "private", "protected", "public", "record", "return", "short",
+    "static", "strictfp", "super", "switch", "synchronized", "this", "throw", "throws", "transient",
+    "true", "try", "var", "void", "volatile", "while",
+];
+const C_KEYWORDS = [
+    "auto", "break", "case", "char", "const", "continue", "default", "do", "double", "else", "enum",
+    "extern", "false", "float", "for", "goto", "if", "inline", "int", "long", "NULL", "register",
+    "restrict", "return", "short", "signed", "sizeof", "static", "struct", "switch", "true", "typedef",
+    "union", "unsigned", "void", "volatile", "while",
+];
+const CPP_KEYWORDS = [
+    ...C_KEYWORDS,
+    "bool", "catch", "class", "constexpr", "delete", "explicit", "friend", "namespace", "new", "noexcept",
+    "nullptr", "operator", "private", "protected", "public", "template", "this", "throw", "try",
+    "typename", "using", "virtual",
+];
+const LANGS = {
+    js: { lineComments: ["//"], blockComment: ["/*", "*/"], quotes: ['"', "'", "`"], keywords: JS_KEYWORDS },
+    ts: { lineComments: ["//"], blockComment: ["/*", "*/"], quotes: ['"', "'", "`"], keywords: TS_KEYWORDS },
+    json: { lineComments: [], quotes: ['"'], keywords: ["true", "false", "null"] },
+    python: { lineComments: ["#"], quotes: ['"', "'"], keywords: PYTHON_KEYWORDS },
+    rust: { lineComments: ["//"], blockComment: ["/*", "*/"], quotes: ['"', "'"], keywords: RUST_KEYWORDS },
+    go: { lineComments: ["//"], blockComment: ["/*", "*/"], quotes: ['"', "`"], keywords: GO_KEYWORDS },
+    sh: { lineComments: ["#"], quotes: ['"', "'"], keywords: SH_KEYWORDS },
+    java: { lineComments: ["//"], blockComment: ["/*", "*/"], quotes: ['"', "'"], keywords: JAVA_KEYWORDS },
+    c: { lineComments: ["//"], blockComment: ["/*", "*/"], quotes: ['"', "'"], keywords: C_KEYWORDS },
+    cpp: { lineComments: ["//"], blockComment: ["/*", "*/"], quotes: ['"', "'"], keywords: CPP_KEYWORDS },
+    css: { lineComments: [], blockComment: ["/*", "*/"], quotes: ['"', "'"], keywords: [] },
+    yaml: { lineComments: ["#"], quotes: ['"', "'"], keywords: [] },
+    toml: { lineComments: ["#"], quotes: ['"', "'"], keywords: [] },
+    sql: { lineComments: ["--"], quotes: ["'"], keywords: SQL_KEYWORDS },
+    dockerfile: { lineComments: ["#"], quotes: ['"', "'"], keywords: DOCKERFILE_KEYWORDS },
+};
+/** Language ids keyed by file extension and fenced-code info string. */
+const LANGUAGES = {
+    ts: "ts", typescript: "ts", tsx: "ts", mts: "ts", cts: "ts",
+    js: "js", javascript: "js", jsx: "js", mjs: "js", cjs: "js",
+    json: "json", jsonc: "json",
+    py: "python", pyi: "python", python: "python",
+    rs: "rust", rust: "rust",
+    go: "go", golang: "go",
+    sh: "sh", bash: "sh", zsh: "sh", shell: "sh",
+    java: "java",
+    c: "c", h: "c",
+    cpp: "cpp", "c++": "cpp", cc: "cpp", cxx: "cpp", hpp: "cpp", hh: "cpp",
+    css: "css", scss: "css",
+    yml: "yaml", yaml: "yaml",
+    toml: "toml",
+    sql: "sql",
+    dockerfile: "dockerfile", docker: "dockerfile",
+};
+/** Language id for a file path, or undefined when it has no known extension. */
+export function languageForPath(path) {
+    const dot = path.lastIndexOf(".");
+    if (dot < 0)
+        return undefined;
+    return LANGUAGES[path.slice(dot + 1).toLowerCase()];
+}
+/** Language id for a fenced code block's info string (e.g. "ts title=x"). */
+export function languageForFence(language) {
+    const name = language?.trim().split(/\s+/)[0]?.toLowerCase();
+    return name ? LANGUAGES[name] : undefined;
+}
+const TOKEN_STYLES = {
+    comment: syntaxComment,
+    string: syntaxString,
+    number: syntaxNumber,
+    keyword: syntaxKeyword,
+};
+/**
+ * Split one line into highlightable tokens: comments, strings, numbers and
+ * keywords, with everything else left plain. Line-oriented — an unterminated
+ * block comment colors to the end of the line.
+ */
+export function tokenizeLine(language, line) {
+    if (line.length === 0)
+        return [];
+    const spec = language === undefined ? undefined : LANGS[language];
+    if (!spec)
+        return [{ kind: "plain", text: line }];
+    const tokens = [];
+    const push = (kind, text) => {
+        if (text.length === 0)
+            return;
+        const last = tokens[tokens.length - 1];
+        if (kind === "plain" && last?.kind === "plain")
+            last.text += text;
+        else
+            tokens.push({ kind, text });
+    };
+    let index = 0;
+    while (index < line.length) {
+        const rest = line.slice(index);
+        if (spec.blockComment && rest.startsWith(spec.blockComment[0])) {
+            const end = rest.indexOf(spec.blockComment[1], spec.blockComment[0].length);
+            const text = end === -1 ? rest : rest.slice(0, end + spec.blockComment[1].length);
+            push("comment", text);
+            index += text.length;
+            continue;
+        }
+        const lineComment = spec.lineComments.find((prefix) => rest.startsWith(prefix));
+        if (lineComment) {
+            push("comment", rest);
+            break;
+        }
+        const quote = spec.quotes.find((q) => rest.startsWith(q));
+        if (quote) {
+            let end = index + 1;
+            while (end < line.length) {
+                if (line[end] === "\\") {
+                    end += 2;
+                    continue;
+                }
+                if (line[end] === quote) {
+                    end += 1;
+                    break;
+                }
+                end += 1;
+            }
+            const text = line.slice(index, Math.min(end, line.length));
+            push("string", text);
+            index += text.length;
+            continue;
+        }
+        const number = /^\d[\w.]*/.exec(rest);
+        if (number) {
+            push("number", number[0]);
+            index += number[0].length;
+            continue;
+        }
+        const word = /^[A-Za-z_$][\w$]*/.exec(rest);
+        if (word) {
+            push(spec.keywords.includes(word[0]) ? "keyword" : "plain", word[0]);
+            index += word[0].length;
+            continue;
+        }
+        push("plain", line[index]);
+        index += 1;
+    }
+    return tokens;
+}
+/** Apply the syntax palette to one line, optionally tinting the plain runs. */
+export function highlightLine(language, line, base) {
+    return tokenizeLine(language, line)
+        .map((token) => (token.kind === "plain" ? (base ? base(token.text) : token.text) : TOKEN_STYLES[token.kind](token.text)))
+        .join("");
+}
+/** Markdown `highlightCode` hook: one highlighted line per source line. */
+export function highlightCodeBlock(code, language) {
+    const resolved = languageForFence(language);
+    return code.split("\n").map((line) => highlightLine(resolved, line));
+}

package/dist/ui/logo.d.ts

@@ -0,0 +1,24 @@
+import type { Component, TUI } from "@earendil-works/pi-tui";
+export declare const LOGO: string[];
+export declare const TAGLINE = "      \u2726 your machine, in the hands of the agent \u2726";
+/** Paint the logo for a given gradient phase; returns the 5 colored rows. */
+export declare function paintLogo(phase: number): string[];
+/**
+ * Transcript component rendering the logo. `start()` kicks off the one-shot
+ * shimmer; the component stops animating after the final frame.
+ */
+export declare class LogoComponent implements Component {
+    private readonly options;
+    private phase;
+    private timer;
+    private frame;
+    readonly frames = 22;
+    constructor(options?: {
+        animate: boolean;
+        tagline?: boolean;
+    });
+    start(tui: TUI): void;
+    stop(): void;
+    invalidate(): void;
+    render(width: number): string[];
+}