chocolatito-code 1.0.0

package/dist/tools/writeFile.d.ts

@@ -0,0 +1 @@
+export declare function writeFile(filePath: string, content: string, cwd?: string): Promise<string>;

package/dist/tools/writeFile.js

@@ -0,0 +1,13 @@
+import fs from "node:fs";
+import path from "node:path";
+export async function writeFile(filePath, content, cwd = process.cwd()) {
+    const resolved = path.isAbsolute(filePath) ? filePath : path.resolve(cwd, filePath);
+    const dir = path.dirname(resolved);
+    if (!fs.existsSync(dir)) {
+        fs.mkdirSync(dir, { recursive: true });
+    }
+    const isNew = !fs.existsSync(resolved);
+    fs.writeFileSync(resolved, content, "utf-8");
+    const action = isNew ? "creado" : "sobreescrito";
+    return `✔ Archivo "${filePath}" ${action} exitosamente (${content.length} caracteres).`;
+}

package/dist/ui/banner.d.ts

@@ -0,0 +1,10 @@
+import { EspectroModel } from "../config/constants.js";
+export type MascotState = "idle" | "blink" | "happy" | "thinking";
+export declare const SILKSCREEN_TITLE_ROWS: string[];
+export declare function colorizeSilkscreenLine(line: string): string;
+export declare function renderMascotLines(isBlinking?: boolean): string[];
+export declare function buildBannerContent(cwd: string, model: EspectroModel, isBlinking?: boolean): string;
+export declare function showBanner(cwd: string, model: EspectroModel, state?: MascotState): void;
+export declare function animateStartupBanner(cwd: string, model: EspectroModel): Promise<void>;
+export declare function showEffortMenu(currentId: string): void;
+export declare function showHelp(): void;

package/dist/ui/banner.js

