chocolatito-code 1.3.4 → 1.4.3

package/dist/config/license.js

@@ -4,6 +4,7 @@ import path from "node:path";
 import readline from "node:readline";
 import chalk from "chalk";
 import { getGlobalConfigPath } from "./env.js";
+import { CONFIG_FILE_NAME } from "./constants.js";
 /**
  * LICENCIAS
  *
@@ -365,9 +366,10 @@ export async function ensureLicense() {
     if (res.kind === "ok")
         return true;
     if (res.kind === "rejected") {
-        // Respuesta clara de Lemon Squeezy: se corta ya.
+        // Respuesta clara de Lemon Squeezy: esta clave ya no vale. Pero eso NO es
+        // motivo para cerrarle la puerta al que acaba de comprar otra.
         console.log(chalk.red(`\n✖ ${res.reason}\n`));
-        return false;
+        return pedirClaveDeRecambio();
     }
     // No se pudo preguntar. Aqui es donde importa no castigar al cliente por una
     // caida que no es suya.
@@ -382,6 +384,56 @@ export async function ensureLicense() {
         chalk.gray("\n  Conéctate a internet una vez para reanudarla.\n"));
     return false;
 }
+/**
+ * LA PUERTA QUE SE CERRABA POR DENTRO
+ *
+ * Cuando la clave guardada dejaba de valer, esto imprimía el motivo y devolvía
+ * `false`. El programa se cerraba y no volvía a preguntar NUNCA: al arrancar de
+ * nuevo encontraba la misma clave guardada, la volvía a rechazar y se volvía a
+ * cerrar. La única salida era borrar a mano ~/.chocolatitorc, un archivo oculto
+ * que ningún cliente sabe que existe.
+ *
+ * Le pasó al dueño en su propio portátil, que es la peor forma de enterarse: lo
+ * tenía instalado con una licencia de MODO PRUEBA de Lemon Squeezy, compró la
+ * suscripción de verdad, y no hubo manera de meter la clave nueva. Desde fuera
+ * se ve como "compré y no funciona", que es exactamente el momento en que un
+ * cliente pide la devolución.
+ *
+ * Y no hace falta que sea una prueba: pasa igual con una suscripción que caducó
+ * y se renovó, con un equipo liberado desde el panel, o con un reembolso
+ * seguido de una compra nueva.
+ *
+ * Ahora se ofrece meter otra clave ahí mismo. Sin terminal delante —un script,
+ * una tubería— al menos se dice DÓNDE está el archivo, que es lo único
+ * accionable en ese caso.
+ */
+async function pedirClaveDeRecambio() {
+    const donde = path.join(os.homedir(), CONFIG_FILE_NAME);
+    if (!process.stdin.isTTY) {
+        console.log(chalk.gray(`  La clave guardada está en ${donde}.`) +
+            chalk.gray("\n  Bórrala y ejecuta 'chocolatito' en una terminal para introducir la nueva.\n"));
+        return false;
+    }
+    console.log(chalk.gray("  Si has comprado una suscripción nueva, pega aquí su clave y se cambia.") +
+        chalk.gray(`\n  (Enter en blanco para salir. La anterior está guardada en ${donde}.)\n`));
+    const clave = await pedirClave();
+    if (!clave) {
+        console.log(chalk.gray("\n  No se introdujo ninguna clave.\n"));
+        return false;
+    }
+    const nueva = await activate(clave);
+    if (nueva.kind === "ok") {
+        console.log(chalk.green(`\n✔ Licencia activada${nueva.license.customerEmail ? ` para ${nueva.license.customerEmail}` : ""}.\n`));
+        return true;
+    }
+    // Un solo intento. Encadenar preguntas hasta acertar convierte un fallo de
+    // conexión en un bucle del que no se sale con Ctrl+C limpio.
+    const motivo = nueva.kind === "rejected" || nueva.kind === "unpersisted"
+        ? nueva.reason
+        : `No se pudo activar (${nueva.reason}).`;
+    console.log(chalk.red(`\n✖ ${motivo}\n`));
+    return false;
+}
 /** Texto del comando /licencia. */
 export function licenseStatus() {
     const l = getStoredLicense();

package/dist/ui/banner.js

@@ -123,7 +123,8 @@ export const FILAS_MINIMAS_PARA_ANCLAR = 16;
  * Filas que se imprimen DESPUES del banner y hay que dejarles sitio.
  *
  * Son el aviso del atajo (su texto ya trae un salto dentro, mas el que anade
- * console.log: 2 filas) y el marco del prompt (barra, entrada, barra, estado: 4).
+ * console.log: 2 filas) y el marco del prompt, que son cinco: una de aire y
+ * despues barra, entrada, barra y estado.
  *
  * AQUI ESTABA EL FALLO DEL ZORRO CORTADO
  *
