pi-ui-extend 0.1.1

package/dist/app/conversation-tool-renderer.js

@@ -0,0 +1,216 @@
+import { resolveColor, resolveToolRule, stripDcpDisplayMetadata } from "../config.js";
+import { formatMarkdownTables, markdownSyntaxHighlightsForText } from "../markdown-format.js";
+import { renderToolDisplay } from "../tool-renderers/index.js";
+import { DEFAULT_THINKING_TOOL_RULE, SUBAGENT_STATUSES, THINKING_TOOL_NAME, TODO_TOOL_NAME } from "./constants.js";
+import { attachImageClickTargets } from "./image-click-targets.js";
+import { formatStructuredText } from "./message-content.js";
+import { formatSubagentTimestamp, isSubagentRunRenderDetails, isSubagentsToolName, subagentRunName, subagentStatusIcon, taskPreviewMap, } from "./subagents-model.js";
+import { formatTodoTaskLine, isTodoDetails, visibleTodoTasks } from "./todo-model.js";
+import { renderToolBlock } from "./tool-block-renderer.js";
+export function renderConversationToolEntry(entry, width, options) {
+    const todoLines = renderTodoToolEntry(entry, width, options);
+    if (todoLines)
+        return todoLines;
+    const subagentsLines = renderSubagentsToolEntry(entry, width, options);
+    if (subagentsLines)
+        return subagentsLines;
+    const display = renderToolDisplay({
+        toolName: entry.toolName,
+        argsText: entry.argsText,
+        output: entry.output,
+        details: entry.details,
+        isError: entry.isError,
+        status: entry.status,
+        cwd: options.cwd,
+        colors: options.colors,
+        toolColor: resolveColor(resolveToolRule(entry.toolName, options.pixConfig.toolRenderer).color, options.colors),
+    });
+    const toolName = display.toolName ?? entry.toolName;
+    const rule = resolveToolRule(toolName, options.pixConfig.toolRenderer);
+    const lines = renderToolBlock({
+        id: entry.id,
+        toolName,
+        headerArgs: display.headerArgs,
+        headerArgsSegments: display.headerArgsSegments,
+        bodyLineStyles: display.bodyLineStyles,
+        bodyStyle: display.bodyStyle,
+        preserveAnsi: display.preserveAnsi,
+        expanded: entry.expanded,
+        status: entry.status,
+        isError: entry.isError,
+        output: entry.output,
+        collapsedBody: display.collapsedBody,
+        expandedText: display.expandedText,
+        syntaxHighlight: display.syntaxHighlight,
+    }, rule, width, options.colors, { superCompact: Boolean(options.superCompactTools) });
+    return attachImageClickTargets(lines, entry.id, entry.images, { foreground: options.colors.info, underline: true });
+}
+export function renderThinkingEntry(entry, width, options) {
+    const rule = resolveThinkingToolRule(options.pixConfig);
+    const displayText = stripDcpDisplayMetadata(entry.text);
+    const markdownText = displayText ? formatMarkdownTables(displayText, Math.max(1, width - 2)) : "";
+    const expandedText = trimTrailingBlankLines(markdownText);
+    const compactExpandedText = options.superCompactTools ? removeBlankLines(expandedText) : expandedText;
+    const forceExpanded = Boolean(options.allThinkingExpanded);
+    return renderToolBlock({
+        id: entry.id,
+        toolName: THINKING_TOOL_NAME,
+        expanded: entry.expanded || forceExpanded,
+        status: entry.status,
+        isError: false,
+        output: markdownText,
+        collapsedBody: markdownText,
+        expandedText: compactExpandedText || "(empty)",
+        bodyWrap: "word",
+        syntaxHighlight: compactExpandedText ? markdownSyntaxHighlightsForText(compactExpandedText) : undefined,
+    }, rule, width, options.colors, { superCompact: Boolean(options.superCompactTools && !forceExpanded) });
+}
+function trimTrailingBlankLines(text) {
+    return text.replace(/(?:\r?\n[ \t]*)+$/u, "");
+}
+function removeBlankLines(text) {
+    return text.split(/\r?\n/u).filter((line) => line.trim().length > 0).join("\n");
+}
+function renderTodoToolEntry(entry, width, options) {
+    if (entry.toolName !== TODO_TOOL_NAME)
+        return undefined;
+    if (!isTodoDetails(entry.details))
+        return undefined;
+    const rule = resolveToolRule(TODO_TOOL_NAME, options.pixConfig.toolRenderer);
+    const body = todoDetailsText(entry.details);
+    return renderToolBlock({
+        id: entry.id,
+        toolName: TODO_TOOL_NAME,
+        headerArgs: `action=${entry.details.action} nextId=${entry.details.nextId}`,
+        expanded: entry.expanded,
+        status: entry.status,
+        isError: entry.isError || Boolean(entry.details.error),
+        output: body,
+        collapsedBody: body,
+        expandedText: body,
+    }, rule, width, options.colors, { superCompact: Boolean(options.superCompactTools) });
+}
+function todoDetailsText(details) {
+    const lines = [];
+    if (details.error)
+        lines.push(`error: ${details.error}`);
+    const tasks = visibleTodoTasks(details);
+    if (tasks.length === 0) {
+        lines.push("todo: no tasks");
+    }
+    else {
+        for (const task of tasks)
+            lines.push(formatTodoTaskLine(task));
+    }
+    return lines.join("\n");
+}
+function renderSubagentsToolEntry(entry, width, options) {
+    if (!isSubagentsToolName(entry.toolName))
+        return undefined;
+    if (!isSubagentRunRenderDetails(entry.details))
+        return undefined;
+    const rule = resolveToolRule(entry.toolName, options.pixConfig.toolRenderer);
+    const collapsedBody = subagentsCollapsedText(entry.details);
+    const expandedText = subagentsExpandedText(entry, entry.details);
+    return renderToolBlock({
+        id: entry.id,
+        toolName: entry.toolName,
+        headerArgs: subagentsToolHeaderArgs(entry.details),
+        expanded: entry.expanded,
+        status: entry.status,
+        isError: entry.isError,
+        output: expandedText,
+        collapsedBody,
+        expandedText,
+    }, rule, width, options.colors, { superCompact: Boolean(options.superCompactTools) });
+}
+function subagentsToolHeaderArgs(details) {
+    const parts = [`started=${subagentsStartedCount(details)}/${details.agents.length}`, `run=${subagentRunName(details.runDir)}`];
+    if (details.mode)
+        parts.unshift(`mode=${details.mode}`);
+    if (details.agentId)
+        parts.push(`agent=${details.agentId}`);
+    return parts.join(" ");
+}
+function subagentsStartedCount(details) {
+    return details.agents.filter((agent) => agent.status !== "planned").length;
+}
+function subagentsCollapsedText(details) {
+    const total = details.agents.length;
+    const label = total === 1 ? "subagent" : "subagents";
+    const statusCounts = new Map();
+    for (const agent of details.agents)
+        statusCounts.set(agent.status, (statusCounts.get(agent.status) ?? 0) + 1);
+    const statuses = SUBAGENT_STATUSES
+        .map((status) => {
+        const count = statusCounts.get(status) ?? 0;
+        return count > 0 ? `${status}:${count}` : undefined;
+    })
+        .filter((status) => status !== undefined)
+        .join(" ");
+    const started = subagentsStartedCount(details);
+    const statusSuffix = statuses ? ` — ${statuses}` : "";
+    return `started ${started}/${total} ${label}${statusSuffix} — run ${subagentRunName(details.runDir)}`;
+}
+function subagentsExpandedText(entry, details) {
+    const sections = [
+        subagentsCollapsedText(details),
+        formatStructuredText(entry.argsText),
+        subagentsDetailsText(details),
+        formatStructuredText(details),
+    ];
+    if (entry.output.trim())
+        sections.push(entry.isError ? `error\n${entry.output.trimEnd()}` : entry.output.trimEnd());
+    return sections.join("\n\n");
+}
+function subagentsDetailsText(details) {
+    if (details.agents.length === 0)
+        return `run ${details.runDir}: no agents`;
+    const previewById = taskPreviewMap(details.tasks);
+    const lines = [];
+    for (const agent of details.agents) {
+        lines.push(formatSubagentToolLine(agent, previewById.get(agent.id)));
+    }
+    return lines.join("\n");
+}
+function formatSubagentToolLine(agent, preview) {
+    const parts = [subagentStatusIcon(agent.status), agent.status, agent.id];
+    if (preview?.model)
+        parts.push(`model:${preview.model}`);
+    if (preview?.task)
+        parts.push(`task:${preview.task}`);
+    else if (preview?.scope)
+        parts.push(`scope:${preview.scope}`);
+    else
+        parts.push("task:unavailable");
+    if (agent.pid !== undefined)
+        parts.push(`pid:${agent.pid}`);
+    if (agent.exitCode !== undefined)
+        parts.push(`exitCode:${agent.exitCode}`);
+    const startedAt = formatSubagentTimestamp(agent.startedAt);
+    if (startedAt)
+        parts.push(`started:${startedAt}`);
+    const finishedAt = formatSubagentTimestamp(agent.finishedAt);
+    if (finishedAt)
+        parts.push(`finished:${finishedAt}`);
+    if (agent.nextRetryAt)
+        parts.push(`nextRetry:${agent.nextRetryAt}`);
+    if (agent.retryCount !== undefined)
+        parts.push(`retry:${agent.retryCount}`);
+    return parts.join(" ");
+}
+function resolveThinkingToolRule(pixConfig) {
+    const configured = pixConfig.toolRenderer.tools[THINKING_TOOL_NAME];
+    if (!configured)
+        return DEFAULT_THINKING_TOOL_RULE;
+    const rule = {
+        previewLines: configured.previewLines ?? DEFAULT_THINKING_TOOL_RULE.previewLines,
+        direction: configured.direction ?? DEFAULT_THINKING_TOOL_RULE.direction,
+        color: configured.color ?? DEFAULT_THINKING_TOOL_RULE.color,
+    };
+    if (configured.compactHidden != null)
+        rule.compactHidden = configured.compactHidden;
+    if (configured.hidden != null)
+        rule.hidden = configured.hidden;
+    return rule;
+}