@@ -0,0 +1,165 @@
+import chalk from "chalk";
+import { ESPECTRO_MODELS } from "../config/constants.js";
+import { CONTEXT_WINDOW } from "../config/constants.js";
+// Base grid for mascota-pixeleada: 16 cols x 16 rows
+const BASE_GRID_16X16 = [
+    [0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, 0, 0, 0],
+    [1, 3, 1, 0, 0, 0, 0, 0, 0, 0, 1, 3, 1, 0, 0, 0],
+    [1, 3, 1, 1, 1, 1, 1, 1, 1, 1, 1, 3, 1, 0, 0, 0],
+    [1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 0, 0, 0],
+    [1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 0, 0, 0],
+    [1, 1, 4, 4, 1, 1, 1, 1, 4, 4, 1, 1, 1, 0, 0, 0], // Row 5: Eyes Upper
+    [1, 1, 4, 4, 1, 1, 1, 1, 4, 4, 1, 1, 1, 0, 0, 0], // Row 6: Eyes Lower
+    [1, 3, 3, 1, 1, 4, 4, 1, 1, 3, 3, 1, 1, 0, 0, 0], // Row 7: Cheeks + Nose
+    [0, 1, 3, 3, 3, 3, 3, 3, 3, 3, 1, 0, 1, 1, 0, 0], // Row 8: Muzzle
+    [0, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 0, 1, 5, 5, 0], // Row 9: Body + Tail
+    [0, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 0, 0, 1, 5, 0], // Row 10: Body + Tail
+    [0, 1, 1, 0, 1, 1, 0, 1, 1, 0, 1, 1, 0, 0, 0, 0], // Row 11: 4 Legs
+    [0, 1, 1, 0, 1, 1, 0, 1, 1, 0, 1, 1, 0, 0, 0, 0], // Row 12
+    [0, 1, 1, 0, 1, 1, 0, 1, 1, 0, 1, 1, 0, 0, 0, 0], // Row 13
+    [0, 2, 2, 0, 2, 2, 0, 2, 2, 0, 2, 2, 0, 0, 0, 0], // Row 14: Feet
+    [0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0],
+];
+const COLOR_MAP = {
+    0: null,
+    1: "#D97757", // Terracotta
+    2: "#C06345", // Darker feet
+    3: "#F5C7B2", // Peach / inner ear
+    4: "#1C1917", // Black eyes / nose
+    5: "#FAF5F0", // White tail
+    6: "#A855F7", // Purple sparkle
+};
+// Exact Mascot Holographic Palette from Sticker:
+const HOLO_PALETTE = ["#E4CDEC", "#FFC7C7", "#F6E0B4", "#FDFFDE", "#C5E4B5", "#A4C5BF"];
+// Complete 3D Silkscreen Pixel Typography for "CHOCOLATITO CODE"
+export const SILKSCREEN_TITLE_ROWS = [
+    "█▀▀█ █  █ █▀▀█ █▀▀█ █▀▀█ █    █▀▀█ ▀▀█▀▀ ▀█▀ ▀▀█▀▀ █▀▀█   █▀▀█ █▀▀█ █▀▀▄ █▀▀▀",
+    "█    █▀▀█ █  █ █    █  █ █    █▄▄█   █    █    █   █  █   █    █  █ █  █ █▀▀▀",
+    "█▄▄█ █  █ █▄▄█ █▄▄█ █▄▄█ █▄▄█ █  █   █   ▄█▄   █   █▄▄█   █▄▄█ █▄▄█ █▄▄▀ █▄▄▄",
+];
+export function colorizeSilkscreenLine(line) {
+    let out = "";
+    for (let i = 0; i < line.length; i++) {
+        const char = line[i];
+        if (char === " ") {
+            out += " ";
+            continue;
+        }
+        const t = i / line.length;
+        const colorIdx = Math.min(HOLO_PALETTE.length - 1, Math.floor(t * HOLO_PALETTE.length));
+        out += chalk.hex(HOLO_PALETTE[colorIdx]).bold(char);
+    }
+    return out;
+}
+export function renderMascotLines(isBlinking = false) {
+    const grid = BASE_GRID_16X16.map((r) => [...r]);
+    if (isBlinking) {
+        grid[5][2] = 1;
+        grid[5][3] = 1;
+        grid[5][8] = 1;
+        grid[5][9] = 1;
+        grid[6][2] = 4;
+        grid[6][3] = 4;
+        grid[6][8] = 4;
+        grid[6][9] = 4;
+    }
+    const lines = [];
+    for (let y = 0; y < 16; y += 2) {
+        const topRow = grid[y];
+        const botRow = grid[y + 1];
+        let lineStr = "";
+        for (let x = 0; x < 16; x++) {
+            const topColor = COLOR_MAP[topRow[x]];
+            const botColor = COLOR_MAP[botRow[x]];
+            if (!topColor && !botColor) {
+                lineStr += " ";
+            }
+            else if (topColor && !botColor) {
+                lineStr += chalk.hex(topColor)("▀");
+            }
+            else if (!topColor && botColor) {
+                lineStr += chalk.hex(botColor)("▄");
+            }
+            else if (topColor && botColor) {
+                if (topColor === botColor) {
+                    lineStr += chalk.hex(topColor)("█");
+                }
+                else {
+                    lineStr += chalk.hex(topColor).bgHex(botColor)("▀");
+                }
+            }
+        }
+        lines.push(`  ${lineStr}   `);
+    }
+    return lines;
+}
+export function buildBannerContent(cwd, model, isBlinking = false) {
+    const mascotLines = renderMascotLines(isBlinking);
+    const rightLines = [
+        colorizeSilkscreenLine(SILKSCREEN_TITLE_ROWS[0]),
+        colorizeSilkscreenLine(SILKSCREEN_TITLE_ROWS[1]),
+        colorizeSilkscreenLine(SILKSCREEN_TITLE_ROWS[2]),
+        chalk.gray("─".repeat(74)),
+        `${chalk.gray("Motor:")}   ${chalk.bold.white(model.name)} · ${chalk.hex("#A4C5BF")("Espectro Engine")}`,
+        `${chalk.gray("Carpeta:")} ${chalk.cyan(cwd)}`,
+        `${chalk.gray("Memoria:")} ${chalk.bold.green(`${(CONTEXT_WINDOW / 1000).toLocaleString("es")}k tokens`)} ${chalk.gray("(Prompt Caching)")}`,
+        `${chalk.gray("Escribe")} ${chalk.hex("#A855F7")("/")} ${chalk.gray("para comandos,")} ${chalk.hex("#A4C5BF")("@")} ${chalk.gray("para archivos, o")} ${chalk.hex("#E4CDEC")("/effort")}${chalk.gray(".")}`,
+    ];
+    const combinedRows = [];
+    for (let i = 0; i < 8; i++) {
+        const left = mascotLines[i] || "                   ";
+        combinedRows.push(`${left}${rightLines[i]}`);
+    }
+    return ["", ...combinedRows, ""].join("\n");
+}
+export function showBanner(cwd, model, state = "idle") {
+    const content = buildBannerContent(cwd, model, state === "blink");
+    console.log(content);
+}
+export async function animateStartupBanner(cwd, model) {
+    // Impresión limpia instantánea sin animaciones lentas en el terminal
+    showBanner(cwd, model, "idle");
+}
+export function showEffortMenu(currentId) {
+    const items = Object.values(ESPECTRO_MODELS).map((m) => {
+        const isCurrent = m.id === currentId;
+        const bullet = isCurrent ? chalk.hex("#A855F7")("●") : chalk.gray("○");
+        const title = isCurrent ? chalk.bold.hex("#D97757")(m.name) : chalk.bold.white(m.name);
+        const tag = isCurrent ? chalk.bgHex("#A855F7").black.bold(" ACTIVO ") : "";
+        return `  ${bullet} ${title} ${chalk.gray(`[Esfuerzo: ${m.effortLevel}]`)} ${tag}\n     ${chalk.gray(m.description)}\n     ${chalk.gray("Uso:")} ${chalk.hex("#A855F7")(`/effort ${m.id}`)}`;
+    });
+    console.log([
+        "",
+        chalk.bold.hex("#E4CDEC")("POTENCIA DEL MOTOR — CHOCOLATITO CODE"),
+        "",
+        ...items,
+        "",
+        chalk.italic.gray("  Selecciona con /effort 1.0, 1.5, 2.0, 2.5 según la dificultad del problema."),
+        "",
+    ].join("\n"));
+}
+export function showHelp() {
+    console.log([
+        "",
+        chalk.bold.hex("#E4CDEC")("GUÍA DE COMANDOS — CHOCOLATITO CODE"),
+        "",
+        `  ${chalk.hex("#A855F7")("/plan")}            Alterna Modo Plan (solo lectura y diseño de arquitectura)`,
+        `  ${chalk.hex("#A855F7")("/resume [id]")}     Reanuda una sesión de trabajo guardada`,
+        `  ${chalk.hex("#A855F7")("/skills")}          Lista los skills disponibles bajo demanda`,
+        `  ${chalk.hex("#A855F7")("/memory")}          Muestra el índice de memoria persistente`,
+        `  ${chalk.hex("#A855F7")("/goal <meta>")}     Ejecuta una meta compleja con auto-curación`,
+        `  ${chalk.hex("#A855F7")("/effort [nivel]")}  Cambia la potencia del motor (1.0, 1.5, 2.0, 2.5)`,
+        `  ${chalk.hex("#A855F7")("/compact")}         Comprime y optimiza la memoria del chat`,
+        `  ${chalk.hex("#A855F7")("/undo")}            Deshace el último cambio de archivos en la sesión`,
+        `  ${chalk.hex("#A855F7")("/export [doc.md]")} Exporta la bitácora de la sesión a Markdown`,
+        `  ${chalk.hex("#A855F7")("/diff")}            Muestra diferencias de código en Git`,
+        `  ${chalk.hex("#A855F7")("/commit <msg>")}    Crea un commit en Git`,
+        `  ${chalk.hex("#A855F7")("/cd <ruta>")}       Cambia de directorio con búsqueda profunda`,
+        `  ${chalk.hex("#A855F7")("/cost")}            Muestra el resumen de tokens y costo en USD`,
+        `  ${chalk.hex("#A855F7")("/init")}            Crea el archivo ${chalk.yellow("CHOCOLATITO.md")} de directivas`,
+        `  ${chalk.hex("#A855F7")("/clear")}           Limpia el historial de la conversación`,
+        `  ${chalk.hex("#A855F7")("/help")}            Muestra esta ayuda`,
+        `  ${chalk.hex("#A855F7")("/exit")}            Cierra la sesión`,
+        "",
+    ].join("\n"));
+}

