pi-ui-extend 0.1.1

package/dist/terminal-width.js

@@ -0,0 +1,245 @@
+const TAB_WIDTH = 4;
+const ANSI_RESET = "\x1b[0m";
+export function expandTabs(text, tabWidth = TAB_WIDTH) {
+    let result = "";
+    let column = 0;
+    for (let index = 0; index < text.length;) {
+        const ansiLength = ansiSequenceLength(text, index);
+        if (ansiLength > 0) {
+            result += text.slice(index, index + ansiLength);
+            index += ansiLength;
+            continue;
+        }
+        const codePoint = text.codePointAt(index) ?? 0;
+        const char = String.fromCodePoint(codePoint);
+        index += codePointLength(codePoint);
+        if (char === "\n") {
+            result += char;
+            column = 0;
+            continue;
+        }
+        if (char === "\t") {
+            const spaces = tabWidth - (column % tabWidth || tabWidth);
+            const count = spaces === 0 ? tabWidth : spaces;
+            result += " ".repeat(count);
+            column += count;
+            continue;
+        }
+        result += char;
+        column += charDisplayWidth(char.codePointAt(0) ?? 0);
+    }
+    return result;
+}
+export function stringDisplayWidth(text) {
+    let width = 0;
+    for (let index = 0; index < text.length;) {
+        const ansiLength = ansiSequenceLength(text, index);
+        if (ansiLength > 0) {
+            index += ansiLength;
+            continue;
+        }
+        const codePoint = text.codePointAt(index) ?? 0;
+        width += charDisplayWidth(codePoint);
+        index += codePointLength(codePoint);
+    }
+    return width;
+}
+export function sliceByDisplayWidth(text, width) {
+    const safeWidth = Math.max(0, width);
+    let result = "";
+    let used = 0;
+    let sawAnsi = false;
+    let clipped = false;
+    for (let index = 0; index < text.length;) {
+        const ansiLength = ansiSequenceLength(text, index);
+        if (ansiLength > 0) {
+            result += text.slice(index, index + ansiLength);
+            sawAnsi = true;
+            index += ansiLength;
+            continue;
+        }
+        const codePoint = text.codePointAt(index) ?? 0;
+        const char = String.fromCodePoint(codePoint);
+        const charWidth = charDisplayWidth(codePoint);
+        if (used + charWidth > safeWidth) {
+            clipped = true;
+            break;
+        }
+        result += char;
+        used += charWidth;
+        index += codePointLength(codePoint);
+    }
+    if (sawAnsi && clipped && !result.endsWith(ANSI_RESET))
+        return `${result}${ANSI_RESET}`;
+    return result;
+}
+export function padOrTrimDisplay(text, width) {
+    const safeWidth = Math.max(0, width);
+    const trimmed = sliceByDisplayWidth(text, safeWidth);
+    return `${trimmed}${" ".repeat(Math.max(0, safeWidth - stringDisplayWidth(trimmed)))}`;
+}
+export function wrapDisplayLine(text, width) {
+    const safeWidth = Math.max(1, width);
+    const chunks = [];
+    let chunk = "";
+    let chunkWidth = 0;
+    for (let index = 0; index < text.length;) {
+        const ansiLength = ansiSequenceLength(text, index);
+        if (ansiLength > 0) {
+            chunk += text.slice(index, index + ansiLength);
+            index += ansiLength;
+            continue;
+        }
+        const codePoint = text.codePointAt(index) ?? 0;
+        const char = String.fromCodePoint(codePoint);
+        const charWidth = charDisplayWidth(codePoint);
+        if (chunk && chunkWidth + charWidth > safeWidth) {
+            chunks.push(chunk);
+            chunk = "";
+            chunkWidth = 0;
+        }
+        chunk += char;
+        chunkWidth += charWidth;
+        index += codePointLength(codePoint);
+    }
+    chunks.push(chunk);
+    return chunks;
+}
+export function wrapDisplayLineByWords(text, width) {
+    const safeWidth = Math.max(1, width);
+    if (stringDisplayWidth(text) <= safeWidth)
+        return [text];
+    const chunks = [];
+    let chunk = "";
+    for (const token of displayTokens(text)) {
+        if (token.whitespace) {
+            if (!chunk) {
+                chunk = appendTokenToEmptyChunk(token.text, safeWidth, chunks);
+                continue;
+            }
+            const candidate = `${chunk}${token.text}`;
+            if (stringDisplayWidth(candidate) <= safeWidth) {
+                chunk = candidate;
+            }
+            else {
+                chunks.push(trimTrailingWhitespace(chunk));
+                chunk = "";
+            }
+            continue;
+        }
+        if (!chunk) {
+            chunk = appendTokenToEmptyChunk(token.text, safeWidth, chunks);
+            continue;
+        }
+        const candidate = `${chunk}${token.text}`;
+        if (stringDisplayWidth(candidate) <= safeWidth) {
+            chunk = candidate;
+            continue;
+        }
+        chunks.push(trimTrailingWhitespace(chunk));
+        chunk = appendTokenToEmptyChunk(token.text, safeWidth, chunks);
+    }
+    chunks.push(chunk);
+    return chunks;
+}
+function displayTokens(text) {
+    const tokens = [];
+    let current = "";
+    let currentWhitespace;
+    for (let index = 0; index < text.length;) {
+        const ansiLength = ansiSequenceLength(text, index);
+        if (ansiLength > 0) {
+            current += text.slice(index, index + ansiLength);
+            index += ansiLength;
+            continue;
+        }
+        const codePoint = text.codePointAt(index) ?? 0;
+        const char = String.fromCodePoint(codePoint);
+        const whitespace = /\s/u.test(char);
+        if (current && currentWhitespace !== whitespace) {
+            tokens.push({ text: current, whitespace: currentWhitespace ?? false });
+            current = "";
+        }
+        current += char;
+        currentWhitespace = whitespace;
+        index += codePointLength(codePoint);
+    }
+    if (current)
+        tokens.push({ text: current, whitespace: currentWhitespace ?? false });
+    return tokens;
+}
+function appendTokenToEmptyChunk(token, width, chunks) {
+    if (stringDisplayWidth(token) <= width)
+        return token;
+    const wrapped = wrapDisplayLine(token, width);
+    chunks.push(...wrapped.slice(0, -1));
+    return wrapped.at(-1) ?? "";
+}
+function trimTrailingWhitespace(text) {
+    return text.replace(/\s+$/u, "");
+}
+function ansiSequenceLength(text, index) {
+    if (text.charCodeAt(index) !== 0x1b)
+        return 0;
+    const next = text[index + 1];
+    if (!next)
+        return 1;
+    if (next === "[") {
+        for (let cursor = index + 2; cursor < text.length; cursor += 1) {
+            const code = text.charCodeAt(cursor);
+            if (code >= 0x40 && code <= 0x7e)
+                return cursor - index + 1;
+        }
+        return text.length - index;
+    }
+    if (next === "]") {
+        for (let cursor = index + 2; cursor < text.length; cursor += 1) {
+            const code = text.charCodeAt(cursor);
+            if (code === 0x07)
+                return cursor - index + 1;
+            if (code === 0x1b && text[cursor + 1] === "\\")
+                return cursor - index + 2;
+        }
+        return text.length - index;
+    }
+    return 2;
+}
+function codePointLength(codePoint) {
+    return codePoint > 0xffff ? 2 : 1;
+}
+function charDisplayWidth(codePoint) {
+    if (codePoint === 0)
+        return 0;
+    if (codePoint < 32 || (codePoint >= 0x7f && codePoint < 0xa0))
+        return 0;
+    if (isCombining(codePoint))
+        return 0;
+    if (isFullWidth(codePoint))
+        return 2;
+    return 1;
+}
+function isCombining(codePoint) {
+    return ((codePoint >= 0x0300 && codePoint <= 0x036f) ||
+        (codePoint >= 0x1ab0 && codePoint <= 0x1aff) ||
+        (codePoint >= 0x1dc0 && codePoint <= 0x1dff) ||
+        (codePoint >= 0x20d0 && codePoint <= 0x20ff) ||
+        (codePoint >= 0xfe00 && codePoint <= 0xfe0f) ||
+        (codePoint >= 0xfe20 && codePoint <= 0xfe2f) ||
+        (codePoint >= 0xe0100 && codePoint <= 0xe01ef) ||
+        codePoint === 0x200d);
+}
+function isFullWidth(codePoint) {
+    return (codePoint >= 0x1100 &&
+        (codePoint <= 0x115f ||
+            codePoint === 0x2329 ||
+            codePoint === 0x232a ||
+            (codePoint >= 0x2e80 && codePoint <= 0xa4cf && codePoint !== 0x303f) ||
+            (codePoint >= 0xac00 && codePoint <= 0xd7a3) ||
+            (codePoint >= 0xf900 && codePoint <= 0xfaff) ||
+            (codePoint >= 0xfe10 && codePoint <= 0xfe19) ||
+            (codePoint >= 0xfe30 && codePoint <= 0xfe6f) ||
+            (codePoint >= 0xff00 && codePoint <= 0xff60) ||
+            (codePoint >= 0xffe0 && codePoint <= 0xffe6) ||
+            (codePoint >= 0x1f300 && codePoint <= 0x1faff) ||
+            (codePoint >= 0x20000 && codePoint <= 0x3fffd)));
+}

