chocolatito-code 1.4.2 → 1.5.0

package/dist/index.js

@@ -15,6 +15,7 @@ import { codigoDeSalida, EXIT_OK, EXIT_FALLO, EXIT_USO, EXIT_LICENCIA } from "./
 import { showBanner, animateStartupBanner, showHelp, showEffortMenu } from "./ui/banner.js";
 import { fijarMotor } from "./ui/motorActual.js";
 import { elegirDeLista } from "./ui/selector.js";
+import { entrarEnPantallaFija, pantallaFijaPedida } from "./ui/pantalla.js";
 import { reafirmarModoCrudo } from "./ui/keyboardGuard.js";
 import { askInteractivePrompt, SLASH_COMMANDS } from "./ui/prompt.js";
 import { changeDir } from "./tools/changeDir.js";
@@ -235,6 +236,11 @@ ${nodeViejo}
     const hookManager = new HookManager(context.cwd);
     const sessionManager = new SessionManager();
     const sessionId = `session_${Date.now()}`;
+    // La barra de abajo solo puede quedarse clavada si el programa toma la
+    // pantalla entera. Se pide con CHOCOLATITO_PANTALLA=fija y se paga con el
+    // historial del terminal: ver ui/pantalla.ts.
+    if (pantallaFijaPedida())
+        entrarEnPantallaFija();
     let currentModel = DEFAULT_ESPECTRO;
     // La barra de estado lo lee de aqui. Fijarlo al arrancar y no solo al
     // cambiarlo: si no, hasta el primer /effort la barra no dice nada.

package/dist/ui/historial.d.ts

@@ -0,0 +1,49 @@
+/**
+ * LO QUE HA SALIDO POR PANTALLA, GUARDADO EN MEMORIA
+ *
+ * POR QUE HACE FALTA
+ *
+ * En la pantalla normal el historial lo lleva el terminal: sale una línea, se va
+ * hacia arriba, y la rueda del ratón la recupera. Por eso la barra de abajo sube
+ * con el scroll: es una línea más del historial, no una capa encima.
+ *
+ * En la pantalla alternativa —la que usan vim o htop— el terminal NO guarda
+ * nada. A cambio, la barra se queda clavada de verdad. Pero si nadie recuerda lo
+ * que salió, la conversación desaparece en cuanto pasa de una pantalla, que sería
+ * mucho peor que el problema que se quiere resolver.
+ *
+ * Así que aquí se guarda. Es el precio de tener la barra fija: el historial deja
+ * de ser del terminal y pasa a ser nuestro.
+ *
+ * POR QUE SE GUARDA POR LÍNEAS Y NO EL FLUJO CRUDO
+ *
+ * Lo que llega trae códigos de color y a veces medio renglón sin terminar. Para
+ * poder pintar "las últimas N líneas" hay que saber dónde acaba cada una, así
+ * que se parte por saltos y el resto sin terminar se queda esperando al suyo.
+ * Los colores se conservan tal cual: recortarlos aquí sería pintar la
+ * conversación en gris.
+ */
+/** Añade lo que se acaba de escribir. Acepta trozos a medio renglón. */
+export declare function apuntar(texto: string): void;
+/**
+ * Todas las líneas, con el resto sin terminar como última.
+ *
+ * Se incluye a propósito: mientras el modelo escribe una frase larga, el resto
+ * ES lo que está saliendo. Ocultarlo hasta el salto haría que la respuesta
+ * apareciera a tirones, un renglón entero de golpe.
+ */
+export declare function todas(): string[];
+export declare function cuantas(): number;
+/** Se llama en cada escritura, para que quien pinte se entere. */
+export declare function alEscribir(cb: () => void): () => void;
+export declare function vaciar(): void;
+/**
+ * La ventana visible: `alto` líneas terminando `desdeElFinal` por encima del
+ * final.
+ *
+ * `desdeElFinal` es cuánto se ha subido con el scroll. Cero es el fondo, que es
+ * donde se está mientras se trabaja.
+ */
+export declare function ventana(alto: number, desdeElFinal?: number): string[];
+/** Cuánto se puede subir todavía. Sirve para no pasarse del principio. */
+export declare function tope(alto: number): number;

