chocolatito-code 1.2.0 → 1.3.0

package/dist/ui/pieFijo.d.ts

@@ -0,0 +1,56 @@
+/**
+ * Las secciones, de arriba abajo. El orden es fijo a proposito: si cada quien
+ * pintara donde le tocara, dos productores independientes -el razonamiento y el
+ * spinner llegan por caminos distintos- se turnarian el sitio y el pie bailaria.
+ */
+declare const ORDEN: readonly ["razonamiento", "spinner", "entrada"];
+export type SeccionDelPie = (typeof ORDEN)[number];
+/**
+ * Enciende o apaga el pie a mano. Con `null` vuelve a mandar el terminal.
+ *
+ * Las pruebas lo encienden porque en `node --test` no hay TTY y sin esto el pie
+ * seria un no-op silencioso: pasarian todas sin comprobar nada.
+ */
+export declare function habilitarPie(valor: boolean | null): void;
+/** ¿Hay algo pintado abajo que haya que respetar? */
+export declare function hayPie(): boolean;
+/**
+ * Pone (o reemplaza) una seccion del pie y repinta.
+ *
+ * Con la lista vacia la seccion desaparece, que es lo mismo que quitarla. Si el
+ * contenido es identico al que ya habia, no se repinta: el spinner llama ocho
+ * veces por segundo y la barra de escribir casi nunca cambia entre dos.
+ */
+export declare function fijarSeccion(nombre: SeccionDelPie, lineas: string[]): void;
+/**
+ * Varias secciones de una vez, con UN solo repintado.
+ *
+ * El spinner cambia su linea y la barra de escribir en el mismo tick. Puestas
+ * por separado se pintaba el bloque dos veces cada 120 ms, y la segunda pasada
+ * borraba y reescribia lo que la primera acababa de dejar: el doble de bytes
+ * para el mismo resultado, y un parpadeo que se nota en un terminal lento.
+ */
+export declare function fijarSecciones(entradas: Array<[SeccionDelPie, string[]]>): void;
+export declare function quitarSeccion(nombre: SeccionDelPie): void;
+/**
+ * Escribe texto permanente sin que el pie se lo lleve por delante.
+ *
+ * Sin pie es un write normal y no cuesta nada; por eso puede sustituir a
+ * `console.log` en el camino del agente sin pensarlo dos veces.
+ */
+export declare function escribirEncimaDelPie(texto: string): void;
+/**
+ * Quita el pie entero y deja el terminal como si nunca hubiera estado.
+ *
+ * Lo que quede a medias de linea se conserva en pantalla: es texto del agente,
+ * no adorno, y borrarlo seria perder salida.
+ */
+export declare function soltarPie(): void;
+/**
+ * Olvida el estado sin tocar la pantalla.
+ *
+ * Para las pruebas y para la salida del proceso: ahi no queda terminal al que
+ * repintar, pero el cursor escondido si sobrevive y hay que devolverlo.
+ */
+export declare function reiniciarPie(): void;
+export {};

package/dist/ui/pieFijo.js

