chocolatito-code 1.3.0 → 1.3.1

package/dist/ui/banner.d.ts

@@ -4,6 +4,37 @@ 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;
+/**
+ * Ventana por debajo de esto y no se ancla nada: el hueco se comeria el banner.
+ * Con 16 filas quedan tres o cuatro libres, que ya es una separacion util.
+ */
+export declare const FILAS_MINIMAS_PARA_ANCLAR = 16;
+/**
+ * Filas en blanco que hay que soltar tras `contenido` para que lo siguiente que
+ * se pinte caiga al fondo de la ventana. Cero si no cabe o no hace falta.
+ *
+ * Se exporta para poder comprobar la cuenta: dentro de un terminal esto no se
+ * revisa a ojo, y pasarse de una fila hace desaparecer la primera del banner.
+ */
+export declare function filasParaAnclar(contenido: string, filasDeVentana: number): number;
+/**
+ * ANCLAR EL PROMPT AL FONDO DE LA VENTANA
+ *
+ * El usuario lo enseno con una captura y una frase: "mira hay espacio y no es
+ * fijo como te decia, eso debe estar fijo en la parte de abajo". Con la sesion
+ * recien empezada, el contenido no llega al final de la pantalla, asi que el
+ * marco del prompt se queda a media altura con hueco vacio DEBAJO. Se lee como
+ * si el programa estuviera a medio dibujar.
+ *
+ * Se arregla soltando las filas en blanco que faltan justo detras del banner. A
+ * partir de ahi el prompt nace abajo, y ya no se mueve de ahi en toda la sesion:
+ * el contenido solo crece hacia abajo, y cuando llega al final el terminal
+ * desplaza, asi que el marco vuelve a quedar en las ultimas filas.
+ *
+ * NO se usa la region de scroll ni la pantalla alternativa: las dos se llevan
+ * por delante el historial del terminal, y aqui media sesion consiste en subir
+ * a releer lo que salio.
+ */
 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;

package/dist/ui/banner.js

@@ -1,6 +1,8 @@
 import chalk from "chalk";
+import process from "node:process";
 import { ESPECTRO_MODELS } from "../config/constants.js";
 import { CONTEXT_WINDOW } from "../config/constants.js";
+import { dibujar } from "./salida.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],
@@ -112,9 +114,52 @@ export function buildBannerContent(cwd, model, isBlinking = false) {
     }
     return ["", ...combinedRows, ""].join("\n");
 }