@@ -132,7 +133,7 @@ export const FILAS_MINIMAS_PARA_ANCLAR = 16;
  * arriba la cabeza del zorro. El usuario lo vio en cuanto abrio: "hay mucho
  * espacio y se baja y se corta el zorrito al iniciar".
  */
-const FILAS_DESPUES_DEL_BANNER = 6;
+const FILAS_DESPUES_DEL_BANNER = 7;
 /**
  * Filas en blanco que hay que soltar ANTES de `contenido` para que el prompt
  * acabe pegado al fondo de la ventana. Cero si no cabe o no hace falta.

package/dist/ui/entrada.d.ts

@@ -0,0 +1,41 @@
+import type { DropdownItem } from "./marco.js";
+/**
+ * LA LÓGICA DEL PROMPT, SIN TERMINAL DELANTE
+ *
+ * Todo esto vivía dentro del closure de `askInteractivePrompt`, mezclado con el
+ * dibujo, el modo crudo y el oyente de teclas. Mientras hubo una sola forma de
+ * pintar el prompt eso daba igual; con dos —la de siempre y la de Ink— habría
+ * significado escribir dos veces el autocompletado, el historial y la detección
+ * de menciones, y que se separaran al primer arreglo.
+ *
+ * Aquí no hay nada que sepa de terminales: entra texto y una posición de
+ * cursor, sale qué ofrecer. Por eso se puede comprobar sin abrir nada.
+ */
+/** Una arroba a medio escribir justo antes del cursor. */
+export declare function mencionEnCurso(texto: string, cursor: number): {
+    activa: boolean;
+    consulta: string;
+    desde: number;
+};
+/**
+ * Archivos del proyecto para el autocompletado de "@".
+ *
+ * Tope de resultados y de profundidad a propósito: esto corre en cada
+ * pulsación, y recorrer un monorepo entero por cada letra se nota.
+ */
+export declare function archivosDelProyecto(dir: string, maximo?: number): string[];
+/** Lo que se ofrece debajo de la entrada, o nada si no toca ofrecer. */
+export declare function opcionesDelDesplegable(texto: string, cursor: number, archivos: string[]): DropdownItem[];
+/**
+ * Aplica la opción elegida. Devuelve el texto y el cursor nuevos, o `null` si
+ * no había nada que aplicar.
+ *
+ * Devuelve valores en vez de mutar: así el componente de Ink puede meterlo en
+ * su estado sin que nada cambie a sus espaldas entre dos dibujados.
+ */
+export declare function aplicarOpcion(texto: string, cursor: number, opcion: DropdownItem | undefined): {
+    texto: string;
+    cursor: number;
+} | null;
+export declare function leerHistorial(): string[];
+export declare function apuntarEnHistorial(orden: string): void;

package/dist/ui/entrada.js

