@chengchenccc/oh-my-agent 0.1.1-rc.1

package/dist/modes/tui/tui-render.js

@@ -0,0 +1,399 @@
+import { CachedOutputBlock, Card, Markdown, renderStatusBar, renderToolHeader, Text, truncateToWidth, wrapTextWithAnsi, } from "@chengchenccc/tui";
+import { cleanHeaderTitle, contextColor, formatWorkspace, gitStatus, MARKDOWN_THEME, MAX_DIFF_LINES, prettyJson, renderGitSegment, summarizeResult, summarizeToolArgs, USER_TEXT_STYLE, } from "./tui-format.js";
+import { renderTaskTool, renderTodoTool } from "./tui-tool-render.js";
+import { TuiTranscriptReconciler } from "./tui-transcript-reconciler.js";
+/** Renders transcript items to display lines, memoizing markdown/tool blocks.
+ *  Extracted from tui-io.ts to keep the io assembly file under 500 lines. */
+export class TuiItemRenderer {
+    tui;
+    markdownCache = new WeakMap();
+    itemLineCache = new WeakMap();
+    toolBlockCache = new WeakMap();
+    constructor(tui) {
+        this.tui = tui;
+    }
+    renderItem(item, state) {
+        const cached = this.itemLineCache.get(item);
+        if (cached &&
+            !item.streaming &&
+            cached.showThinking === state.showThinking &&
+            cached.showToolDetail === state.showToolDetail &&
+            cached.width === this.tui.terminal.columns) {
+            return cached.lines;
+        }
+        const lines = this.computeRenderItem(item, state);
+        if (!item.streaming) {
+            this.itemLineCache.set(item, {
+                lines,
+                showThinking: state.showThinking,
+                showToolDetail: state.showToolDetail,
+                width: this.tui.terminal.columns,
+            });
+        }
+        return lines;
+    }
+    computeRenderItem(item, state) {
+        switch (item.kind) {
+            case "user":
+                if (!item.text)
+                    return [];
+                if (item.pending) {
+                    return [`\u001b[2m  » ${item.text.replace(/\r?\n/g, " ↵ ")}\u001b[0m`];
+                }
+                return this.markdownLines(item, 1, 1, USER_TEXT_STYLE);
+            case "assistant": {
+                const lines = [];
+                if (item.thinking)
+                    lines.push(...this.renderThinking(item.thinking, state.showThinking));
+                if (item.text)
+                    lines.push(...this.markdownLines(item, 1, 0));
+                return lines;
+            }
+            case "thinking":
+                return this.renderThinking(item.text, state.showThinking);
+            case "tool":
+                return this.renderTool(item, state.showToolDetail);
+            case "status":
+                return [`\u001b[2m  [${item.text}]\u001b[0m`];
+            case "error":
+                return [`\u001b[31m  error: ${item.text}\u001b[0m`];
+        }
+    }
+    markdownLines(item, paddingX, paddingY, style) {
+        let md = this.markdownCache.get(item);
+        if (!md) {
+            md = new Markdown(item.text, paddingX, paddingY, MARKDOWN_THEME, style);
+            this.markdownCache.set(item, md);
+        }
+        else {
+            md.setText(item.text);
+        }
+        return md.render(this.tui.terminal.columns);
+    }
+    renderThinking(text, expanded) {
+        if (!text)
+            return [];
+        const firstLine = text.split("\n", 1)[0] ?? "";
+        const dim = (s) => `\u001b[2m${s}\u001b[0m`;
+        if (!expanded) {
+            if (text.length === firstLine.length)
+                return [dim(`  ~ ${firstLine}`)];
+            return [dim(`  ~ ${firstLine} … (ctrl+t)`)];
+        }
+        const wrapWidth = Math.max(20, this.tui.terminal.columns - 6);
+        return wrapTextWithAnsi(text, wrapWidth).map((line) => dim(`  ~ ${line}`));
+    }
+    renderTool(item, expanded) {
+        const toolName = item.text.replace(/…$/, "");
+        if (toolName === "todo" || toolName === "todo_read" || toolName === "todo_write") {
+            return renderTodoTool(item, expanded);
+        }
+        if (toolName === "task" || toolName === "task_list" || toolName === "task_output") {
+            return renderTaskTool(item, expanded);
+        }
+        const failed = item.result !== undefined &&
+            (item.result.isError === true || item.result.error !== undefined);
+        const running = item.streaming;
+        const mark = running ? "\u27f3" : failed ? "\u2718" : "\u2714";
+        const state = running ? "running" : failed ? "error" : "success";
+        const titleColor = state === "running" ? "\u001b[33m" : state === "error" ? "\u001b[31m" : "\u001b[32m";
+        const wallMs = item.durationMs ??
+            (item.streaming && item.startedAt !== undefined ? Date.now() - item.startedAt : undefined);
+        const wall = wallMs === undefined ? "—" : `${(wallMs / 1000).toFixed(2)}s`;
+        const timeoutMs = item.timeoutMs;
+        const timeout = timeoutMs === undefined ? "—" : `${(timeoutMs / 1000).toFixed(0)}s`;
+        const header = renderToolHeader({
+            icon: mark,
+            title: toolName,
+            meta: [`\u001b[2m⟦Wall: ${wall} | Timeout: ${timeout}⟧\u001b[0m`],
+            titleColor,
+        });
+        const sections = [];
+        if (item.input !== undefined) {
+            const lines = [];
+            if (expanded) {
+                for (const line of prettyJson(item.input).split("\n")) {
+                    lines.push(`\u001b[2m${line}\u001b[0m`);
+                }
+            }
+            else {
+                lines.push(`\u001b[2m└ ${summarizeToolArgs(toolName, item.input)}\u001b[0m`);
+            }
+            sections.push({ lines });
+        }
+        if (toolName === "edit" && item.input !== undefined) {
+            const str = (v) => (typeof v === "string" ? v : "");
+            const lines = [];
+            for (const line of str(item.input.old_string).split("\n").slice(0, MAX_DIFF_LINES)) {
+                lines.push(`\u001b[31m- ${line.slice(0, 90)}\u001b[0m`);
+            }
+            for (const line of str(item.input.new_string).split("\n").slice(0, MAX_DIFF_LINES)) {
+                lines.push(`\u001b[32m+ ${line.slice(0, 90)}\u001b[0m`);
+            }
+            sections.push({ lines });
+        }
+        if (item.output && item.streaming) {
+            const tail = item.output.slice(-600);
+            const lines = [];
+            for (const line of tail.split("\n").slice(-4)) {
+                if (line.trim())
+                    lines.push(`\u001b[2m${line}\u001b[0m`);
+            }
+            sections.push({ lines });
+        }
+        if (item.result !== undefined) {
+            const content = typeof item.result.content === "string" ? item.result.content : null;
+            const resultColor = failed ? "\u001b[31m" : "\u001b[2m";
+            const lines = [];
+            if (content !== null) {
+                let textContent = content.trimEnd();
+                const trimmed = textContent.trimStart();
+                if (trimmed.startsWith("{") || trimmed.startsWith("[")) {
+                    try {
+                        textContent = prettyJson(JSON.parse(textContent));
+                    }
+                    catch {
+                        // non-JSON that merely starts with a bracket: keep raw text
+                    }
+                }
+                const outputLines = textContent
+                    .split("\n")
+                    .filter((line) => !(!failed && /\[exit: \d+\]/.test(line)));
+                const maxOut = expanded ? 12 : 4;
+                const display = outputLines.slice(0, maxOut);
+                const isCodeResult = toolName === "read" || toolName === "write";
+                for (const line of display) {
+                    const truncated = truncateToWidth(line, this.tui.terminal.columns - 6);
+                    lines.push(isCodeResult && !failed
+                        ? MARKDOWN_THEME.codeBlock(truncated)
+                        : `${resultColor}${truncated}\u001b[0m`);
+                }
+                if (outputLines.length > maxOut) {
+                    lines.push(`\u001b[2m… ${outputLines.length - maxOut} more lines · (ctrl+o)\u001b[0m`);
+                }
+                else if (!expanded) {
+                    lines.push(`\u001b[2m· (ctrl+o)\u001b[0m`);
+                }
+            }
+            else {
+                const summary = summarizeResult(item.result);
+                if (summary)
+                    lines.push(`${resultColor}${summary}\u001b[0m`);
+            }
+            if (content !== null || Object.keys(item.result).length > 0) {
+                sections.push({ label: "Output", lines });
+            }
+        }
+        let block = this.toolBlockCache.get(item);
+        if (!block) {
+            block = new CachedOutputBlock();
+            this.toolBlockCache.set(item, block);
+        }
+        return [
+            ...block.render({
+                header,
+                state,
+                sections,
+                width: this.tui.terminal.columns,
+                bg: (line) => `\u001b[48;5;234m${line}\u001b[0m`,
+            }),
+        ];
+    }
+}
+/** Header/status/transcript render shell for createTerminalIo. Owns the
+ *  display-only mutable state (header fields, busy, status line) so the io
+ *  assembly file stays small. */
+export class TuiRenderShell {
+    tui;
+    headerContainer;
+    transcript;
+    statusContainer;
+    workspaceRoot;
+    welcomeTip;
+    headerInfo = "oma";
+    headerModel = "";
+    headerSession = "";
+    headerTitle = "";
+    headerContext = "";
+    busy = false;
+    loader = null;
+    busySeconds = 0;
+    currentState = null;
+    statusLineText = "";
+    itemRenderer;
+    reconciler;
+    lastLiveStartRow = 0;
+    lastTotalRows = 0;
+    constructor(tui, headerContainer, transcript, statusContainer, workspaceRoot, welcomeTip) {
+        this.tui = tui;
+        this.headerContainer = headerContainer;
+        this.transcript = transcript;
+        this.statusContainer = statusContainer;
+        this.workspaceRoot = workspaceRoot;
+        this.welcomeTip = welcomeTip;
+        this.itemRenderer = new TuiItemRenderer(tui);
+        this.reconciler = new TuiTranscriptReconciler();
+    }
+    setHeader(model, session, title, context) {
+        this.headerModel = model;
+        this.headerSession = session;
+        this.headerTitle = title;
+        if (context !== undefined)
+            this.headerContext = context;
+        this.renderHeader();
+        if (!this.busy) {
+            this.statusContainer.clear();
+            this.renderIdleFooter();
+        }
+        this.tui.requestRender();
+    }
+    setBusy(busy, loader, busySeconds) {
+        this.busy = busy;
+        this.loader = loader;
+        this.busySeconds = busySeconds;
+    }
+    setBusySeconds(busySeconds) {
+        this.busySeconds = busySeconds;
+    }
+    setCurrentState(state) {
+        this.currentState = state;
+    }
+    renderHeader() {
+        this.headerContainer.clear();
+        const banner = [
+            "\u001b[36m  ██████╗ ███╗   ███╗ █████╗ \u001b[0m",
+            "\u001b[36m ██╔═══██╗████╗ ████║██╔══██╗\u001b[0m",
+            "\u001b[36m ██║   ██║██╔████╔██║███████║\u001b[0m",
+            "\u001b[36m ██║   ██║██║╚██╔╝██║██╔══██║\u001b[0m",
+            "\u001b[36m ╚██████╔╝██║ ╚═╝ ██║██║  ██║\u001b[0m",
+            "\u001b[36m  ╚═════╝ ╚═╝     ╚═╝╚═╝  ╚═╝\u001b[0m",
+        ];
+        const infoLines = [];
+        infoLines.push(`\u001b[1m  ${this.headerInfo}\u001b[0m`);
+        const hTitle = cleanHeaderTitle(this.headerTitle);
+        if (hTitle)
+            infoLines.push(`\u001b[2m  ${hTitle}\u001b[0m`);
+        if (this.headerModel) {
+            infoLines.push(`\u001b[2m  model:\u001b[0m \u001b[36m${this.headerModel}\u001b[0m`);
+        }
+        infoLines.push(`\u001b[2m  workspace:\u001b[0m \u001b[38;5;39m${formatWorkspace(this.workspaceRoot)}\u001b[0m`);
+        const hGit = gitStatus(this.workspaceRoot);
+        if (hGit)
+            infoLines.push(`\u001b[2m  git:\u001b[0m ${renderGitSegment(hGit)}`);
+        if (this.headerSession)
+            infoLines.push(`\u001b[2m  session:\u001b[0m ${this.headerSession.slice(0, 8)}`);
+        if (this.headerContext)
+            infoLines.push(`\u001b[2m  context:\u001b[0m ${this.headerContext}`);
+        const combined = [];
+        const rows = Math.max(banner.length, infoLines.length);
+        for (let i = 0; i < rows; i++) {
+            const left = banner[i] ?? "";
+            const right = infoLines[i] ?? "";
+            combined.push(`${left}${left ? "   " : ""}${right}`);
+        }
+        const headerCard = new Card(combined.map((line) => new Text(truncateToWidth(line, this.tui.terminal.columns - 2), 0, 0)), {
+            paddingX: 0,
+            paddingY: 0,
+            border: { color: (s) => `\u001b[2m${s}\u001b[0m` },
+        });
+        const infoLinesRendered = headerCard.render(this.tui.terminal.columns);
+        for (const line of infoLinesRendered) {
+            this.headerContainer.addChild(new Text(truncateToWidth(line, this.tui.terminal.columns), 0, 0));
+        }
+    }
+    currentActivitySummary() {
+        if (!this.currentState)
+            return undefined;
+        for (let r = this.currentState.runs.length - 1; r >= 0; r--) {
+            const run = this.currentState.runs[r];
+            for (let i = run.items.length - 1; i >= 0; i--) {
+                const item = run.items[i];
+                if (item.kind === "tool" && item.streaming) {
+                    const name = item.text.replace(/…$/, "");
+                    const intent = typeof item.input?.intent === "string"
+                        ? item.input.intent.trim()
+                        : typeof item.input?.description === "string"
+                            ? item.input.description.trim()
+                            : "";
+                    const summary = intent
+                        ? intent
+                        : item.input !== undefined
+                            ? summarizeToolArgs(name, item.input)
+                            : "";
+                    return summary.trim() ? `${name} · ${summary}` : name;
+                }
+                if (item.kind === "assistant" && item.streaming) {
+                    const source = `${item.thinking ?? ""}
+${item.text ?? ""}`;
+                    const first = source.split("\n", 1)[0]?.trim() ?? "";
+                    if (first)
+                        return first.length > 80 ? `${first.slice(0, 80)}…` : first;
+                }
+            }
+        }
+        // Fallback: a busy run with a tool item (even if the streaming flag is
+        // lost) should never read as a bare "working…".
+        for (let r = this.currentState.runs.length - 1; r >= 0; r--) {
+            const run = this.currentState.runs[r];
+            for (let i = run.items.length - 1; i >= 0; i--) {
+                const item = run.items[i];
+                if (item.kind === "tool" && item.text)
+                    return item.text.replace(/…$/, "");
+            }
+        }
+        return undefined;
+    }
+    updateWorkingMessage() {
+        if (!this.busy || !this.loader)
+            return;
+        const summary = this.currentActivitySummary();
+        const seconds = this.busySeconds > 0 ? ` · ${this.busySeconds}s` : "";
+        const msg = summary
+            ? `${summary}${seconds} (esc to abort)`
+            : `working…${seconds} (esc to abort)`;
+        this.loader.setMessage(msg);
+    }
+    addStatusBar() {
+        const git = gitStatus(this.workspaceRoot);
+        const segs = [];
+        if (this.headerModel) {
+            segs.push({ text: this.headerModel, chip: true, bg: "\u001b[48;5;25m" });
+        }
+        segs.push({ text: formatWorkspace(this.workspaceRoot), fg: "\u001b[38;5;39m" });
+        if (git)
+            segs.push({ text: renderGitSegment(git) });
+        if (this.headerSession)
+            segs.push({ text: this.headerSession.slice(0, 8), fg: "\u001b[2m" });
+        if (this.headerContext)
+            segs.push({ text: this.headerContext, fg: contextColor(this.headerContext) });
+        if (segs.length > 0) {
+            this.statusLineText = renderStatusBar(segs);
+        }
+    }
+    renderIdleFooter() {
+        if (this.busy || this.statusContainer.children.length > 0)
+            return;
+        this.addStatusBar();
+    }
+    render(state) {
+        this.setCurrentState(state);
+        this.transcript.setDeferCommit(state.runs.some((r) => r.running &&
+            r.items.some((i) => i.kind === "assistant" &&
+                (i.text.includes("```mermaid") || i.text.includes("~~~mermaid")))));
+        if (this.busy)
+            this.updateWorkingMessage();
+        const result = this.reconciler.reconcile(this.transcript, state.runs, state, (item) => this.itemRenderer.renderItem(item, state));
+        this.lastLiveStartRow = result.liveStartRow;
+        this.lastTotalRows = result.totalRows;
+        if (state.runs.length === 0 && this.welcomeTip && this.transcript.children.length === 0) {
+            this.transcript.addChild(new Text(`\u001b[33m  ${this.welcomeTip}\u001b[0m`, 0, 0));
+        }
+        this.renderIdleFooter();
+        if (result.didReset) {
+            this.tui.requestRender(true);
+        }
+        else {
+            this.tui.requestRender();
+        }
+    }
+}

