@andorra-labs/code 0.0.0-stage → 0.1.4

package/dist/vendor/engine/runtime/coding-agent/core/tools/renderers/bash.js

@@ -0,0 +1,137 @@
+/**
+ * Presentation for the shell tools.
+ *
+ * Renderers live apart from the implementation so a process that only displays tool output does not
+ * load the execution path or its typebox parameter schema. `bash.ts` spreads these into the shell
+ * tool definition, so the tool's public shape is unchanged.
+ */
+import { AndorraContainer, AndorraText, andorraTruncateToWidth } from "../../../../tui/index.js";
+import { andorraKeyHint } from "../../../modes/interactive/components/keybinding-hints.js";
+import { andorraTruncateToVisualLines } from "../../../modes/interactive/components/visual-truncate.js";
+import { theme } from "../../../modes/interactive/theme/theme.js";
+import { andorraGetTextOutput, andorraInvalidArgText, andorraStr } from "../render-utils.js";
+import { DEFAULT_MAX_BYTES, andorraFormatSize } from "../truncate.js";
+const BASH_PREVIEW_LINES = 5;
+export const BASH_UPDATE_THROTTLE_MS = 100;
+class AndorraBashResultRenderComponent extends AndorraContainer {
+    state = {
+        cachedWidth: undefined,
+        cachedLines: undefined,
+        cachedSkipped: undefined,
+    };
+}
+function andorraFormatDuration(ms) {
+    const seconds = ms / 1000;
+    if (seconds < 60)
+        return `${seconds.toFixed(1)}s`;
+    const totalSeconds = Math.floor(seconds);
+    const minutes = Math.floor(totalSeconds / 60);
+    const remainder = totalSeconds % 60;
+    if (minutes < 60)
+        return `${minutes}m ${remainder}s`;
+    return `${Math.floor(minutes / 60)}h ${minutes % 60}m ${remainder}s`;
+}
+function andorraFormatShellCall(args, prompt) {
+    const command = andorraStr(args?.command);
+    const timeout = args?.timeout;
+    const timeoutSuffix = timeout ? theme.fg("muted", ` (timeout ${timeout}s)`) : "";
+    const commandDisplay = command === null ? andorraInvalidArgText(theme) : command ? command : theme.fg("toolOutput", "...");
+    return theme.fg("toolTitle", theme.bold(`${prompt} ${commandDisplay}`)) + timeoutSuffix;
+}
+function andorraRebuildBashResultRenderComponent(component, result, options, showImages, startedAt, endedAt) {
+    const state = component.state;
+    component.clear();
+    let output = andorraGetTextOutput(result, showImages).trim();
+    const truncation = result.details?.truncation;
+    const fullOutputPath = result.details?.fullOutputPath;
+    if (!options.isPartial && truncation?.truncated && fullOutputPath && output.endsWith("]")) {
+        const footerStart = output.lastIndexOf("\n\n[");
+        if (footerStart !== -1 && output.slice(footerStart).includes(fullOutputPath)) {
+            output = output.slice(0, footerStart).trimEnd();
+        }
+    }
+    if (output) {
+        const styledOutput = output
+            .split("\n")
+            .map((line) => theme.fg("toolOutput", line))
+            .join("\n");
+        if (options.expanded) {
+            component.addChild(new AndorraText(`\n${styledOutput}`, 0, 0));
+        }
+        else {
+            component.addChild({
+                render: (width) => {
+                    if (state.cachedLines === undefined || state.cachedWidth !== width) {
+                        const preview = andorraTruncateToVisualLines(styledOutput, BASH_PREVIEW_LINES, width);
+                        state.cachedLines = preview.visualLines;
+                        state.cachedSkipped = preview.skippedCount;
+                        state.cachedWidth = width;
+                    }
+                    if (state.cachedSkipped && state.cachedSkipped > 0) {
+                        const hint = theme.fg("muted", `... (${state.cachedSkipped} earlier lines,`) +
+                            ` ${andorraKeyHint("app.tools.expand", "to expand")}${theme.fg("muted", ")")}`;
+                        return ["", andorraTruncateToWidth(hint, width, "..."), ...(state.cachedLines ?? [])];
+                    }
+                    return ["", ...(state.cachedLines ?? [])];
+                },
+                invalidate: () => {
+                    state.cachedWidth = undefined;
+                    state.cachedLines = undefined;
+                    state.cachedSkipped = undefined;
+                },
+            });
+        }
+    }
+    if (truncation?.truncated || fullOutputPath) {
+        const warnings = [];
+        if (fullOutputPath) {
+            warnings.push(`Full output: ${fullOutputPath}`);
+        }
+        if (truncation?.truncated) {
+            if (truncation.truncatedBy === "lines") {
+                warnings.push(`Truncated: showing ${truncation.outputLines} of ${truncation.totalLines} lines`);
+            }
+            else {
+                warnings.push(`Truncated: ${truncation.outputLines} lines shown (${andorraFormatSize(truncation.maxBytes ?? DEFAULT_MAX_BYTES)} limit)`);
+            }
+        }
+        component.addChild(new AndorraText(`\n${theme.fg("warning", `[${warnings.join(". ")}]`)}`, 0, 0));
+    }
+    if (startedAt !== undefined) {
+        const label = options.isPartial ? "Elapsed" : "Took";
+        const endTime = endedAt ?? Date.now();
+        component.addChild(new AndorraText(`\n${theme.fg("muted", `${label} ${andorraFormatDuration(endTime - startedAt)}`)}`, 0, 0));
+    }
+}
+/** Shell renderers are shared by bash and powershell, which differ only in the prompt they display. */
+export function andorraCreateShellRenderers(prompt) {
+    return {
+        renderCall(args, _theme, context) {
+            const state = context.state;
+            if (context.executionStarted && state.startedAt === undefined) {
+                state.startedAt = Date.now();
+                state.endedAt = undefined;
+            }
+            const text = context.lastComponent ?? new AndorraText("", 0, 0);
+            text.setText(andorraFormatShellCall(args, prompt));
+            return text;
+        },
+        renderResult(result, options, _theme, context) {
+            const state = context.state;
+            if (state.startedAt !== undefined && options.isPartial && !state.interval) {
+                state.interval = setInterval(() => context.invalidate(), 1000);
+            }
+            if (!options.isPartial || context.isError) {
+                state.endedAt ??= Date.now();
+                if (state.interval) {
+                    clearInterval(state.interval);
+                    state.interval = undefined;
+                }
+            }
+            const component = context.lastComponent ?? new AndorraBashResultRenderComponent();
+            andorraRebuildBashResultRenderComponent(component, result, options, context.showImages, state.startedAt, state.endedAt);
+            component.invalidate();
+            return component;
+        },
+    };
+}