package/dist/ui/diffViewer.d.ts

@@ -0,0 +1 @@
+export declare function formatNumberedDiff(filePath: string, oldText: string, newText: string, startLine?: number): string;

package/dist/ui/diffViewer.js

@@ -0,0 +1,60 @@
+import chalk from "chalk";
+import { diffLines } from "diff";
+export function formatNumberedDiff(filePath, oldText, newText, startLine = 1) {
+    const changes = diffLines(oldText, newText);
+    const lines = [];
+    lines.push(`  ${chalk.gray("⎿")}  ${chalk.bold.white(filePath)} ${chalk.gray(`(L${startLine}+)`)}`);
+    lines.push("");
+    let oldLineNum = startLine;
+    let newLineNum = startLine;
+    for (const part of changes) {
+        const rawLines = part.value.replace(/\r\n/g, "\n").split("\n");
+        if (rawLines[rawLines.length - 1] === "")
+            rawLines.pop();
+        if (part.added) {
+            for (const line of rawLines) {
+                const numStr = String(newLineNum).padStart(6, " ");
+                lines.push(`     ${chalk.gray(numStr)} ${chalk.green("+")} ${chalk.bgHex("#1E382B").hex("#A3E635")(line)}`);
+                newLineNum++;
+            }
+        }
+        else if (part.removed) {
+            for (const line of rawLines) {
+                const numStr = String(oldLineNum).padStart(6, " ");
+                lines.push(`     ${chalk.gray(numStr)} ${chalk.red("-")} ${chalk.bgHex("#3B1D22").hex("#FCA5A5")(line)}`);
+                oldLineNum++;
+            }
+        }
+        else {
+            // Unchanged context (show first 2 and last 2 if too long)
+            if (rawLines.length > 6) {
+                const firstTwo = rawLines.slice(0, 2);
+                const lastTwo = rawLines.slice(-2);
+                for (const line of firstTwo) {
+                    const numStr = String(newLineNum).padStart(6, " ");
+                    lines.push(`     ${chalk.gray(numStr)}   ${chalk.gray(line)}`);
+                    oldLineNum++;
+                    newLineNum++;
+                }
+                lines.push(`     ${chalk.gray("   ...")}   ${chalk.gray(`(${rawLines.length - 4} líneas sin cambios)`)}`);
+                oldLineNum += rawLines.length - 4;
+                newLineNum += rawLines.length - 4;
+                for (const line of lastTwo) {
+                    const numStr = String(newLineNum).padStart(6, " ");
+                    lines.push(`     ${chalk.gray(numStr)}   ${chalk.gray(line)}`);
+                    oldLineNum++;
+                    newLineNum++;
+                }
+            }
+            else {
+                for (const line of rawLines) {
+                    const numStr = String(newLineNum).padStart(6, " ");
+                    lines.push(`     ${chalk.gray(numStr)}   ${chalk.gray(line)}`);
+                    oldLineNum++;
+                    newLineNum++;
+                }
+            }
+        }
+    }
+    return lines.join("\n");
+}