package/dist/modes/tui/tui-slash.d.ts

@@ -0,0 +1,12 @@
+import type { SlashCommand } from "@chengchenccc/tui";
+import type { CommandDef, TuiSessionContext } from "./tui-commands.js";
+export interface SlashSystem {
+    commandsWithSkills: CommandDef[];
+    slashCommands: SlashCommand[];
+    runCommandText: (text: string) => Promise<void>;
+}
+/** Auto-registered skill commands (pi's /skill:<name> pattern): every
+ *  discovered skill becomes a slash command that submits a prompt pointing
+ *  the model at the skill. */
+export declare function buildSlashSystem(ctx: TuiSessionContext, commands: CommandDef[]): SlashSystem;
+//# sourceMappingURL=tui-slash.d.ts.map

package/dist/modes/tui/tui-slash.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"tui-slash.d.ts","sourceRoot":"","sources":["../../../src/modes/tui/tui-slash.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,mBAAmB,CAAC;AAGtD,OAAO,KAAK,EAAE,UAAU,EAAE,iBAAiB,EAAE,MAAM,mBAAmB,CAAC;AAEvE,MAAM,WAAW,WAAW;IAC1B,kBAAkB,EAAE,UAAU,EAAE,CAAC;IACjC,aAAa,EAAE,YAAY,EAAE,CAAC;IAC9B,cAAc,EAAE,CAAC,IAAI,EAAE,MAAM,KAAK,OAAO,CAAC,IAAI,CAAC,CAAC;CACjD;AAED;;8BAE8B;AAC9B,wBAAgB,gBAAgB,CAAC,GAAG,EAAE,iBAAiB,EAAE,QAAQ,EAAE,UAAU,EAAE,GAAG,WAAW,CAsE5F"}

