chocolatito-code 1.0.0

package/dist/ui/prompt.js

@@ -0,0 +1,466 @@
+import readline from "node:readline";
+import process from "node:process";
+import fs from "node:fs";
+import path from "node:path";
+import os from "node:os";
+import chalk from "chalk";
+import { cycleMode, describeMode, getMode } from "./modes.js";
+import { releaseKeyboard } from "./interrupt.js";
+import { clearTyped } from "./typeAhead.js";
+export const SLASH_COMMANDS = [
+    { name: "/mcp", description: "Ver servidores MCP conectados y sus herramientas" },
+    { name: "/undo", description: "Deshacer las últimas modificaciones de archivos de la sesión" },
+    { name: "/export", description: "Exportar bitácora de la sesión a archivo Markdown", args: "[nombre.md]" },
+    { name: "/plan", description: "Alternar Modo Plan (solo lectura e investigación previa)" },
+    { name: "/resume", description: "Reanudar una sesión anterior guardada", args: "[id]" },
+    { name: "/skills", description: "Ver skills disponibles y cómo usarlos" },
+    { name: "/memory", description: "Consultar la memoria persistente transversal (~/.chocolatito/memory/)" },
+    { name: "/effort", description: "Regular potencia del motor (1.0, 1.5, 2.0, 2.5)", args: "[nivel]" },
+    { name: "/goal", description: "Ejecutar meta compleja autónoma con auto-corrección", args: "<meta>" },
+    { name: "/compact", description: "Comprimir contexto y optimizar memoria de la sesión" },
+    { name: "/diff", description: "Ver diferencias de código (Git diff) del proyecto" },
+    { name: "/commit", description: "Crear un commit en Git con mensaje semántico", args: "<mensaje>" },
+    { name: "/cd", description: "Cambiar el directorio de trabajo activo", args: "<ruta>" },
+    { name: "/cost", description: "Ver consumo detallado de tokens e inversión en USD" },
+    { name: "/clear", description: "Limpiar historial y reiniciar contexto" },
+    { name: "/init", description: "Crear archivo de directivas CHOCOLATITO.md" },
+    { name: "/help", description: "Mostrar guía completa de comandos y ayuda" },
+    { name: "/exit", description: "Cerrar sesión de Chocolatito Code" },
+];
+let isKeypressInitialized = false;
+function stripAnsi(str) {
+    return str.replace(/\x1b\[[0-9;]*m/g, "");
+}
+function getHistoryFilePath() {
+    const dir = path.join(os.homedir(), ".chocolatito");
+    if (!fs.existsSync(dir))
+        fs.mkdirSync(dir, { recursive: true });
+    return path.join(dir, "history");
+}
+function loadHistory() {
+    const file = getHistoryFilePath();
+    if (fs.existsSync(file)) {
+        try {
+            return fs.readFileSync(file, "utf-8").split("\n").filter((l) => l.trim().length > 0);
+        }
+        catch { }
+    }
+    return [];
+}
+function appendHistory(prompt) {
+    if (!prompt.trim())
+        return;
+    const file = getHistoryFilePath();
+    try {
+        fs.appendFileSync(file, `${prompt.trim()}\n`, "utf-8");
+    }
+    catch { }
+}
+function scanProjectFiles(dir, maxResults = 40) {
+    const results = [];
+    const ignore = new Set(["node_modules", ".git", "dist", "build", ".next", "out", "venv", "__pycache__", ".turbo"]);
+    function walk(current, depth = 0) {
+        if (depth > 6 || results.length >= maxResults)
+            return;
+        try {
+            const entries = fs.readdirSync(current, { withFileTypes: true });
+            for (const ent of entries) {
+                if (ent.name.startsWith(".") && ent.name !== ".env")
+                    continue;
+                if (ignore.has(ent.name))
+                    continue;
+                const full = path.join(current, ent.name);
+                const rel = path.relative(dir, full).replace(/\\/g, "/");
+                if (ent.isDirectory()) {
+                    walk(full, depth + 1);
+                }
+                else if (ent.isFile()) {
+                    results.push(rel);
+                    if (results.length >= maxResults)
+                        break;
+                }
+            }
+        }
+        catch { }
+    }
+    walk(dir);
+    return results;
+}
+export async function askInteractivePrompt(promptSymbol = "❯", cwd = process.cwd()) {
+    return new Promise((resolve) => {
+        let inputBuffer = "";
+        let cursorIndex = 0;
+        let selectedIndex = 0;
+        let isFinished = false;
+        let lastRenderedLines = [];
+        let lastCursorLineIndex = 1;
+        const history = loadHistory();
+        let historyIdx = history.length;
+        // Cache project files for @ autocompletion
+        let projectFiles = [];
+        try {
+            projectFiles = scanProjectFiles(cwd);
+        }
+        catch { }
+        if (!isKeypressInitialized) {
+            readline.emitKeypressEvents(process.stdin);
+            isKeypressInitialized = true;
+        }
+        // El prompt reclama el teclado antes de dibujarse. Si un vigilante de la
+        // generacion anterior se quedo escuchando (el bucle tiene muchas salidas y
+        // basta que una se escape), el usuario teclearia y no aparecerian sus letras
+        // aqui: se las estaria comiendo el vigilante. Reclamarlo cuesta nada y
+        // convierte veinte sitios que hay que acertar en uno.
+        releaseKeyboard();
+        // Lo que quedara a medio escribir del turno anterior no es de este prompt.
+        clearTyped();
+        const wasRaw = process.stdin.isRaw;
+        if (process.stdin.setRawMode) {
+            process.stdin.setRawMode(true);
+        }
+        process.stdin.resume();
+        function getAtMention() {
+            const textBeforeCursor = inputBuffer.slice(0, cursorIndex);
+            const match = textBeforeCursor.match(/@([^\s]*)$/);
+            if (match && match.index !== undefined) {
+                return {
+                    active: true,
+                    query: match[1].toLowerCase(),
+                    startIndex: match.index,
+                };
+            }
+            return { active: false, query: "", startIndex: -1 };
+        }
+        function getDropdownItems() {
+            // 1. Slash commands
+            if (inputBuffer.startsWith("/")) {
+                const query = inputBuffer.toLowerCase();
+                return SLASH_COMMANDS
+                    .filter((cmd) => cmd.name.toLowerCase().startsWith(query) || query === "/")
+                    .map((cmd) => ({
+                    type: "command",
+                    label: `${cmd.name}${cmd.args ? " " + cmd.args : ""}`,
+                    secondary: cmd.description,
+                    insertText: cmd.name,
+                }));
+            }
+            // 2. @ File mentions
+            const at = getAtMention();
+            if (at.active) {
+                return projectFiles
+                    .filter((f) => f.toLowerCase().includes(at.query))
+                    .slice(0, 8)
+                    .map((f) => ({
+                    type: "file",
+                    label: `@${f}`,
+                    secondary: "Archivo del proyecto",
+                    insertText: `@${f} `,
+                }));
+            }
+            return [];
+        }
+        function render() {
+            if (isFinished)
+                return;
+            const cols = Math.max(20, process.stdout.columns || 80);
+            // 1. Top separator line
+            const topBar = chalk.gray("─".repeat(cols));
+            // 2. Prompt symbol & input text
+            const symbolStr = promptSymbol.includes("plan")
+                ? `${chalk.cyan.bold("plan ❯")} `
+                : `${chalk.bold.hex("#D97757")("❯")} `;
+            const rawSymbolLen = promptSymbol.includes("plan") ? 7 : 2;
+            const placeholderText = "Escribe una instrucción, '@' para archivos o '/' para comandos...";
+            let formattedInput = "";
+            if (inputBuffer.length === 0) {
+                formattedInput = chalk.gray(placeholderText);
+            }
+            else if (inputBuffer.startsWith("/")) {
+                const parts = inputBuffer.split(" ");
+                const cmdPart = chalk.bold.hex("#A855F7")(parts[0]);
+                const restPart = parts.slice(1).join(" ");
+                formattedInput = restPart ? `${cmdPart} ${chalk.white(restPart)}` : cmdPart;
+            }
+            else {
+                formattedInput = inputBuffer.replace(/(@[^\s]+)/g, (m) => chalk.bold.hex("#D97757")(m));
+            }
+            // 3. Dropdown items (if any)
+            const items = getDropdownItems();
+            const dropdownLines = [];
+            if (items.length > 0) {
+                if (selectedIndex >= items.length)
+                    selectedIndex = 0;
+                if (selectedIndex < 0)
+                    selectedIndex = items.length - 1;
+                items.forEach((item, idx) => {
+                    const isSelected = idx === selectedIndex;
+                    const isFile = item.type === "file";
+                    const colorHex = isFile ? "#D97757" : "#A855F7";
+                    const pointer = isSelected
+                        ? chalk.bold.hex(colorHex)(" ❯ ")
+                        : chalk.gray("   ");
+                    const label = isSelected
+                        ? chalk.bold.white(item.label)
+                        : chalk.hex(colorHex)(item.label);
+                    const desc = isSelected
+                        ? chalk.whiteBright(`  ${item.secondary || ""}`)
+                        : chalk.gray(`  ${item.secondary || ""}`);
+                    dropdownLines.push(`${pointer}${label}${desc}`);
+                });
+            }
+            // 4. Bottom separator line
+            const bottomBar = chalk.gray("─".repeat(cols));
+            // 5. Footer status line
+            const modeLook = describeMode(getMode());
+            const leftFooter = chalk.gray("? /help para atajos · shift+tab modo · esc cancelar");
+            const rightFooter = `${chalk.hex(modeLook.color)(`⇥ modo ${modeLook.label}`)} ${chalk.gray("· Espectro 1.0 (Ágil)")}`;
+            const leftLen = stripAnsi(leftFooter).length;
+            const rightLen = stripAnsi(rightFooter).length;
+            const padLen = Math.max(1, cols - leftLen - rightLen);
+            const footerLine = `${leftFooter}${" ".repeat(padLen)}${rightFooter}`;
+            // Build current frame array
+            const currentFrame = [topBar, symbolStr + formattedInput];
+            if (dropdownLines.length > 0) {
+                currentFrame.push(...dropdownLines);
+            }
+            currentFrame.push(bottomBar, footerLine);
+            const inputLineIdx = 1;
+            const totalCharsCursor = rawSymbolLen + (inputBuffer.length === 0 ? 0 : cursorIndex);
+            const cursorCol = totalCharsCursor % cols;
+            if (lastRenderedLines.length === 0) {
+                // First render: write frame and position cursor on input line
+                process.stdout.write(currentFrame.join("\n"));
+                const moveUp = currentFrame.length - 1 - inputLineIdx;
+                process.stdout.write(`\x1b[${moveUp}A\r\x1b[${cursorCol}C`);
+            }
+            else {
+                // Subsequent render: re-draw lines in place with 0 scrolling drift
+                if (lastCursorLineIndex > 0) {
+                    process.stdout.write(`\x1b[${lastCursorLineIndex}A\r`);
+                }
+                else {
+                    process.stdout.write("\r");
+                }
+                const maxLines = Math.max(currentFrame.length, lastRenderedLines.length);
+                for (let i = 0; i < maxLines; i++) {
+                    const content = i < currentFrame.length ? currentFrame[i] : "";
+                    process.stdout.write(`\x1b[2K${content}`);
+                    if (i < maxLines - 1) {
+                        process.stdout.write("\x1b[1E");
+                    }
+                }
+                const moveUp = (maxLines - 1) - inputLineIdx;
+                if (moveUp > 0) {
+                    process.stdout.write(`\x1b[${moveUp}A\r\x1b[${cursorCol}C`);
+                }
+                else {
+                    process.stdout.write(`\r\x1b[${cursorCol}C`);
+                }
+            }
+            lastRenderedLines = currentFrame;
+            lastCursorLineIndex = inputLineIdx;
+        }
+        function cleanup() {
+            isFinished = true;
+            process.stdin.removeListener("keypress", onKeypress);
+            if (process.stdin.setRawMode) {
+                process.stdin.setRawMode(wasRaw || false);
+            }
+        }
+        function applySelectedDropdownItem() {
+            const items = getDropdownItems();
+            if (items.length === 0)
+                return false;
+            const item = items[selectedIndex];
+            if (item.type === "command") {
+                inputBuffer = item.insertText;
+                cursorIndex = inputBuffer.length;
+                return true;
+            }
+            else if (item.type === "file") {
+                const at = getAtMention();
+                if (at.active) {
+                    inputBuffer = inputBuffer.slice(0, at.startIndex) + item.insertText + inputBuffer.slice(cursorIndex);
+                    cursorIndex = at.startIndex + item.insertText.length;
+                    return true;
+                }
+            }
+            return false;
+        }
+        function finalizePromptOnSubmit(submittedText) {
+            const cols = Math.max(20, process.stdout.columns || 80);
+            const symbolStr = promptSymbol.includes("plan")
+                ? `${chalk.cyan.bold("plan ❯")} `
+                : `${chalk.bold.hex("#D97757")("❯")} `;
+            // Move cursor to top of frame
+            if (lastCursorLineIndex > 0) {
+                process.stdout.write(`\x1b[${lastCursorLineIndex}A\r`);
+            }
+            else {
+                process.stdout.write("\r");
+            }
+            // Draw clean submitted prompt box in terminal history
+            process.stdout.write(`\x1b[2K${chalk.gray("─".repeat(cols))}\x1b[1E`);
+            process.stdout.write(`\x1b[2K${symbolStr}${chalk.bold.white(submittedText)}\x1b[1E`);
+            process.stdout.write(`\x1b[2K${chalk.gray("─".repeat(cols))}\x1b[1E`);
+            // Clear any leftover rows (dropdown, old footer)
+            const extraLines = Math.max(0, lastRenderedLines.length - 3);
+            for (let i = 0; i < extraLines; i++) {
+                process.stdout.write(`\x1b[2K`);
+                if (i < extraLines - 1)
+                    process.stdout.write("\x1b[1E");
+            }
+            // Move cursor directly below the bottom bar
+            if (extraLines > 0) {
+                process.stdout.write(`\x1b[${extraLines}A\r\x1b[1E\n`);
+            }
+            else {
+                process.stdout.write("\n");
+            }
+        }
+        function onKeypress(str, key) {
+            if (isFinished)
+                return;
+            const items = getDropdownItems();
+            // Enter key
+            if (key && (key.name === "return" || key.name === "enter")) {
+                // Multi-line continuation if ends with \
+                if (inputBuffer.endsWith("\\")) {
+                    inputBuffer = inputBuffer.slice(0, -1) + "\n";
+                    cursorIndex = inputBuffer.length;
+                    render();
+                    return;
+                }
+                if (items.length > 0 && (inputBuffer === "/" || getAtMention().active)) {
+                    if (applySelectedDropdownItem()) {
+                        render();
+                        return;
+                    }
+                }
+                appendHistory(inputBuffer);
+                cleanup();
+                finalizePromptOnSubmit(inputBuffer);
+                resolve(inputBuffer);
+                return;
+            }
+            // Shift+Tab: cambia el modo de permisos instantáneamente
+            const isShiftTab = Boolean(key && key.name === "tab" && key.shift) ||
+                str === "\x1b[Z" ||
+                Boolean(key && key.sequence === "\x1b[Z");
+            if (isShiftTab) {
+                cycleMode();
+                render();
+                return;
+            }
+            // Tab autocompletion
+            if (key && key.name === "tab") {
+                if (items.length > 0) {
+                    if (applySelectedDropdownItem()) {
+                        render();
+                        return;
+                    }
+                }
+            }
+            // Up arrow
+            if (key && key.name === "up") {
+                if (items.length > 0) {
+                    selectedIndex = (selectedIndex - 1 + items.length) % items.length;
+                    render();
+                    return;
+                }
+                else if (history.length > 0 && historyIdx > 0) {
+                    historyIdx--;
+                    inputBuffer = history[historyIdx] || "";
+                    cursorIndex = inputBuffer.length;
+                    render();
+                    return;
+                }
+            }
+            // Down arrow
+            if (key && key.name === "down") {
+                if (items.length > 0) {
+                    selectedIndex = (selectedIndex + 1) % items.length;
+                    render();
+                    return;
+                }
+                else if (historyIdx < history.length - 1) {
+                    historyIdx++;
+                    inputBuffer = history[historyIdx] || "";
+                    cursorIndex = inputBuffer.length;
+                    render();
+                    return;
+                }
+                else if (historyIdx === history.length - 1) {
+                    historyIdx = history.length;
+                    inputBuffer = "";
+                    cursorIndex = 0;
+                    render();
+                    return;
+                }
+            }
+            // Left arrow
+            if (key && key.name === "left") {
+                if (cursorIndex > 0) {
+                    cursorIndex--;
+                    render();
+                }
+                return;
+            }
+            // Right arrow
+            if (key && key.name === "right") {
+                if (cursorIndex < inputBuffer.length) {
+                    cursorIndex++;
+                    render();
+                }
+                return;
+            }
+            // Backspace
+            if (key && (key.name === "backspace" || (key.ctrl && key.name === "h"))) {
+                if (cursorIndex > 0) {
+                    inputBuffer = inputBuffer.slice(0, cursorIndex - 1) + inputBuffer.slice(cursorIndex);
+                    cursorIndex--;
+                    selectedIndex = 0;
+                    render();
+                }
+                return;
+            }
+            // Ctrl + C / Esc to exit
+            if ((key && key.ctrl && key.name === "c") || (key && key.name === "escape" && inputBuffer.length === 0)) {
+                cleanup();
+                finalizePromptOnSubmit(inputBuffer);
+                process.exit(0);
+            }
+            // Esc when text is written: clear line
+            if (key && key.name === "escape" && inputBuffer.length > 0) {
+                inputBuffer = "";
+                cursorIndex = 0;
+                selectedIndex = 0;
+                render();
+                return;
+            }
+            // Ctrl + L (clear screen)
+            if (key && key.ctrl && key.name === "l") {
+                console.clear();
+                lastRenderedLines = [];
+                lastCursorLineIndex = 1;
+                render();
+                return;
+            }
+            // Printable characters or pasted text
+            if (str &&
+                !isShiftTab &&
+                str !== "\x1b[Z" &&
+                (!key || (!key.ctrl && !key.meta) || (key.ctrl && key.meta) || (!key.name && str.length > 0))) {
+                const cleanStr = str.replace(/[\r\n]/g, "");
+                if (cleanStr.length > 0) {
+                    inputBuffer = inputBuffer.slice(0, cursorIndex) + cleanStr + inputBuffer.slice(cursorIndex);
+                    cursorIndex += cleanStr.length;
+                    selectedIndex = 0;
+                    render();
+                }
+            }
+        }
+        process.stdin.on("keypress", onKeypress);
+        render();
+    });
+}

package/dist/ui/reasoningStream.d.ts

@@ -0,0 +1,6 @@
+export declare class ReasoningStream {
+    private hasStarted;
+    private atLineStart;
+    push(chunk: string): void;
+    flush(): void;
+}

package/dist/ui/reasoningStream.js

@@ -0,0 +1,38 @@
+import chalk from "chalk";
+import process from "node:process";
+export class ReasoningStream {
+    hasStarted = false;
+    atLineStart = true;
+    push(chunk) {
+        if (!chunk)
+            return;
+        if (!this.hasStarted) {
+            this.hasStarted = true;
+            process.stdout.write(`\n  ${chalk.bold.hex("#8B5CF6")("💭 Razonando:")}\n`);
+        }
+        for (let i = 0; i < chunk.length; i++) {
+            const char = chunk[i];
+            if (this.atLineStart) {
+                process.stdout.write(`  ${chalk.hex("#8B5CF6")("│")} `);
+                this.atLineStart = false;
+            }
+            if (char === "\n") {
+                process.stdout.write("\n");
+                this.atLineStart = true;
+            }
+            else {
+                process.stdout.write(chalk.gray(char));
+            }
+        }
+    }
+    flush() {
+        if (this.hasStarted) {
+            if (!this.atLineStart) {
+                process.stdout.write("\n");
+                this.atLineStart = true;
+            }
+            process.stdout.write("\n");
+            this.hasStarted = false;
+        }
+    }
+}

package/dist/ui/renderer.d.ts

@@ -0,0 +1,10 @@
+export declare function renderUserPrompt(text: string): void;
+export declare function renderToolStart(name: string, summary: string): void;
+export declare function renderToolSuccess(name: string, resultSummary: string): void;
+export declare function renderToolError(name: string, errorSummary: string): void;
+export declare function renderDiff(filePath: string, diffText: string): void;
+export declare function renderReasoning(reasoningText: string): void;
+export declare function renderAssistantResponse(markdownText: string): void;
+export declare function renderFooter(costStr: string, outTokens: number, cachedTokens: number, modelName: string, durationMs?: number, contextPercent?: number, quotaStr?: string): void;
+export declare function renderError(message: string): void;
+export declare function formatToolName(name: string): string;

package/dist/ui/renderer.js

@@ -0,0 +1,142 @@
+import chalk from "chalk";
+import { Marked } from "marked";
+import { markedTerminal } from "marked-terminal";
+const marked = new Marked(markedTerminal({
+    heading: chalk.bold.hex("#D97757"),
+    firstHeading: chalk.bold.hex("#D97757").underline,
+    secondHeading: chalk.bold.hex("#FFA500"),
+    thirdHeading: chalk.bold.white,
+    code: chalk.cyan,
+    codespan: (text) => chalk.bgHex("#27272A").hex("#F4F4F5")(` ${text} `),
+    strong: chalk.bold.white,
+    em: chalk.italic.hex("#D97757"),
+    hr: () => chalk.gray("\n  ──────────────────────────────────────────────────────────\n"),
+    unescape: true,
+    tableOptions: {
+        style: {
+            head: ["cyan", "bold"],
+            border: ["gray"],
+        },
+    },
+}));
+export function renderUserPrompt(text) {
+    const symbol = chalk.bold.hex("#D97757")("❯");
+    const shaded = chalk.bgHex("#242730").hex("#F4F4F5").bold(`  ${text.trim()}  `);
+    console.log(`\n${symbol} ${shaded}\n`);
+}
+// Tool call rendering as specified in §B5
+export function renderToolStart(name, summary) {
+    const bullet = chalk.hex("#FFA500")("●"); // Amber while starting
+    const toolName = chalk.bold.white(formatToolName(name));
+    const argPart = summary ? chalk.gray(`(${summary.length > 60 ? summary.slice(0, 57) + '...' : summary})`) : "";
+    console.log(`\n${bullet} ${toolName}${argPart}`);
+}
+export function renderToolSuccess(name, resultSummary) {
+    const rawLines = resultSummary.trim().split("\n");
+    const maxVisibleLines = 5;
+    const visibleLines = rawLines.slice(0, maxVisibleLines);
+    const remainingCount = rawLines.length - maxVisibleLines;
+    const indented = visibleLines.map((line, idx) => {
+        const prefix = idx === 0 ? `  ${chalk.gray("⎿")}  ` : "     ";
+        return `${prefix}${colorizeText(line)}`;
+    }).join("\n");
+    console.log(indented);
+    if (remainingCount > 0) {
+        console.log(chalk.gray(`     … +${remainingCount} líneas más`));
+    }
+}
+export function renderToolError(name, errorSummary) {
+    console.log(`  ${chalk.red("⎿")}  ${chalk.red(errorSummary)}`);
+}
+export function renderDiff(filePath, diffText) {
+    console.log(`\n${diffText}\n`);
+}
+export function renderReasoning(reasoningText) {
+    if (!reasoningText.trim())
+        return;
+    const lines = reasoningText.trim().split("\n");
+    const formatted = lines.map((l) => `  ${chalk.hex("#8B5CF6")("│")} ${chalk.gray(l)}`).join("\n");
+    console.log(`\n  ${chalk.bold.hex("#8B5CF6")("💭 Razonamiento:")}\n${formatted}\n`);
+}
+export function renderAssistantResponse(markdownText) {
+    try {
+        // Aggressively clean triple asterisks, triple underscores, and excessive separators
+        let cleaned = markdownText
+            .replace(/\r\n/g, "\n")
+            .replace(/^\s*(\*\*\*|---|___|\*\s+\*\s+\*)\s*$/gm, "\n---\n")
+            .replace(/\n{3,}/g, "\n\n");
+        let parsed = String(marked.parse(cleaned));
+        // Convert raw asterisks bullets to terracotta bullets
+        parsed = parsed.replace(/^(\s*)\*\s+/gm, `$1${chalk.hex("#D97757")("•")} `);
+        console.log(`\n${parsed}`);
+    }
+    catch {
+        console.log(`\n${markdownText.trim()}\n`);
+    }
+}
+export function renderFooter(costStr, outTokens, cachedTokens, modelName, durationMs, contextPercent, quotaStr) {
+    const durationPart = durationMs ? `${(durationMs / 1000).toFixed(1)}s · ` : "";
+    const outPart = `${outTokens.toLocaleString()} tokens salida`;
+    const cachePart = cachedTokens > 0 ? ` (${(cachedTokens / 1000).toFixed(1)}k en caché)` : "";
+    const contextPart = contextPercent !== undefined ? ` · ${contextPercent}% contexto libre` : "";
+    const quotaPart = quotaStr ? ` · ${quotaStr}` : "";
+    const line = chalk.gray(`  ${chalk.hex("#D97757")("⚡")} ${durationPart}${outPart}${cachePart} · ${chalk.green(costStr)} · ${modelName}${contextPart}${quotaPart}`);
+    console.log(`${line}\n`);
+}
+export function renderError(message) {
+    console.log(`\n  ${chalk.bgRed.white.bold(" ERROR ")} ${chalk.red(message)}\n`);
+}
+function colorizeText(text) {
+    // Highlight file paths (C:\..., /path/...) in cyan
+    return text
+        .replace(/([a-zA-Z]:\\[^\s"']+)/g, (m) => chalk.cyan(m))
+        .replace(/(\b\w+\.(?:ts|js|json|png|py|md|html|css|tsx|jsx)\b)/g, (m) => chalk.bold.white(m));
+}
+export function formatToolName(name) {
+    switch (name) {
+        case "todo_write":
+            return "Task";
+        case "use_skill":
+            return "Skill";
+        case "save_memory":
+            return "MemorySave";
+        case "read_memory":
+            return "MemoryRead";
+        case "spawn_agent":
+            return "SubAgent";
+        case "browser_live":
+            return "BrowserLive";
+        case "computer_use":
+            return "ComputerUse";
+        case "change_dir":
+            return "Cd";
+        case "create_image":
+            return "CreateImage";
+        case "web_search":
+            return "SearchWeb";
+        case "find_files":
+            return "Glob";
+        case "view_file":
+            return "Read";
+        case "edit_file":
+            return "Edit";
+        case "write_file":
+            return "Write";
+        case "delete_file":
+            return "Delete";
+        case "move_copy_file":
+            return "Move";
+        case "run_command":
+            return "Bash";
+        case "list_dir":
+            return "ListDir";
+        case "grep_search":
+            return "Grep";
+        case "web_fetch":
+            return "WebFetch";
+        case "get_system_info":
+            return "SystemInfo";
+        default:
+            return name;
+    }
+}