package/dist/ui/interrupt.d.ts

@@ -0,0 +1,17 @@
+/** Suelta el teclado de cualquier vigilante que lo tenga. Lo llama el prompt. */
+export declare function releaseKeyboard(): void;
+export declare class InterruptWatcher {
+    private controller;
+    private wasRaw;
+    private listening;
+    private onKey;
+    private aborted;
+    private ctrlCCount;
+    get interrupted(): boolean;
+    get signal(): AbortSignal | undefined;
+    start(): AbortSignal | undefined;
+    private abort;
+    stop(): void;
+}
+/** Un error de aborto no es un fallo: es el usuario diciendo "para". */
+export declare function isAbortError(err: any): boolean;

package/dist/ui/interrupt.js

@@ -0,0 +1,156 @@
+import readline from "node:readline";
+import process from "node:process";
+import chalk from "chalk";
+import { cycleMode, modeAnnouncement } from "./modes.js";
+import { pushTyped, backspaceTyped, commitTyped } from "./typeAhead.js";
+/**
+ * Interrupcion con Esc mientras el agente trabaja.
+ *
+ * El spinner llevaba tiempo anunciando "esc para pausar", pero no habia nada
+ * detras: la tecla no hacia nada y la unica salida era matar el proceso con
+ * Ctrl+C, perdiendo la sesion entera. Prometer un atajo que no existe es peor
+ * que no ofrecerlo.
+ *
+ * Aqui se escucha el teclado solo mientras dura la peticion, y se aborta la
+ * llamada HTTP de verdad (no se deja corriendo de fondo gastando tokens).
+ *
+ * El teclado sigue siendo del usuario mientras tanto: Shift+Tab cambia el modo
+ * de permisos sin esperar a que acabe el turno, y lo que escriba se acumula y se
+ * encola en vez de perderse. Antes, todo lo que no fuera Esc o Ctrl+C se tiraba
+ * en silencio y parecia que el terminal se habia colgado.
+ */
+/**
+ * Vigilantes con el teclado cogido ahora mismo.
+ *
+ * Deberia haber como mucho uno, pero el bucle tiene muchas salidas (error del
+ * motor, interrupcion, hook que deniega, permiso rechazado) y basta que una se
+ * escape sin parar el suyo para que el teclado se quede en manos de nadie: el
+ * prompt siguiente se dibuja, el usuario teclea y no aparece nada.
+ *
+ * En vez de confiar en que las 20 salidas esten bien, el prompt reclama el
+ * teclado antes de abrirse.
+ */
+const activos = new Set();
+/** Suelta el teclado de cualquier vigilante que lo tenga. Lo llama el prompt. */
+export function releaseKeyboard() {
+    for (const w of Array.from(activos)) {
+        w.stop();
+    }
+}
+export class InterruptWatcher {
+    controller = null;
+    wasRaw = false;
+    listening = false;
+    onKey = null;
+    aborted = false;
+    ctrlCCount = 0;
+    get interrupted() {
+        return this.aborted;
+    }
+    get signal() {
+        return this.controller?.signal;
+    }
+    start() {
+        if (this.listening)
+            return this.controller?.signal;
+        this.controller = new AbortController();
+        this.aborted = false;
+        this.ctrlCCount = 0;
+        // Sin terminal interactiva (modo `chocolatito "tarea"`, CI, tuberias) no hay
+        // teclado que escuchar: se devuelve la senal y ya.
+        if (!process.stdin.isTTY || !process.stdin.setRawMode) {
+            return this.controller.signal;
+        }
+        readline.emitKeypressEvents(process.stdin);
+        this.wasRaw = process.stdin.isRaw || false;
+        process.stdin.setRawMode(true);
+        process.stdin.resume();
+        this.onKey = (str, key) => {
+            // 1. Shift+Tab: cambiar de modo de permisos sin esperar al final del turno.
+            const isShiftTab = Boolean(key && key.name === "tab" && key.shift) ||
+                str === "\x1b[Z" ||
+                Boolean(key && key.sequence === "\x1b[Z");
+            if (isShiftTab) {
+                cycleMode();
+                process.stdout.write(`\r\x1b[2K${modeAnnouncement()}\n`);
+                return;
+            }
+            // Ignorar secuencias de escape multi-byte (flechas, inicio, fin, etc.) para que no aborten
+            if (key && (key.sequence?.startsWith("\x1b[") || key.sequence?.startsWith("\x1bO"))) {
+                return;
+            }
+            // 2. Solo la tecla Escape explícita aborta la tarea
+            if (key && key.name === "escape" && (str === "\x1b" || !str)) {
+                this.abort();
+                return;
+            }
+            // Enter durante la generacion: lo escrito queda en cola como siguiente
+            // orden, en vez de perderse.
+            if (key && (key.name === "return" || key.name === "enter")) {
+                const texto = commitTyped();
+                if (texto) {
+                    const corto = texto.length > 70 ? `${texto.slice(0, 67)}...` : texto;
+                    process.stdout.write(`\r\x1b[2K${chalk.gray("↳ en cola:")} ${chalk.white(corto)}\n`);
+                }
+                return;
+            }
+            if (key && (key.name === "backspace" || (key.ctrl && key.name === "h"))) {
+                backspaceTyped();
+                return;
+            }
+            // El primer Ctrl+C interrumpe la tarea; el segundo cierra el programa.
+            // Asi no se pierde la sesion por querer parar una sola accion.
+            if (key && key.ctrl && key.name === "c") {
+                this.ctrlCCount++;
+                if (this.ctrlCCount === 1) {
+                    this.abort();
+                }
+                else {
+                    this.stop();
+                    process.stdout.write("\n");
+                    process.exit(0);
+                }
+                return;
+            }
+            // Todo lo demas es texto: se guarda para el siguiente turno. El spinner lo
+            // va pintando debajo segun se escribe.
+            if (str && !isShiftTab && str !== "\x1b[Z" && (!key || (!key.ctrl && !key.meta))) {
+                pushTyped(str);
+            }
+        };
+        process.stdin.on("keypress", this.onKey);
+        this.listening = true;
+        activos.add(this);
+        return this.controller.signal;
+    }
+    abort() {
+        if (this.aborted)
+            return;
+        this.aborted = true;
+        try {
+            this.controller?.abort();
+        }
+        catch { }
+    }
+    stop() {
+        if (this.onKey) {
+            process.stdin.removeListener("keypress", this.onKey);
+            this.onKey = null;
+        }
+        if (this.listening && process.stdin.setRawMode) {
+            // Se devuelve el terminal como estaba, o el prompt siguiente queda roto.
+            process.stdin.setRawMode(this.wasRaw);
+        }
+        this.listening = false;
+        activos.delete(this);
+    }
+}
+/** Un error de aborto no es un fallo: es el usuario diciendo "para". */
+export function isAbortError(err) {
+    const name = String(err?.name || "");
+    const msg = String(err?.message || "").toLowerCase();
+    return (name === "AbortError" ||
+        name === "APIUserAbortError" ||
+        msg.includes("aborted") ||
+        msg.includes("request was aborted"));
+}