package/dist/ui/historial.js

@@ -0,0 +1,92 @@
+/**
+ * LO QUE HA SALIDO POR PANTALLA, GUARDADO EN MEMORIA
+ *
+ * POR QUE HACE FALTA
+ *
+ * En la pantalla normal el historial lo lleva el terminal: sale una línea, se va
+ * hacia arriba, y la rueda del ratón la recupera. Por eso la barra de abajo sube
+ * con el scroll: es una línea más del historial, no una capa encima.
+ *
+ * En la pantalla alternativa —la que usan vim o htop— el terminal NO guarda
+ * nada. A cambio, la barra se queda clavada de verdad. Pero si nadie recuerda lo
+ * que salió, la conversación desaparece en cuanto pasa de una pantalla, que sería
+ * mucho peor que el problema que se quiere resolver.
+ *
+ * Así que aquí se guarda. Es el precio de tener la barra fija: el historial deja
+ * de ser del terminal y pasa a ser nuestro.
+ *
+ * POR QUE SE GUARDA POR LÍNEAS Y NO EL FLUJO CRUDO
+ *
+ * Lo que llega trae códigos de color y a veces medio renglón sin terminar. Para
+ * poder pintar "las últimas N líneas" hay que saber dónde acaba cada una, así
+ * que se parte por saltos y el resto sin terminar se queda esperando al suyo.
+ * Los colores se conservan tal cual: recortarlos aquí sería pintar la
+ * conversación en gris.
+ */
+/** Tope de líneas recordadas. Más allá, se olvidan las de arriba. */
+const MAXIMO = Number(process.env.CHOCOLATITO_HISTORIAL_LINEAS || 5000);
+let lineas = [];
+let resto = "";
+const oyentes = [];
+/** Añade lo que se acaba de escribir. Acepta trozos a medio renglón. */
+export function apuntar(texto) {
+    if (!texto)
+        return;
+    const completo = resto + texto.replace(/\r\n/g, "\n");
+    const partes = completo.split("\n");
+    // El último trozo no lleva salto: todavía no es una línea terminada.
+    resto = partes.pop() ?? "";
+    for (const l of partes)
+        lineas.push(l);
+    if (lineas.length > MAXIMO)
+        lineas = lineas.slice(lineas.length - MAXIMO);
+    for (const cb of oyentes) {
+        try {
+            cb();
+        }
+        catch { }
+    }
+}
+/**
+ * Todas las líneas, con el resto sin terminar como última.
+ *
+ * Se incluye a propósito: mientras el modelo escribe una frase larga, el resto
+ * ES lo que está saliendo. Ocultarlo hasta el salto haría que la respuesta
+ * apareciera a tirones, un renglón entero de golpe.
+ */
+export function todas() {
+    return resto ? [...lineas, resto] : lineas;
+}
+export function cuantas() {
+    return todas().length;
+}
+/** Se llama en cada escritura, para que quien pinte se entere. */
+export function alEscribir(cb) {
+    oyentes.push(cb);
+    return () => {
+        const i = oyentes.indexOf(cb);
+        if (i >= 0)
+            oyentes.splice(i, 1);
+    };
+}
+export function vaciar() {
+    lineas = [];
+    resto = "";
+}
+/**
+ * La ventana visible: `alto` líneas terminando `desdeElFinal` por encima del
+ * final.
+ *
+ * `desdeElFinal` es cuánto se ha subido con el scroll. Cero es el fondo, que es
+ * donde se está mientras se trabaja.
+ */
+export function ventana(alto, desdeElFinal = 0) {
+    const todo = todas();
+    const fin = Math.max(0, todo.length - Math.max(0, desdeElFinal));
+    const inicio = Math.max(0, fin - Math.max(1, alto));
+    return todo.slice(inicio, fin);
+}
+/** Cuánto se puede subir todavía. Sirve para no pasarse del principio. */
+export function tope(alto) {
+    return Math.max(0, cuantas() - Math.max(1, alto));
+}