@@ -0,0 +1,143 @@
+import fs from "node:fs";
+import path from "node:path";
+import os from "node:os";
+import { SLASH_COMMANDS } from "./comandos.js";
+/**
+ * LA LÓGICA DEL PROMPT, SIN TERMINAL DELANTE
+ *
+ * Todo esto vivía dentro del closure de `askInteractivePrompt`, mezclado con el
+ * dibujo, el modo crudo y el oyente de teclas. Mientras hubo una sola forma de
+ * pintar el prompt eso daba igual; con dos —la de siempre y la de Ink— habría
+ * significado escribir dos veces el autocompletado, el historial y la detección
+ * de menciones, y que se separaran al primer arreglo.
+ *
+ * Aquí no hay nada que sepa de terminales: entra texto y una posición de
+ * cursor, sale qué ofrecer. Por eso se puede comprobar sin abrir nada.
+ */
+/** Una arroba a medio escribir justo antes del cursor. */
+export function mencionEnCurso(texto, cursor) {
+    const antes = texto.slice(0, cursor);
+    const m = antes.match(/@([^\s]*)$/);
+    if (m && m.index !== undefined) {
+        return { activa: true, consulta: m[1].toLowerCase(), desde: m.index };
+    }
+    return { activa: false, consulta: "", desde: -1 };
+}
+/**
+ * Archivos del proyecto para el autocompletado de "@".
+ *
+ * Tope de resultados y de profundidad a propósito: esto corre en cada
+ * pulsación, y recorrer un monorepo entero por cada letra se nota.
+ */
+export function archivosDelProyecto(dir, maximo = 40) {
+    const encontrados = [];
+    const ignorar = new Set([
+        "node_modules",
+        ".git",
+        "dist",
+        "build",
+        ".next",
+        "out",
+        "venv",
+        "__pycache__",
+        ".turbo",
+    ]);
+    function recorrer(actual, hondo = 0) {
+        if (hondo > 6 || encontrados.length >= maximo)
+            return;
+        try {
+            for (const ent of fs.readdirSync(actual, { withFileTypes: true })) {
+                if (ent.name.startsWith(".") && ent.name !== ".env")
+                    continue;
+                if (ignorar.has(ent.name))
+                    continue;
+                const completo = path.join(actual, ent.name);
+                if (ent.isDirectory()) {
+                    recorrer(completo, hondo + 1);
+                }
+                else if (ent.isFile()) {
+                    encontrados.push(path.relative(dir, completo).replace(/\\/g, "/"));
+                    if (encontrados.length >= maximo)
+                        break;
+                }
+            }
+        }
+        catch { }
+    }
+    recorrer(dir);
+    return encontrados;
+}
+/** Lo que se ofrece debajo de la entrada, o nada si no toca ofrecer. */
+export function opcionesDelDesplegable(texto, cursor, archivos) {
+    if (texto.startsWith("/")) {
+        const consulta = texto.toLowerCase();
+        return SLASH_COMMANDS.filter((c) => c.name.toLowerCase().startsWith(consulta) || consulta === "/").map((c) => ({
+            type: "command",
+            label: `${c.name}${c.args ? " " + c.args : ""}`,
+            secondary: c.description,
+            insertText: c.name,
+        }));
+    }
+    const arroba = mencionEnCurso(texto, cursor);
+    if (arroba.activa) {
+        return archivos
+            .filter((f) => f.toLowerCase().includes(arroba.consulta))
+            .slice(0, 8)
+            .map((f) => ({
+            type: "file",
+            label: f,
+            secondary: "Archivo del proyecto",
+            insertText: `@${f} `,
+        }));
+    }
+    return [];
+}
+/**
+ * Aplica la opción elegida. Devuelve el texto y el cursor nuevos, o `null` si
+ * no había nada que aplicar.
+ *
+ * Devuelve valores en vez de mutar: así el componente de Ink puede meterlo en
+ * su estado sin que nada cambie a sus espaldas entre dos dibujados.
+ */
+export function aplicarOpcion(texto, cursor, opcion) {
+    if (!opcion)
+        return null;
+    if (opcion.type === "command") {
+        return { texto: opcion.insertText, cursor: opcion.insertText.length };
+    }
+    const arroba = mencionEnCurso(texto, cursor);
+    if (!arroba.activa)
+        return null;
+    const nuevo = texto.slice(0, arroba.desde) + opcion.insertText + texto.slice(cursor);
+    return { texto: nuevo, cursor: arroba.desde + opcion.insertText.length };
+}
+// ------------------------------------------------------------------ historial
+function archivoDeHistorial() {
+    const dir = path.join(os.homedir(), ".chocolatito");
+    if (!fs.existsSync(dir))
+        fs.mkdirSync(dir, { recursive: true });
+    return path.join(dir, "history");
+}
+export function leerHistorial() {
+    try {
+        const f = archivoDeHistorial();
+        if (!fs.existsSync(f))
+            return [];
+        return fs
+            .readFileSync(f, "utf-8")
+            .split("\n")
+            .filter((l) => l.trim().length > 0);
+    }
+    catch {
+        // Un historial ilegible no puede impedir escribir: se sigue sin él.
+        return [];
+    }
+}
+export function apuntarEnHistorial(orden) {
+    if (!orden.trim())
+        return;
+    try {
+        fs.appendFileSync(archivoDeHistorial(), `${orden.trim()}\n`, "utf-8");
+    }
+    catch { }
+}