package/dist/ui/markdownStream.d.ts

@@ -0,0 +1,23 @@
+/**
+ * Formatea UNA linea de markdown ya completa.
+ *
+ * Es pura y exportada para poder comprobarla: lo que se ve en el terminal es
+ * dificil de revisar a ojo, y las reglas se pisan entre si con facilidad.
+ */
+export declare function formatLine(line: string): string;
+/**
+ * Va recibiendo los trozos del stream y escribe lineas ya formateadas.
+ *
+ * Guarda el resto incompleto hasta que llegue su salto de linea, y lleva la
+ * cuenta de si estamos dentro de un bloque de codigo, donde no se formatea nada.
+ */
+export declare class MarkdownStream {
+    private pendiente;
+    private enBloqueCodigo;
+    private write;
+    constructor(write?: (s: string) => void);
+    push(chunk: string): void;
+    /** Lo que quede sin salto de linea al acabar el mensaje. */
+    flush(): void;
+    private renderLinea;
+}

package/dist/ui/modes.d.ts

@@ -0,0 +1,28 @@
+/**
+ * MODO DE PERMISOS INTERACTIVO
+ *
+ * El usuario tiene que poder cambiar de modo con Shift+Tab en cualquier momento,
+ * tambien a mitad de una generacion. Antes solo se podia antes de escribir la
+ * orden, y una vez lanzada la tarea no quedaba mas remedio que contestar cada
+ * dialogo uno a uno hasta el final.
+ *
+ * El estado vive aqui, fuera del bucle del agente, porque lo tocan tres sitios
+ * distintos: el prompt, el vigilante de teclas mientras se genera, y el propio
+ * dialogo de permiso.
+ */
+export type InteractiveMode = "default" | "acceptEdits" | "bypass";
+export declare function getMode(): InteractiveMode;
+export declare function setMode(mode: InteractiveMode): InteractiveMode;
+/** Shift+Tab: normal -> acepta ediciones -> automatico -> normal. */
+export declare function cycleMode(): InteractiveMode;
+export declare function onModeChange(cb: (m: InteractiveMode) => void): void;
+export interface ModeLook {
+    label: string;
+    hint: string;
+    color: string;
+}
+export declare function describeMode(mode?: InteractiveMode): ModeLook;
+/** Etiqueta de una linea para el pie del prompt y para el spinner. */
+export declare function modeBadge(mode?: InteractiveMode): string;
+/** Aviso completo, para cuando el usuario acaba de cambiar de modo. */
+export declare function modeAnnouncement(mode?: InteractiveMode): string;

