chocolatito-code 1.6.13 → 1.6.14

package/dist/ui/ink/Prompt.js

@@ -1,10 +1,11 @@
 import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
-import { useMemo, useRef, useState } 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 { solicitarLimpieza } from "./control.js";
 /** Marca del cursor. Ink esconde el de verdad, así que este se dibuja. */
 const CARET = "█";
 /**
@@ -21,7 +22,7 @@ const CARET = "█";
 function conCuerpo(texto) {
     return texto.length > 0 ? texto : " ";
 }
-export function Prompt({ alEnviar, alCancelar, cwd, promptSymbol, avisos, cerrarAlEnviar = true, alto, }) {
+export function Prompt({ alEnviar, alCancelar, cwd, promptSymbol, avisos, cerrarAlEnviar = true, alto, cols: colsProp, filas: filasProp, }) {
     const { stdout } = useStdout();
     const { exit } = useApp();
     const [texto, setTexto] = useState("");
@@ -29,6 +30,26 @@ export function Prompt({ alEnviar, alCancelar, cwd, promptSymbol, avisos, cerrar
     const [elegido, setElegido] = useState(0);
     /** Contador para forzar un dibujado cuando cambia algo de fuera de React. */
     const [, setRedibujar] = useState(0);
+    const [tamano, setTamano] = useState(() => ({
+        cols: Math.max(20, colsProp ?? (stdout?.columns && stdout.columns > 0 ? stdout.columns : process.stdout?.columns) ?? 80),
+        rows: Math.max(6, alto ?? filasProp ?? (stdout?.rows && stdout.rows > 0 ? stdout.rows : process.stdout?.rows) ?? 24),
+    }));
+    // Reaccionar inmediatamente cuando la ventana se maximiza, restaura o cambia de tamaño
+    useEffect(() => {
+        const alRedimensionar = () => {
+            setTamano({
+                cols: Math.max(20, colsProp ?? (stdout?.columns && stdout.columns > 0 ? stdout.columns : process.stdout?.columns) ?? 80),
+                rows: Math.max(6, alto ?? filasProp ?? (stdout?.rows && stdout.rows > 0 ? stdout.rows : process.stdout?.rows) ?? 24),
+            });
+            setRedibujar((n) => n + 1);
+        };
+        stdout?.on("resize", alRedimensionar);
+        process.stdout?.on("resize", alRedimensionar);
+        return () => {
+            stdout?.off("resize", alRedimensionar);
+            process.stdout?.off("resize", alRedimensionar);
+        };
+    }, [stdout, colsProp, alto, filasProp]);
     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