package/dist/modes/tui/tui-slash.js

@@ -0,0 +1,64 @@
+import { resolveStandaloneSkillRoots } from "../../cli/initial-input.js";
+import { buildSkillIndex } from "../../core/tools/index.js";
+/** Auto-registered skill commands (pi's /skill:<name> pattern): every
+ *  discovered skill becomes a slash command that submits a prompt pointing
+ *  the model at the skill. */
+export function buildSlashSystem(ctx, commands) {
+    const skillCommands = buildSkillIndex(resolveStandaloneSkillRoots(ctx.opts.workspaceRoot)).map((sk) => ({
+        name: `skill:${sk.name}`,
+        description: sk.description || `invoke the ${sk.name} skill`,
+        group: "skill",
+        run: (args) => {
+            ctx.pendingPrompt = args
+                ? `${args}\n\n(follow the "${sk.name}" skill — skill_load "${sk.name}" first)`
+                : `Follow the "${sk.name}" skill (skill_load "${sk.name}" first).`;
+        },
+    }));
+    const commandsWithSkills = [...commands, ...skillCommands];
+    ctx.commandsWithSkills = commandsWithSkills;
+    // Autocomplete: the editor already triggers on "/" — hand it the table
+    // (static commands + auto-registered skill commands).
+    const slashCommands = commandsWithSkills.map((c) => {
+        const command = { name: c.name, description: c.description };
+        if (c.argumentHint)
+            command.argumentHint = c.argumentHint;
+        if (c.name === "model") {
+            command.getArgumentCompletions = async (prefix) => {
+                const models = await ctx.listModels();
+                return models.filter((m) => m.startsWith(prefix)).map((m) => ({ value: m, label: m }));
+            };
+        }
+        if (c.name === "resume") {
+            command.getArgumentCompletions = (prefix) => ctx
+                .listSessions()
+                .filter((s) => s.id.startsWith(prefix))
+                .slice(0, 20)
+                .map((s) => ({
+                value: s.id,
+                label: s.id,
+                description: s.title ?? (s.preview || undefined),
+            }));
+        }
+        return command;
+    });
+    /** Slash-command dispatch shared by the idle loop and live submissions
+     *  (pi's LiveCommandController: /commands execute even mid-run instead of
+     *  being steered into the model as literal text). */
+    async function runCommandText(text) {
+        const space = text.indexOf(" ");
+        const name = space === -1 ? text.slice(1) : text.slice(1, space);
+        const args = space === -1 ? "" : text.slice(space + 1).trim();
+        const command = commandsWithSkills.find((c) => c.name === name) ??
+            commandsWithSkills.find((c) => c.aliases?.includes(name));
+        if (!command) {
+            ctx.pushStatus(`unknown command /${name} — try /help`);
+            return;
+        }
+        if (ctx.liveRuntime && !command.live) {
+            ctx.pushStatus(`/${name} is not available while a run is live`);
+            return;
+        }
+        await command.run(args);
+    }
+    return { commandsWithSkills, slashCommands, runCommandText };
+}