package/dist/ui/modes.js

@@ -0,0 +1,57 @@
+import chalk from "chalk";
+const ORDER = ["default", "acceptEdits", "bypass"];
+let current = "default";
+const listeners = [];
+export function getMode() {
+    return current;
+}
+export function setMode(mode) {
+    current = mode;
+    for (const cb of listeners) {
+        try {
+            cb(current);
+        }
+        catch { }
+    }
+    return current;
+}
+/** Shift+Tab: normal -> acepta ediciones -> automatico -> normal. */
+export function cycleMode() {
+    const idx = ORDER.indexOf(current);
+    return setMode(ORDER[(idx + 1) % ORDER.length]);
+}
+export function onModeChange(cb) {
+    listeners.push(cb);
+}
+const LOOKS = {
+    default: {
+        label: "normal",
+        hint: "pregunta antes de cada accion con consecuencias",
+        color: "#8B8B8B",
+    },
+    acceptEdits: {
+        label: "acepta ediciones",
+        hint: "escribe archivos sin preguntar; sigue preguntando por comandos y por el control del ordenador",
+        color: "#22C55E",
+    },
+    bypass: {
+        label: "automatico",
+        hint: "no pregunta nada, ni comandos ni control del ordenador",
+        color: "#EF4444",
+    },
+};
+export function describeMode(mode = current) {
+    return LOOKS[mode];
+}
+/** Etiqueta de una linea para el pie del prompt y para el spinner. */
+export function modeBadge(mode = current) {
+    if (mode === "default")
+        return "";
+    const look = LOOKS[mode];
+    return chalk.hex(look.color)(`⇥ modo ${look.label}`);
+}
+/** Aviso completo, para cuando el usuario acaba de cambiar de modo. */
+export function modeAnnouncement(mode = current) {
+    const look = LOOKS[mode];
+    return `${chalk.bold.hex(look.color)(`⇥ modo ${look.label}`)} ${chalk.gray(`· ${look.hint}`)} ${chalk.gray("· shift+tab para cambiar")}`;
+}