package/dist/ui/ink/Prompt.d.ts

@@ -0,0 +1,42 @@
+import React from "react";
+/**
+ * EL PROMPT, DIBUJADO POR INK
+ *
+ * POR QUE SE CAMBIÓ
+ *
+ * La versión de siempre lo hacía todo a mano: pedía el modo crudo, escuchaba
+ * `keypress` de readline, contaba filas físicas, subía el cursor con `\x1b[nA` y
+ * repintaba. Funcionaba, pero cada arreglo destapaba otro agujero —el marco que
+ * bajaba una fila por pulsación, el cursor detrás del acento, el teclado que se
+ * quedaba en modo cocido después de un hijo—, y todos eran del MISMO tipo:
+ * llevar a mano una cuenta que el terminal también lleva.
+ *
+ * Ink se queda con esa parte. El modo crudo lo pide y lo devuelve él, con cuenta
+ * de referencias, y al desmontar lo restaura pase lo que pase. El repintado lo
+ * hace por diferencias, así que no hay filas que contar.
+ *
+ * LO QUE NO CAMBIA, Y ES DELIBERADO
+ *
+ * El aspecto sale del MISMO `buildPromptFrame` de antes. No se ha reescrito el
+ * marco en cajas de Ink: se pinta la lista de líneas que ya devolvía. Así el
+ * cambio no puede alterar ni una columna de lo que se ve, y las pruebas del
+ * marco —anchos, recortes, el modo a la izquierda, el motor a la derecha— siguen
+ * valiendo como red mientras se cambia lo de debajo.
+ *
+ * EL CURSOR
+ *
+ * Ink no mueve el cursor del terminal: lo esconde. Por eso el cursor se pinta
+ * como un carácter más dentro del texto, igual que ya se hacía en la barra
+ * mientras el agente trabaja.
+ */
+export interface PromptProps {
+    /** Se llama UNA vez, con la orden ya expandida. */
+    alEnviar: (orden: string) => void;
+    /** Ctrl+C: cerrar la sesión. */
+    alCancelar: () => void;
+    cwd: string;
+    promptSymbol: string;
+    /** Mensajes que llegaron tarde y hay que dejar por encima del marco. */
+    avisos: string[];
+}
+export declare function Prompt({ alEnviar, alCancelar, cwd, promptSymbol, avisos, }: PromptProps): React.ReactElement;

package/dist/ui/ink/Prompt.js