package/dist/modes/tui/tui-tool-render.d.ts

@@ -0,0 +1,6 @@
+import type { TranscriptItem } from "./view-state.js";
+/** omp-style plain-list todo rendering (no card/box). */
+export declare function renderTodoTool(item: TranscriptItem, expanded: boolean): string[];
+/** omp-style plain-list task rendering (no card/box). */
+export declare function renderTaskTool(item: TranscriptItem, expanded: boolean): string[];
+//# sourceMappingURL=tui-tool-render.d.ts.map

package/dist/modes/tui/tui-tool-render.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"tui-tool-render.d.ts","sourceRoot":"","sources":["../../../src/modes/tui/tui-tool-render.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,iBAAiB,CAAC;AAEtD,yDAAyD;AACzD,wBAAgB,cAAc,CAAC,IAAI,EAAE,cAAc,EAAE,QAAQ,EAAE,OAAO,GAAG,MAAM,EAAE,CAoBhF;AAED,yDAAyD;AACzD,wBAAgB,cAAc,CAAC,IAAI,EAAE,cAAc,EAAE,QAAQ,EAAE,OAAO,GAAG,MAAM,EAAE,CAoBhF"}

package/dist/modes/tui/tui-tool-render.js

@@ -0,0 +1,79 @@
+/** omp-style plain-list todo rendering (no card/box). */
+export function renderTodoTool(item, expanded) {
+    const lines = ["\u001b[36m  todo\u001b[0m"];
+    const items = todoItems(item);
+    if (items.length === 0)
+        return ["\u001b[36m  todo\u001b[0m", "\u001b[2m    (no items)\u001b[0m"];
+    for (const it of items) {
+        const mark = it.status === "done"
+            ? "\u001b[32m✓\u001b[0m"
+            : it.status === "in_progress"
+                ? "\u001b[33m●\u001b[0m"
+                : it.status === "cancelled"
+                    ? "\u001b[31m✗\u001b[0m"
+                    : "\u001b[2m☐\u001b[0m";
+        lines.push(`  ${mark} ${it.text}`);
+    }
+    if (!expanded) {
+        const open = items.filter((i) => i.status !== "done" && i.status !== "cancelled").length;
+        if (open > 0)
+            lines.push(`\u001b[2m    ${open} open — (ctrl+o for full list)\u001b[0m`);
+    }
+    return lines;
+}
+/** omp-style plain-list task rendering (no card/box). */
+export function renderTaskTool(item, expanded) {
+    const label = typeof item.input?.label === "string" ? item.input.label : "";
+    const lines = [`\u001b[36m  task${label ? ` · ${label}` : ""}\u001b[0m`];
+    const result = item.result;
+    if (result && typeof result === "object" && "status" in result) {
+        const st = String(result.status);
+        lines.push(`\u001b[2m    status: ${st}\u001b[0m`);
+    }
+    const content = typeof result?.content === "string"
+        ? result.content
+        : typeof result?.text === "string"
+            ? result.text
+            : "";
+    if (content) {
+        const text = content.trim();
+        if (text)
+            lines.push(`\u001b[2m    ${text.slice(0, expanded ? 400 : 160)}\u001b[0m`);
+    }
+    if (lines.length === 1)
+        lines.push(`\u001b[2m    (done)\u001b[0m`);
+    return lines;
+}
+function todoItems(item) {
+    const candidates = [];
+    const result = item.result;
+    if (result) {
+        if (Array.isArray(result.items))
+            candidates.push(...result.items);
+        const content = typeof result.content === "string" ? result.content : "";
+        if (content) {
+            try {
+                const parsed = JSON.parse(content);
+                if (Array.isArray(parsed.items))
+                    candidates.push(...parsed.items);
+            }
+            catch {
+                // keep raw string path below
+            }
+        }
+    }
+    if (item.input && Array.isArray(item.input.items))
+        candidates.push(...item.input.items);
+    return candidates
+        .filter((v) => typeof v === "object" &&
+        v !== null &&
+        "text" in v &&
+        typeof v.text === "string" &&
+        "status" in v &&
+        typeof v.status === "string")
+        .map((v) => ({
+        id: "id" in v && typeof v.id === "string" ? v.id : "",
+        text: v.text,
+        status: v.status,
+    }));
+}