package/dist/vendor/engine/runtime/coding-agent/core/tools/renderers/edit.d.ts

@@ -0,0 +1,22 @@
+/**
+ * Presentation for the edit tool.
+ *
+ * Renderers live apart from the implementation so a process that only displays tool output does not
+ * load the execution path or its typebox parameter schema. `edit.ts` spreads these into its
+ * definition, so the tool's public shape is unchanged.
+ */
+import { AndorraBox } from "../../../../tui/index.js";
+import type { ToolDefinition } from "../../extensions/types.js";
+import { type EditDiffError, type EditDiffResult } from "../edit-diff.js";
+type EditPreview = EditDiffResult | EditDiffError;
+export type EditRenderState = {
+    callComponent?: EditCallRenderComponent;
+};
+type EditCallRenderComponent = AndorraBox & {
+    preview?: EditPreview;
+    previewArgsKey?: string;
+    previewPending?: boolean;
+    settledError?: boolean;
+};
+export declare const editRenderers: Pick<ToolDefinition<any, any>, "renderCall" | "renderResult">;
+export {};

package/dist/vendor/engine/runtime/coding-agent/core/tools/renderers/edit.js

@@ -0,0 +1,166 @@
+/**
+ * Presentation for the edit tool.
+ *
+ * Renderers live apart from the implementation so a process that only displays tool output does not
+ * load the execution path or its typebox parameter schema. `edit.ts` spreads these into its
+ * definition, so the tool's public shape is unchanged.
+ */
+import { AndorraBox, AndorraContainer, AndorraSpacer, AndorraText } from "../../../../tui/index.js";
+import { andorraRenderDiff } from "../../../modes/interactive/components/diff.js";
+import { andorraComputeEditsDiff } from "../edit-diff.js";
+import { andorraRenderToolPath, andorraStr } from "../render-utils.js";
+function andorraCreateEditCallRenderComponent() {
+    return Object.assign(new AndorraBox(1, 1, (text) => text), {
+        preview: undefined,
+        previewArgsKey: undefined,
+        previewPending: false,
+        settledError: false,
+    });
+}
+function andorraGetEditCallRenderComponent(state, lastComponent) {
+    if (lastComponent instanceof AndorraBox) {
+        const component = lastComponent;
+        state.callComponent = component;
+        return component;
+    }
+    if (state.callComponent) {
+        return state.callComponent;
+    }
+    const component = andorraCreateEditCallRenderComponent();
+    state.callComponent = component;
+    return component;
+}
+function andorraGetRenderablePreviewInput(args) {
+    if (!args) {
+        return null;
+    }
+    const path = typeof args.path === "string" ? args.path : typeof args.file_path === "string" ? args.file_path : null;
+    if (!path) {
+        return null;
+    }
+    if (Array.isArray(args.edits) &&
+        args.edits.length > 0 &&
+        args.edits.every((edit) => typeof edit?.oldText === "string" && typeof edit?.newText === "string")) {
+        return { path, edits: args.edits };
+    }
+    if (typeof args.oldText === "string" && typeof args.newText === "string") {
+        return { path, edits: [{ oldText: args.oldText, newText: args.newText }] };
+    }
+    return null;
+}
+function andorraFormatEditCall(args, theme, cwd) {
+    const pathDisplay = andorraRenderToolPath(andorraStr(args?.file_path ?? args?.path), theme, cwd);
+    return `${theme.fg("toolTitle", theme.bold("edit"))} ${pathDisplay}`;
+}
+function andorraFormatEditResult(args, preview, result, theme, isError) {
+    const rawPath = andorraStr(args?.file_path ?? args?.path);
+    const previewDiff = preview && !("error" in preview) ? preview.diff : undefined;
+    const previewError = preview && "error" in preview ? preview.error : undefined;
+    if (isError) {
+        const errorText = result.content
+            .filter((c) => c.type === "text")
+            .map((c) => c.text || "")
+            .join("\n");
+        if (!errorText || errorText === previewError) {
+            return undefined;
+        }
+        return theme.fg("error", errorText);
+    }
+    const resultDiff = result.details?.diff;
+    if (resultDiff && resultDiff !== previewDiff) {
+        return andorraRenderDiff(resultDiff, { filePath: rawPath ?? undefined });
+    }
+    return undefined;
+}
+function andorraGetEditHeaderBg(preview, settledError, theme) {
+    if (preview) {
+        if ("error" in preview) {
+            return (text) => theme.bg("toolErrorBg", text);
+        }
+        return (text) => theme.bg("toolSuccessBg", text);
+    }
+    if (settledError) {
+        return (text) => theme.bg("toolErrorBg", text);
+    }
+    return (text) => theme.bg("toolPendingBg", text);
+}
+function andorraBuildEditCallComponent(component, args, theme, cwd) {
+    component.setBgFn(andorraGetEditHeaderBg(component.preview, component.settledError, theme));
+    component.clear();
+    component.addChild(new AndorraText(andorraFormatEditCall(args, theme, cwd), 0, 0));
+    if (!component.preview) {
+        return component;
+    }
+    const body = "error" in component.preview ? theme.fg("error", component.preview.error) : andorraRenderDiff(component.preview.diff);
+    component.addChild(new AndorraSpacer(1));
+    component.addChild(new AndorraText(body, 0, 0));
+    return component;
+}
+function andorraSetEditPreview(component, preview, argsKey) {
+    const current = component.preview;
+    const changed = current === undefined ||
+        ("error" in current && "error" in preview
+            ? current.error !== preview.error
+            : "error" in current !== "error" in preview) ||
+        (!("error" in current) &&
+            !("error" in preview) &&
+            (current.diff !== preview.diff || current.firstChangedLine !== preview.firstChangedLine));
+    component.preview = preview;
+    component.previewArgsKey = argsKey;
+    component.previewPending = false;
+    return changed;
+}
+export const editRenderers = {
+    renderCall(args, theme, context) {
+        const component = andorraGetEditCallRenderComponent(context.state, context.lastComponent);
+        const previewInput = andorraGetRenderablePreviewInput(args);
+        const argsKey = previewInput ? JSON.stringify({ path: previewInput.path, edits: previewInput.edits }) : undefined;
+        if (component.previewArgsKey !== argsKey) {
+            component.preview = undefined;
+            component.previewArgsKey = argsKey;
+            component.previewPending = false;
+            component.settledError = false;
+        }
+        if (context.argsComplete && previewInput && !component.preview && !component.previewPending) {
+            component.previewPending = true;
+            const requestKey = argsKey;
+            void andorraComputeEditsDiff(previewInput.path, previewInput.edits, context.cwd).then((preview) => {
+                if (component.previewArgsKey === requestKey) {
+                    andorraSetEditPreview(component, preview, requestKey);
+                    context.invalidate();
+                }
+            });
+        }
+        return andorraBuildEditCallComponent(component, args, theme, context.cwd);
+    },
+    renderResult(result, _options, theme, context) {
+        const callComponent = context.state.callComponent;
+        const previewInput = andorraGetRenderablePreviewInput(context.args);
+        const argsKey = previewInput ? JSON.stringify({ path: previewInput.path, edits: previewInput.edits }) : undefined;
+        const typedResult = result;
+        const resultDiff = !context.isError ? typedResult.details?.diff : undefined;
+        let changed = false;
+        if (callComponent) {
+            if (typeof resultDiff === "string") {
+                changed =
+                    andorraSetEditPreview(callComponent, { diff: resultDiff, firstChangedLine: typedResult.details?.firstChangedLine }, argsKey) || changed;
+            }
+            if (callComponent.settledError !== context.isError) {
+                callComponent.settledError = context.isError;
+                changed = true;
+            }
+            if (changed) {
+                andorraBuildEditCallComponent(callComponent, context.args, theme, context.cwd);
+            }
+        }
+        const output = andorraFormatEditResult(context.args, callComponent?.preview, typedResult, theme, context.isError);
+        const component = context.lastComponent ?? new AndorraContainer();
+        component.clear();
+        if (!output) {
+            return component;
+        }
+        component.addChild(new AndorraSpacer(1));
+        component.addChild(new AndorraText(output, 1, 0));
+        return component;
+    },
+};