@@ -0,0 +1,309 @@
+import process from "node:process";
+import { dibujar } from "./salida.js";
+/**
+ * EL PIE QUE NO SE VA CON EL SCROLL
+ *
+ * EL PROBLEMA
+ *
+ * El spinner y la linea de razonamiento se pintaban donde estuviera el cursor:
+ *
+ *     process.stdout.write(`\r\x1b[2K${glyph} ${verb} (${segundos}s)`);
+ *
+ * Eso escribe en la fila actual y ahi se queda. En cuanto llega la respuesta,
+ * cada linea nueva empuja el contenido hacia arriba y se lleva el spinner con
+ * ella. El usuario lo describio mejor que ninguna documentacion: "la nubecita y
+ * el rayito suben con lo que me respondes". Y lo mismo la barra de escribir.
+ *
+ * El resultado es que mientras el modelo habla no hay NADA fijo en pantalla: ni
+ * cuanto lleva, ni cuantos tokens, ni donde escribir para encolar algo. Todo
+ * queda enterrado unas pantallas mas arriba.
+ *
+ * LA IDEA
+ *
+ * Un terminal no tiene "zonas". Se puede pedir una con la region de scroll
+ * (DECSTBM), pero lo que sale por arriba de una region asi NO entra en el
+ * historial del terminal en la mayoria de emuladores: se pierde. En un agente
+ * de codigo, donde media sesion consiste en subir a releer lo que salio, eso es
+ * inaceptable.
+ *
+ * Asi que se hace al reves, sin regiones: el pie se BORRA antes de cada
+ * escritura permanente y se REPINTA justo despues. El texto permanente se
+ * escribe con saltos de linea normales, entra en el historial como siempre, y
+ * el pie acaba de nuevo abajo del todo. Visto desde fuera, el pie no se mueve.
+ *
+ * LA INVARIANTE QUE LO SOSTIENE
+ *
+ * Tras pintar, el cursor queda al final de la ultima fila del bloque. Con eso
+ * basta para borrarlo entero: subir `filasPintadas - 1` filas, ir a la columna
+ * cero y borrar hacia abajo. Se cuentan filas FISICAS (lo que el terminal parte
+ * al llegar al ancho), no elementos del array: contar lineas logicas es
+ * exactamente el fallo que dejaba barras huerfanas en el prompt.
+ *
+ * Y LA SEGUNDA, LA QUE EVITA CORROMPER LA SALIDA AJENA
+ *
+ * Sin secciones puestas, el pie no pinta nada y la pantalla queda byte a byte
+ * como la habria dejado un `console.log` normal. Por eso el resto del programa
+ * -las herramientas, el renderizador, los avisos- puede seguir escribiendo
+ * directo sin saber que esto existe. Solo hay que pasar por aqui mientras haya
+ * pie, que es justo el rato que el bucle controla toda la salida.
+ */
+const OCULTAR_CURSOR = "\x1b[?25l";
+const MOSTRAR_CURSOR = "\x1b[?25h";
+/**
+ * Las secciones, de arriba abajo. El orden es fijo a proposito: si cada quien
+ * pintara donde le tocara, dos productores independientes -el razonamiento y el
+ * spinner llegan por caminos distintos- se turnarian el sitio y el pie bailaria.
+ */
+const ORDEN = ["razonamiento", "spinner", "entrada"];
+const secciones = new Map();
+/**
+ * Texto permanente que aun no ha recibido su salto de linea.
+ *
+ * Un `flush()` de markdown puede dejar media linea escrita. Si el pie se
+ * pintara detras, empezaria en mitad de esa fila. En vez de calcular columnas
+ * -aritmetica que se rompe con cada emoji- se guarda ese resto AQUI y se
+ * repinta como primera linea del bloque. Deja de ser texto permanente hasta que
+ * llegue su salto, y entonces se escribe de verdad.
+ */
+let colaSinSalto = "";
+/** Filas fisicas que ocupo el bloque en el ultimo pintado. Es lo que se borra. */
+let filasPintadas = 0;
+/**
+ * Lo ultimo que escribimos NOSOTROS se quedo a medio renglon.
+ *
+ * Sin secciones puestas, la linea a medias deja de estar protegida y sale como
+ * texto permanente (ver `repintar`). Si despues vuelve a haber pie, tiene que
+ * empezar en un renglon nuevo y no pegado al final de esa frase.
+ */
+let aMediaLinea = false;
+let cursorEscondido = false;
+/** `null` = decidirlo por el terminal. Las pruebas lo fuerzan. */
+let habilitado = null;
+function pieUsable() {
+    return habilitado ?? Boolean(process.stdout.isTTY);
+}
+/**
+ * Enciende o apaga el pie a mano. Con `null` vuelve a mandar el terminal.
+ *
+ * Las pruebas lo encienden porque en `node --test` no hay TTY y sin esto el pie
+ * seria un no-op silencioso: pasarian todas sin comprobar nada.
+ */
+export function habilitarPie(valor) {
+    habilitado = valor;
+}
+function ancho() {
+    return Math.max(20, process.stdout.columns || 80);
+}
+function alto() {
+    return Math.max(4, process.stdout.rows || 24);
+}
+function sinColores(texto) {
+    return texto.replace(/\x1b\[[0-9;]*m/g, "");
+}
+/**
+ * Filas de pantalla que ocupa una linea con este ancho.
+ *
+ * `ceil(largo / cols)` coincide con el ajuste diferido de los terminales: tras
+ * escribir exactamente `cols` caracteres el cursor sigue en esa fila esperando,
+ * y eso es una fila, no dos.
+ */
+function filasFisicas(linea, cols) {
+    return sinColores(linea)
+        .split("\n")
+        .reduce((n, seg) => n + Math.max(1, Math.ceil(seg.length / cols)), 0);
+}
+function lineasDelBloque() {
+    const lineas = [];
+    if (colaSinSalto)
+        lineas.push(colaSinSalto);
+    for (const nombre of ORDEN) {
+        const trozo = secciones.get(nombre);
+        if (trozo && trozo.length > 0)
+            lineas.push(...trozo);
+    }
+    return lineas;
+}
+/** Secuencia que deja el cursor donde empezaba el bloque, con todo borrado debajo. */
+function borrado() {
+    if (filasPintadas === 0)
+        return "";
+    const subir = filasPintadas > 1 ? `\x1b[${filasPintadas - 1}A` : "";
+    return `\r${subir}\x1b[0J`;
+}
+/** Secuencia del bloque nuevo. Actualiza `filasPintadas`. */
+function pintado() {
+    let lineas = lineasDelBloque();
+    if (lineas.length === 0) {
+        filasPintadas = 0;
+        return "";
+    }
+    const cols = ancho();
+    // Un pie mas alto que la ventana no se puede repintar: al pintarlo el
+    // terminal desplaza, y la cuenta de filas -que es lo unico que sabemos para
+    // borrarlo- deja de valer. Se recorta por abajo, que es donde esta lo menos
+    // urgente; la cola sin salto va primera y nunca se cae.
+    const tope = alto() - 1;
+    let filas = lineas.reduce((n, l) => n + filasFisicas(l, cols), 0);
+    while (filas > tope && lineas.length > 1) {
+        lineas = lineas.slice(0, -1);
+        filas = lineas.reduce((n, l) => n + filasFisicas(l, cols), 0);
+    }
+    filasPintadas = filas;
+    return lineas.join("\n");
+}
+/**
+ * El unico sitio que escribe. Borra lo de antes, suelta el texto permanente en
+ * medio, y vuelve a pintar el pie debajo. Todo en UNA escritura: un pie pintado
+ * a trozos es un pie que parpadea.
+ */
+function repintar(permanente) {
+    const fuera = borrado();
+    // Sin secciones ya no hay de que proteger la linea a medias, y retenerla seria
+    // peor que soltarla: el pie seguiria contando esa fila como suya, y el
+    // siguiente repintado borraria lo que hubiera escrito cualquier otro por su
+    // cuenta -las herramientas imprimen con console.log y no pasan por aqui-.
+    // Soltandola, `filasPintadas` vuelve a cero y el pie no debe nada a nadie.
+    let suelto = "";
+    if (secciones.size === 0 && colaSinSalto) {
+        suelto = colaSinSalto;
+        colaSinSalto = "";
+    }
+    let dentro = pintado();
+    const texto = permanente + suelto;
+    if (texto)
+        aMediaLinea = !texto.endsWith("\n");
+    if (dentro && aMediaLinea) {
+        // El salto va DELANTE del bloque, y no cuenta como fila suya: el borrado
+        // sube hasta la primera fila del pie, no hasta la frase de encima.
+        dentro = `\n${dentro}`;
+        aMediaLinea = false;
+    }
+    let salida = fuera + texto + dentro;
+    if (dentro && !cursorEscondido) {
+        // Con el pie repintandose cada 120 ms, un cursor visible salta de sitio sin
+        // parar. Se esconde mientras dure y se devuelve al soltarlo.
+        salida = OCULTAR_CURSOR + salida;
+        cursorEscondido = true;
+    }
+    else if (!dentro && cursorEscondido) {
+        salida += MOSTRAR_CURSOR;
+        cursorEscondido = false;
+    }
+    if (salida)
+        dibujar(salida);
+}
+/** ¿Hay algo pintado abajo que haya que respetar? */
+export function hayPie() {
+    return filasPintadas > 0;
+}
+function iguales(a, b) {
+    if (!a || a.length !== b.length)
+        return false;
+    return a.every((l, i) => l === b[i]);
+}
+/** Guarda la seccion. Devuelve si algo cambio, que es lo que decide repintar. */
+function anotar(nombre, lineas) {
+    if (lineas.length === 0) {
+        return secciones.delete(nombre);
+    }
+    if (iguales(secciones.get(nombre), lineas))
+        return false;
+    secciones.set(nombre, lineas);
+    return true;
+}
+/**
+ * Pone (o reemplaza) una seccion del pie y repinta.
+ *
+ * Con la lista vacia la seccion desaparece, que es lo mismo que quitarla. Si el
+ * contenido es identico al que ya habia, no se repinta: el spinner llama ocho
+ * veces por segundo y la barra de escribir casi nunca cambia entre dos.
+ */
+export function fijarSeccion(nombre, lineas) {
+    if (!pieUsable())
+        return;
+    if (anotar(nombre, lineas))
+        repintar("");
+}
+/**
+ * Varias secciones de una vez, con UN solo repintado.
+ *
+ * El spinner cambia su linea y la barra de escribir en el mismo tick. Puestas
+ * por separado se pintaba el bloque dos veces cada 120 ms, y la segunda pasada
+ * borraba y reescribia lo que la primera acababa de dejar: el doble de bytes
+ * para el mismo resultado, y un parpadeo que se nota en un terminal lento.
+ */
+export function fijarSecciones(entradas) {
+    if (!pieUsable())
+        return;
+    let cambio = false;
+    for (const [nombre, lineas] of entradas) {
+        if (anotar(nombre, lineas))
+            cambio = true;
+    }
+    if (cambio)
+        repintar("");
+}
+export function quitarSeccion(nombre) {
+    fijarSeccion(nombre, []);
+}
+/**
+ * Escribe texto permanente sin que el pie se lo lleve por delante.
+ *
+ * Sin pie es un write normal y no cuesta nada; por eso puede sustituir a
+ * `console.log` en el camino del agente sin pensarlo dos veces.
+ */
+export function escribirEncimaDelPie(texto) {
+    if (!texto)
+        return;
+    if (!pieUsable() || (filasPintadas === 0 && !colaSinSalto)) {
+        dibujar(texto);
+        return;
+    }
+    const completo = colaSinSalto + texto;
+    const corte = completo.lastIndexOf("\n");
+    const permanente = corte >= 0 ? completo.slice(0, corte + 1) : "";
+    colaSinSalto = corte >= 0 ? completo.slice(corte + 1) : completo;
+    repintar(permanente);
+}
+/**
+ * Quita el pie entero y deja el terminal como si nunca hubiera estado.
+ *
+ * Lo que quede a medias de linea se conserva en pantalla: es texto del agente,
+ * no adorno, y borrarlo seria perder salida.
+ */
+export function soltarPie() {
+    if (secciones.size === 0 && filasPintadas === 0)
+        return;
+    secciones.clear();
+    repintar("");
+}
+/**
+ * Olvida el estado sin tocar la pantalla.
+ *
+ * Para las pruebas y para la salida del proceso: ahi no queda terminal al que
+ * repintar, pero el cursor escondido si sobrevive y hay que devolverlo.
+ */
+export function reiniciarPie() {
+    secciones.clear();
+    colaSinSalto = "";
+    filasPintadas = 0;
+    aMediaLinea = false;
+    if (cursorEscondido) {
+        dibujar(MOSTRAR_CURSOR);
+        cursorEscondido = false;
+    }
+}
+/**
+ * Un cursor escondido sobrevive al proceso: la shell de despues se queda sin
+ * cursor y el usuario no tiene forma de saber por que. Se devuelve pase lo que
+ * pase, tambien si el programa se cae.
+ */
+process.on("exit", () => {
+    if (cursorEscondido) {
+        try {
+            process.stdout.write(MOSTRAR_CURSOR);
+        }
+        catch { }
+        cursorEscondido = false;
+    }
+});

package/dist/ui/prompt.js

@@ -9,6 +9,7 @@ import { releaseKeyboard, tomarTecladoParaPrompt, devolverTecladoDelPrompt } fro
 import { repararTeclado, reafirmarModoCrudo, MS_ENTRE_COMPROBACIONES } from "./keyboardGuard.js";
 import { clearTyped } from "./typeAhead.js";
 import { dibujar } from "./salida.js";
+import { escribirEncimaDelPie, reiniciarPie } from "./pieFijo.js";
 import { esGrande, guardarPegado, expandirPegados, marcaQueTerminaEn, limpiarPegados } from "./pegados.js";
 /**
  * Escribir algo mientras el prompt esta dibujado.
@@ -40,7 +41,9 @@ export function imprimirSobreElPrompt(texto) {
         escribirEncimaDelPrompt(texto);
         return;
     }
-    dibujar(texto.endsWith("\n") ? texto : `${texto}\n`);
+    // Sin prompt abierto puede haber pie: el spinner y la linea de razonamiento
+    // viven ahi. Un aviso que llegue tarde tiene que pasar por encima igual.
+    escribirEncimaDelPie(texto.endsWith("\n") ? texto : `${texto}\n`);
 }
 export const SLASH_COMMANDS = [
     { name: "/mcp", description: "Ver servidores MCP conectados y sus herramientas" },
@@ -285,6 +288,11 @@ export function buildPromptFrame(opts) {
 }
 export async function askInteractivePrompt(promptSymbol = "❯", cwd = process.cwd()) {
     return new Promise((resolve) => {
+        // A partir de aqui el terminal es del prompt, que lleva su propia cuenta de
+        // filas. El pie fijo tiene que olvidar la suya SIN borrar nada: lo que dejo
+        // en pantalla es respuesta del agente, no adorno. Y devuelve el cursor, que
+        // lo escondia mientras se repintaba.
+        reiniciarPie();
         let inputBuffer = "";
         let cursorIndex = 0;
         let selectedIndex = 0;

package/dist/ui/reasoningStream.js

@@ -1,5 +1,6 @@
 import chalk from "chalk";
 import process from "node:process";
+import { fijarSeccion, quitarSeccion, escribirEncimaDelPie } from "./pieFijo.js";
 /**
  * Lo que se ve mientras el modelo piensa.
  *
@@ -23,9 +24,17 @@ import process from "node:process";
  * que aparecia justo en las tareas largas -las que mas razonan- y nunca al
  * saludar.
  *
- * Ahora se resume: una sola linea que se reescribe sobre si misma diciendo
- * cuanto lleva pensando y en que anda. Cero avance de scroll, una escritura por
- * trozo recibido en vez de una por letra.
+ * Ahora se resume: una sola linea que dice cuanto lleva pensando y en que anda.
+ * Cero avance de scroll, una escritura por trozo recibido en vez de una por
+ * letra.
+ *
+ * DONDE VIVE ESA LINEA
+ *
+ * En el pie fijo, no en la fila actual. Antes se reescribia sobre si misma con
+ * `\r\x1b[2K`, que la ata a la fila donde nacio: al empezar a llegar la
+ * respuesta, el terminal desplaza y se la lleva hacia arriba. Es la "nubecita
+ * que sube con lo que me respondes". Entregandola al pie, se repinta abajo tras
+ * cada linea de respuesta y se queda quieta.
  *
  * Quien quiera verlo entero: CHOCOLATITO_RAZONAMIENTO=completo.
  */
@@ -56,7 +65,7 @@ export class ReasoningStream {
             this.caracteres = 0;
             this.cola = "";
             if (COMPLETO) {
-                process.stdout.write(`\n  ${chalk.bold.hex("#8B5CF6")("💭 Razonando:")}\n`);
+                escribirEncimaDelPie(`\n  ${chalk.bold.hex("#8B5CF6")("💭 Razonando:")}\n`);
             }
         }
         if (COMPLETO) {
@@ -87,22 +96,20 @@ export class ReasoningStream {
         }
         // Un solo write, y el color se aplica una vez al bloque entero en vez de a
         // cada letra: mismo resultado en pantalla, una fraccion de los bytes.
-        process.stdout.write(chalk.gray(salida));
+        escribirEncimaDelPie(chalk.gray(salida));
     }
     refrescar(forzar) {
         const ahora = Date.now();
         if (!forzar && ahora - this.ultimoRefresco < MS_ENTRE_REFRESCOS)
             return;
         this.ultimoRefresco = ahora;
-        if (!process.stdout.isTTY)
-            return;
         const segundos = Math.round((ahora - this.inicio) / 1000);
         const ancho = Math.max(20, (process.stdout.columns || 80) - 4);
         const cabeza = `  ${chalk.hex("#8B5CF6")("💭")} ${chalk.gray(`pensando… ${segundos}s`)}`;
         // La ultima frase a medias da una pista de por donde va sin contarlo todo.
         const pista = unaLinea(this.cola, Math.max(0, ancho - 24));
         const linea = pista ? `${cabeza} ${chalk.dim("·")} ${chalk.dim(pista)}` : cabeza;
-        process.stdout.write(`\r\x1b[2K${unaLinea(linea, ancho + 40)}`);
+        fijarSeccion("razonamiento", [linea]);
         this.lineaPintada = true;
     }
     flush() {
@@ -110,17 +117,20 @@ export class ReasoningStream {
             return;
         if (COMPLETO) {
             if (!this.atLineStart) {
-                process.stdout.write("\n");
+                escribirEncimaDelPie("\n");
                 this.atLineStart = true;
             }
-            process.stdout.write("\n");
+            escribirEncimaDelPie("\n");
             this.hasStarted = false;
             return;
         }
         const segundos = Math.max(1, Math.round((Date.now() - this.inicio) / 1000));
+        // Primero se quita la linea viva del pie y despues se escribe el resumen
+        // como texto permanente. Al reves, el resumen quedaria por encima de una
+        // linea de "pensando…" que ya no viene a cuento.
+        quitarSeccion("razonamiento");
         if (this.lineaPintada) {
-            // Se deja una sola linea de resumen donde estaba la que iba cambiando.
-            process.stdout.write(`\r\x1b[2K  ${chalk.hex("#8B5CF6")("💭")} ${chalk.gray(`pensó ${segundos}s`)}\n`);
+            escribirEncimaDelPie(`  ${chalk.hex("#8B5CF6")("💭")} ${chalk.gray(`pensó ${segundos}s`)}\n`);
         }
         this.lineaPintada = false;
         this.hasStarted = false;

package/dist/ui/spinner.d.ts

@@ -6,19 +6,26 @@ export declare class DynamicSpinner {
     private isRunning;
     private prefix;
     tokenCount: number;
-    /** Lineas extra pintadas debajo del spinner en el ultimo tick. */
-    private extraRows;
     constructor(prefix?: string);
     start(initialPrefix?: string): void;
     private tick;
     /**
-     * Segunda linea con lo que el usuario esta escribiendo mientras se genera.
+     * `✳ Compactando historial… (3s · ↓ 1.2k tokens · esc para pausar)   ⇥ modo`
      *
-     * Antes el teclado se tragaba todo sin pintar nada y parecia que el terminal
-     * se habia colgado. Se dibuja debajo y el cursor vuelve arriba, para que el
-     * siguiente tick sobrescriba las dos lineas sin dejar rastro.
+     * El prefijo se pasaba en `start("Compactando historial")` y no se pintaba en
+     * ningun sitio: `tick()` usaba siempre los verbos rotatorios. Asi que las
+     * cuatro esperas con nombre propio -compactar, optimizar memoria, verificar-
+     * salian todas como "Rumiando…", indistinguibles de una peticion normal.
      */
-    private drawTypeAhead;
-    private clearExtraRows;
+    private lineaDelSpinner;
+    /**
+     * La barra de escribir, debajo del spinner.
+     *
+     * Antes solo aparecia si ya habias escrito algo, asi que mientras el agente
+     * trabajaba no habia ninguna senal de que se pudiera escribir: el teclado es
+     * del vigilante y lo tecleado se acumulaba a ciegas. Ahora la barra esta
+     * siempre, y es la misma que se ve al escribir el prompt.
+     */
+    private lineasDeEntrada;
     stop(): void;
 }