+/**
+ * Ventana por debajo de esto y no se ancla nada: el hueco se comeria el banner.
+ * Con 16 filas quedan tres o cuatro libres, que ya es una separacion util.
+ */
+export const FILAS_MINIMAS_PARA_ANCLAR = 16;
+/**
+ * Filas en blanco que hay que soltar tras `contenido` para que lo siguiente que
+ * se pinte caiga al fondo de la ventana. Cero si no cabe o no hace falta.
+ *
+ * Se exporta para poder comprobar la cuenta: dentro de un terminal esto no se
+ * revisa a ojo, y pasarse de una fila hace desaparecer la primera del banner.
+ */
+export function filasParaAnclar(contenido, filasDeVentana) {
+    if (filasDeVentana < FILAS_MINIMAS_PARA_ANCLAR)
+        return 0;
+    // El `console.log` anade su propio salto: por eso la altura del bloque es una
+    // linea mas de las que trae el texto.
+    const alto = contenido.split("\n").length;
+    return Math.max(0, filasDeVentana - alto - 1);
+}
+/**
+ * ANCLAR EL PROMPT AL FONDO DE LA VENTANA
+ *
+ * El usuario lo enseno con una captura y una frase: "mira hay espacio y no es
+ * fijo como te decia, eso debe estar fijo en la parte de abajo". Con la sesion
+ * recien empezada, el contenido no llega al final de la pantalla, asi que el
+ * marco del prompt se queda a media altura con hueco vacio DEBAJO. Se lee como
+ * si el programa estuviera a medio dibujar.
+ *
+ * Se arregla soltando las filas en blanco que faltan justo detras del banner. A
+ * partir de ahi el prompt nace abajo, y ya no se mueve de ahi en toda la sesion:
+ * el contenido solo crece hacia abajo, y cuando llega al final el terminal
+ * desplaza, asi que el marco vuelve a quedar en las ultimas filas.
+ *
+ * NO se usa la region de scroll ni la pantalla alternativa: las dos se llevan
+ * por delante el historial del terminal, y aqui media sesion consiste en subir
+ * a releer lo que salio.
+ */
 export function showBanner(cwd, model, state = "idle") {
     const content = buildBannerContent(cwd, model, state === "blink");
     console.log(content);
+    if (!process.stdout.isTTY)
+        return;
+    const relleno = filasParaAnclar(content, process.stdout.rows || 0);
+    if (relleno > 0)
+        dibujar("\n".repeat(relleno));
 }
 export async function animateStartupBanner(cwd, model) {
     // Impresión limpia instantánea sin animaciones lentas en el terminal

package/dist/ui/comandos.d.ts

@@ -0,0 +1,33 @@
+/**
+ * LOS COMANDOS DE BARRA, EN UN SOLO SITIO
+ *
+ * Vivian dentro de prompt.ts, que es quien los autocompleta. Ahora tambien los
+ * necesita el prompt de sistema, y prompt.ts arrastra readline, el historial en
+ * disco y el escaneo del proyecto: no es algo que deba cargar quien solo quiere
+ * la lista.
+ *
+ * POR QUE LE HACEN FALTA AL MODELO
+ *
+ * Sesion real. El usuario pregunta como ver su consumo y el agente contesta
+ * hablando de "la barra lateral", "la app de escritorio" y "empezar un hilo
+ * nuevo". Ninguna de esas cosas existe aqui: esto es una terminal. El modelo
+ * sabia que se llamaba Chocolatito Code -se lo dice el prompt- pero no sabia
+ * NADA de su propio producto, asi que contestaba con lo que sabe de los chats
+ * web. Y la respuesta correcta era una palabra: /cost.
+ *
+ * Con la lista en un modulo aparte, la que ve el usuario al escribir "/" y la
+ * que se le cuenta al modelo son la misma. Duplicarla habria durado hasta el
+ * primer comando nuevo.
+ *
+ * OJO: esta lista SE MODIFICA EN CALIENTE. index.ts anade /actualizar y
+ * /licencia al arrancar, segun como este instalado el programa. Por eso el
+ * prompt de sistema la lee en cada turno y no una vez al importar.
+ */
+export interface SlashCommandItem {
+    name: string;
+    description: string;
+    args?: string;
+}
+export declare const SLASH_COMMANDS: SlashCommandItem[];
+/** La lista tal y como se le cuenta al modelo. Una linea por comando. */
+export declare function listaParaElModelo(): string;

package/dist/ui/comandos.js

@@ -0,0 +1,49 @@
+/**
+ * LOS COMANDOS DE BARRA, EN UN SOLO SITIO
+ *
+ * Vivian dentro de prompt.ts, que es quien los autocompleta. Ahora tambien los
+ * necesita el prompt de sistema, y prompt.ts arrastra readline, el historial en
+ * disco y el escaneo del proyecto: no es algo que deba cargar quien solo quiere
+ * la lista.
+ *
+ * POR QUE LE HACEN FALTA AL MODELO
+ *
+ * Sesion real. El usuario pregunta como ver su consumo y el agente contesta
+ * hablando de "la barra lateral", "la app de escritorio" y "empezar un hilo
+ * nuevo". Ninguna de esas cosas existe aqui: esto es una terminal. El modelo
+ * sabia que se llamaba Chocolatito Code -se lo dice el prompt- pero no sabia
+ * NADA de su propio producto, asi que contestaba con lo que sabe de los chats
+ * web. Y la respuesta correcta era una palabra: /cost.
+ *
+ * Con la lista en un modulo aparte, la que ve el usuario al escribir "/" y la
+ * que se le cuenta al modelo son la misma. Duplicarla habria durado hasta el
+ * primer comando nuevo.
+ *
+ * OJO: esta lista SE MODIFICA EN CALIENTE. index.ts anade /actualizar y
+ * /licencia al arrancar, segun como este instalado el programa. Por eso el
+ * prompt de sistema la lee en cada turno y no una vez al importar.
+ */
+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: "/uso", description: "Ver cuánto llevas consumido de tu cuenta" },
+    { 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" },
+];
+/** La lista tal y como se le cuenta al modelo. Una linea por comando. */
+export function listaParaElModelo() {
+    return SLASH_COMMANDS.map((c) => `- ${c.name}${c.args ? ` ${c.args}` : ""}: ${c.description}`).join("\n");
+}