@@ -43,10 +64,10 @@ export function Prompt({ alEnviar, alCancelar, cwd, promptSymbol, avisos, cerrar
     }, [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 cols = colsProp ?? tamano.cols;
     // El alto que da App ya viene descontado de lo que hay por encima; sin él, la
     // ventana entera.
-    const rows = Math.max(6, alto ?? stdout?.rows ?? 24);
+    const rows = Math.max(6, alto ?? tamano.rows);
     // El cursor se dibuja: Ink esconde el del terminal.
     const conCaret = texto.slice(0, cursor) + CARET + texto.slice(cursor);
     const marco = buildPromptFrame({
@@ -87,6 +108,73 @@ export function Prompt({ alEnviar, alCancelar, cwd, promptSymbol, avisos, cerrar
             cerrar();
             return;
         }
+        // ------------------------------------------------------------- limpiar pantalla (Ctrl+L)
+        if (tecla.ctrl && entrada === "l") {
+            solicitarLimpieza();
+            return;
+        }
+        // ------------------------------------------------------------- escape cancela / limpia entrada
+        if (tecla.escape) {
+            if (texto.length > 0) {
+                setTexto("");
+                setCursor(0);
+                setElegido(0);
+                return;
+            }
+        }
+        // ------------------------------------------------------------- inicio de línea (Ctrl+A o Home)
+        if ((tecla.ctrl && entrada === "a") || entrada === "\x1b[H" || entrada === "\x1b[1~") {
+            setCursor(0);
+            return;
+        }
+        // ------------------------------------------------------------- fin de línea (Ctrl+E o End)
+        if ((tecla.ctrl && entrada === "e") || entrada === "\x1b[F" || entrada === "\x1b[4~") {
+            setCursor(texto.length);
+            return;
+        }
+        // ------------------------------------------------------------- borrar hasta inicio de línea (Ctrl+U)
+        if (tecla.ctrl && entrada === "u") {
+            setTexto(texto.slice(cursor));
+            setCursor(0);
+            setElegido(0);
+            return;
+        }
+        // ------------------------------------------------------------- borrar hasta fin de línea (Ctrl+K)
+        if (tecla.ctrl && entrada === "k") {
+            setTexto(texto.slice(0, cursor));
+            return;
+        }
+        // ------------------------------------------------------------- borrar palabra atrás (Ctrl+W)
+        if (tecla.ctrl && entrada === "w") {
+            if (cursor === 0)
+                return;
+            const antes = texto.slice(0, cursor);
+            const sinEspaciosFinal = antes.trimEnd();
+            const pos = Math.max(sinEspaciosFinal.lastIndexOf(" "), sinEspaciosFinal.lastIndexOf("\t"), sinEspaciosFinal.lastIndexOf("/"), sinEspaciosFinal.lastIndexOf("\\"));
+            const nuevoCursor = Math.max(0, pos >= 0 ? pos + 1 : 0);
+            setTexto(texto.slice(0, nuevoCursor) + texto.slice(cursor));
+            setCursor(nuevoCursor);
+            setElegido(0);
+            return;
+        }
+        // ------------------------------------------------- saltar palabra atrás (Alt+B / Ctrl+Left)
+        if ((tecla.meta && entrada === "b") || (tecla.ctrl && tecla.leftArrow) || (tecla.meta && tecla.leftArrow)) {
+            if (cursor === 0)
+                return;
+            const antes = texto.slice(0, cursor).trimEnd();
+            const pos = Math.max(antes.lastIndexOf(" "), antes.lastIndexOf("\t"), antes.lastIndexOf("/"), antes.lastIndexOf("\\"));
+            setCursor(Math.max(0, pos >= 0 ? pos + 1 : 0));
+            return;
+        }
+        // ------------------------------------------------- saltar palabra adelante (Alt+F / Ctrl+Right)
+        if ((tecla.meta && entrada === "f") || (tecla.ctrl && tecla.rightArrow) || (tecla.meta && tecla.rightArrow)) {
+            if (cursor >= texto.length)
+                return;
+            const despues = texto.slice(cursor);
+            const coincidencia = despues.search(/\s\S|[/\\]\S/);
+            setCursor(coincidencia >= 0 ? cursor + coincidencia + 1 : texto.length);
+            return;
+        }
         // ------------------------------------------- cambiar el modo de permisos
         if (tecla.tab && tecla.shift) {
             cycleMode();

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

@@ -34,3 +34,5 @@ export declare function alCambiarElTurno(cb: (e: EstadoDelTurno) => void): () =>
  * promesa deja el bucle avanzando por su cuenta con una orden que nadie escribió.
  */
 export declare function pedirOrden(promptSymbol: string, cwd: string): Promise<string>;
+export declare function registrarLimpiador(fn: (() => void) | null): void;
+export declare function solicitarLimpieza(): void;

package/dist/ui/ink/control.js

@@ -52,3 +52,18 @@ export function pedirOrden(promptSymbol, cwd) {
         avisar();
     });
 }
+let limpiador = null;
+export function registrarLimpiador(fn) {
+    limpiador = fn;
+}
+export function solicitarLimpieza() {
+    if (limpiador) {
+        limpiador();
+    }
+    else {
+        try {
+            process.stdout.write("\x1b[2J\x1b[3J\x1b[H");
+        }
+        catch { }
+    }
+}

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

@@ -14,23 +14,4 @@ export declare function montarArbol(): void;
  */
 export declare function desmontarArbol(): void;
 export declare function hayArbol(): boolean;
-/**
- * Borra la pantalla de verdad. Es lo que hacen /clear, /cd y Ctrl+L.
- *
- * POR QUE NO VALE UN `console.clear()`
- *
- * `console.clear()` escribe la secuencia de borrado directa al terminal, y no
- * pasa por la interceptación de consola: ahí solo van `log`, `error`, `warn` e
- * `info`. Con el árbol montado eso borra filas que Ink cree suyas, y a partir de
- * ahí Ink borra y repinta sobre un sitio que ya no existe. Lo que se ve es
- * basura, o nada.
- *
- * Aquí se hace en el orden que no rompe nada: se borra el marco con la cuenta
- * todavía buena, se suelta el árbol, se limpia la pantalla —y el historial del
- * terminal con `3J`, que es lo que el usuario espera de un /clear— y se vuelve a
- * montar de cero.
- *
- * Y se vacía la transcripción: si no, el <Static> nuevo tendría por delante toda
- * la conversación que se acaba de borrar.
- */
 export declare function limpiarLaPantalla(): void;

package/dist/ui/ink/montarApp.js

@@ -109,6 +109,7 @@ export function hayArbol() {
  * Y se vacía la transcripción: si no, el <Static> nuevo tendría por delante toda
  * la conversación que se acaba de borrar.
  */
+import { registrarLimpiador } from "./control.js";
 export function limpiarLaPantalla() {
     const habia = arbol !== null;
     if (habia)
@@ -122,6 +123,8 @@ export function limpiarLaPantalla() {
     if (habia)
         montarArbol();
 }
+// Conectar el limpiador con el prompt para soportar Ctrl+L sin ciclos circulares de módulos
+registrarLimpiador(limpiarLaPantalla);
 // Si el proceso muere sin pasar por la salida ordenada, el árbol tiene que
 // soltarse igual: un árbol vivo en un proceso que se cierra deja el terminal a
 // medio restaurar.

package/dist/ui/permissionPrompt.js

@@ -67,12 +67,17 @@ async function askToolPermissionDirecto(toolName, args, cwd = process.cwd()) {
             process.stdout.write(lines.map((l) => `\r\x1b[2K${l}`).join("\n") + "\n");
             renderedRows = lines.length;
         }
-        draw();
         function cleanup() {
             process.stdin.removeListener("keypress", onKeypress);
+            process.stdout.removeListener("resize", onResize);
             if (process.stdin.setRawMode)
                 process.stdin.setRawMode(wasRaw || false);
         }
+        const onResize = () => {
+            draw();
+        };
+        process.stdout.on("resize", onResize);
+        draw();
         async function promptForFeedback() {
             cleanup();
             return new Promise((resFeedback) => {
@@ -329,15 +334,45 @@ function details(toolName, args, cwd, width) {
         }
     }
     else if (typeof args.action === "string") {
-        // Sobre QUE actua importa tanto como la accion. Un "close_tab" a secas no
+        // POR QUE: Sobre QUE actua importa tanto como la accion. Un "close_tab" a secas no
         // decia que pestana moria, asi que aprobarlo era aprobar a ciegas.
-        const objetivo = args.url || args.appName || args.window || args.text ||
-            (typeof args.tabId === "number" ? `pestaña ${args.tabId}` : "") ||
-            (typeof args.ref === "number" ? `elemento [${args.ref}]` : "") ||
-            "";
-        const extra = objetivo || (esNavegador(toolName) ? "en la pestaña de trabajo" : "");
-        const plain = extra ? `${args.action}  ${String(extra)}` : String(args.action);
-        add(plain, extra ? `${chalk.bold.white(args.action)}  ${chalk.gray(String(extra))}` : chalk.bold.white(args.action));
+        // Con "sequence" pasaba exactamente lo mismo: ensenar solo la palabra "sequence"
+        // hacia que el usuario aprobara N clics y pulsaciones a ciegas sin ver que se iba
+        // a ejecutar en su maquina.
+        if (args.action === "sequence" && Array.isArray(args.steps) && args.steps.length > 0) {
+            const resumirPaso = (s) => {
+                if (!s || typeof s !== "object")
+                    return "?";
+                const act = String(s.action || "paso");
+                if (typeof s.ref === "number")
+                    return `${act} [${s.ref}]`;
+                if (typeof s.text === "string")
+                    return `${act} '${s.text}'`;
+                if (typeof s.key === "string")
+                    return `${act} ${s.key}`;
+                if (typeof s.keys === "string")
+                    return `${act} ${s.keys}`;
+                if (Array.isArray(s.coordinate) && s.coordinate.length === 2)
+                    return `${act} (${s.coordinate[0]}, ${s.coordinate[1]})`;
+                if (typeof s.x === "number" && typeof s.y === "number")
+                    return `${act} (${s.x}, ${s.y})`;
+                return act;
+            };
+            const n = args.steps.length;
+            const cadenaPasos = args.steps.map(resumirPaso).join(" -> ");
+            const plain = `${n} pasos: ${cadenaPasos}`;
+            const painted = `${chalk.bold.white(`${n} pasos:`)} ${chalk.gray(cadenaPasos)}`;
+            add(plain, painted);
+        }
+        else {
+            const objetivo = args.url || args.appName || args.window || args.text ||
+                (typeof args.tabId === "number" ? `pestaña ${args.tabId}` : "") ||
+                (typeof args.ref === "number" ? `elemento [${args.ref}]` : "") ||
+                "";
+            const extra = objetivo || (esNavegador(toolName) ? "en la pestaña de trabajo" : "");
+            const plain = extra ? `${args.action}  ${String(extra)}` : String(args.action);
+            add(plain, extra ? `${chalk.bold.white(args.action)}  ${chalk.gray(String(extra))}` : chalk.bold.white(args.action));
+        }
     }
     else {
         add(toolName, chalk.bold.white(toolName));

package/dist/ui/pieFijo.js

@@ -356,6 +356,11 @@ export function reiniciarPie() {
  * cursor y el usuario no tiene forma de saber por que. Se devuelve pase lo que
  * pase, tambien si el programa se cae.
  */
+process.stdout.on("resize", () => {
+    if (pieUsable() && filasPintadas > 0) {
+        repintar("");
+    }
+});
 process.on("exit", () => {
     if (cursorEscondido) {
         try {

package/dist/ui/prompt.js

@@ -373,6 +373,7 @@ async function promptClasico(promptSymbol = "❯", cwd = process.cwd()) {
                 pendingSubmit = null;
             }
             process.stdin.removeListener("keypress", onKeypress);
+            process.stdout.removeListener("resize", onResize);
             if (process.stdin.setRawMode) {
                 process.stdin.setRawMode(wasRaw || false);
             }
@@ -703,6 +704,11 @@ async function promptClasico(promptSymbol = "❯", cwd = process.cwd()) {
             lastCursorRow = 0;
             render();
         };
+        const onResize = () => {
+            if (!isFinished)
+                render();
+        };
+        process.stdout.on("resize", onResize);
         process.stdin.on("keypress", onKeypress);
         render();
     });

package/dist/ui/renderer.d.ts

@@ -21,6 +21,7 @@ export declare function renderUserPrompt(text: string): void;
 export declare function renderToolStart(name: string, summary: string): void;
 export declare function renderToolSuccess(name: string, resultSummary: string): void;
 export declare function renderToolError(name: string, errorSummary: string): void;
+export declare function formatColorDiff(diffText: string): string;
 export declare function renderDiff(filePath: string, diffText: string): void;
 export declare function renderReasoning(reasoningText: string): void;
 export declare function renderAssistantResponse(markdownText: string): void;

package/dist/ui/renderer.js

@@ -65,7 +65,9 @@ export function renderUserPrompt(text) {
 export function renderToolStart(name, summary) {
     const bullet = chalk.hex("#FFA500")("●"); // Amber while starting
     const toolName = chalk.bold.white(formatToolName(name));
-    const argPart = summary ? chalk.gray(`(${summary.length > 60 ? summary.slice(0, 57) + '...' : summary})`) : "";
+    const cols = (process.stdout && process.stdout.columns) || 80;
+    const maxSummary = Math.max(60, cols - name.length - 12);
+    const argPart = summary ? chalk.gray(`(${summary.length > maxSummary ? summary.slice(0, maxSummary - 3) + '...' : summary})`) : "";
     salida.linea(`\n${bullet} ${toolName}${argPart}`);
 }
 export function renderToolSuccess(name, resultSummary) {
@@ -85,8 +87,31 @@ export function renderToolSuccess(name, resultSummary) {
 export function renderToolError(name, errorSummary) {
     salida.linea(`  ${chalk.red("⎿")}  ${chalk.red(errorSummary)}`);
 }
+export function formatColorDiff(diffText) {
+    return diffText
+        .split("\n")
+        .map((line) => {
+        if (line.startsWith("diff --git") || line.startsWith("index ")) {
+            return chalk.bold.white(line);
+        }
+        if (line.startsWith("---") || line.startsWith("+++")) {
+            return chalk.bold.hex("#D97757")(line);
+        }
+        if (line.startsWith("@@")) {
+            return chalk.cyan(line);
+        }
+        if (line.startsWith("+")) {
+            return chalk.green(line);
+        }
+        if (line.startsWith("-")) {
+            return chalk.red(line);
+        }
+        return chalk.gray(line);
+    })
+        .join("\n");
+}
 export function renderDiff(filePath, diffText) {
-    salida.linea(`\n${diffText}\n`);
+    salida.linea(`\n${formatColorDiff(diffText)}\n`);
 }
 export function renderReasoning(reasoningText) {
     if (!reasoningText.trim())

package/dist/ui/selector.js

@@ -56,6 +56,7 @@ async function elegirDeListaDirecto(titulo, opciones, indiceInicial = 0) {
         }
         function terminar(valor) {
             process.stdin.removeListener("keypress", alPulsar);
+            process.stdout.removeListener("resize", onResize);
             // Se devuelve el modo que habia, no se fuerza uno: si el prompt tenia el
             // teclado en crudo y aqui se dejara en cocido, la sesion se queda sin
             // poder escribir y no se sabe por que.
@@ -63,6 +64,10 @@ async function elegirDeListaDirecto(titulo, opciones, indiceInicial = 0) {
                 process.stdin.setRawMode(eraCrudo || false);
             resolve(valor);
         }
+        const onResize = () => {
+            pintar();
+        };
+        process.stdout.on("resize", onResize);
         function alPulsar(_str, key) {
             if (!key)
                 return;

package/dist/ui/spinner.d.ts

@@ -14,6 +14,7 @@ export declare class DynamicSpinner {
      */
     setPrefijo(prefijo: string): void;
     start(initialPrefix?: string): void;
+    private onResize;
     private tick;
     /**
      * `✳ Compactando historial… (3s · ↓ 1.2k tokens · esc para pausar)   ⇥ modo`

package/dist/ui/spinner.js

@@ -60,10 +60,15 @@ export class DynamicSpinner {
         this.glyphIdx = 0;
         this.verbIdx = 0;
         this.tick();
+        process.stdout.on("resize", this.onResize);
         this.timer = setInterval(() => {
             this.tick();
         }, 120);
     }
+    onResize = () => {
+        if (this.isRunning)
+            this.tick();
+    };
     tick() {
         if (!this.isRunning)
             return;
@@ -132,6 +137,7 @@ export class DynamicSpinner {
         if (!this.isRunning)
             return;
         this.isRunning = false;
+        process.stdout.off("resize", this.onResize);
         if (this.timer) {
             clearInterval(this.timer);
             this.timer = null;

package/extension/manifest.json

@@ -2,7 +2,7 @@
   "manifest_version": 3,
   "minimum_chrome_version": "102",
   "name": "Chocolatito Code",
-  "version": "1.6.13",
+  "version": "1.6.14",
   "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.6.13",
+  "version": "1.6.14",
   "description": "Agente autónomo de programación para la terminal, con control real del ordenador y del navegador. Desarrollado por Chocolatito.",
   "type": "module",
   "bin": {