package/dist/theme.d.ts

@@ -0,0 +1,56 @@
+export type ThemeName = "dark" | "light";
+export type Theme = {
+    name: ThemeName;
+    colors: {
+        background: string;
+        foreground: string;
+        assistantForeground: string;
+        muted: string;
+        headerForeground: string;
+        headerBackground: string;
+        statusForeground: string;
+        statusBackground: string;
+        inputForeground: string;
+        inputBackground: string;
+        inputBorder: string;
+        userMessageBackground: string;
+        inputCursorBackground: string;
+        popupForeground: string;
+        popupBackground: string;
+        popupHeaderBackground: string;
+        popupBorder: string;
+        popupMuted: string;
+        popupSelectedForeground: string;
+        popupSelectedBackground: string;
+        selectionForeground: string;
+        selectionBackground: string;
+        toastForeground: string;
+        toastBackground: string;
+        accent: string;
+        success: string;
+        warning: string;
+        info: string;
+        toolMutation: string;
+        toolSearch: string;
+        toolTitle: string;
+        thinkingXHigh: string;
+        modelOpenAI: string;
+        statusDotBase: string;
+        statusDotRunningDim: string;
+        statusDotThinkingDim: string;
+        error: string;
+    };
+};
+export declare const THEMES: Record<ThemeName, Theme>;
+export declare const ANSI_RESET = "\u001B[0m";
+export type TextStyleOptions = {
+    foreground?: string;
+    background?: string;
+    bold?: boolean;
+    underline?: boolean;
+    strikethrough?: boolean;
+};
+export declare function parseThemeName(value: string): ThemeName | undefined;
+export declare function colorize(text: string, options: TextStyleOptions): string;
+export declare function colorLine(text: string, width: number, options: TextStyleOptions): string;
+export declare function padOrTrimPlain(text: string, width: number): string;