package/dist/ui/ink/Prompt.js

@@ -1,10 +1,12 @@
 import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
-import { useState, useMemo, useRef } from "react";
+import { useEffect, useMemo, useRef, useState } from "react";
 import { Box, Text, useApp, useInput, useStdout } from "ink";
 import { buildPromptFrame } from "../marco.js";
 import { cycleMode } from "../modes.js";
 import { aplicarOpcion, archivosDelProyecto, leerHistorial, mencionEnCurso, opcionesDelDesplegable, } from "../entrada.js";
 import { esGrande, guardarPegado, marcaQueTerminaEn } from "../pegados.js";
+import { alEscribir, tope, ventana } from "../historial.js";
+import { enPantallaFija } from "../pantalla.js";
 /** Marca del cursor. Ink esconde el de verdad, así que este se dibuja. */
 const CARET = "█";
 export function Prompt({ alEnviar, alCancelar, cwd, promptSymbol, avisos, }) {
@@ -13,8 +15,22 @@ export function Prompt({ alEnviar, alCancelar, cwd, promptSymbol, avisos, }) {
     const [texto, setTexto] = useState("");
     const [cursor, setCursor] = useState(0);
     const [elegido, setElegido] = useState(0);
+    /** Contador para forzar un dibujado cuando cambia algo de fuera de React. */
+    const [, setRedibujar] = useState(0);
     const historial = useRef(leerHistorial());
     const [posHistorial, setPosHistorial] = useState(historial.current.length);
+    // Cuanto se ha subido con Re Pag. Cero es el fondo, que es donde se esta
+    // mientras se trabaja. Solo se usa en pantalla fija.
+    const [subido, setSubido] = useState(0);
+    const fija = enPantallaFija();
+    // En pantalla fija el terminal ya no guarda nada: lo que sale lo pintamos
+    // nosotros, asi que hay que repintar en cada escritura del agente. El
+    // historial vive fuera de React y React no puede adivinar que ha crecido.
+    useEffect(() => {
+        if (!fija)
+            return;
+        return alEscribir(() => setRedibujar((n) => n + 1));
+    }, [fija]);
     // Se escanea UNA vez por prompt, no en cada tecla: recorrer el proyecto entero
     // por cada letra se nota en cuanto el proyecto pasa de mediano.
     const archivos = useMemo(() => {
@@ -27,6 +43,27 @@ export function Prompt({ alEnviar, alCancelar, cwd, promptSymbol, avisos, }) {
     }, [cwd]);
     const opciones = opcionesDelDesplegable(texto, cursor, archivos);
     const indice = opciones.length > 0 ? ((elegido % opciones.length) + opciones.length) % opciones.length : 0;
+    const cols = Math.max(20, stdout?.columns || 80);
+    const rows = stdout?.rows || 24;
+    // El cursor se dibuja: Ink esconde el del terminal.
+    const conCaret = texto.slice(0, cursor) + CARET + texto.slice(cursor);
+    const marco = buildPromptFrame({
+        cols,
+        rows,
+        promptSymbol,
+        input: conCaret,
+        cursorIndex: cursor,
+        items: opciones,
+        selectedIndex: indice,
+    });
+    // Filas que le quedan a la conversacion una vez puesta la barra. En pantalla
+    // fija es lo que se pinta; en la normal no se usa, que ahi el historial es del
+    // terminal.
+    // Cuando se ha subido, una fila se va en el aviso de que se esta mirando
+    // atras. Sin descontarla, el arbol mide una fila mas que la ventana y el
+    // terminal desplaza: la barra dejaria de estar clavada justo al usar el scroll,
+    // que es para lo que existe este modo.
+    const altoDelTexto = Math.max(1, rows - marco.lines.length - (subido > 0 ? 1 : 0));
     function enviar() {
         const orden = texto.trim();
         if (!orden)
@@ -35,6 +72,15 @@ export function Prompt({ alEnviar, alCancelar, cwd, promptSymbol, avisos, }) {
         exit();
     }
     useInput((entrada, tecla) => {
+        // ----------------------------------------------- recorrer lo que salio
+        //
+        // Solo Re Pag y Av Pag. Las flechas y los caracteres son para escribir:
+        // robarselos aqui dejaria al usuario sin poder teclear.
+        if (fija && (tecla.pageUp || tecla.pageDown)) {
+            const salto = Math.max(1, Math.floor(altoDelTexto / 2));
+            setSubido((n) => tecla.pageUp ? Math.min(tope(altoDelTexto), n + salto) : Math.max(0, n - salto));
+            return;
+        }
         // ------------------------------------------------------------- salir
         if (tecla.ctrl && entrada === "c") {
             alCancelar();
@@ -44,6 +90,11 @@ export function Prompt({ alEnviar, alCancelar, cwd, promptSymbol, avisos, }) {
         // ------------------------------------------- cambiar el modo de permisos
         if (tecla.tab && tecla.shift) {
             cycleMode();
+            // El modo NO vive en el estado de React: lo guarda modes.ts, que lo
+            // comparten el prompt, el vigilante de teclas y el dialogo de permisos.
+            // Sin este empujon, React no tiene motivo para volver a dibujar y la barra
+            // se queda anunciando el modo anterior mientras el de verdad ya cambio.
+            setRedibujar((n) => n + 1);
             return;
         }
         // ------------------------------------------------------------- enviar
@@ -164,18 +215,14 @@ export function Prompt({ alEnviar, alCancelar, cwd, promptSymbol, avisos, }) {
             setElegido(0);
         }
     });
-    const cols = Math.max(20, stdout?.columns || 80);
-    const rows = stdout?.rows || 24;
-    // El cursor se dibuja: Ink esconde el del terminal.
-    const conCaret = texto.slice(0, cursor) + CARET + texto.slice(cursor);
-    const marco = buildPromptFrame({
-        cols,
-        rows,
-        promptSymbol,
-        input: conCaret,
-        cursorIndex: cursor,
-        items: opciones,
-        selectedIndex: indice,
-    });
-    return (_jsxs(Box, { flexDirection: "column", children: [avisos.map((a, i) => (_jsx(Text, { children: a }, `aviso-${i}`))), marco.lines.map((linea, i) => (_jsx(Text, { children: linea }, i)))] }));
+    if (!fija) {
+        return (_jsxs(Box, { flexDirection: "column", children: [avisos.map((a, i) => (_jsx(Text, { children: a }, `aviso-${i}`))), marco.lines.map((linea, i) => (_jsx(Text, { children: linea }, i)))] }));
+    }
+    // PANTALLA FIJA: el arbol ocupa la ventana entera y la barra va la ultima, asi
+    // que no puede moverse. Lo de arriba se rellena con huecos cuando hay poca
+    // conversacion; sin eso la barra subiria a media pantalla, que es justo la
+    // queja que este modo viene a resolver.
+    const visible = ventana(altoDelTexto, subido);
+    const huecos = Math.max(0, altoDelTexto - visible.length);
+    return (_jsxs(Box, { flexDirection: "column", height: rows, children: [Array.from({ length: huecos }, (_, i) => (_jsx(Text, { children: " " }, `hueco-${i}`))), visible.map((linea, i) => (_jsx(Text, { children: linea }, `h-${i}`))), subido > 0 && (_jsx(Text, { dimColor: true, children: `  ↑ ${subido} lineas mas arriba · Av Pag para volver al final` })), marco.lines.map((linea, i) => (_jsx(Text, { children: linea }, `b-${i}`)))] }));
 }

package/dist/ui/ink/montarPrompt.js

@@ -90,6 +90,22 @@ export async function preguntarConInk(promptSymbol = "❯", cwd = process.cwd())
         instancia.waitUntilExit().then(() => {
             escribirTardio = null;
             limpiarPegados();
+            // EL PROGRAMA SE CERRABA SOLO AL ELEGIR /effort
+            //
+            // Ink desreferencia stdin al desmontarse (stdin.unref) para no dejar el
+            // proceso vivo por una entrada que ya nadie escucha. Muy razonable... pero
+            // lo que viene DESPUES del prompt tambien lee el teclado: el menu de
+            // /effort, el dialogo de permisos. Con stdin sin referencia, esos se
+            // quedan esperando una tecla mientras Node ve el bucle de eventos vacio y
+            // se cierra.
+            //
+            // Visto por el usuario: escribia "/efor", pulsaba Enter sobre la
+            // recomendacion, y Chocolatito desaparecia dejandolo en la ruta de la
+            // consola. Ni error ni despedida: como si nunca hubiera estado.
+            //
+            // Se vuelve a referenciar aqui, que es el punto por el que se pasa SIEMPRE
+            // al cerrar el prompt, venga la orden de donde venga.
+            process.stdin.ref?.();
             // Si el árbol muere sin haber entregado nada -una excepción, un Ctrl+C
             // del sistema-, la promesa no puede quedarse colgada: el bucle se
             // detendría para siempre sin decir por qué.

package/dist/ui/pantalla.d.ts

@@ -0,0 +1,19 @@
+export declare function pantallaFijaPedida(): boolean;
+/**
+ * Enciende o apaga el modo a mano, SIN tocar el terminal.
+ *
+ * Las pruebas lo necesitan: entrar de verdad escribiria la secuencia de la
+ * pantalla alternativa en la consola de quien corre las pruebas y le dejaria el
+ * informe en una pantalla que desaparece al acabar.
+ */
+export declare function forzarPantallaFija(valor: boolean | null): void;
+export declare function enPantallaFija(): boolean;
+export declare function entrarEnPantallaFija(): void;
+/**
+ * Devuelve el terminal como estaba.
+ *
+ * Se llama al salir del programa, y también si algo revienta: quedarse en la
+ * pantalla alternativa deja al usuario en una consola en blanco sin su prompt,
+ * y la única salida es cerrar la ventana.
+ */
+export declare function salirDePantallaFija(): void;

package/dist/ui/pantalla.js

@@ -0,0 +1,84 @@
+import process from "node:process";
+import { redirigirDibujo } from "./salida.js";
+import { apuntar } from "./historial.js";
+/**
+ * LA PANTALLA ALTERNATIVA
+ *
+ * La barra de abajo sube al hacer scroll porque ES una línea del historial del
+ * terminal, no una capa encima. Ninguna secuencia de escape la clava ahí; lo
+ * único que lo consigue es que el programa tome la pantalla entera, como hacen
+ * vim o htop.
+ *
+ * QUÉ CAMBIA AL ENTRAR
+ *
+ * El terminal deja de guardar historial: la rueda del ratón no sirve y al salir
+ * la sesión desaparece de la consola. Por eso, mientras dura, TODO lo que se
+ * imprime se guarda en memoria (historial.ts) y lo pinta el árbol de Ink.
+ *
+ * Y por eso hay que interceptar también `console.log`. Aquí no vale con desviar
+ * el conducto de dibujo: media docena de sitios —el arranque, la licencia, los
+ * avisos— siguen imprimiendo directo, y en la pantalla alternativa eso escribe
+ * encima de lo que Ink acaba de dibujar y descuadra el árbol entero.
+ *
+ * ES UN MODO, NO EL COMPORTAMIENTO NORMAL
+ *
+ * Cambiar el historial del terminal por uno propio es un intercambio de verdad,
+ * no una mejora: quien use mucho la rueda del ratón para releer sale perdiendo.
+ * Se activa con CHOCOLATITO_PANTALLA=fija.
+ */
+const ENTRAR = "\x1b[?1049h";
+const SALIR = "\x1b[?1049l";
+let dentro = false;
+let logOriginal = null;
+export function pantallaFijaPedida() {
+    return process.env.CHOCOLATITO_PANTALLA === "fija";
+}
+/** `null` = manda el estado real. Las pruebas lo fuerzan. */
+let forzado = null;
+/**
+ * Enciende o apaga el modo a mano, SIN tocar el terminal.
+ *
+ * Las pruebas lo necesitan: entrar de verdad escribiria la secuencia de la
+ * pantalla alternativa en la consola de quien corre las pruebas y le dejaria el
+ * informe en una pantalla que desaparece al acabar.
+ */
+export function forzarPantallaFija(valor) {
+    forzado = valor;
+}
+export function enPantallaFija() {
+    return forzado ?? dentro;
+}
+export function entrarEnPantallaFija() {
+    if (dentro || !process.stdout.isTTY)
+        return;
+    dentro = true;
+    process.stdout.write(ENTRAR);
+    // Lo que se dibujaba en el terminal pasa a ser historial nuestro.
+    redirigirDibujo((texto) => apuntar(texto));
+    logOriginal = console.log;
+    console.log = (...args) => {
+        apuntar(args.map((a) => (typeof a === "string" ? a : String(a))).join(" ") + "\n");
+    };
+}
+/**
+ * Devuelve el terminal como estaba.
+ *
+ * Se llama al salir del programa, y también si algo revienta: quedarse en la
+ * pantalla alternativa deja al usuario en una consola en blanco sin su prompt,
+ * y la única salida es cerrar la ventana.
+ */
+export function salirDePantallaFija() {
+    if (!dentro)
+        return;
+    dentro = false;
+    if (logOriginal) {
+        console.log = logOriginal;
+        logOriginal = null;
+    }
+    redirigirDibujo(null);
+    try {
+        process.stdout.write(SALIR);
+    }
+    catch { }
+}
+process.on("exit", salirDePantallaFija);

package/dist/ui/selector.js

@@ -24,6 +24,16 @@ export async function elegirDeLista(titulo, opciones, indiceInicial = 0) {
         if (process.stdin.setRawMode)
             process.stdin.setRawMode(true);
         process.stdin.resume();
+        // Y referenciado, no solo reanudado. Son cosas distintas: `resume` hace que
+        // lleguen los datos, `ref` hace que Node considere que hay trabajo
+        // pendiente. Sin lo segundo, este menu se queda esperando una tecla
+        // mientras el proceso ve el bucle de eventos vacio y se cierra solo.
+        //
+        // No es hipotetico: paso justo aqui. Ink desreferencia stdin al desmontar el
+        // prompt, y al abrir este menu Chocolatito desaparecia dejando al usuario en
+        // la ruta de la consola. Se arreglo tambien alli, pero este menu no tiene
+        // por que depender de quien haya corrido antes.
+        process.stdin.ref?.();
         /** Filas del ultimo dibujo. Se repinta encima, sin dejar restos. */
         let filas = 0;
         function pintar() {

package/extension/manifest.json

@@ -2,7 +2,7 @@
   "manifest_version": 3,
   "minimum_chrome_version": "102",
   "name": "Chocolatito Code",
-  "version": "1.4.2",
+  "version": "1.5.0",
   "description": "Deja que Chocolatito Code trabaje dentro de tu Chrome, en segundo plano y con tus sesiones ya iniciadas.",
   "permissions": [
     "tabs",

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "chocolatito-code",
-  "version": "1.4.2",
+  "version": "1.5.0",
   "description": "Agente autónomo de programación para la terminal, con control real del ordenador y del navegador. Desarrollado por Chocolatito.",
   "type": "module",
   "bin": {