chocolatito-code 1.1.0 → 1.3.0

package/dist/tools/browserExtension.js

@@ -1,6 +1,7 @@
 import fs from "node:fs";
 import path from "node:path";
 import os from "node:os";
+import { fileURLToPath } from "node:url";
 import { WebSocketServer, WebSocket } from "ws";
 import { describeScreen } from "./visionBridge.js";
 /**
@@ -46,6 +47,8 @@ class ExtensionBridge {
     rejectedOrigin = null;
     port = 0;
     start() {
+        if (this.wss)
+            return Promise.resolve();
         if (this.starting)
             return this.starting;
         this.starting = (async () => {
@@ -54,11 +57,14 @@ class ExtensionBridge {
                 if (ok) {
                     this.port = port;
                     this.portTaken = false;
+                    this.starting = null;
                     return;
                 }
             }
-            // Todos ocupados: hay tantas sesiones como puertos.
+            // #78: Todos ocupados temporalmente. Reseteamos starting para que
+            // una llamada posterior pueda reintentar si otra sesión liberó su puerto.
             this.portTaken = true;
+            this.starting = null;
         })();
         return this.starting;
     }
@@ -135,12 +141,29 @@ class ExtensionBridge {
                     waiter.resolve(msg);
                 });
                 ws.on("close", () => {
-                    if (this.client === ws)
+                    if (this.client === ws) {
                         this.client = null;
+                        // #52: Si la conexión se cae a media acción, rechazar de inmediato
+                        // las peticiones en vuelo en lugar de esperar 45 s al timeout.
+                        const errDesconexion = "La conexión con la extensión de Chrome se cerró inesperadamente durante la ejecución de la acción. " +
+                            "Comprueba si la pestaña o el navegador se han cerrado.";
+                        for (const [id, waiter] of this.pending.entries()) {
+                            clearTimeout(waiter.timer);
+                            waiter.resolve({ ok: false, error: errDesconexion });
+                        }
+                        this.pending.clear();
+                    }
                 });
-                ws.on("error", () => {
-                    if (this.client === ws)
+                ws.on("error", (err) => {
+                    if (this.client === ws) {
                         this.client = null;
+                        const msgError = `Error en el socket con la extensión de Chrome: ${err?.message || err}`;
+                        for (const [id, waiter] of this.pending.entries()) {
+                            clearTimeout(waiter.timer);
+                            waiter.resolve({ ok: false, error: msgError });
+                        }
+                        this.pending.clear();
+                    }
                 });
             });
         });
@@ -167,6 +190,10 @@ class ExtensionBridge {
      * eso la primera espera es generosa y las siguientes, cortas.
      */
     async waitForClient(ms) {
+        // #78: Si estaba marcado como ocupado pero otra sesión se cerró, reintentar enlazar
+        if (this.portTaken && !this.wss) {
+            await this.start();
+        }
         const budget = ms ?? (this.everConnected ? 4000 : 12_000);
         return this.waitUpTo(budget);
     }
@@ -224,6 +251,11 @@ class ExtensionBridge {
         try {
             this.client?.close();
             this.wss?.close();
+            this.wss = null;
+            this.client = null;
+            this.starting = null;
+            this.portTaken = false;
+            this.port = 0;
         }
         catch { }
     }
@@ -247,6 +279,55 @@ function emparejar(objetivo, origen, destino) {
         return candidatos[pos].ref;
     return null;
 }