package/dist/ui/informeDeUso.d.ts

@@ -0,0 +1,17 @@
+import { QuotaStatus } from "../config/quota.js";
+export interface DatosDeSesion {
+    motor: string;
+    tokensEntrada: number;
+    tokensSalida: number;
+    tokensEnCache: number;
+    /** Coste de la sesion, ya formateado. Solo se usa con clave propia. */
+    costeFormateado: string;
+}
+/**
+ * Arma el informe. Puro y exportado para poder comprobarlo: lo que importa aqui
+ * es lo que NO sale, y eso a ojo en un terminal no se revisa.
+ *
+ * `vaciaEn` es cuando la ventana corta vuelve a cero (quota.ventanaVaciaEn).
+ * `null` cuando no hay nada dentro de ella.
+ */
+export declare function construirInformeDeUso(estado: QuotaStatus, sesion: DatosDeSesion, vaciaEn: Date | null, ahora?: number, gestionado?: boolean): string;

package/dist/ui/informeDeUso.js

@@ -0,0 +1,81 @@
+import chalk from "chalk";
+import { faltaPara, isManagedMode } from "../config/quota.js";
+/**
+ * EL INFORME DE /cost
+ *
+ * QUE ENSENABA ANTES
+ *
+ *     • Tokens entrada:  11,553 ($0.00508 USD)
+ *     • Tokens salida:   332 ($0.00044 USD)
+ *     • Inversion total: $0.0055 USD
+ *
+ * Tarifas de API en la cara de alguien que paga una suscripcion plana. Dos
+ * problemas, y el segundo es el importante.
+ *
+ * **No le sirve.** Su factura es fija; que un turno costara medio centimo no le
+ * dice nada que pueda usar. Lo que necesita saber es cuanto le queda antes de
+ * que el programa le pare, y eso son las ventanas de uso.
+ *
+ * **Y ensena el margen.** El coste de API por cuenta es informacion del negocio
+ * de quien vende esto, no del cliente. Puesto en pantalla, cualquiera saca la
+ * cuenta de lo que se gana con el.
+ *
+ * CON CLAVE PROPIA ES AL REVES
+ *
+ * Ahi el dinero es del usuario, se lo cobra su proveedor y no hay ventana que
+ * ensenar porque no se le limita nada (ver la nota de quota.ts). Ocultarle el
+ * gasto seria esconderle SU factura. Asi que ese caso mantiene los dolares.
+ */
+const ANCHO_BARRA = 20;
+/** Barra de progreso en texto. Se ve el nivel de un vistazo, sin leer el numero. */
+function barra(porcentaje) {
+    const llenas = Math.max(0, Math.min(ANCHO_BARRA, Math.round((porcentaje / 100) * ANCHO_BARRA)));
+    // Tres colores y no un degradado: lo unico que hay que distinguir es "vas
+    // bien", "ojo" y "estas a punto de quedarte sin".
+    const color = porcentaje >= 90 ? "#EF4444" : porcentaje >= 70 ? "#FFA500" : "#22C55E";
+    return chalk.hex(color)("█".repeat(llenas)) + chalk.gray("░".repeat(ANCHO_BARRA - llenas));
+}
+function porcentaje(gastado, tope) {
+    if (!(tope > 0))
+        return 0;
+    return Math.min(100, Math.round((gastado / tope) * 100));
+}
+/**
+ * Arma el informe. Puro y exportado para poder comprobarlo: lo que importa aqui
+ * es lo que NO sale, y eso a ojo en un terminal no se revisa.
+ *
+ * `vaciaEn` es cuando la ventana corta vuelve a cero (quota.ventanaVaciaEn).
+ * `null` cuando no hay nada dentro de ella.
+ */
+export function construirInformeDeUso(estado, sesion, vaciaEn, ahora = Date.now(), gestionado = isManagedMode()) {
+    const num = (n) => n.toLocaleString("es-ES");
+    const lineas = [];
+    lineas.push(chalk.bold.hex("#A855F7")("\n📊 CONSUMO DE TU CUENTA"));
+    lineas.push("");
+    if (gestionado) {
+        const pctVentana = porcentaje(estado.spentWindowUsd, estado.config.windowBudgetUsd);
+        const pctSemana = porcentaje(estado.spentWeekUsd, estado.config.weeklyBudgetUsd);
+        // La de 5 h va primera: es la que corta antes y la que sorprende.
+        const cuando = vaciaEn
+            ? chalk.gray(`  vuelve a cero en ${faltaPara(vaciaEn, ahora)}`)
+            : chalk.gray("  sin uso reciente");
+        lineas.push(`  ${chalk.gray(`Ventana de ${estado.config.windowHours} h`.padEnd(16))}${barra(pctVentana)} ` +
+            `${chalk.bold.white(`${pctVentana}%`.padStart(4))}${cuando}`);
+        lineas.push(`  ${chalk.gray("Últimos 7 días".padEnd(16))}${barra(pctSemana)} ` +
+            `${chalk.bold.white(`${pctSemana}%`.padStart(4))}`);
+    }
+    else {
+        // Clave propia: no hay cuenta que gestionar, hay una factura que es suya.
+        lineas.push(`  ${chalk.gray("Gasto de API".padEnd(16))}${chalk.bold.green(sesion.costeFormateado)}`);
+        lineas.push(`  ${chalk.gray("".padEnd(16))}${chalk.gray("con tu propia clave: esto te lo cobra tu proveedor")}`);
+    }
+    lineas.push("");
+    lineas.push(`  ${chalk.gray("Esta sesión".padEnd(16))}${chalk.white(num(sesion.tokensEntrada))} de entrada · ` +
+        `${chalk.white(num(sesion.tokensSalida))} de salida`);
+    if (sesion.tokensEnCache > 0) {
+        lineas.push(`  ${chalk.gray("".padEnd(16))}${chalk.gray(`${num(sesion.tokensEnCache)} reaprovechados de la caché`)}`);
+    }
+    lineas.push(`  ${chalk.gray("Motor".padEnd(16))}${chalk.white(sesion.motor)}`);
+    lineas.push("");
+    return lineas.join("\n");
+}

