chocolatito-code 1.6.5 → 1.6.7

package/dist/ui/permissionPrompt.d.ts

@@ -4,23 +4,6 @@ export interface PermissionPromptResult {
     userFeedback?: string;
 }
 export declare function setAutoApprove(value: boolean): void;
-/**
- * DIALOGO DE PERMISO
- *
- * La version anterior tenia dos fallos visibles en cuanto se usaba:
- *
- *  1. Al mover la seleccion subia el cursor 12 lineas fijas, pero la caja mide
- *     entre 10 y 14 segun cuantos detalles tenga. Cada flecha dejaba media caja
- *     huerfana en pantalla, y por eso salian marcos vacios apilados.
- *
- *  2. El titulo llevaba un simbolo de anchura ambigua. El terminal lo pinta
- *     ocupando dos columnas y el calculo del ancho contaba una, asi que el borde
- *     derecho quedaba descuadrado justo en esa linea.
- *
- * Aqui se dibuja la caja a mano, con anchura conocida, y se repinta subiendo
- * exactamente las lineas que se escribieron.
- */
-export declare function askToolPermission(toolName: string, args: Record<string, any>, cwd?: string): Promise<PermissionPromptResult>;
 export declare const PERMISSION_OPTIONS: {
     label: string;
     hint: string;
@@ -33,3 +16,13 @@ export declare const PERMISSION_OPTIONS: {
  * derecho no se ve leyendo el codigo, solo ejecutandolo.
  */
 export declare function buildPermissionBox(toolName: string, args: Record<string, any>, cwd: string, selectedIndex: number, width?: number): string[];
+/**
+ * Se pide el terminal prestado antes de abrir esto.
+ *
+ * Con el árbol de Ink montado hay un dueño de la pantalla, y esta función es de
+ * las que necesitan el teclado para ellas solas: escribe directo a stdout y abre
+ * su propia lectura de teclas. Sin el préstamo, las dos cuentas de filas se pisan
+ * y el marco de Ink no se recupera. Sin árbol, `conElTerminalPrestado` ejecuta la
+ * tarea tal cual y no cuesta nada. Ver ui/ink/prestamo.ts.
+ */
+export declare function askToolPermission(toolName: string, args: Record<string, any>, cwd?: string): Promise<PermissionPromptResult>;

package/dist/ui/permissionPrompt.js

@@ -3,6 +3,7 @@ import process from "node:process";
 import chalk from "chalk";
 import { cycleMode, describeMode, getMode, modeAnnouncement } from "./modes.js";
 import { isOutsideProject, isSvgSource } from "../config/permissions.js";
+import { conElTerminalPrestado } from "./ink/prestamo.js";
 /**
  * Aprobacion automatica: se activa con --yes / -y o con la variable de entorno
  * CHOCOLATITO_AUTO_APPROVE. Pensada para modo no interactivo y CI.
@@ -27,7 +28,7 @@ export function setAutoApprove(value) {
  * Aqui se dibuja la caja a mano, con anchura conocida, y se repinta subiendo
  * exactamente las lineas que se escribieron.
  */
-export async function askToolPermission(toolName, args, cwd = process.cwd()) {
+async function askToolPermissionDirecto(toolName, args, cwd = process.cwd()) {
     if (autoApprove) {
         return { approved: true };
     }
@@ -351,3 +352,15 @@ function details(toolName, args, cwd, width) {
     out.push({ text: "", length: 0 });
     return out;
 }
+/**
+ * Se pide el terminal prestado antes de abrir esto.
+ *
+ * Con el árbol de Ink montado hay un dueño de la pantalla, y esta función es de
+ * las que necesitan el teclado para ellas solas: escribe directo a stdout y abre
+ * su propia lectura de teclas. Sin el préstamo, las dos cuentas de filas se pisan
+ * y el marco de Ink no se recupera. Sin árbol, `conElTerminalPrestado` ejecuta la
+ * tarea tal cual y no cuesta nada. Ver ui/ink/prestamo.ts.
+ */
+export function askToolPermission(toolName, args, cwd = process.cwd()) {
+    return conElTerminalPrestado(() => askToolPermissionDirecto(toolName, args, cwd));
+}

package/dist/ui/pieFijo.js

@@ -219,10 +219,24 @@ function anotar(nombre, lineas) {
  * 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("");
+    // DELEGA, Y ESO ARREGLA UN FALLO GORDO
+    //
+    // Antes empezaba con `if (!pieUsable()) return;`, o sea que con el pie apagado
+    // -que es exactamente lo que pasa cuando manda el arbol de Ink- esta funcion no
+    // hacia NADA. Ni guardaba la seccion ni avisaba a quien la pinta.
+    //
+    // Dos consecuencias, las dos visibles:
+    //
+    //   - La linea de razonamiento (el 💭) es el unico sitio que llama aqui
+    //     (ui/reasoningStream.ts:122). Con el arbol montado no salia nunca.
+    //   - `quitarSeccion` pasa por aqui. Asi que `quitarSeccion("spinner")` al
+    //     acabar el turno tampoco hacia nada: el "✳ Trabajando…" se quedaba
+    //     puesto para siempre, mucho despues de que el agente hubiera terminado.
+    //     Eso es lo que se ve como "se queda trabado".
+    //
+    // `fijarSecciones` ya distingue bien las dos cosas -guardar y avisar SIEMPRE,
+    // pintar solo si el pie esta encendido-, asi que aqui basta con delegar.
+    fijarSecciones([[nombre, lineas]]);
 }
 /**
  * Varias secciones de una vez, con UN solo repintado.
@@ -312,6 +326,14 @@ export function soltarPie() {
         return;
     secciones.clear();
     repintar("");
+    // Y se avisa, que si no el arbol sigue pintando una barra que ya no existe
+    // hasta que otra cosa cualquiera le haga redibujar.
+    for (const cb of alCambiarElPie) {
+        try {
+            cb();
+        }
+        catch { }
+    }
 }
 /**
  * Olvida el estado sin tocar la pantalla.

package/dist/ui/selector.d.ts

@@ -28,10 +28,12 @@ export interface OpcionDeLista {
     detalle?: string;
 }
 /**
- * Enseña la lista y devuelve el id elegido. `null` si se sale con Esc.
+ * Se pide el terminal prestado antes de abrir esto.
  *
- * Sin terminal no hay nada que elegir: devuelve null en el acto en vez de
- * quedarse esperando una tecla que no va a llegar nunca. Es lo que pasaria al
- * correrlo desde un script o dentro de las pruebas.
+ * Con el árbol de Ink montado hay un dueño de la pantalla, y esta función es de
+ * las que necesitan el teclado para ellas solas: escribe directo a stdout y abre
+ * su propia lectura de teclas. Sin el préstamo, las dos cuentas de filas se pisan
+ * y el marco de Ink no se recupera. Sin árbol, `conElTerminalPrestado` ejecuta la
+ * tarea tal cual y no cuesta nada. Ver ui/ink/prestamo.ts.
  */
 export declare function elegirDeLista(titulo: string, opciones: OpcionDeLista[], indiceInicial?: number): Promise<string | null>;

package/dist/ui/selector.js

@@ -2,6 +2,7 @@ import chalk from "chalk";
 import process from "node:process";
 import readline from "node:readline";
 import { dibujar } from "./salida.js";
+import { conElTerminalPrestado } from "./ink/prestamo.js";
 /**
  * Enseña la lista y devuelve el id elegido. `null` si se sale con Esc.
  *
@@ -9,7 +10,7 @@ import { dibujar } from "./salida.js";
  * quedarse esperando una tecla que no va a llegar nunca. Es lo que pasaria al
  * correrlo desde un script o dentro de las pruebas.
  */
-export async function elegirDeLista(titulo, opciones, indiceInicial = 0) {
+async function elegirDeListaDirecto(titulo, opciones, indiceInicial = 0) {
     if (opciones.length === 0)
         return null;
     if (!process.stdin.isTTY)
@@ -89,3 +90,15 @@ export async function elegirDeLista(titulo, opciones, indiceInicial = 0) {
         process.stdin.on("keypress", alPulsar);
     });
 }
+/**
+ * Se pide el terminal prestado antes de abrir esto.
+ *
+ * Con el árbol de Ink montado hay un dueño de la pantalla, y esta función es de
+ * las que necesitan el teclado para ellas solas: escribe directo a stdout y abre
+ * su propia lectura de teclas. Sin el préstamo, las dos cuentas de filas se pisan
+ * y el marco de Ink no se recupera. Sin árbol, `conElTerminalPrestado` ejecuta la
+ * tarea tal cual y no cuesta nada. Ver ui/ink/prestamo.ts.
+ */
+export function elegirDeLista(titulo, opciones, indiceInicial = 0) {
+    return conElTerminalPrestado(() => elegirDeListaDirecto(titulo, opciones, indiceInicial));
+}

package/extension/manifest.json

@@ -1,60 +1,60 @@
-{
-  "manifest_version": 3,
-  "minimum_chrome_version": "102",
-  "name": "Chocolatito Code",
-  "version": "1.6.5",
-  "description": "Deja que Chocolatito Code trabaje dentro de tu Chrome, en segundo plano y con tus sesiones ya iniciadas.",
-  "permissions": [
-    "tabs",
-    "tabGroups",
-    "scripting",
-    "debugger",
-    "webNavigation",
-    "storage",
-    "downloads"
-  ],
-  "host_permissions": [
-    "<all_urls>"
-  ],
-  "icons": {
-    "16": "iconos/16.png",
-    "32": "iconos/32.png",
-    "48": "iconos/48.png",
-    "128": "iconos/128.png"
-  },
-  "background": {
-    "service_worker": "background.js"
-  },
-  "content_scripts": [
-    {
-      "matches": [
-        "<all_urls>"
-      ],
-      "js": [
-        "content.js"
-      ],
-      "run_at": "document_idle",
-      "all_frames": true
-    }
-  ],
-  "action": {
-    "default_title": "Chocolatito Code",
-    "default_popup": "popup.html",
-    "default_icon": {
-      "16": "iconos/16.png",
-      "32": "iconos/32.png",
-      "48": "iconos/48.png"
-    }
-  },
-  "web_accessible_resources": [
-    {
-      "resources": [
-        "iconos/*",
-        "fuentes/*"
-      ],
-      "matches": [
-        "<all_urls>"
-      ]
-    }
-  ]
-}
+{
+  "manifest_version": 3,
+  "minimum_chrome_version": "102",
+  "name": "Chocolatito Code",
+  "version": "1.6.7",
+  "description": "Deja que Chocolatito Code trabaje dentro de tu Chrome, en segundo plano y con tus sesiones ya iniciadas.",
+  "permissions": [
+    "tabs",
+    "tabGroups",
+    "scripting",
+    "debugger",
+    "webNavigation",
+    "storage",
+    "downloads"
+  ],
+  "host_permissions": [
+    "<all_urls>"
+  ],
+  "icons": {
+    "16": "iconos/16.png",
+    "32": "iconos/32.png",
+    "48": "iconos/48.png",
+    "128": "iconos/128.png"
+  },
+  "background": {
+    "service_worker": "background.js"
+  },
+  "content_scripts": [
+    {
+      "matches": [
+        "<all_urls>"
+      ],
+      "js": [
+        "content.js"
+      ],
+      "run_at": "document_idle",
+      "all_frames": true
+    }
+  ],
+  "action": {
+    "default_title": "Chocolatito Code",
+    "default_popup": "popup.html",
+    "default_icon": {
+      "16": "iconos/16.png",
+      "32": "iconos/32.png",
+      "48": "iconos/48.png"
+    }
+  },
+  "web_accessible_resources": [
+    {
+      "resources": [
+        "iconos/*",
+        "fuentes/*"
+      ],
+      "matches": [
+        "<all_urls>"
+      ]
+    }
+  ]
+}

package/package.json

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

package/dist/ui/historial.d.ts

@@ -1,49 +0,0 @@
-/**
- * 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

@@ -1,92 +0,0 @@
-/**
- * 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));
-}