+/**
+ * Avisar cuando la extension de Chrome se quedo atras.
+ *
+ * POR QUE HACE FALTA
+ *
+ * El CLI se actualiza solo, y la extension viaja DENTRO del paquete npm. Asi
+ * que al actualizarse, los archivos de la extension en el disco pasan a ser
+ * nuevos... pero Chrome sigue ejecutando los que cargo en su dia. No se entera
+ * hasta que alguien pulsa "recargar" en chrome://extensions.
+ *
+ * Eso deja al usuario con una version del CLI que espera cosas que su extension
+ * no sabe hacer, y los fallos que salen de ahi no se parecen en nada a su causa:
+ * una captura que llega en PNG cuando el CLI ya cuenta con JPEG, una accion que
+ * contesta distinto de lo que se espera. Sintomas raros, causa invisible.
+ *
+ * La extension ya decia su version en cada `status` y nadie la miraba. Ahora se
+ * compara con la que trae este CLI, y si no cuadran se dice una vez.
+ */
+let yaAvisadoDeVersion = false;
+/** La version de extension que trae ESTE CLI, leida del paquete instalado. */
+function versionEsperadaDeExtension() {
+    try {
+        const aqui = path.dirname(fileURLToPath(import.meta.url));
+        const manifiesto = path.resolve(aqui, "..", "..", "extension", "manifest.json");
+        return String(JSON.parse(fs.readFileSync(manifiesto, "utf-8")).version || "");
+    }
+    catch {
+        // Sin manifiesto no se puede comparar, y adivinar seria peor que callar.
+        return "";
+    }
+}
+/**
+ * Aviso si la extension va por detras. Cadena vacia si todo cuadra o no se sabe.
+ *
+ * Solo se avisa UNA vez por sesion: repetirlo en cada accion seria ruido que
+ * acaba ignorandose, que es como se pierden los avisos que importan.
+ */
+function avisoDeVersion(deLaExtension) {
+    if (yaAvisadoDeVersion)
+        return "";
+    const esperada = versionEsperadaDeExtension();
+    if (!esperada || !deLaExtension || esperada === deLaExtension)
+        return "";
+    yaAvisadoDeVersion = true;
+    return (`\n\nAVISO: tu extension de Chrome es la v${deLaExtension} y este Chocolatito trae la v${esperada}. ` +
+        `Chrome sigue ejecutando la que cargo en su dia aunque los archivos del disco ya sean nuevos. ` +
+        `Recargala en chrome://extensions (boton de recargar en la tarjeta de Chocolatito Code) o ` +
+        `veras fallos raros que no se parecen a su causa.`);
+}
 class CatalogoDeRefs {
     /** Lo que vio el modelo: los numeros en los que habla. */
     vista = [];
@@ -284,6 +365,10 @@ class CatalogoDeRefs {
         return this.filtroVista;
     }
     /** Nombre que tenia ese ref cuando el modelo lo vio. */
+    /** Huella de lo que vio el modelo, para poder comparar despues de actuar. */
+    huellaVista() {
+        return this.vista.map((e) => `${e.role}::${e.name}`);
+    }
     nombreDe(ref) {
         return this.vista.find((e) => e.ref === ref)?.name || "";
     }
@@ -322,6 +407,61 @@ async function refrescarCatalogo(filtro) {
     catalogo.verInterno(fresh.data.elements || []);
     return true;
 }
+/**
+ * Comprobar que el clic hizo ALGO, en vez de dar por hecho que si.
+ *
+ * EL FALLO, VISTO EN UNA SESION REAL
+ *
+ * En Google Flow, el agente pulso el boton de generar y la herramienta contesto:
+ *
+ *     Pulsado [19] "Iniciar generación". Pagina ahora: "Google Flow: sept 06..."
+ *
+ * El modelo leyo eso como "hecho" y se puso a esperar el resultado. Pero el clic
+ * no habia disparado nada: la pagina seguia igual. Espero, no vio nada, volvio a
+ * pulsar, volvio a esperar, gasto una captura de pantalla, y solo se desatasco
+ * cuando el usuario le dijo a mano "dale al boton de la flechita".
+ *
+ * El problema no fue del modelo: la herramienta le habia dicho que el clic se
+ * habia dado. Y "se envio el evento" no es lo mismo que "la pagina reacciono".
+ * Una web puede ignorar un clic sintetico por mil motivos -el manejador esta en
+ * otro elemento, hay un overlay delante, el framework escucha pointerdown y no
+ * click-, y ninguno de esos se ve desde fuera.
+ *
+ * QUE SE HACE AHORA
+ *
+ * Se mira la pagina antes y despues. Si no cambio absolutamente nada, se dice —
+ * que es informacion util y no un error: significa "el evento salio pero nadie
+ * lo recogio, prueba otra cosa". Es la diferencia entre que el agente se quede
+ * quince segundos esperando algo que no va a pasar, y que cambie de estrategia
+ * en el turno siguiente.
+ */
+async function reaccionAlClic(filtro, antes) {
+    let fresh;
+    try {
+        fresh = await extensionBridge.send("snapshot", { filter: filtro || "", max: 200 });
+    }
+    catch {
+        return "";
+    }
+    if (!fresh?.ok)
+        return "";
+    const els = fresh.data.elements || [];
+    catalogo.verInterno(els);
+    const ahora = els.map((e) => `${e.role}::${e.name}`);
+    const nuevos = ahora.filter((k) => !antes.includes(k));
+    const idos = antes.filter((k) => !ahora.includes(k));
+    if (nuevos.length === 0 && idos.length === 0) {
+        return (`\nOJO: el clic se envio, pero la pagina NO cambio en nada. Eso suele significar que ` +
+            `el elemento pulsado no es el que dispara la accion (el manejador esta en otro, hay algo ` +
+            `delante, o el framework escucha otro evento). No esperes un resultado: haz snapshot y ` +
+            `busca el control de verdad, o usa computer_use para un clic real del sistema.`);
+    }
+    const resumen = [
+        ...nuevos.slice(0, 6).map((k) => `  + ${k.replace("::", " ")}`),
+        ...idos.slice(0, 4).map((k) => `  - ${k.replace("::", " ")} (ya no esta)`),
+    ].join("\n");
+    return `\nLa pagina reacciono (${nuevos.length} nuevos, ${idos.length} fuera):\n${resumen}`;
+}
 /**
  * Ejecuta una accion sobre un ref del snapshot del modelo, traduciendolo al
  * numero que la extension tiene vivo ahora mismo. Si el ref ha caducado (el
@@ -390,7 +530,8 @@ export async function chromeExtension(params, cwd = process.cwd(), apiKey) {
                         `Si no la reconoces, revisala en chrome://extensions.`
                     : "";
                 return (`Extension conectada (v${res.data.version}), emparejada con ${origin}. ` +
-                    `Puedo trabajar en tus pestanas en segundo plano, sin robarte el foco.${aviso}`);
+                    `Puedo trabajar en tus pestanas en segundo plano, sin robarte el foco.${aviso}` +
+                    avisoDeVersion(String(res.data.version || "")));
             }
             case "tabs": {
                 const res = await extensionBridge.send("tabs");
@@ -469,6 +610,9 @@ export async function chromeExtension(params, cwd = process.cwd(), apiKey) {
             case "click": {
                 if (params.ref === undefined)
                     return fail(action, 'indica el "ref" del snapshot.');
+                // Se apunta como estaba la pagina ANTES: sin eso no hay con que comparar
+                // despues, y "se envio el clic" seguiria pasando por "la pagina reacciono".
+                const antesDelClic = catalogo.huellaVista();
                 const res = await accionSobreRef("click", {}, params.ref, params.filter);
                 if (!res.ok)
                     return fail(action, res.error);
@@ -481,7 +625,9 @@ export async function chromeExtension(params, cwd = process.cwd(), apiKey) {
                 const aviso = mismoElemento(pedido, pulsado)
                     ? ""
                     : `\nAVISO: pediste "${pedido}" y se pulso "${pulsado}". Haz snapshot y comprueba en que estado quedo la pagina.`;
-                return (`Pulsado [${params.ref}] "${pulsado}". Pagina ahora: "${res.data.title}" (${res.data.url})${aviso}`);
+                // Y lo que de verdad importa: si la pagina hizo algo o no. Ver reaccionAlClic.
+                const reaccion = antesDelClic.length > 0 ? await reaccionAlClic(params.filter || "", antesDelClic) : "";
+                return (`Pulsado [${params.ref}] "${pulsado}". Pagina ahora: "${res.data.title}" (${res.data.url})${aviso}${reaccion}`);
             }
             case "type": {
                 if (params.ref === undefined)
@@ -620,7 +766,7 @@ export async function chromeExtension(params, cwd = process.cwd(), apiKey) {
                     ? path.isAbsolute(params.outputPath)
                         ? params.outputPath
                         : path.resolve(cwd, params.outputPath)
-                    : path.join(dir, "chrome_tab.png");
+                    : path.join(dir, "chrome_tab.jpg");
                 const outDir = path.dirname(out);
                 if (!fs.existsSync(outDir))
                     fs.mkdirSync(outDir, { recursive: true });

package/dist/tools/computerUse.d.ts

@@ -23,7 +23,7 @@
  *     "background": se actua sobre una ventana concreta sin traerla al frente y
  *     sin mover el raton del usuario.
  */
-export type ComputerAction = "screenshot" | "ui_snapshot" | "ui_click" | "ui_type" | "ui_focus" | "find_element" | "left_click" | "click" | "double_click" | "triple_click" | "right_click" | "middle_click" | "mouse_move" | "move" | "left_click_drag" | "scroll" | "type" | "key" | "hotkey" | "wait" | "sleep" | "cursor_position" | "list_windows" | "focus_window" | "get_active_window" | "open_app";
+export type ComputerAction = "screenshot" | "ui_snapshot" | "ui_click" | "ui_type" | "ui_focus" | "find_element" | "left_click" | "click" | "double_click" | "triple_click" | "right_click" | "middle_click" | "mouse_move" | "move" | "left_click_drag" | "scroll" | "type" | "key" | "hotkey" | "wait" | "wait_change" | "sleep" | "cursor_position" | "list_windows" | "focus_window" | "get_active_window" | "open_app";
 export interface ComputerUseParams {
     action: ComputerAction;
     /** Ventana objetivo por titulo o proceso (ej. "chrome", "Flow"). */

package/dist/tools/computerUse.js

@@ -68,6 +68,155 @@ function ambiguityNote(p, choice) {
 function fail(action, msg) {
     return `Error en computer_use (${action}): ${msg}`;
 }
+/**
+ * El estado de la ventana DESPUES de actuar, en el mismo resultado.
+ *
+ * POR QUE
+ *
+ * El ciclo de trabajo del agente es mirar, actuar, mirar. Hasta ahora eso
+ * costaba TRES viajes al modelo:
+ *
+ *     ui_snapshot  -> llamada al modelo
+ *     ui_click     -> llamada al modelo   (devolvia solo "Activado [3]")
+ *     ui_snapshot  -> llamada al modelo   (para ver que habia pasado)
+ *
+ * Y cada viaje son entre tres y diez segundos. Medido en esta maquina, un
+ * ui_snapshot cuesta 43 ms: es GRATIS al lado de una llamada al modelo. Asi que
+ * el tercer viaje se hacia solo para pedir algo que el ordenador podia haber
+ * adjuntado desde el principio.
+ *
+ * Devolviendo el estado nuevo con la accion, el ciclo pasa de tres viajes a
+ * dos. En una tarea de diez pasos son diez viajes menos: medio minuto largo.
+ *
+ * CUANDO NO SE HACE
+ *
+ * Si la accion fallo no se adjunta nada: lo que hace falta entonces es el
+ * motivo del fallo, y una lista de controles solo lo entierra.
+ */
+/**
+ * Mirar una ventana muchas veces sin pagarlo muchas veces.
+ *
+ * EL PROBLEMA
+ *
+ * Leer el arbol de accesibilidad cuesta 43 ms: es gratis. Lo que no es gratis
+ * es MANDARSELO al modelo. Un ui_snapshot de una ventana normal son cien lineas
+ * que entran en el historial y se vuelven a pagar en cada turno siguiente. Asi
+ * que mirar seguido -que es lo que hace falta para trabajar en tiempo real- sale
+ * caro por el lado del contexto, no por el de la maquina.
+ *
+ * LA IDEA
+ *
+ * Casi nunca cambia la ventana entera. Se pulsa un boton y se habilita otro; se
+ * escribe en un campo y cambia su valor. De cien controles cambian dos.
+ *
+ * Guardando la ultima foto de cada ventana se puede devolver solo la diferencia:
+ *
+ *     CAMBIOS EN "Calculadora" (3 de 47 controles):
+ *       ~ [12] Text "0" -> "42"
+ *       + [31] Button "Igual" (nuevo)
+ *       - Button "Limpiar" (ya no esta)
+ *
+ * Tres lineas en vez de cuarenta y siete. Eso es lo que hace viable mirar
+ * despues de cada accion sin inflar el contexto.
+ *
+ * CUANDO SE DEVUELVE LA FOTO ENTERA
+ *
+ * La primera vez, cuando no hay con que comparar. Y cuando cambia tanto que el
+ * resumen ya no es mas corto que la lista: si cambio media ventana, es que se
+ * abrio otra pantalla, y ahi lo util es verla entera.
+ */
+/** La ultima foto de cada ventana, para poder contar solo lo que cambio. */
+const ultimaFoto = new Map();
+/** Identidad de un control que NO depende de su numero de ref, que se renumera. */
+function claveDe(e) {
+    return `${e.role}::${e.name}`;
+}
+function compararCon(clave, els) {
+    const ahora = new Map();
+    for (const e of els)
+        ahora.set(claveDe(e), String(e.value ?? ""));
+    const antes = ultimaFoto.get(clave);
+    ultimaFoto.set(clave, ahora);
+    if (!antes)
+        return { hayFoto: false, texto: "", cuantos: 0 };
+    const lineas = [];
+    const porClave = new Map(els.map((e) => [claveDe(e), e]));
+    for (const [k, valor] of ahora) {
+        const e = porClave.get(k);
+        if (!antes.has(k)) {
+            lineas.push(`  + [${e.ref}] ${e.role} "${e.name}" (nuevo)`);
+        }
+        else if (antes.get(k) !== valor) {
+            lineas.push(`  ~ [${e.ref}] ${e.role} "${e.name}": "${antes.get(k)}" -> "${valor}"`);
+        }
+    }
+    for (const k of antes.keys()) {
+        if (!ahora.has(k)) {
+            const [role, name] = k.split("::");
+            lineas.push(`  - ${role} "${name}" (ya no esta)`);
+        }
+    }
+    return { hayFoto: true, texto: lineas.join("\n"), cuantos: lineas.length };
+}
+/** Cuantos controles se adjuntan. Bastantes para decidir, pocos para no inundar. */
+const CONTROLES_TRAS_ACTUAR = 40;
+/**
+ * Espera a que la ventana se quede quieta, y no un tiempo fijo.
+ *
+ * Un clic puede abrir un menu, cargar una lista o no hacer nada visible. Dormir
+ * 700 ms "por si acaso" es lento cuando no pasa nada y corto cuando si pasa.
+ * Se mira dos veces seguidas: si el arbol de controles sale igual, la ventana
+ * ya termino.
+ */
+async function esperarQuieto(args) {
+    let anterior = "";
+    for (let intento = 0; intento < 4; intento++) {
+        const res = await winHost.send("ui_snapshot", { ...args, max: CONTROLES_TRAS_ACTUAR, interactiveOnly: true }, 20_000);
+        if (!res.ok)
+            return null;
+        const huella = JSON.stringify((res.elements || []).map((e) => [e.role, e.name, e.value]));
+        if (huella === anterior)
+            return res;
+        anterior = huella;
+        await new Promise((r) => setTimeout(r, 120));
+    }
+    // Cuatro vueltas sin quedarse quieta: la ventana esta animando algo. Se
+    // devuelve lo ultimo visto, que es mas util que nada.
+    return null;
+}
+/** Lo que se pega al resultado de una accion. Cadena vacia si no hay nada que contar. */
+async function estadoTrasActuar(args) {
+    let res;
+    try {
+        res = await esperarQuieto(args);
+    }
+    catch {
+        return "";
+    }
+    const els = res?.elements || [];
+    if (els.length === 0)
+        return "";
+    // Si hay foto anterior de esta ventana, con decir lo que cambio basta: tres
+    // lineas en vez de cuarenta, y el contexto no se infla en cada clic.
+    const cambios = compararCon(String(res.title || ""), els);
+    if (cambios.hayFoto && cambios.cuantos > 0 && cambios.cuantos <= els.length / 2) {
+        return `\n\nCAMBIOS EN "${res.title}" (${cambios.cuantos} de ${els.length} controles):\n${cambios.texto}`;
+    }
+    if (cambios.hayFoto && cambios.cuantos === 0) {
+        return `\n\nLa ventana "${res.title}" no cambio en nada visible.`;
+    }
+    // Primera vez, o cambio tanto que el resumen ya no seria mas corto: entonces
+    // lo util es la lista entera, porque eso significa que se abrio otra pantalla.
+    const filas = els
+        .map((e) => {
+        const val = e.value ? ` = "${e.value}"` : "";
+        const off = e.enabled ? "" : " [deshabilitado]";
+        return `  [${e.ref}] ${e.role} "${e.name}"${val}${off}  @(${e.x}, ${e.y})`;
+    })
+        .join("\n");
+    return (`\n\nASI HA QUEDADO "${res.title}" (los numeros son NUEVOS, usa estos):\n${filas}` +
+        (res.truncated ? `\n  … hay mas controles; pide ui_snapshot con 'max' mas alto si te falta alguno.` : ""));
+}
 export async function computerUse(params, cwd = process.cwd(), apiKey) {
     const { action } = params;
     const mode = params.mode || "background";
@@ -151,6 +300,10 @@ export async function computerUse(params, cwd = process.cwd(), apiKey) {
                         `Si es un lienzo grafico, usa screenshot con analyze.` +
                         ambiguityNote(params, choice));
                 }
+                // Se apunta esta foto como referencia: si no, el resumen de cambios de la
+                // siguiente accion comparara contra una foto vieja y contara cambios que
+                // el modelo ya ha visto.
+                compararCon(String(res.title || ""), els);
                 const rows = els
                     .map((e) => {
                     const val = e.value ? ` = "${e.value}"` : "";
@@ -163,13 +316,38 @@ export async function computerUse(params, cwd = process.cwd(), apiKey) {
                     `Actua con ui_click / ui_type usando el numero entre corchetes. No hace falta mover el raton.` +
                     ambiguityNote(params, choice));
             }
+            // Esperar a que la ventana haga algo, en vez de dormir un rato y mirar.
+            //
+            // Antes solo existia "wait", que duerme un numero fijo de milisegundos:
+            // corto cuando la aplicacion tarda y desperdiciado cuando no tarda nada.
+            // Esto se suscribe a los avisos de la propia ventana y vuelve en cuanto
+            // pasa algo. Medido en vivo: 275 ms contra los 2 s que se habrian dormido.
+            case "wait_change": {
+                const elegida = await resolveWindow(params);
+                if (!elegida.ok)
+                    return fail(action, elegida.error);
+                const ms = Math.min(Math.max(params.ms ?? 3000, 100), 30_000);
+                const res = await winHost.send("wait_change", { ...pinned(elegida), ...(elegida.hwnd ? {} : windowArgs(params)), timeoutMs: ms }, ms + 10_000);
+                if (!res.ok)
+                    return fail(action, res.error || "fallo desconocido");
+                if (!res.changed) {
+                    return (`La ventana "${elegida.title || params.window}" no cambio en ${ms} ms. ` +
+                        `Si esperabas una reaccion, puede que la accion anterior no surtiera efecto.`);
+                }
+                // Y ya que se vuelve, se dice COMO quedo: si no, hace falta otro viaje.
+                const despues = await estadoTrasActuar(windowArgs(params));
+                return `Cambio: ${res.what}.${despues}`;
+            }
             case "ui_click": {
                 if (!params.ref)
                     return fail(action, 'indica el "ref" que devolvio ui_snapshot.');
                 const res = await winHost.send("ui_click", { ref: params.ref }, 20_000);
                 if (!res.ok)
                     return fail(action, res.error || "fallo desconocido");
-                return `Activado [${params.ref}] ${res.label || ""} (via ${res.via}, sin mover el raton).`;
+                // El estado nuevo va aqui y no en otro viaje al modelo: cuesta 43 ms en
+                // la maquina contra varios segundos de ida y vuelta. Ver estadoTrasActuar.
+                const despues = await estadoTrasActuar(windowArgs(params));
+                return `Activado [${params.ref}] ${res.label || ""} (via ${res.via}, sin mover el raton).${despues}`;
             }
             case "ui_type": {
                 if (!params.ref)
@@ -221,8 +399,11 @@ export async function computerUse(params, cwd = process.cwd(), apiKey) {
                         interactiveOnly: false,
                     });
                     const landed = (check.elements || []).length > 0;
+                    // Igual que en ui_click: el estado nuevo viaja con la accion en vez de
+                    // costar otra ida y vuelta al modelo.
+                    const tras = landed ? await estadoTrasActuar(windowArgs(params)) : "";
                     return landed
-                        ? `Texto escrito en [${params.ref}] con clic y teclado reales, y verificado en el control: "${preview(params.text)}"`
+                        ? `Texto escrito en [${params.ref}] con clic y teclado reales, y verificado en el control: "${preview(params.text)}"${tras}`
                         : `Aviso: se escribio en [${params.ref}] pero el control no muestra el texto. ` +
                             `Puede que el foco se perdiera. Haz ui_snapshot y reintenta antes de dar por hecho que funciono.`;
                 }

package/dist/tools/definitions.js

@@ -205,7 +205,9 @@ export const TOOLS = [
         type: "function",
         function: {
             name: "write_file",
-            description: "Crea un archivo nuevo o sobreescribe uno existente con el contenido provisto. Si el archivo ya existe hay que haberlo leido antes con view_file: sobreescribir borra todo lo que hubiera dentro.",
+            description: "Crea un archivo nuevo o sobreescribe uno existente. Si el archivo ya existe hay que haberlo leido antes con view_file: sobreescribir borra todo lo que hubiera dentro. " +
+                "ARCHIVOS LARGOS: tu respuesta tiene un techo de salida y una pagina entera no cabe de una vez; si se corta, no se escribe NADA. " +
+                "Cuando el archivo pase de unas 400 lineas, parte el trabajo: primera llamada con el principio, y las siguientes con modo=\"anadir\" hasta terminarlo.",
             parameters: {
                 type: "object",
                 properties: {
@@ -215,7 +217,12 @@ export const TOOLS = [
                     },
                     content: {
                         type: "string",
-                        description: "El contenido completo del archivo.",
+                        description: "El contenido del archivo, o el trozo que toca si vas por partes.",
+                    },
+                    modo: {
+                        type: "string",
+                        enum: ["sobrescribir", "anadir"],
+                        description: "sobrescribir (por defecto) reemplaza el archivo entero. anadir pega el contenido al final, para escribir un archivo largo en varias llamadas sin que la segunda borre la primera.",
                     },
                 },
                 required: ["path", "content"],

package/dist/tools/grepSearch.js

@@ -1,37 +1,125 @@
 import fs from "node:fs";
 import path from "node:path";
 import fg from "fast-glob";
+/**
+ * Buscar texto dentro de los archivos.
+ *
+ * TRES FALLOS QUE TENIA, LOS TRES VISTOS EN USO REAL
+ *
+ * 1. Apuntar a UN archivo la reventaba. `fast-glob` recibia ese archivo como
+ *    `cwd` y tiraba `ENOTDIR: not a directory`, que llegaba al modelo como una
+ *    excepcion cruda. Paso en directo: el agente quiso mirar dentro de un .md
+ *    concreto y se comio el error. Buscar dentro de un archivo es lo mas normal
+ *    del mundo y era justo lo que no se podia hacer.
+ *
+ * 2. La consulta se metia tal cual en `new RegExp()`. Buscar "calcular(" o
+ *    "array[0]" -texto plano, lo que escribe cualquiera- lanzaba un
+ *    SyntaxError sin capturar. El agente no tiene por que saber que su busqueda
+ *    era tambien una expresion regular invalida.
+ *
+ * 3. Cortaba en 30 coincidencias y las presentaba como si fueran todas. El
+ *    agente concluia "solo hay 30 usos" y decidia sobre eso.
+ */
+/** Cuantas coincidencias se detallan. Mas no cabe en un resultado de herramienta. */
+const MAX_COINCIDENCIAS = 100;
+/** Tope de archivos que se abren. Un repositorio enorme no puede colgar el turno. */
+const MAX_ARCHIVOS = 3000;
+const IGNORAR = [
+    "**/node_modules/**",
+    "**/.git/**",
+    "**/dist/**",
+    "**/*.lock",
+    "**/*.png",
+    "**/*.jpg",
+    "**/*.mp4",
+    "**/*.webm",
+    "**/*.zip",
+    "**/*.bin",
+];
+/** Escapa el texto para buscarlo literal, cuando no es una regex valida. */
+function comoLiteral(texto) {
+    return texto.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+}
+/**
+ * La consulta, entendida como expresion regular si se puede y como texto si no.
+ *
+ * Se avisa de cual de las dos cosas se hizo: buscar "coste(" literalmente y
+ * buscarlo como regex dan resultados distintos, y el agente decide sobre lo que
+ * lee.
+ */
+function construirRegex(query) {
+    try {
+        return { regex: new RegExp(query, "i"), literal: false };
+    }
+    catch {
+        return { regex: new RegExp(comoLiteral(query), "i"), literal: true };
+    }
+}
 export async function grepSearch(query, searchPath = ".", cwd = process.cwd()) {
+    if (!query)
+        return "Error: no se dijo que buscar.";
     const resolved = path.isAbsolute(searchPath) ? searchPath : path.resolve(cwd, searchPath);
-    if (!fs.existsSync(resolved)) {
+    let stat;
+    try {
+        stat = fs.statSync(resolved);
+    }
+    catch {
         return `Error: La ruta "${searchPath}" no existe.`;
     }
-    const files = await fg(["**/*"], {
-        cwd: resolved,
-        onlyFiles: true,
-        ignore: ["**/node_modules/**", "**/.git/**", "**/dist/**", "**/*.lock", "**/*.png", "**/*.jpg", "**/*.mp4", "**/*.webm", "**/*.zip", "**/*.bin"],
-    });
-    const matches = [];
-    const regex = new RegExp(query, "i");
-    for (const relFile of files) {
-        if (matches.length >= 30)
-            break; // Limit to 30 matches
-        const fullPath = path.join(resolved, relFile);
+    // Un archivo suelto se busca dentro de el, que es lo que pide quien lo apunta.
+    // Antes esto llegaba a fast-glob como `cwd` y reventaba con ENOTDIR.
+    let raiz;
+    let archivos;
+    if (stat.isFile()) {
+        raiz = path.dirname(resolved);
+        archivos = [path.basename(resolved)];
+    }
+    else {
+        raiz = resolved;
+        archivos = await fg(["**/*"], { cwd: raiz, onlyFiles: true, ignore: IGNORAR });
+    }
+    const { regex, literal } = construirRegex(query);
+    const coincidencias = [];
+    let total = 0;
+    let archivosMirados = 0;
+    let quedaronArchivos = false;
+    for (const relFile of archivos) {
+        if (archivosMirados >= MAX_ARCHIVOS) {
+            quedaronArchivos = true;
+            break;
+        }
+        archivosMirados++;
+        let contenido;
         try {
-            const content = fs.readFileSync(fullPath, "utf-8");
-            const lines = content.split(/\r?\n/);
-            lines.forEach((line, idx) => {
-                if (regex.test(line) && matches.length < 30) {
-                    matches.push(`${relFile}:${idx + 1} | ${line.trim()}`);
-                }
-            });
+            contenido = fs.readFileSync(path.join(raiz, relFile), "utf-8");
         }
         catch {
-            // Ignore binary files or read errors
+            // Binario o sin permiso: no es un fallo de la busqueda.
+            continue;
+        }
+        const lineas = contenido.split(/\r?\n/);
+        for (let i = 0; i < lineas.length; i++) {
+            if (!regex.test(lineas[i]))
+                continue;
+            total++;
+            // Se sigue CONTANDO despues del tope: decir "30" cuando hay 400 es lo que
+            // hacia que el agente decidiera sobre un numero falso.
+            if (coincidencias.length < MAX_COINCIDENCIAS) {
+                coincidencias.push(`${relFile}:${i + 1} | ${lineas[i].trim()}`);
+            }
         }
     }
-    if (matches.length === 0) {
-        return `No se encontraron coincidencias para "${query}" en "${searchPath}".`;
+    const nota = literal
+        ? `\n\n(La consulta no era una expresion regular valida, asi que se busco como texto literal.)`
+        : "";
+    if (total === 0) {
+        return `No se encontraron coincidencias para "${query}" en "${searchPath}".${nota}`;
     }
-    return `Coincidencias encontradas (${matches.length}):\n${matches.join("\n")}`;
+    const cabecera = total > coincidencias.length
+        ? `Coincidencias: ${total} en total, se muestran las primeras ${coincidencias.length}. Afina la busqueda o apunta a una carpeta mas concreta.`
+        : `Coincidencias encontradas (${total}):`;
+    const aviso = quedaronArchivos
+        ? `\n\n(Se pararon en ${MAX_ARCHIVOS} archivos: puede haber mas fuera de esa cuenta.)`
+        : "";
+    return `${cabecera}\n${coincidencias.join("\n")}${aviso}${nota}`;
 }

package/dist/tools/runner.js

@@ -164,7 +164,7 @@ export async function executeToolCall(name, args, cwd = process.cwd(), apiKey, m
                     break;
                 }
                 globalUndoManager.snapshotFile(args.path, cwd);
-                rawResult = await writeFile(args.path, args.content, cwd);
+                rawResult = await writeFile(args.path, args.content, cwd, args.modo === "anadir" ? "anadir" : "sobrescribir");
                 fileTracker.markWritten(args.path, cwd);
                 const check = validateFileSyntax(args.path, args.content || "");
                 if (!check.valid && check.warning) {