@@ -0,0 +1,188 @@
+import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
+import { useState, useMemo, useRef } 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";
+/** Marca del cursor. Ink esconde el de verdad, así que este se dibuja. */
+const CARET = "█";
+export function Prompt({ alEnviar, alCancelar, cwd, promptSymbol, avisos, }) {
+    const { stdout } = useStdout();
+    const { exit } = useApp();
+    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);
+    // 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(() => {
+        try {
+            return archivosDelProyecto(cwd);
+        }
+        catch {
+            return [];
+        }
+    }, [cwd]);
+    const opciones = opcionesDelDesplegable(texto, cursor, archivos);
+    const indice = opciones.length > 0 ? ((elegido % opciones.length) + opciones.length) % opciones.length : 0;
+    function enviar() {
+        const orden = texto.trim();
+        if (!orden)
+            return;
+        alEnviar(orden);
+        exit();
+    }
+    useInput((entrada, tecla) => {
+        // ------------------------------------------------------------- salir
+        if (tecla.ctrl && entrada === "c") {
+            alCancelar();
+            exit();
+            return;
+        }
+        // ------------------------------------------- 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
+        if (tecla.return) {
+            // La continuación con barra invertida mete un salto de verdad.
+            if (texto.endsWith("\\")) {
+                setTexto(texto.slice(0, -1) + "\n");
+                setCursor(texto.length);
+                return;
+            }
+            // El desplegable manda sobre lo tecleado: si en pantalla está señalado
+            // "/effort" y has escrito "/e", se envía lo que se ve. Ver la nota larga
+            // en la versión de siempre; esto es el mismo criterio.
+            const arroba = mencionEnCurso(texto, cursor).activa;
+            const escribiendoComando = texto.startsWith("/") && !texto.includes(" ");
+            const soloLaBarra = texto === "/";
+            if (opciones.length > 0 && (escribiendoComando || arroba)) {
+                const opcion = opciones[indice];
+                const yaEntero = Boolean(opcion) && texto === opcion.insertText;
+                if (!yaEntero) {
+                    const aplicado = aplicarOpcion(texto, cursor, opcion);
+                    if (aplicado) {
+                        setTexto(aplicado.texto);
+                        setCursor(aplicado.cursor);
+                        setElegido(0);
+                        // Una mención lleva más texto detrás; con solo "/" no has elegido
+                        // nada todavía. En los dos casos se completa y se espera.
+                        if (arroba || soloLaBarra)
+                            return;
+                        alEnviar(aplicado.texto.trim());
+                        exit();
+                        return;
+                    }
+                }
+            }
+            enviar();
+            return;
+        }
+        // ------------------------------------------------------- autocompletar
+        if (tecla.tab && opciones.length > 0) {
+            const aplicado = aplicarOpcion(texto, cursor, opciones[indice]);
+            if (aplicado) {
+                setTexto(aplicado.texto);
+                setCursor(aplicado.cursor);
+                setElegido(0);
+            }
+            return;
+        }
+        // ------------------------------------------------ moverse por la lista
+        if (tecla.upArrow) {
+            if (opciones.length > 0) {
+                setElegido(indice - 1);
+                return;
+            }
+            if (historial.current.length > 0 && posHistorial > 0) {
+                const nueva = posHistorial - 1;
+                setPosHistorial(nueva);
+                const linea = historial.current[nueva] || "";
+                setTexto(linea);
+                setCursor(linea.length);
+            }
+            return;
+        }
+        if (tecla.downArrow) {
+            if (opciones.length > 0) {
+                setElegido(indice + 1);
+                return;
+            }
+            if (posHistorial < historial.current.length - 1) {
+                const nueva = posHistorial + 1;
+                setPosHistorial(nueva);
+                const linea = historial.current[nueva] || "";
+                setTexto(linea);
+                setCursor(linea.length);
+            }
+            else if (posHistorial === historial.current.length - 1) {
+                // Bajar desde la última deja la línea en blanco, que es de donde se
+                // había salido al empezar a navegar.
+                setPosHistorial(historial.current.length);
+                setTexto("");
+                setCursor(0);
+            }
+            return;
+        }
+        // ------------------------------------------------- moverse por el texto
+        if (tecla.leftArrow) {
+            setCursor(Math.max(0, cursor - 1));
+            return;
+        }
+        if (tecla.rightArrow) {
+            setCursor(Math.min(texto.length, cursor + 1));
+            return;
+        }
+        // --------------------------------------------------------------- borrar
+        if (tecla.backspace || tecla.delete) {
+            if (cursor === 0)
+                return;
+            // Una marca de pegado se borra ENTERA. Dejar "[pegado #1 · 347 line" a
+            // medias no significa nada y al enviar se expandiría a la nada.
+            const marca = marcaQueTerminaEn(texto, cursor);
+            const cuantos = marca ? cursor - marca.inicio : 1;
+            setTexto(texto.slice(0, cursor - cuantos) + texto.slice(cursor));
+            setCursor(cursor - cuantos);
+            setElegido(0);
+            return;
+        }
+        // ---------------------------------------------------------------- texto
+        //
+        // Ink entrega el pegado como UN solo trozo, así que aquí no hace falta nada
+        // del baile de antes con el modo de pegado entre corchetes ni con esperar
+        // al siguiente tick para saber si el Enter era un salto del pegado: si
+        // llegan varias líneas juntas, es un pegado y punto.
+        if (entrada && !tecla.ctrl && !tecla.meta) {
+            const limpio = entrada.replace(/\r\n?/g, "\n");
+            const trozo = esGrande(limpio) ? guardarPegado(limpio) : limpio;
+            setTexto(texto.slice(0, cursor) + trozo + texto.slice(cursor));
+            setCursor(cursor + trozo.length);
+            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)))] }));
+}

package/dist/ui/ink/montarPrompt.d.ts