package/dist/vendor/engine/runtime/coding-agent/core/tools/renderers/find.d.ts

@@ -0,0 +1,9 @@
+/**
+ * Presentation for the find tool.
+ *
+ * Renderers live apart from the implementation so a process that only displays tool output does not
+ * load the execution path or its typebox parameter schema. `find.ts` spreads these into its
+ * definition, so the tool's public shape is unchanged.
+ */
+import type { ToolDefinition } from "../../extensions/types.js";
+export declare const findRenderers: Pick<ToolDefinition<any, any>, "renderCall" | "renderResult">;

package/dist/vendor/engine/runtime/coding-agent/core/tools/renderers/find.js

@@ -0,0 +1,63 @@
+/**
+ * Presentation for the find tool.
+ *
+ * Renderers live apart from the implementation so a process that only displays tool output does not
+ * load the execution path or its typebox parameter schema. `find.ts` spreads these into its
+ * definition, so the tool's public shape is unchanged.
+ */
+import { AndorraText } from "../../../../tui/index.js";
+import { andorraKeyHint } from "../../../modes/interactive/components/keybinding-hints.js";
+import { andorraGetTextOutput, andorraInvalidArgText, andorraShortenPath, andorraStr } from "../render-utils.js";
+import { DEFAULT_MAX_BYTES, andorraFormatSize } from "../truncate.js";
+function andorraFormatFindCall(args, theme) {
+    const pattern = andorraStr(args?.pattern);
+    const rawPath = andorraStr(args?.path);
+    const path = rawPath !== null ? andorraShortenPath(rawPath || ".") : null;
+    const limit = args?.limit;
+    const invalidArg = andorraInvalidArgText(theme);
+    let text = theme.fg("toolTitle", theme.bold("find")) +
+        " " +
+        (pattern === null ? invalidArg : theme.fg("accent", pattern || "")) +
+        theme.fg("toolOutput", ` in ${path === null ? invalidArg : path}`);
+    if (limit !== undefined) {
+        text += theme.fg("toolOutput", ` (limit ${limit})`);
+    }
+    return text;
+}
+function andorraFormatFindResult(result, options, theme, showImages) {
+    const output = andorraGetTextOutput(result, showImages).trim();
+    let text = "";
+    if (output) {
+        const lines = output.split("\n");
+        const maxLines = options.expanded ? lines.length : 20;
+        const displayLines = lines.slice(0, maxLines);
+        const remaining = lines.length - maxLines;
+        text += `\n${displayLines.map((line) => theme.fg("toolOutput", line)).join("\n")}`;
+        if (remaining > 0) {
+            text += `${theme.fg("muted", `\n... (${remaining} more lines,`)} ${andorraKeyHint("app.tools.expand", "to expand")}${theme.fg("muted", ")")}`;
+        }
+    }
+    const resultLimit = result.details?.resultLimitReached;
+    const truncation = result.details?.truncation;
+    if (resultLimit || truncation?.truncated) {
+        const warnings = [];
+        if (resultLimit)
+            warnings.push(`${resultLimit} results limit`);
+        if (truncation?.truncated)
+            warnings.push(`${andorraFormatSize(truncation.maxBytes ?? DEFAULT_MAX_BYTES)} limit`);
+        text += `\n${theme.fg("warning", `[Truncated: ${warnings.join(", ")}]`)}`;
+    }
+    return text;
+}
+export const findRenderers = {
+    renderCall(args, theme, context) {
+        const text = context.lastComponent ?? new AndorraText("", 0, 0);
+        text.setText(andorraFormatFindCall(args, theme));
+        return text;
+    },
+    renderResult(result, options, theme, context) {
+        const text = context.lastComponent ?? new AndorraText("", 0, 0);
+        text.setText(andorraFormatFindResult(result, options, theme, context.showImages));
+        return text;
+    },
+};

package/dist/vendor/engine/runtime/coding-agent/core/tools/renderers/grep.d.ts

@@ -0,0 +1,9 @@
+/**
+ * Presentation for the grep tool.
+ *
+ * Renderers live apart from the implementation so a process that only displays tool output does not
+ * load the execution path or its typebox parameter schema. `grep.ts` spreads these into its
+ * definition, so the tool's public shape is unchanged.
+ */
+import type { ToolDefinition } from "../../extensions/types.js";
+export declare const grepRenderers: Pick<ToolDefinition<any, any>, "renderCall" | "renderResult">;

package/dist/vendor/engine/runtime/coding-agent/core/tools/renderers/grep.js

@@ -0,0 +1,68 @@
+/**
+ * Presentation for the grep tool.
+ *
+ * Renderers live apart from the implementation so a process that only displays tool output does not
+ * load the execution path or its typebox parameter schema. `grep.ts` spreads these into its
+ * definition, so the tool's public shape is unchanged.
+ */
+import { AndorraText } from "../../../../tui/index.js";
+import { andorraKeyHint } from "../../../modes/interactive/components/keybinding-hints.js";
+import { andorraGetTextOutput, andorraInvalidArgText, andorraShortenPath, andorraStr } from "../render-utils.js";
+import { DEFAULT_MAX_BYTES, andorraFormatSize } from "../truncate.js";
+function andorraFormatGrepCall(args, theme) {
+    const pattern = andorraStr(args?.pattern);
+    const rawPath = andorraStr(args?.path);
+    const path = rawPath !== null ? andorraShortenPath(rawPath || ".") : null;
+    const glob = andorraStr(args?.glob);
+    const limit = args?.limit;
+    const invalidArg = andorraInvalidArgText(theme);
+    let text = theme.fg("toolTitle", theme.bold("grep")) +
+        " " +
+        (pattern === null ? invalidArg : theme.fg("accent", `/${pattern || ""}/`)) +
+        theme.fg("toolOutput", ` in ${path === null ? invalidArg : path}`);
+    if (glob)
+        text += theme.fg("toolOutput", ` (${glob})`);
+    if (limit !== undefined)
+        text += theme.fg("toolOutput", ` limit ${limit}`);
+    return text;
+}
+function andorraFormatGrepResult(result, options, theme, showImages) {
+    const output = andorraGetTextOutput(result, showImages).trim();
+    let text = "";
+    if (output) {
+        const lines = output.split("\n");
+        const maxLines = options.expanded ? lines.length : 15;
+        const displayLines = lines.slice(0, maxLines);
+        const remaining = lines.length - maxLines;
+        text += `\n${displayLines.map((line) => theme.fg("toolOutput", line)).join("\n")}`;
+        if (remaining > 0) {
+            text += `${theme.fg("muted", `\n... (${remaining} more lines,`)} ${andorraKeyHint("app.tools.expand", "to expand")}${theme.fg("muted", ")")}`;
+        }
+    }
+    const matchLimit = result.details?.matchLimitReached;
+    const truncation = result.details?.truncation;
+    const linesTruncated = result.details?.linesTruncated;
+    if (matchLimit || truncation?.truncated || linesTruncated) {
+        const warnings = [];
+        if (matchLimit)
+            warnings.push(`${matchLimit} matches limit`);
+        if (truncation?.truncated)
+            warnings.push(`${andorraFormatSize(truncation.maxBytes ?? DEFAULT_MAX_BYTES)} limit`);
+        if (linesTruncated)
+            warnings.push("some lines truncated");
+        text += `\n${theme.fg("warning", `[Truncated: ${warnings.join(", ")}]`)}`;
+    }
+    return text;
+}
+export const grepRenderers = {
+    renderCall(args, theme, context) {
+        const text = context.lastComponent ?? new AndorraText("", 0, 0);
+        text.setText(andorraFormatGrepCall(args, theme));
+        return text;
+    },
+    renderResult(result, options, theme, context) {
+        const text = context.lastComponent ?? new AndorraText("", 0, 0);
+        text.setText(andorraFormatGrepResult(result, options, theme, context.showImages));
+        return text;
+    },
+};

package/dist/vendor/engine/runtime/coding-agent/core/tools/renderers/index.d.ts

@@ -0,0 +1,27 @@
+/**
+ * Built-in tool renderers, without the tools themselves.
+ *
+ * A presentation displays tool calls and results; it does not execute them and does not need their
+ * typebox parameter schemas. Importing this instead of `core/tools/index.ts` keeps ~17 MB of module
+ * graph out of a process that only renders.
+ */
+import type { ToolDefinition } from "../../extensions/types.js";
+import type { ToolName } from "../index.js";
+import { andorraCreateShellRenderers } from "./bash.js";
+import { editRenderers } from "./edit.js";
+import { findRenderers } from "./find.js";
+import { grepRenderers } from "./grep.js";
+import { lsRenderers } from "./ls.js";
+import { readRenderers } from "./read.js";
+import { writeRenderers } from "./write.js";
+export type ToolRenderers = Pick<ToolDefinition<any, any>, "renderCall" | "renderResult">;
+export { andorraCreateShellRenderers, editRenderers, findRenderers, grepRenderers, lsRenderers, readRenderers, writeRenderers, };
+/** Renderers for every built-in tool, keyed by tool name. */
+export declare function andorraCreateAllToolRenderers(): Record<ToolName, ToolRenderers>;
+/**
+ * Merge built-in renderers into a tool definition that does not supply its own.
+ *
+ * `ToolExecutionComponent` used to do this lookup itself, which forced every presentation to import
+ * the tool implementations. Callers do it now, so a process that renders can import renderers alone.
+ */
+export declare function andorraWithBuiltInRenderers<TDefinition extends ToolRenderers>(toolName: string, definition: TDefinition | undefined): TDefinition | ToolRenderers | undefined;

package/dist/vendor/engine/runtime/coding-agent/core/tools/renderers/index.js

@@ -0,0 +1,46 @@
+/**
+ * Built-in tool renderers, without the tools themselves.
+ *
+ * A presentation displays tool calls and results; it does not execute them and does not need their
+ * typebox parameter schemas. Importing this instead of `core/tools/index.ts` keeps ~17 MB of module
+ * graph out of a process that only renders.
+ */
+import { andorraCreateShellRenderers } from "./bash.js";
+import { editRenderers } from "./edit.js";
+import { findRenderers } from "./find.js";
+import { grepRenderers } from "./grep.js";
+import { lsRenderers } from "./ls.js";
+import { readRenderers } from "./read.js";
+import { writeRenderers } from "./write.js";
+export { andorraCreateShellRenderers, editRenderers, findRenderers, grepRenderers, lsRenderers, readRenderers, writeRenderers, };
+/** Renderers for every built-in tool, keyed by tool name. */
+export function andorraCreateAllToolRenderers() {
+    return {
+        read: readRenderers,
+        bash: andorraCreateShellRenderers("$"),
+        powershell: andorraCreateShellRenderers("PS>"),
+        edit: editRenderers,
+        write: writeRenderers,
+        grep: grepRenderers,
+        find: findRenderers,
+        ls: lsRenderers,
+    };
+}
+/**
+ * Merge built-in renderers into a tool definition that does not supply its own.
+ *
+ * `ToolExecutionComponent` used to do this lookup itself, which forced every presentation to import
+ * the tool implementations. Callers do it now, so a process that renders can import renderers alone.
+ */
+export function andorraWithBuiltInRenderers(toolName, definition) {
+    const builtIn = andorraCreateAllToolRenderers()[toolName];
+    if (!definition)
+        return builtIn;
+    if (!builtIn)
+        return definition;
+    return {
+        ...definition,
+        renderCall: definition.renderCall ?? builtIn.renderCall,
+        renderResult: definition.renderResult ?? builtIn.renderResult,
+    };
+}

package/dist/vendor/engine/runtime/coding-agent/core/tools/renderers/ls.d.ts

@@ -0,0 +1,9 @@
+/**
+ * Presentation for the ls tool.
+ *
+ * Renderers live apart from the implementation so a process that only displays tool output does not
+ * load the execution path or its typebox parameter schema. `ls.ts` spreads these into its
+ * definition, so the tool's public shape is unchanged.
+ */
+import type { ToolDefinition } from "../../extensions/types.js";
+export declare const lsRenderers: Pick<ToolDefinition<any, any>, "renderCall" | "renderResult">;

package/dist/vendor/engine/runtime/coding-agent/core/tools/renderers/ls.js

@@ -0,0 +1,57 @@
+/**
+ * Presentation for the ls tool.
+ *
+ * Renderers live apart from the implementation so a process that only displays tool output does not
+ * load the execution path or its typebox parameter schema. `ls.ts` spreads these into its
+ * definition, so the tool's public shape is unchanged.
+ */
+import { AndorraText } from "../../../../tui/index.js";
+import { andorraKeyHint } from "../../../modes/interactive/components/keybinding-hints.js";
+import { andorraGetTextOutput, andorraRenderToolPath, andorraStr } from "../render-utils.js";
+import { DEFAULT_MAX_BYTES, andorraFormatSize } from "../truncate.js";
+function andorraFormatLsCall(args, theme, cwd) {
+    const limit = args?.limit;
+    const pathDisplay = andorraRenderToolPath(andorraStr(args?.path), theme, cwd, { emptyFallback: "." });
+    let text = `${theme.fg("toolTitle", theme.bold("ls"))} ${pathDisplay}`;
+    if (limit !== undefined) {
+        text += theme.fg("toolOutput", ` (limit ${limit})`);
+    }
+    return text;
+}
+function andorraFormatLsResult(result, options, theme, showImages) {
+    const output = andorraGetTextOutput(result, showImages).trim();
+    let text = "";
+    if (output) {
+        const lines = output.split("\n");
+        const maxLines = options.expanded ? lines.length : 20;
+        const displayLines = lines.slice(0, maxLines);
+        const remaining = lines.length - maxLines;
+        text += `\n${displayLines.map((line) => theme.fg("toolOutput", line)).join("\n")}`;
+        if (remaining > 0) {
+            text += `${theme.fg("muted", `\n... (${remaining} more lines,`)} ${andorraKeyHint("app.tools.expand", "to expand")}${theme.fg("muted", ")")}`;
+        }
+    }
+    const entryLimit = result.details?.entryLimitReached;
+    const truncation = result.details?.truncation;
+    if (entryLimit || truncation?.truncated) {
+        const warnings = [];
+        if (entryLimit)
+            warnings.push(`${entryLimit} entries limit`);
+        if (truncation?.truncated)
+            warnings.push(`${andorraFormatSize(truncation.maxBytes ?? DEFAULT_MAX_BYTES)} limit`);
+        text += `\n${theme.fg("warning", `[Truncated: ${warnings.join(", ")}]`)}`;
+    }
+    return text;
+}
+export const lsRenderers = {
+    renderCall(args, theme, context) {
+        const text = context.lastComponent ?? new AndorraText("", 0, 0);
+        text.setText(andorraFormatLsCall(args, theme, context.cwd));
+        return text;
+    },
+    renderResult(result, options, theme, context) {
+        const text = context.lastComponent ?? new AndorraText("", 0, 0);
+        text.setText(andorraFormatLsResult(result, options, theme, context.showImages));
+        return text;
+    },
+};

package/dist/vendor/engine/runtime/coding-agent/core/tools/renderers/read.d.ts

@@ -0,0 +1,10 @@
+/**
+ * Presentation for the read tool.
+ *
+ * Renderers live apart from the implementation so a process that only displays tool output does not
+ * load the execution path or its typebox parameter schema. `read.ts` spreads these into its
+ * definition, so the tool's public shape is unchanged.
+ */
+import type { ToolDefinition } from "../../extensions/types.js";
+import type { ReadToolDetails } from "../read.js";
+export declare const readRenderers: Pick<ToolDefinition<any, ReadToolDetails | undefined>, "renderCall" | "renderResult">;