package/dist/app/conversation-viewport.d.ts

@@ -0,0 +1,55 @@
+import type { AgentSession } from "@earendil-works/pi-coding-agent";
+import type { PixConfig } from "../config.js";
+import type { Theme } from "../theme.js";
+import { type InlineUserMessageMenuContext } from "./conversation-entry-renderer.js";
+import type { ConversationBlockCache, Entry, RenderedLine, SubmittedUserMessage } from "./types.js";
+export type ConversationViewportHost = {
+    readonly entries: readonly Entry[];
+    readonly session: AgentSession | undefined;
+    readonly deferredUserMessages: readonly SubmittedUserMessage[];
+    readonly entryRenderVersions: ReadonlyMap<string, number>;
+    readonly cwd: string;
+    readonly colors: Theme["colors"];
+    readonly pixConfig: PixConfig;
+    readonly outputFilters: readonly RegExp[];
+    readonly suppressPendingDcpIdMetadata: boolean;
+    readonly superCompactTools?: boolean;
+    readonly allThinkingExpanded?: boolean;
+    hasDynamicConversationBlock?(): boolean;
+    isDynamicConversationBlock(entry: Entry): boolean;
+    renderInlineUserMessageMenu(entry: Extract<Entry, {
+        kind: "user";
+    }>, context: InlineUserMessageMenuContext): RenderedLine[];
+};
+export type ConversationEntryBlockPosition = {
+    entry: Entry;
+    offset: number;
+    lineCount: number;
+    block: ConversationBlockCache;
+};
+export declare class ConversationViewport {
+    private readonly host;
+    private readonly blockCachesByWidth;
+    private readonly layoutCachesByWidth;
+    constructor(host: ConversationViewportHost);
+    clear(): void;
+    deleteEntry(entryId: string): void;
+    lineCount(width: number): number;
+    slice(width: number, start: number, count: number): RenderedLine[];
+    entries(): Entry[];
+    blockForEntry(entry: Entry, width: number): ConversationBlockCache;
+    entryBlockPositions(width: number): ConversationEntryBlockPosition[];
+    private queuedEntries;
+    private layoutForWidth;
+    private buildLayout;
+    private layoutStructureChanged;
+    private refreshDirtyLayoutEntries;
+    private blockCacheForWidth;
+    private refreshDynamicLayoutEntries;
+    private refreshLayoutEntry;
+    private lineCountForEntry;
+    private nextVisibleEntry;
+    private gapAfterEntry;
+    private isSuperCompactGaplessEntry;
+    private entryIndexForOffset;
+}