package/dist/ui/marco.d.ts

@@ -0,0 +1,35 @@
+export interface DropdownItem {
+    type: "command" | "file";
+    label: string;
+    secondary?: string;
+    insertText: string;
+}
+export interface PromptFrameOptions {
+    cols: number;
+    /** Alto de la ventana; sirve para no dibujar un marco que no quepa. */
+    rows?: number;
+    promptSymbol?: string;
+    input?: string;
+    cursorIndex?: number;
+    items?: DropdownItem[];
+    selectedIndex?: number;
+}
+export interface PromptFrame {
+    /** Lineas LOGICAS. Cualquiera puede ocupar mas de una fila fisica. */
+    lines: string[];
+    /** Filas de pantalla que ocupara el marco entero con este ancho. */
+    totalRows: number;
+    /** Fila fisica del cursor, con 0 en la primera fila del marco. */
+    cursorRow: number;
+    cursorCol: number;
+    /** Primer elemento del desplegable que se muestra (ventana deslizante). */
+    dropdownOffset: number;
+}
+/**
+ * Arma el marco del prompt y dice exactamente donde queda el cursor.
+ *
+ * Va aparte de render() por dos razones: se puede probar sin terminal, y la
+ * aritmetica de filas se hace UNA vez sobre las mismas lineas que se pintan, en
+ * lugar de estimarse por otro lado y descuadrarse.
+ */
+export declare function buildPromptFrame(opts: PromptFrameOptions): PromptFrame;