@@ -0,0 +1,10 @@
+/**
+ * Pide una orden al usuario. Misma firma que la versión de siempre.
+ *
+ * Devuelve el texto ya expandido: las marcas de pegado vuelven a ser el texto
+ * entero antes de que nadie lo vea, porque lo que el modelo tiene que recibir es
+ * lo que el usuario pegó, no "[pegado #1 · 347 lineas]".
+ */
+export declare function preguntarConInk(promptSymbol?: string, cwd?: string): Promise<string>;
+export declare function hayPromptDeInk(): boolean;
+export declare function avisarSobreElPromptDeInk(texto: string): void;

package/dist/ui/ink/montarPrompt.js

@@ -0,0 +1,129 @@
+import { jsx as _jsx } from "react/jsx-runtime";
+import { useEffect, useState } from "react";
+import process from "node:process";
+import { render } from "ink";
+import { Prompt } from "./Prompt.js";
+import { expandirPegados, limpiarPegados } from "../pegados.js";
+import { apuntarEnHistorial } from "../entrada.js";
+import { soltarPie } from "../pieFijo.js";
+import { clearTyped } from "../typeAhead.js";
+/**
+ * EL PUENTE ENTRE INK Y EL BUCLE DE SIEMPRE
+ *
+ * El programa es un `while` que espera una orden: `const orden = await
+ * askInteractivePrompt()`. Ink, en cambio, es un árbol que se monta y vive.
+ *
+ * Aquí se casan las dos formas: se monta Ink, se espera a que el componente
+ * diga que hay orden, se desmonta y se resuelve la promesa. Para el bucle no ha
+ * cambiado nada —sigue habiendo una función que devuelve un texto— y por eso
+ * este cambio no toca index.ts ni una línea.
+ *
+ * POR QUE SE MONTA Y SE DESMONTA EN CADA VUELTA
+ *
+ * Podría quedarse montado toda la sesión, pero entonces Ink tendría que ser
+ * dueño TAMBIÉN de todo lo que el agente imprime mientras trabaja: las
+ * herramientas, el markdown, el pie. Eso es el resto de la mudanza, no ésta.
+ * Montando por vuelta, Ink manda solo mientras se escribe —que es donde estaban
+ * los fallos— y suelta el terminal en cuanto empieza el turno.
+ *
+ * El desmontaje devuelve el modo del teclado con su propia cuenta de
+ * referencias. Es justamente lo que aquí se llevaba a mano y fallaba.
+ */
+/** Lo que se teclea mientras el agente trabaja; aquí ya no vale. */
+function limpiarRestos() {
+    clearTyped();
+    limpiarPegados();
+}
+/**
+ * Envuelve al prompt para que los mensajes que llegan tarde sean estado de
+ * React y no escrituras sueltas a stdout.
+ *
+ * Sin esto, un servidor MCP que termina de conectarse a destiempo escribiría
+ * justo encima del marco: Ink no se entera de lo que no pasa por su árbol, y en
+ * el siguiente dibujado la cuenta de filas ya no cuadra.
+ */
+function Anfitrion({ cwd, promptSymbol, resolver, cancelar, registrarAviso, }) {
+    const [avisos, setAvisos] = useState([]);
+    useEffect(() => {
+        registrarAviso((texto) => {
+            setAvisos((previos) => [...previos, texto.replace(/\n$/, "")]);
+        });
+    }, [registrarAviso]);
+    return (_jsx(Prompt, { alEnviar: resolver, alCancelar: cancelar, cwd: cwd, promptSymbol: promptSymbol, avisos: avisos }));
+}
+/**
+ * Pide una orden al usuario. Misma firma que la versión de siempre.
+ *
+ * Devuelve el texto ya expandido: las marcas de pegado vuelven a ser el texto
+ * entero antes de que nadie lo vea, porque lo que el modelo tiene que recibir es
+ * lo que el usuario pegó, no "[pegado #1 · 347 lineas]".
+ */
+export async function preguntarConInk(promptSymbol = "❯", cwd = process.cwd()) {
+    // El pie tenía pintado el marco mientras el agente trabajaba. Se borra antes
+    // de que Ink empiece a contar: dos dueños del mismo trozo de pantalla se
+    // pisan, y el que pierde deja filas huérfanas.
+    soltarPie();
+    limpiarRestos();
+    return new Promise((resolve) => {
+        let entregado = false;
+        let empujarAviso = null;
+        // Los avisos tardíos entran por aquí mientras el prompt esté montado.
+        escribirTardio = (texto) => {
+            if (empujarAviso)
+                empujarAviso(texto);
+        };
+        const terminar = (orden) => {
+            if (entregado)
+                return;
+            entregado = true;
+            resolve(orden);
+        };
+        const instancia = render(_jsx(Anfitrion, { cwd: cwd, promptSymbol: promptSymbol, resolver: (orden) => {
+                const entero = expandirPegados(orden);
+                apuntarEnHistorial(entero);
+                terminar(entero);
+            }, cancelar: () => {
+                terminar("/exit");
+            }, registrarAviso: (empujar) => {
+                empujarAviso = empujar;
+            } }));
+        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é.
+            terminar("");
+        });
+    });
+}
+/**
+ * Por dónde entran los mensajes que llegan mientras el prompt está abierto.
+ *
+ * `null` cuando no hay prompt montado: entonces quien avise que escriba por
+ * donde escriba siempre, que no hay nada que romper.
+ */
+let escribirTardio = null;
+export function hayPromptDeInk() {
+    return escribirTardio !== null;
+}
+export function avisarSobreElPromptDeInk(texto) {
+    if (escribirTardio)
+        escribirTardio(texto);
+}