package/dist/modes/tui/tui-transcript-reconciler.d.ts

@@ -0,0 +1,25 @@
+import type { OmaTranscriptContainer } from "./tui-components.js";
+import type { RunViewState, TranscriptItem, TuiViewState } from "./view-state.js";
+export interface ReconcileResult {
+    /** Row index of the first streaming item (or totalRows when none stream). */
+    liveStartRow: number;
+    /** Total rendered rows in the transcript container. */
+    totalRows: number;
+    /** True when a full rebuild was forced (flag toggle or item removal). */
+    didReset: boolean;
+}
+/** Incrementally reconciles transcript children with the current view state.
+ *  Items are matched by `runIndex:itemIndex` because the view-state objects
+ *  are rebuilt every turn; keying by object identity would force a full reset
+ *  (and a scrollback clear) on every render. */
+export declare class TuiTranscriptReconciler {
+    private readonly orderKeys;
+    private readonly groups;
+    private lastShowThinking;
+    private lastShowToolDetail;
+    reconcile(transcript: OmaTranscriptContainer, runs: readonly RunViewState[], state: TuiViewState, renderItem: (item: TranscriptItem) => string[]): ReconcileResult;
+    /** Force a full rebuild (display flag toggle or item removal). */
+    reset(transcript: OmaTranscriptContainer): void;
+    private updateGroup;
+}
+//# sourceMappingURL=tui-transcript-reconciler.d.ts.map