package/dist/app/conversation-viewport.js

@@ -0,0 +1,252 @@
+import { renderConversationEntry as renderConversationEntryLines } from "./conversation-entry-renderer.js";
+import { shortHash } from "./render-text.js";
+export class ConversationViewport {
+    host;
+    blockCachesByWidth = new Map();
+    layoutCachesByWidth = new Map();
+    constructor(host) {
+        this.host = host;
+    }
+    clear() {
+        this.blockCachesByWidth.clear();
+        this.layoutCachesByWidth.clear();
+    }
+    deleteEntry(entryId) {
+        for (const blockCache of this.blockCachesByWidth.values())
+            blockCache.delete(entryId);
+        for (const layoutCache of this.layoutCachesByWidth.values())
+            layoutCache.dirtyEntryIds.add(entryId);
+    }
+    lineCount(width) {
+        return this.layoutForWidth(width).totalLineCount;
+    }
+    slice(width, start, count) {
+        if (count <= 0)
+            return [];
+        const layout = this.layoutForWidth(width);
+        const visible = [];
+        const end = start + count;
+        let entryIndex = this.entryIndexForOffset(layout.offsets, start);
+        for (; entryIndex < layout.entries.length; entryIndex += 1) {
+            const entry = layout.entries[entryIndex];
+            const block = this.blockForEntry(entry, width);
+            const blockLineCount = layout.lineCounts[entryIndex] ?? 0;
+            if (blockLineCount === 0)
+                continue;
+            const offset = layout.offsets[entryIndex] ?? 0;
+            const blockEnd = offset + blockLineCount;
+            if (blockEnd <= start)
+                continue;
+            const localStart = Math.max(0, start - offset);
+            const localEnd = Math.min(blockLineCount, end - offset);
+            for (let lineIndex = localStart; lineIndex < localEnd; lineIndex += 1) {
+                visible.push(lineIndex < block.lines.length ? block.lines[lineIndex] : { text: "" });
+            }
+            if (visible.length >= count)
+                break;
+        }
+        return visible;
+    }
+    entries() {
+        const queued = this.queuedEntries();
+        return queued.length === 0 ? [...this.host.entries] : [...this.host.entries, ...queued];
+    }
+    blockForEntry(entry, width) {
+        const blockCache = this.blockCacheForWidth(width);
+        const version = (this.host.entryRenderVersions.get(entry.id) ?? 0)
+            + (this.host.superCompactTools ? 1_000_000_000 : 0)
+            + (this.host.allThinkingExpanded ? 2_000_000_000 : 0);
+        const cached = blockCache.get(entry.id);
+        const dynamic = this.host.isDynamicConversationBlock(entry);
+        if (!dynamic && cached?.version === version)
+            return cached;
+        const lines = renderConversationEntryLines(entry, width, {
+            cwd: this.host.cwd,
+            colors: this.host.colors,
+            pixConfig: this.host.pixConfig,
+            outputFilters: this.host.outputFilters,
+            suppressPendingDcpIdMetadata: this.host.suppressPendingDcpIdMetadata,
+            superCompactTools: Boolean(this.host.superCompactTools),
+            allThinkingExpanded: Boolean(this.host.allThinkingExpanded),
+            renderInlineUserMessageMenu: (userEntry, context) => this.host.renderInlineUserMessageMenu(userEntry, context),
+        });
+        const block = {
+            version,
+            lines,
+            lineCount: lines.length,
+        };
+        if (!dynamic)
+            blockCache.set(entry.id, block);
+        return block;
+    }
+    entryBlockPositions(width) {
+        const layout = this.layoutForWidth(width);
+        return layout.entries.map((entry, index) => ({
+            entry,
+            offset: layout.offsets[index] ?? 0,
+            lineCount: layout.lineCounts[index] ?? 0,
+            block: this.blockForEntry(entry, width),
+        }));
+    }
+    queuedEntries() {
+        const session = this.host.session;
+        const entries = [];
+        for (const [index, text] of (session?.getSteeringMessages() ?? []).entries()) {
+            entries.push({
+                id: `queued-sdk-steering-${index}-${shortHash(text)}`,
+                kind: "queued",
+                mode: "steering",
+                text,
+                queueSource: "sdk-steering",
+                queueIndex: index,
+            });
+        }
+        for (const [index, text] of (session?.getFollowUpMessages() ?? []).entries()) {
+            entries.push({
+                id: `queued-sdk-follow-up-${index}-${shortHash(text)}`,
+                kind: "queued",
+                mode: "follow-up",
+                text,
+                queueSource: "sdk-follow-up",
+                queueIndex: index,
+            });
+        }
+        for (const [index, message] of this.host.deferredUserMessages.entries()) {
+            entries.push({
+                id: `${message.id}-${index}`,
+                kind: "queued",
+                mode: "steering",
+                text: message.displayText,
+                queueSource: "deferred",
+                queueIndex: index,
+            });
+        }
+        return entries;
+    }
+    layoutForWidth(width) {
+        const queued = this.queuedEntries();
+        const entries = queued.length === 0 ? this.host.entries : [...this.host.entries, ...queued];
+        const queuedSignature = queued.map((entry) => entry.id).join("\n");
+        const superCompactTools = Boolean(this.host.superCompactTools);
+        const allThinkingExpanded = Boolean(this.host.allThinkingExpanded);
+        let layout = this.layoutCachesByWidth.get(width);
+        if (!layout || this.layoutStructureChanged(layout, entries, queuedSignature, superCompactTools, allThinkingExpanded)) {
+            layout = this.buildLayout(entries, width, queuedSignature, superCompactTools, allThinkingExpanded);
+            this.layoutCachesByWidth.set(width, layout);
+        }
+        else {
+            this.refreshDirtyLayoutEntries(layout, width);
+        }
+        if (this.host.hasDynamicConversationBlock?.()) {
+            this.refreshDynamicLayoutEntries(layout, width);
+        }
+        return layout;
+    }
+    buildLayout(entries, width, queuedSignature, superCompactTools, allThinkingExpanded) {
+        const entryIds = [];
+        const lineCounts = [];
+        const offsets = [];
+        const positions = new Map();
+        let totalLineCount = 0;
+        for (const [index, entry] of entries.entries()) {
+            entryIds.push(entry.id);
+            positions.set(entry.id, index);
+            offsets.push(totalLineCount);
+            const lineCount = this.lineCountForEntry(entry, entries, index, width);
+            lineCounts.push(lineCount);
+            totalLineCount += lineCount;
+        }
+        offsets.push(totalLineCount);
+        return { entries, entryIds, lineCounts, offsets, positions, dirtyEntryIds: new Set(), totalLineCount, queuedSignature, superCompactTools, allThinkingExpanded };
+    }
+    layoutStructureChanged(layout, entries, queuedSignature, superCompactTools, allThinkingExpanded) {
+        if (layout.entries.length !== entries.length || layout.queuedSignature !== queuedSignature || layout.superCompactTools !== superCompactTools || layout.allThinkingExpanded !== allThinkingExpanded)
+            return true;
+        if (layout.entries.length === 0)
+            return false;
+        return layout.entryIds[0] !== entries[0]?.id || layout.entryIds[layout.entryIds.length - 1] !== entries[entries.length - 1]?.id;
+    }
+    refreshDirtyLayoutEntries(layout, width) {
+        if (layout.dirtyEntryIds.size === 0)
+            return;
+        for (const entryId of layout.dirtyEntryIds) {
+            const position = layout.positions.get(entryId);
+            if (position === undefined)
+                continue;
+            this.refreshLayoutEntry(layout, width, position);
+        }
+        layout.dirtyEntryIds.clear();
+    }
+    blockCacheForWidth(width) {
+        let blockCache = this.blockCachesByWidth.get(width);
+        if (!blockCache) {
+            blockCache = new Map();
+            this.blockCachesByWidth.set(width, blockCache);
+        }
+        return blockCache;
+    }
+    refreshDynamicLayoutEntries(layout, width) {
+        for (let index = 0; index < layout.entries.length; index += 1) {
+            if (this.host.isDynamicConversationBlock(layout.entries[index]))
+                this.refreshLayoutEntry(layout, width, index);
+        }
+    }
+    refreshLayoutEntry(layout, width, index) {
+        const entry = layout.entries[index];
+        if (!entry)
+            return;
+        const previousLineCount = layout.lineCounts[index] ?? 0;
+        const nextLineCount = this.lineCountForEntry(entry, layout.entries, index, width);
+        if (previousLineCount === nextLineCount)
+            return;
+        const delta = nextLineCount - previousLineCount;
+        layout.lineCounts[index] = nextLineCount;
+        layout.totalLineCount += delta;
+        for (let offsetIndex = index + 1; offsetIndex < layout.offsets.length; offsetIndex += 1) {
+            layout.offsets[offsetIndex] = (layout.offsets[offsetIndex] ?? 0) + delta;
+        }
+    }
+    lineCountForEntry(entry, entries, index, width) {
+        const block = this.blockForEntry(entry, width);
+        if (block.lineCount === 0)
+            return 0;
+        const nextEntry = this.nextVisibleEntry(entries, index, width);
+        return block.lineCount + (this.gapAfterEntry(entry, nextEntry) ? 1 : 0);
+    }
+    nextVisibleEntry(entries, index, width) {
+        for (let nextIndex = index + 1; nextIndex < entries.length; nextIndex += 1) {
+            const nextEntry = entries[nextIndex];
+            if (!nextEntry)
+                continue;
+            if (this.blockForEntry(nextEntry, width).lineCount > 0)
+                return nextEntry;
+        }
+        return undefined;
+    }
+    gapAfterEntry(entry, nextEntry) {
+        if (!this.host.superCompactTools)
+            return true;
+        if (!nextEntry)
+            return false;
+        return !(this.isSuperCompactGaplessEntry(entry) || this.isSuperCompactGaplessEntry(nextEntry));
+    }
+    isSuperCompactGaplessEntry(entry) {
+        return entry.kind === "tool" || entry.kind === "thinking" || entry.kind === "shell";
+    }
+    entryIndexForOffset(offsets, start) {
+        let low = 0;
+        let high = Math.max(0, offsets.length - 2);
+        let result = 0;
+        while (low <= high) {
+            const mid = Math.floor((low + high) / 2);
+            if ((offsets[mid + 1] ?? 0) <= start) {
+                low = mid + 1;
+            }
+            else {
+                result = mid;
+                high = mid - 1;
+            }
+        }
+        return result;
+    }
+}