package/dist/ui/marco.js

@@ -91,7 +91,10 @@ export function buildPromptFrame(opts) {
     // 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));
+    // El 1 de delante es la fila de aire; despues barra, entrada, barra y pie.
+    // Sin contarla, el desplegable pide una fila mas de las que caben y el marco
+    // se sale por arriba de la ventana.
+    const room = Math.max(1, viewportRows - 1 - (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)
@@ -184,13 +187,24 @@ export function buildPromptFrame(opts) {
     else {
         footerLine = chalk.hex(modeLook.color)(truncatePlain(modePlain, util));
     }
-    const lines = [bar, inputLine, ...dropdownLines, bar, footerLine];
+    // UNA FILA DE AIRE ENCIMA DE LA CAJA
+    //
+    // Al anclar el prompt al fondo, el marco quedo pegado a lo de arriba: la
+    // ultima linea de la respuesta y la barra superior de la caja, seguidas. Se
+    // lee apelotonado y cuesta ver donde acaba una cosa y empieza la otra. El
+    // usuario lo pidio asi: "ponle un poquito de espacio pero no tanto".
+    //
+    // Una fila, no dos: dos ya son un hueco, y en una ventana corta cada fila que
+    // se gasta en aire es una que no se ve de conversacion.
+    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);
+    // La fila de aire de arriba cuenta: sin sumarla, el cursor se dibuja una fila
+    // por encima de donde se escribe.
+    let cursorRow = 1 + 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));
     }

package/dist/ui/prompt.js

@@ -19,6 +19,7 @@ import { buildPromptFrame } from "./marco.js";
 export { buildPromptFrame } from "./marco.js";
 export { SLASH_COMMANDS } from "./comandos.js";
 import { escribirEncimaDelPie, soltarPie } from "./pieFijo.js";