package/dist/modes/tui/tui-transcript-reconciler.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"tui-transcript-reconciler.d.ts","sourceRoot":"","sources":["../../../src/modes/tui/tui-transcript-reconciler.ts"],"names":[],"mappings":"AAEA,OAAO,KAAK,EAAE,sBAAsB,EAAE,MAAM,qBAAqB,CAAC;AAClE,OAAO,KAAK,EAAE,YAAY,EAAE,cAAc,EAAE,YAAY,EAAE,MAAM,iBAAiB,CAAC;AAElF,MAAM,WAAW,eAAe;IAC9B,6EAA6E;IAC7E,YAAY,EAAE,MAAM,CAAC;IACrB,uDAAuD;IACvD,SAAS,EAAE,MAAM,CAAC;IAClB,yEAAyE;IACzE,QAAQ,EAAE,OAAO,CAAC;CACnB;AAED;;;gDAGgD;AAChD,qBAAa,uBAAuB;IAClC,OAAO,CAAC,QAAQ,CAAC,SAAS,CAAgB;IAC1C,OAAO,CAAC,QAAQ,CAAC,MAAM,CAAkC;IACzD,OAAO,CAAC,gBAAgB,CAAS;IACjC,OAAO,CAAC,kBAAkB,CAAS;IAEnC,SAAS,CACP,UAAU,EAAE,sBAAsB,EAClC,IAAI,EAAE,SAAS,YAAY,EAAE,EAC7B,KAAK,EAAE,YAAY,EACnB,UAAU,EAAE,CAAC,IAAI,EAAE,cAAc,KAAK,MAAM,EAAE,GAC7C,eAAe;IAiElB,kEAAkE;IAClE,KAAK,CAAC,UAAU,EAAE,sBAAsB,GAAG,IAAI;IAM/C,OAAO,CAAC,WAAW;CAiBpB"}