package/dist/theme.js

@@ -0,0 +1,118 @@
+import { padOrTrimDisplay } from "./terminal-width.js";
+export const THEMES = {
+    dark: {
+        name: "dark",
+        colors: {
+            background: "#090d13",
+            foreground: "#d6deeb",
+            assistantForeground: "#c9d1d9",
+            muted: "#7d8590",
+            headerForeground: "#c9d1d9",
+            headerBackground: "#161b22",
+            statusForeground: "#8b949e",
+            statusBackground: "#090d13",
+            inputForeground: "#f0f6fc",
+            inputBackground: "#090d13",
+            inputBorder: "#30363d",
+            userMessageBackground: "#1e1e1e",
+            inputCursorBackground: "#7fb3c8",
+            popupForeground: "#e6edf3",
+            popupBackground: "#1e1e1e",
+            popupHeaderBackground: "#2a2f36",
+            popupBorder: "#1e1e1e",
+            popupMuted: "#8a8a8a",
+            popupSelectedForeground: "#090d13",
+            popupSelectedBackground: "#7fb3c8",
+            selectionForeground: "#ffffff",
+            selectionBackground: "#3b82f6",
+            toastForeground: "#0d1117",
+            toastBackground: "#a7f3d0",
+            accent: "#7aa2d6",
+            success: "#7ca982",
+            warning: "#d49a4a",
+            info: "#7fb3c8",
+            toolMutation: "#d47aa2",
+            toolSearch: "#a889d6",
+            toolTitle: "#9aa7b4",
+            thinkingXHigh: "#ff8a86",
+            modelOpenAI: "#c8b45a",
+            statusDotBase: "#30363d",
+            statusDotRunningDim: "#30363d",
+            statusDotThinkingDim: "#30363d",
+            error: "#c96a67",
+        },
+    },
+    light: {
+        name: "light",
+        colors: {
+            background: "#f8fafc",
+            foreground: "#1f2937",
+            assistantForeground: "#1f2937",
+            muted: "#64748b",
+            headerForeground: "#0f172a",
+            headerBackground: "#e2e8f0",
+            statusForeground: "#475569",
+            statusBackground: "#f8fafc",
+            inputForeground: "#0f172a",
+            inputBackground: "#f8fafc",
+            inputBorder: "#334155",
+            userMessageBackground: "#ffffff",
+            inputCursorBackground: "#0284c7",
+            popupForeground: "#0f172a",
+            popupBackground: "#ffffff",
+            popupHeaderBackground: "#f1f5f9",
+            popupBorder: "#ffffff",
+            popupMuted: "#64748b",
+            popupSelectedForeground: "#f8fafc",
+            popupSelectedBackground: "#0284c7",
+            selectionForeground: "#ffffff",
+            selectionBackground: "#2563eb",
+            toastForeground: "#064e3b",
+            toastBackground: "#bbf7d0",
+            accent: "#315f9f",
+            success: "#47794c",
+            warning: "#9a631d",
+            info: "#246b8e",
+            toolMutation: "#a33a68",
+            toolSearch: "#6d52a5",
+            toolTitle: "#526070",
+            thinkingXHigh: "#cf333d",
+            modelOpenAI: "#75671f",
+            statusDotBase: "#334155",
+            statusDotRunningDim: "#334155",
+            statusDotThinkingDim: "#334155",
+            error: "#a44949",
+        },
+    },
+};
+export const ANSI_RESET = "\x1b[0m";
+export function parseThemeName(value) {
+    return value === "dark" || value === "light" ? value : undefined;
+}
+export function colorize(text, options) {
+    const codes = [];
+    if (options.bold)
+        codes.push("1");
+    if (options.underline)
+        codes.push("4");
+    if (options.strikethrough)
+        codes.push("9");
+    if (options.foreground)
+        codes.push(rgbCode("38", options.foreground));
+    if (options.background)
+        codes.push(rgbCode("48", options.background));
+    return codes.length === 0 ? text : `\x1b[${codes.join(";")}m${text}${ANSI_RESET}`;
+}
+export function colorLine(text, width, options) {
+    return colorize(padOrTrimPlain(text, width), options);
+}
+export function padOrTrimPlain(text, width) {
+    return padOrTrimDisplay(text, width);
+}
+function rgbCode(prefix, hex) {
+    const normalized = hex.replace(/^#/, "");
+    const red = Number.parseInt(normalized.slice(0, 2), 16);
+    const green = Number.parseInt(normalized.slice(2, 4), 16);
+    const blue = Number.parseInt(normalized.slice(4, 6), 16);
+    return `${prefix};2;${red};${green};${blue}`;
+}

package/dist/tool-renderers/apply-patch.d.ts

@@ -0,0 +1,2 @@
+import type { ToolRendererMiddleware } from "./types.js";
+export declare const renderApplyPatchTool: ToolRendererMiddleware;

package/dist/tool-renderers/apply-patch.js

@@ -0,0 +1,36 @@
+import { isAbsolute, relative, sep } from "node:path";
+import { expandedTextFromParts, resultText, stringArg, summarizePatch } from "./utils.js";
+export const renderApplyPatchTool = (input) => {
+    const detailsDiff = diffFromDetails(input.details);
+    const argPatch = stringArg(input, ["input", "patch"]);
+    const patch = argPatch ?? detailsDiff?.text;
+    const path = pathForDisplay(stringArg(input, ["path", "file_path", "filePath"]), input.cwd);
+    const summary = summarizePatch(patch) ?? "patch";
+    const expanded = expandedTextFromParts({ text: patch }, { text: resultText(input, { empty: !patch }) });
+    return {
+        headerArgs: summary === "patch" && path ? path : summary,
+        bodyStyle: "diff",
+        collapsedBody: patch || input.output || summary,
+        ...expanded,
+    };
+};
+function diffFromDetails(details) {
+    if (!isDiffDetails(details))
+        return undefined;
+    if (typeof details.diff === "string" && details.diff.trim())
+        return { text: details.diff.trim() };
+    if (typeof details.patch === "string" && details.patch.trim())
+        return { text: details.patch.trim() };
+    return undefined;
+}
+function isDiffDetails(value) {
+    return typeof value === "object" && value !== null;
+}
+function pathForDisplay(filePath, cwd) {
+    if (!filePath || !cwd || !isAbsolute(filePath))
+        return filePath;
+    const relativePath = relative(cwd, filePath);
+    if (!relativePath)
+        return ".";
+    return relativePath === ".." || relativePath.startsWith(`..${sep}`) || isAbsolute(relativePath) ? filePath : relativePath.replace(/\\/gu, "/");
+}

package/dist/tool-renderers/ast.d.ts

@@ -0,0 +1,2 @@
+import type { ToolRendererMiddleware } from "./types.js";
+export declare const renderAstTool: ToolRendererMiddleware;

package/dist/tool-renderers/ast.js

@@ -0,0 +1,5 @@
+import { compactCommand, renderWithArgsAndResult, stringArg } from "./utils.js";
+export const renderAstTool = (input) => {
+    const pattern = compactCommand(stringArg(input, ["pattern", "target", "command"]));
+    return renderWithArgsAndResult(input, { headerArgs: pattern, collapsedBody: input.output });
+};

package/dist/tool-renderers/compress.d.ts

@@ -0,0 +1,2 @@
+import type { ToolRendererMiddleware } from "./types.js";
+export declare const renderCompressTool: ToolRendererMiddleware;

package/dist/tool-renderers/compress.js

@@ -0,0 +1,126 @@
+import { compactProgressBarSegments, formatCompactProgressBar } from "../context-progress-bar.js";
+import { parseArgsText, stringArg } from "./utils.js";
+export const renderCompressTool = (input) => {
+    const topic = stringArg(input, ["topic"]);
+    const summary = formatCompressSummary(input);
+    const header = joinHeaderParts(topic ? { text: topic } : undefined, summary) ?? { text: "" };
+    return {
+        ...(header.text ? { headerArgs: header.text } : {}),
+        ...((header.segments?.length ?? 0) > 0 ? { headerArgsSegments: header.segments } : {}),
+        collapsedBody: "",
+        expandedText: fullCompressResponse(input.output, input.status),
+    };
+};
+function formatCompressSummary(input) {
+    const { output, isError, status } = input;
+    if (!output)
+        return { text: status === "running" ? "running…" : "(empty)" };
+    if (isError)
+        return { text: `error: ${oneLine(output)}` };
+    const parsed = parseArgsText(output);
+    if (!isRecord(parsed))
+        return { text: oneLine(output) };
+    return formatCompressSuccess(parsed, input);
+}
+function fullCompressResponse(output, status) {
+    if (output.trim())
+        return output.trimEnd();
+    return status === "running" ? "running…" : "(empty)";
+}
+function formatCompressSuccess(result, input) {
+    const tokensSaved = numberValue(result.tokensSaved);
+    const contextPercent = numberValue(result.contextPercent);
+    const contextTokens = numberValue(result.contextTokens);
+    const contextWindow = numberValue(result.contextWindow);
+    const activeBlocks = numberValue(result.activeBlocks);
+    const totalBlocks = numberValue(result.totalBlocks);
+    const prunedTools = numberValue(result.prunedTools);
+    const itemCount = numberValue(result.itemCount) ?? sumDefined(numberValue(result.ranges), numberValue(result.messages));
+    const summaryTokens = numberValue(result.totalSummaryTokens);
+    const compressedContextTokens = contextTokens ?? inferContextTokens(contextPercent, contextWindow);
+    const originalContextTokens = compressedContextTokens != null && tokensSaved != null ? compressedContextTokens + tokensSaved : undefined;
+    const compressedContextPercent = percentOfOriginalContext(compressedContextTokens, originalContextTokens);
+    const barPercent = compressedContextPercent ?? contextPercent;
+    const parts = [
+        { text: tokensSaved != null ? `saved ${formatCompactNumber(tokensSaved)}` : "compressed" },
+        barPercent != null ? progressPart(barPercent, input, originalContextTokens) : undefined,
+        compressedContextPercent != null && contextPercent != null ? { text: `context ${formatPercent(contextPercent)}` } : undefined,
+        itemCount != null ? { text: `${itemCount} ${plural(itemCount, "item")}` } : undefined,
+        summaryTokens != null ? { text: `${formatCompactNumber(summaryTokens)} summary tokens` } : undefined,
+        activeBlocks != null && totalBlocks != null ? { text: `blocks ${activeBlocks}/${totalBlocks}` } : undefined,
+        prunedTools != null ? { text: `pruned ${prunedTools} tools` } : undefined,
+        barPercent == null && contextTokens != null ? { text: `context ${formatCompactNumber(contextTokens)}` } : undefined,
+    ].filter((part) => Boolean(part));
+    return joinHeaderParts(...parts) ?? { text: "compressed" };
+}
+function progressPart(percent, input, previousContextTokens) {
+    const text = `${formatCompactProgressBar(percent)} ${formatPercent(percent)}${previousContextTokens != null ? ` of ${formatCompactNumber(previousContextTokens)}` : ""}`;
+    if (!input.colors)
+        return { text };
+    return {
+        text,
+        segments: compactProgressBarSegments(0, percent, {
+            fill: input.toolColor ?? input.colors.muted,
+            track: input.colors.statusDotBase,
+        }),
+    };
+}
+function inferContextTokens(contextPercent, contextWindow) {
+    if (contextPercent == null || contextWindow == null || contextWindow <= 0)
+        return undefined;
+    return (contextPercent / 100) * contextWindow;
+}
+function percentOfOriginalContext(compressedContextTokens, originalContextTokens) {
+    if (compressedContextTokens == null || originalContextTokens == null || originalContextTokens <= 0)
+        return undefined;
+    return (compressedContextTokens / originalContextTokens) * 100;
+}
+function joinHeaderParts(...parts) {
+    const defined = parts.filter((part) => part !== undefined && Boolean(part.text));
+    if (defined.length === 0)
+        return undefined;
+    const separator = " · ";
+    const segments = [];
+    let offset = 0;
+    for (const [index, part] of defined.entries()) {
+        if (index > 0)
+            offset += separator.length;
+        if (part.segments) {
+            for (const segment of part.segments) {
+                segments.push({ ...segment, start: offset + segment.start, end: offset + segment.end });
+            }
+        }
+        offset += part.text.length;
+    }
+    return { text: defined.map((part) => part.text).join(separator), segments };
+}
+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 String(value);
+}
+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 oneLine(text) {
+    return text.replace(/\s+/g, " ").trim();
+}
+function isRecord(value) {
+    return typeof value === "object" && value !== null && !Array.isArray(value);
+}