package/dist/ui/marco.js

@@ -0,0 +1,161 @@
+import chalk from "chalk";
+import { describeMode, getMode } from "./modes.js";
+/**
+ * EL MARCO DE LA BARRA, EN UN SOLO SITIO
+ *
+ * Vivia dentro de prompt.ts. Ahora lo necesitan dos: el prompt cuando espera una
+ * orden, y el spinner mientras el agente trabaja.
+ *
+ * POR QUE COMPARTIDO Y NO COPIADO
+ *
+ * Habia DOS barras distintas turnandose. Al esperar salia el marco entero
+ * -barra, entrada, barra, linea de ayuda-; al trabajar, una version recortada
+ * con otro texto. Se parecian lo justo para que el cambio de una a otra se viera
+ * como un salto, y el usuario lo dijo asi: "aun no es fija... debe ser fija y
+ * por debajo deben pasar los otros mensajes".
+ *
+ * Con el constructor compartido no pueden divergir: si alguien toca el marco, lo
+ * toca en los dos estados a la vez. Copiarlo habria durado hasta el primer
+ * retoque.
+ *
+ * Va aparte tambien por peso: prompt.ts arrastra readline, el historial en disco
+ * y el escaneo del proyecto, y el spinner no tiene por que cargar nada de eso.
+ */
+function stripAnsi(str) {
+    return str.replace(/\x1b\[[0-9;]*m/g, "");
+}
+const PLACEHOLDER = "Escribe una instrucción, '@' para archivos o '/' para comandos...";
+/**
+ * Filas FISICAS que ocupa una linea del marco.
+ *
+ * Aqui estaba el fallo de verdad: el repintado contaba elementos del array del
+ * marco mientras el terminal cuenta filas de pantalla. Cualquier linea que no
+ * cupiera en el ancho se partia en dos filas, el cursor subia una fila de menos
+ * y el marco entero se iba bajando, dejando una barra huerfana por pulsacion.
+ * La entrada ademas puede llevar saltos de linea dentro (continuacion con "\").
+ */
+function physicalRows(line, cols) {
+    return stripAnsi(line)
+        .split("\n")
+        .reduce((n, seg) => n + Math.max(1, Math.ceil(seg.length / cols)), 0);
+}
+/** Recorta a `width` columnas visibles. Texto sin pintar: aqui no hay que cerrar colores. */
+function truncatePlain(text, width) {
+    if (width <= 0)
+        return "";
+    if (text.length <= width)
+        return text;
+    return width <= 1 ? text.slice(0, width) : `${text.slice(0, width - 1)}…`;
+}
+/**
+ * Arma el marco del prompt y dice exactamente donde queda el cursor.
+ *
+ * Va aparte de render() por dos razones: se puede probar sin terminal, y la
+ * aritmetica de filas se hace UNA vez sobre las mismas lineas que se pintan, en
+ * lugar de estimarse por otro lado y descuadrarse.
+ */
+export function buildPromptFrame(opts) {
+    const cols = Math.max(20, opts.cols || 80);
+    const viewportRows = Math.max(6, opts.rows || 24);
+    const promptSymbol = opts.promptSymbol ?? "❯";
+    const input = opts.input ?? "";
+    const cursorIndex = Math.max(0, Math.min(opts.cursorIndex ?? input.length, input.length));
+    const items = opts.items ?? [];
+    const selectedIndex = items.length > 0 ? (((opts.selectedIndex ?? 0) % items.length) + items.length) % items.length : 0;
+    const isPlan = promptSymbol.includes("plan");
+    const symbolStr = isPlan
+        ? `${chalk.cyan.bold("plan ❯")} `
+        : `${chalk.bold.hex("#D97757")("❯")} `;
+    const symbolWidth = isPlan ? 7 : 2;
+    const bar = chalk.gray("─".repeat(cols));
+    // 1. Linea de entrada. Lo que el usuario escribe NO se recorta nunca: se deja
+    // que el terminal la parta y despues se cuentan las filas que ocupa.
+    let formattedInput;
+    if (input.length === 0) {
+        // La pista si se recorta: en una ventana estrecha ocupaba una segunda fila
+        // para no decir nada que el usuario no sepa ya.
+        formattedInput = chalk.gray(truncatePlain(PLACEHOLDER, cols - symbolWidth));
+    }
+    else if (input.startsWith("/")) {
+        const parts = input.split(" ");
+        const cmdPart = chalk.bold.hex("#A855F7")(parts[0]);
+        const restPart = parts.slice(1).join(" ");
+        formattedInput = restPart ? `${cmdPart} ${chalk.white(restPart)}` : cmdPart;
+    }
+    else {
+        formattedInput = input.replace(/(@[^\s]+)/g, (m) => chalk.bold.hex("#D97757")(m));
+    }
+    const inputLine = symbolStr + formattedInput;
+    const inputRows = physicalRows(inputLine, cols);
+    // 2. Desplegable. Un marco mas alto que la ventana obliga al terminal a
+    // desplazar el contenido, y a partir de ahi el repintado ya no sabe donde
+    // esta su primera fila: se muestra solo una ventana alrededor del elegido.
+    const room = Math.max(1, viewportRows - 1 - (1 + inputRows + 1 + 1));
+    const shown = Math.min(items.length, room);
+    const dropdownOffset = shown > 0 && items.length > shown
+        ? Math.min(Math.max(0, selectedIndex - Math.floor(shown / 2)), items.length - shown)
+        : 0;
+    const dropdownLines = [];
+    for (let i = dropdownOffset; i < dropdownOffset + shown; i++) {
+        const item = items[i];
+        const isSelected = i === selectedIndex;
+        const colorHex = item.type === "file" ? "#D97757" : "#A855F7";
+        const pointer = isSelected ? chalk.bold.hex(colorHex)(" ❯ ") : chalk.gray("   ");
+        // El puntero se lleva 3 columnas fijas. De lo que queda manda la etiqueta:
+        // la descripcion es lo primero que se cae, porque una ruta a medias no se
+        // puede ni leer ni elegir.
+        const free = cols - 3;
+        const label = truncatePlain(item.label, free);
+        const roomForDesc = free - label.length - 2;
+        const secondary = item.secondary && roomForDesc >= 8 ? truncatePlain(item.secondary, roomForDesc) : "";
+        const paintedLabel = isSelected ? chalk.bold.white(label) : chalk.hex(colorHex)(label);
+        const paintedDesc = secondary
+            ? isSelected
+                ? chalk.whiteBright(`  ${secondary}`)
+                : chalk.gray(`  ${secondary}`)
+            : "";
+        dropdownLines.push(`${pointer}${paintedLabel}${paintedDesc}`);
+    }
+    // 3. Pie de estado. El relleno se calculaba con Math.max(1, ...): cuando no
+    // cabia, en vez de recortarse se quedaba con un espacio y la linea salia MAS
+    // ancha que el terminal. En una consola de 80 columnas el pie media 87 y se
+    // partia en dos filas desde el primer dibujado.
+    const modeLook = describeMode(getMode());
+    const hintPlain = "? /help para atajos · shift+tab modo · esc cancelar";
+    const modePlain = `⇥ modo ${modeLook.label}`;
+    const enginePlain = "· Espectro 1.0 (Ágil)";
+    const hint = chalk.gray(hintPlain);
+    const modeTag = chalk.hex(modeLook.color)(modePlain);
+    const engine = chalk.gray(enginePlain);
+    let footerLine;
+    if (hintPlain.length + 1 + modePlain.length + 1 + enginePlain.length <= cols) {
+        const padLen = cols - hintPlain.length - modePlain.length - 1 - enginePlain.length;
+        footerLine = `${hint}${" ".repeat(padLen)}${modeTag} ${engine}`;
+    }
+    else if (modePlain.length + 1 + enginePlain.length <= cols) {
+        // Los atajos son opcionales; el modo activo no, que es lo que decide si te
+        // van a preguntar antes de tocar tus archivos.
+        footerLine = `${" ".repeat(cols - modePlain.length - 1 - enginePlain.length)}${modeTag} ${engine}`;
+    }
+    else if (modePlain.length <= cols) {
+        footerLine = `${" ".repeat(cols - modePlain.length)}${modeTag}`;
+    }
+    else {
+        footerLine = chalk.hex(modeLook.color)(truncatePlain(modePlain, cols));
+    }
+    const lines = [bar, inputLine, ...dropdownLines, bar, footerLine];
+    // 4. Donde queda el cursor, en filas fisicas. Antes se hacia cursorCol =
+    // total % cols: aplicaba el modulo pero nunca sumaba la fila, asi que en
+    // cuanto la entrada se partia el acento se iba a escribir a otra linea.
+    const typed = input.length === 0 ? "" : input.slice(0, cursorIndex);
+    const segments = typed.split("\n");
+    let cursorRow = physicalRows(bar, cols);
+    for (let i = 0; i < segments.length - 1; i++) {
+        cursorRow += Math.max(1, Math.ceil(((i === 0 ? symbolWidth : 0) + segments[i].length) / cols));
+    }
+    const lastSegWidth = (segments.length === 1 ? symbolWidth : 0) + segments[segments.length - 1].length;
+    cursorRow += Math.floor(lastSegWidth / cols);
+    const cursorCol = lastSegWidth % cols;
+    const totalRows = lines.reduce((n, l) => n + physicalRows(l, cols), 0);
+    return { lines, totalRows, cursorRow, cursorCol, dropdownOffset };
+}

package/dist/ui/prompt.d.ts

@@ -1,47 +1,10 @@
+export { buildPromptFrame } from "./marco.js";
+export type { DropdownItem, PromptFrame, PromptFrameOptions } from "./marco.js";
+export { SLASH_COMMANDS } from "./comandos.js";
+export type { SlashCommandItem } from "./comandos.js";
 /**
  * Imprime sin romper el prompt. Uselo en vez de `console.log` para todo lo que
  * pueda llegar TARDE: conexiones en segundo plano, avisos, temporizadores.
  */
 export declare function imprimirSobreElPrompt(texto: string): void;
-export interface SlashCommandItem {
-    name: string;
-    description: string;
-    args?: string;
-}
-export declare const SLASH_COMMANDS: SlashCommandItem[];
-export interface DropdownItem {
-    type: "command" | "file";
-    label: string;
-    secondary?: string;
-    insertText: string;
-}
-export interface PromptFrameOptions {
-    cols: number;
-    /** Alto de la ventana; sirve para no dibujar un marco que no quepa. */
-    rows?: number;
-    promptSymbol?: string;
-    input?: string;
-    cursorIndex?: number;
-    items?: DropdownItem[];
-    selectedIndex?: number;
-}
-export interface PromptFrame {
-    /** Lineas LOGICAS. Cualquiera puede ocupar mas de una fila fisica. */
-    lines: string[];
-    /** Filas de pantalla que ocupara el marco entero con este ancho. */
-    totalRows: number;
-    /** Fila fisica del cursor, con 0 en la primera fila del marco. */
-    cursorRow: number;
-    cursorCol: number;
-    /** Primer elemento del desplegable que se muestra (ventana deslizante). */
-    dropdownOffset: number;
-}
-/**
- * Arma el marco del prompt y dice exactamente donde queda el cursor.
- *
- * Va aparte de render() por dos razones: se puede probar sin terminal, y la
- * aritmetica de filas se hace UNA vez sobre las mismas lineas que se pintan, en
- * lugar de estimarse por otro lado y descuadrarse.
- */
-export declare function buildPromptFrame(opts: PromptFrameOptions): PromptFrame;
 export declare function askInteractivePrompt(promptSymbol?: string, cwd?: string): Promise<string>;