package/dist/app/dcp-stats.d.ts

@@ -0,0 +1,2 @@
+import type { AgentSession } from "@earendil-works/pi-coding-agent";
+export declare function formatDcpStatsToast(session: AgentSession): string;

package/dist/app/dcp-stats.js

@@ -0,0 +1,116 @@
+import { normalizeToolName, parseArgsText } from "../tool-renderers/utils.js";
+export function formatDcpStatsToast(session) {
+    const stats = collectDcpSessionStats(session);
+    const parts = [
+        `context ${formatContextUsage(stats)}`,
+        `freed ${formatCompactNumber(stats.tokensSaved)} tokens`,
+        `${stats.runs.toLocaleString()} ${plural(stats.runs, "run")}`,
+        stats.items > 0 ? `${stats.items.toLocaleString()} ${plural(stats.items, "item")}` : undefined,
+        stats.summaryTokens > 0 ? `${formatCompactNumber(stats.summaryTokens)} summary` : undefined,
+        stats.activeBlocks != null && stats.totalBlocks != null ? `blocks ${stats.activeBlocks}/${stats.totalBlocks}` : undefined,
+        stats.prunedTools > 0 ? `pruned ${stats.prunedTools.toLocaleString()} tools` : undefined,
+    ].filter((part) => Boolean(part));
+    return `DCP: ${parts.join(" · ")}`;
+}
+function collectDcpSessionStats(session) {
+    const usage = session.getContextUsage();
+    const stats = {
+        runs: 0,
+        tokensSaved: 0,
+        items: 0,
+        summaryTokens: 0,
+        prunedTools: 0,
+        ...(usage?.tokens != null ? { contextTokens: usage.tokens } : {}),
+        ...(usage?.contextWindow != null ? { contextWindow: usage.contextWindow } : {}),
+        ...(usage?.percent != null ? { contextPercent: usage.percent } : {}),
+    };
+    for (const entry of session.sessionManager.getBranch()) {
+        if (entry.type !== "message")
+            continue;
+        const message = entry.message;
+        if (message.role !== "toolResult")
+            continue;
+        if (normalizeToolName(message.toolName) !== "compress")
+            continue;
+        if ("isError" in message && message.isError === true)
+            continue;
+        const result = parseToolResultText(message.content);
+        if (!result)
+            continue;
+        stats.runs += 1;
+        stats.tokensSaved += numberValue(result.tokensSaved) ?? 0;
+        stats.items += numberValue(result.itemCount) ?? sumDefined(numberValue(result.ranges), numberValue(result.messages)) ?? 0;
+        stats.summaryTokens += numberValue(result.totalSummaryTokens) ?? 0;
+        stats.prunedTools += numberValue(result.prunedTools) ?? 0;
+        const activeBlocks = numberValue(result.activeBlocks);
+        const totalBlocks = numberValue(result.totalBlocks);
+        if (activeBlocks != null)
+            stats.activeBlocks = activeBlocks;
+        if (totalBlocks != null)
+            stats.totalBlocks = totalBlocks;
+        const contextTokens = numberValue(result.contextTokens);
+        const contextWindow = numberValue(result.contextWindow);
+        const contextPercent = numberValue(result.contextPercent);
+        if (stats.contextTokens == null && contextTokens != null)
+            stats.contextTokens = contextTokens;
+        if (stats.contextWindow == null && contextWindow != null)
+            stats.contextWindow = contextWindow;
+        if (stats.contextPercent == null && contextPercent != null)
+            stats.contextPercent = contextPercent;
+    }
+    return stats;
+}
+function parseToolResultText(content) {
+    const parsed = parseArgsText(textContent(content));
+    return isRecord(parsed) ? parsed : undefined;
+}
+function textContent(content) {
+    if (typeof content === "string")
+        return content;
+    if (!Array.isArray(content))
+        return "";
+    return content
+        .map((part) => isRecord(part) && typeof part.text === "string" ? part.text : "")
+        .filter(Boolean)
+        .join("\n");
+}
+function formatContextUsage(stats) {
+    const percent = stats.contextPercent;
+    const tokens = stats.contextTokens;
+    const window = stats.contextWindow;
+    const percentText = percent != null ? formatPercent(percent) : "unknown";
+    if (tokens != null && window != null)
+        return `${percentText} (${formatCompactNumber(tokens)}/${formatCompactNumber(window)})`;
+    if (tokens != null)
+        return `${formatCompactNumber(tokens)} tokens`;
+    if (window != null)
+        return `${percentText} of ${formatCompactNumber(window)}`;
+    return percentText;
+}
+function numberValue(value) {
+    return typeof value === "number" && Number.isFinite(value) ? value : undefined;
+}
+function sumDefined(...values) {
+    const defined = values.filter((value) => value != null);
+    return defined.length > 0 ? defined.reduce((sum, value) => sum + value, 0) : undefined;
+}
+function formatCompactNumber(value) {
+    const abs = Math.abs(value);
+    if (abs >= 1_000_000)
+        return `${trimDecimal(value / 1_000_000)}M`;
+    if (abs >= 1_000)
+        return `${trimDecimal(value / 1_000)}K`;
+    return Math.round(value).toLocaleString();
+}
+function formatPercent(value) {
+    return `${trimDecimal(value)}%`;
+}
+function trimDecimal(value) {
+    return value.toFixed(1).replace(/\.0$/, "");
+}
+function plural(count, word) {
+    return count === 1 ? word : `${word}s`;
+}
+function isRecord(value) {
+    return typeof value === "object" && value !== null && !Array.isArray(value);
+}