package/dist/ui/permissionPrompt.d.ts

@@ -0,0 +1,35 @@
+export interface PermissionPromptResult {
+    approved: boolean;
+    rememberPattern?: boolean;
+    userFeedback?: string;
+}
+export declare function setAutoApprove(value: boolean): void;
+/**
+ * DIALOGO DE PERMISO
+ *
+ * La version anterior tenia dos fallos visibles en cuanto se usaba:
+ *
+ *  1. Al mover la seleccion subia el cursor 12 lineas fijas, pero la caja mide
+ *     entre 10 y 14 segun cuantos detalles tenga. Cada flecha dejaba media caja
+ *     huerfana en pantalla, y por eso salian marcos vacios apilados.
+ *
+ *  2. El titulo llevaba un simbolo de anchura ambigua. El terminal lo pinta
+ *     ocupando dos columnas y el calculo del ancho contaba una, asi que el borde
+ *     derecho quedaba descuadrado justo en esa linea.
+ *
+ * Aqui se dibuja la caja a mano, con anchura conocida, y se repinta subiendo
+ * exactamente las lineas que se escribieron.
+ */
+export declare function askToolPermission(toolName: string, args: Record<string, any>, cwd?: string): Promise<PermissionPromptResult>;
+export declare const PERMISSION_OPTIONS: {
+    label: string;
+    hint: string;
+}[];
+/**
+ * Construye el dialogo entero como lista de lineas.
+ *
+ * Es una funcion pura a proposito: asi se puede comprobar en una prueba que
+ * todas las lineas del marco miden exactamente lo mismo. El descuadre del borde
+ * derecho no se ve leyendo el codigo, solo ejecutandolo.
+ */
+export declare function buildPermissionBox(toolName: string, args: Record<string, any>, cwd: string, selectedIndex: number, width?: number): string[];