package/dist/tool-renderers/index.d.ts

@@ -0,0 +1,3 @@
+import type { ToolRenderInput, ToolRenderResult } from "./types.js";
+export declare function renderToolDisplay(input: ToolRenderInput): ToolRenderResult;
+export type { ToolRenderInput, ToolRenderResult } from "./types.js";

package/dist/tool-renderers/index.js

@@ -0,0 +1,44 @@
+import { renderApplyPatchTool } from "./apply-patch.js";
+import { renderAstTool } from "./ast.js";
+import { renderCompressTool } from "./compress.js";
+import { renderQuestionTool } from "./question.js";
+import { renderReadTool } from "./read.js";
+import { renderRepoTool } from "./repo.js";
+import { renderShellTool } from "./shell.js";
+import { applySkillReadDisplay } from "./skill.js";
+import { renderSubagentsTool } from "./subagents.js";
+import { renderTodoTool } from "./todo.js";
+import { defaultToolRender, normalizeToolName } from "./utils.js";
+import { renderWebFetchTool, renderWebSearchTool } from "./web.js";
+import { renderWriteTool } from "./write.js";
+const TOOL_RENDERERS = {
+    bash: renderShellTool,
+    Bash: renderShellTool,
+    shell: renderShellTool,
+    shell_command: renderShellTool,
+    read: renderReadTool,
+    Read: renderReadTool,
+    apply_patch: renderApplyPatchTool,
+    edit: renderApplyPatchTool,
+    Edit: renderApplyPatchTool,
+    write: renderWriteTool,
+    Write: renderWriteTool,
+    ast_grep: renderAstTool,
+    ast_apply: renderAstTool,
+    web_search: renderWebSearchTool,
+    web_fetch: renderWebFetchTool,
+    todo: renderTodoTool,
+    question: renderQuestionTool,
+    subagents: renderSubagentsTool,
+    compress: renderCompressTool,
+};
+const PREFIX_RENDERERS = [
+    ["repo_", renderRepoTool],
+    ["ast_", renderAstTool],
+];
+export function renderToolDisplay(input) {
+    const normalizedName = normalizeToolName(input.toolName);
+    const exact = TOOL_RENDERERS[input.toolName] ?? TOOL_RENDERERS[normalizedName];
+    const rendered = exact?.(input) ?? PREFIX_RENDERERS.find(([prefix]) => normalizedName.startsWith(prefix))?.[1](input);
+    return applySkillReadDisplay(input, rendered ?? defaultToolRender(input));
+}

package/dist/tool-renderers/question.d.ts

@@ -0,0 +1,2 @@
+import type { ToolRendererMiddleware } from "./types.js";
+export declare const renderQuestionTool: ToolRendererMiddleware;