package/dist/app/editor-layout-renderer.d.ts

@@ -0,0 +1,31 @@
+import type { InputEditor } from "../input-editor.js";
+import type { Theme } from "../theme.js";
+import type { EditorLayout, ExtensionWidgetRegistration, ExtensionWidgetTheme, SubagentsWidgetState, TodoDetails, WidgetTuiHandle } from "./types.js";
+export type EditorLayoutRendererHost = {
+    readonly theme: Theme;
+    readonly inputEditor: InputEditor;
+    readonly extensionWidgets: ReadonlyMap<string, ExtensionWidgetRegistration>;
+    readonly todoDetails: TodoDetails | undefined;
+    readonly todoPanelExpanded: boolean;
+    readonly subagentsPanelExpanded: boolean;
+    readonly subagentsWidgetState: SubagentsWidgetState | undefined;
+    readonly voicePartialText: string | undefined;
+    renderExtensionInputComponent(width: number): string[] | undefined;
+    extensionInputUsesEditor(): boolean;
+    widgetTuiHandle(): WidgetTuiHandle;
+    createExtensionTheme(): ExtensionWidgetTheme;
+    suppressExtensionWidget(key: string): void;
+};
+export declare class EditorLayoutRenderer {
+    private readonly host;
+    constructor(host: EditorLayoutRendererHost);
+    computeLayout(width: number, rows: number): EditorLayout;
+    private renderWidgetRegistration;
+    private renderWidgetComponent;
+    private renderAboveEditorEntities;
+    private renderVoicePartial;
+    private renderExtensionWidgets;
+    private limitEntityLines;
+    private renderInput;
+    private limitExtensionInputLines;
+}