+import { avisarSobreElPromptDeInk, hayPromptDeInk, preguntarConInk } from "./ink/montarPrompt.js";
 import { esGrande, guardarPegado, expandirPegados, marcaQueTerminaEn, limpiarPegados } from "./pegados.js";
 /**
  * Escribir algo mientras el prompt esta dibujado.
@@ -46,6 +47,12 @@ let escribirEncimaDelPrompt = null;
  * pueda llegar TARDE: conexiones en segundo plano, avisos, temporizadores.
  */
 export function imprimirSobreElPrompt(texto) {
+    // Con Ink montado, escribir a stdout por fuera de su arbol le descuadra la
+    // cuenta de filas en el siguiente dibujado. Se le entrega como estado.
+    if (hayPromptDeInk()) {
+        avisarSobreElPromptDeInk(texto);
+        return;
+    }
     if (escribirEncimaDelPrompt) {
         escribirEncimaDelPrompt(texto);
         return;
@@ -140,7 +147,24 @@ function scanProjectFiles(dir, maxResults = 40) {
     walk(dir);
     return results;
 }
+/**
+ * ¿Se usa el prompt de Ink? Sí, salvo que se pida lo contrario.
+ *
+ * La salida de emergencia existe porque esto cambia la parte más frágil del
+ * programa —el teclado— justo cuando hay clientes pagando. Si Ink se porta mal
+ * en una consola concreta, `CHOCOLATITO_PROMPT=clasico` devuelve el de siempre
+ * sin reinstalar ni bajar de versión.
+ */
+function usarInk() {
+    return process.env.CHOCOLATITO_PROMPT !== "clasico";
+}
 export async function askInteractivePrompt(promptSymbol = "❯", cwd = process.cwd()) {
+    if (usarInk())
+        return preguntarConInk(promptSymbol, cwd);
+    return promptClasico(promptSymbol, cwd);
+}
+/** La implementación de siempre: readline en crudo y las filas contadas a mano. */
+async function promptClasico(promptSymbol = "❯", cwd = process.cwd()) {
     return new Promise((resolve) => {
         // El relevo de la barra.
         //
@@ -200,9 +224,38 @@ export async function askInteractivePrompt(promptSymbol = "❯", cwd = process.c
         // demasiados los sitios que apagan el modo crudo con razon, y basta que uno
         // llegue tarde para que el usuario teclee y su texto salga en la linea de
         // ayuda en vez de en el recuadro.
+        /**
+         * La primera vuelta REAFIRMA aunque Node crea que todo esta bien.
+         *
+         * EL AGUJERO QUE TAPA
+         *
+         * `repararTeclado` solo actua cuando SABE que se perdio el modo crudo: mira
+         * `process.stdin.isRaw`. Pero hay una forma de perderlo que Node no ve. Un
+         * proceso hijo que hereda la consola -git al refrescar el contexto, un hook,
+         * un comando- puede devolverla en cocido al terminar, y `isRaw` se queda
+         * diciendo `true`. Node cree que manda y no manda.
+         *
+         * Si eso pasa DESPUES de abrir el prompt, la reafirmacion de arriba ya paso
+         * y el vigilante no lo ve: el usuario teclea, no sale nada, y solo se
+         * desatasca al pulsar Enter, que es cuando la consola en cocido suelta la
+         * linea. Palabras del usuario, dos veces: "al cambiar de potencia se queda
+         * pegado y no deja escribir, tengo que presionar enter".
+         *
+         * Reafirmar una vez mas, poco despues de abrir, cubre esa ventana. No se
+         * hace en cada vuelta a proposito: pasar por false y volver a true ocho
+         * veces por segundo es pedirle problemas a la consola por un caso raro.
+         */
+        let primeraVigilancia = true;
         const vigilanteTeclado = setInterval(() => {
             if (isFinished)
                 return;
+            if (primeraVigilancia) {
+                primeraVigilancia = false;
+                reafirmarModoCrudo(process.stdin);
+                if (process.env.CHOCOLATITO_TECLADO === "debug") {
+                    process.stderr.write(`\n[teclado] reafirmado al abrir (isRaw decia ${process.stdin.isRaw})\n`);
+                }
+            }
             const reparado = repararTeclado(process.stdin);
             if (reparado.length === 0)
                 return;

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.3.4",
+  "version": "1.4.3",
   "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.3.4",
+  "version": "1.4.3",
   "description": "Agente autónomo de programación para la terminal, con control real del ordenador y del navegador. Desarrollado por Chocolatito.",
   "type": "module",
   "bin": {
@@ -51,17 +51,21 @@
     "dotenv": "^16.4.7",
     "execa": "^9.5.2",
     "fast-glob": "^3.3.3",
+    "ink": "^7.1.1",
     "marked": "^15.0.12",
     "marked-terminal": "^7.3.0",
     "openai": "^4.85.4",
     "ora": "^8.2.0",
     "puppeteer-core": "^25.9.0",
+    "react": "^19.2.8",
     "ws": "^8.21.3"
   },
   "devDependencies": {
     "@types/diff": "^7.0.0",
     "@types/node": "^22.13.5",
+    "@types/react": "^19.2.18",
     "@types/ws": "^8.18.1",
+    "ink-testing-library": "^4.0.0",
     "typescript": "^5.7.3"
   }
 }