chocolatito-code 1.1.0 → 1.2.0

package/dist/mcp/client.d.ts

@@ -68,7 +68,35 @@ export declare class McpClient {
     private spawnServer;
     private onMessage;
     private request;
+    /**
+     * Identificador de sesion que asigna el servidor HTTP.
+     *
+     * El transporte "streamable HTTP" del protocolo permite que el servidor
+     * devuelva una cabecera `Mcp-Session-Id` al responder al `initialize`, y a
+     * partir de ahi EXIGE que el cliente la mande en todas las peticiones
+     * siguientes. Sin esto, un servidor con sesion acepta el saludo y luego
+     * rechaza absolutamente todo lo demas: la conexion parece buena, la lista de
+     * herramientas llega vacia o con un 400, y desde fuera solo se ve un servidor
+     * que "no funciona" sin decir por que.
+     */
+    private sessionId;
+    /** Las mismas cabeceras para peticiones y notificaciones, sesion incluida. */
+    private cabecerasHttp;
     private notify;
+    /**
+     * Una notificacion por HTTP.
+     *
+     * Antes esto no existia y `notify()` se iba de vacio en cuanto habia una URL,
+     * asi que `notifications/initialized` solo viajaba por stdio. El protocolo la
+     * exige despues del `initialize`, y hay servidores que no atienden nada mas
+     * hasta recibirla: quedaban colgados en el saludo.
+     *
+     * No lleva id y no espera resultado -el servidor contesta 202 con el cuerpo
+     * vacio-, asi que no se parsea nada. Un fallo aqui tampoco se propaga: si el
+     * servidor no la queria, se vera en la peticion siguiente, que si tiene a
+     * quien quejarse.
+     */
+    private httpNotify;
     private httpRequest;
     private initialize;
     private listTools;

package/dist/mcp/client.js

@@ -272,13 +272,62 @@ export class McpClient {
             }
         });
     }
+    /**
+     * Identificador de sesion que asigna el servidor HTTP.
+     *
+     * El transporte "streamable HTTP" del protocolo permite que el servidor
+     * devuelva una cabecera `Mcp-Session-Id` al responder al `initialize`, y a
+     * partir de ahi EXIGE que el cliente la mande en todas las peticiones
+     * siguientes. Sin esto, un servidor con sesion acepta el saludo y luego
+     * rechaza absolutamente todo lo demas: la conexion parece buena, la lista de
+     * herramientas llega vacia o con un 400, y desde fuera solo se ve un servidor
+     * que "no funciona" sin decir por que.
+     */
+    sessionId = null;
+    /** Las mismas cabeceras para peticiones y notificaciones, sesion incluida. */
+    cabecerasHttp() {
+        return {
+            "Content-Type": "application/json",
+            Accept: "application/json, text/event-stream",
+            ...(this.sessionId ? { "Mcp-Session-Id": this.sessionId } : {}),
+            // Las del usuario van al final: si configura una a mano, manda la suya.
+            ...(this.config.headers || {}),
+        };
+    }
     notify(method, params) {
-        if (this.config.url || !this.proc)
-            return;
+        if (this.config.url)
+            return this.httpNotify(method, params);
+        if (!this.proc)
+            return Promise.resolve();
         try {
             this.proc.stdin.write(JSON.stringify({ jsonrpc: "2.0", method, params }) + "\n");
         }
         catch { }
+        return Promise.resolve();
+    }
+    /**
+     * Una notificacion por HTTP.
+     *
+     * Antes esto no existia y `notify()` se iba de vacio en cuanto habia una URL,
+     * asi que `notifications/initialized` solo viajaba por stdio. El protocolo la
+     * exige despues del `initialize`, y hay servidores que no atienden nada mas
+     * hasta recibirla: quedaban colgados en el saludo.
+     *
+     * No lleva id y no espera resultado -el servidor contesta 202 con el cuerpo
+     * vacio-, asi que no se parsea nada. Un fallo aqui tampoco se propaga: si el
+     * servidor no la queria, se vera en la peticion siguiente, que si tiene a
+     * quien quejarse.
+     */
+    async httpNotify(method, params) {
+        try {
+            await fetch(this.config.url, {
+                method: "POST",
+                headers: this.cabecerasHttp(),
+                body: JSON.stringify({ jsonrpc: "2.0", method, params }),
+                signal: AbortSignal.timeout(5000),
+            });
+        }
+        catch { }
     }
     async httpRequest(method, params, timeoutMs) {
         const controller = new AbortController();
@@ -287,14 +336,16 @@ export class McpClient {
         try {
             const res = await fetch(this.config.url, {
                 method: "POST",
-                headers: {
-                    "Content-Type": "application/json",
-                    Accept: "application/json, text/event-stream",
-                    ...(this.config.headers || {}),
-                },
+                headers: this.cabecerasHttp(),
                 body: JSON.stringify({ jsonrpc: "2.0", id, method, params }),
                 signal: controller.signal,
             });
+            // La sesion se apunta ANTES de mirar si la respuesta fue buena: hay
+            // servidores que la asignan y en la misma respuesta se quejan de algo
+            // menor, y tirarla aqui condenaria todas las peticiones siguientes.
+            const sesion = res.headers.get("mcp-session-id");
+            if (sesion)
+                this.sessionId = sesion;
             if (!res.ok)
                 throw new Error(`HTTP ${res.status}`);
             const text = await res.text();
@@ -314,7 +365,10 @@ export class McpClient {
             capabilities: { tools: {} },
             clientInfo: { name: "chocolatito-code", version: "1.0.0" },
         }, timeoutMs);
-        this.notify("notifications/initialized", {});
+        // Se ESPERA a que salga, no se lanza y se olvida. Por HTTP la notificacion
+        // es otra peticion, y si `tools/list` sale antes de que el servidor haya
+        // visto el "ya estoy listo", hay servidores que la rechazan.
+        await this.notify("notifications/initialized", {});
     }
     async listTools(timeoutMs) {
         const out = [];

package/dist/mcp/ide.d.ts

@@ -0,0 +1,76 @@
+import type { McpServerConfig } from "./client.js";
+/**
+ * Encontrar el editor que hay delante, sin que el usuario configure nada.
+ *
+ * COMO SE HABLAN
+ *
+ * Al reves de lo que parece: la extension del editor es el SERVIDOR MCP y el
+ * agente es el cliente. La extension levanta un servidor en localhost y deja
+ * aqui una ficha con el puerto; el agente la lee al arrancar y se conecta solo.
+ * Asi el editor le presta al agente lo unico que el agente no puede tener por su
+ * cuenta: los diagnosticos del servidor de lenguaje, lo que hay seleccionado, y
+ * un sitio donde pintar los diffs de verdad.
+ *
+ * POR QUE UNA FICHA POR VENTANA Y NO UN PUERTO FIJO
+ *
+ * Porque casi nadie tiene un solo VSCode abierto. Con un puerto fijo, el segundo
+ * que arranca no puede escuchar, y el agente de un proyecto acabaria pintando
+ * sus diffs en la ventana de otro. Cada ventana deja su ficha con su carpeta, y
+ * aqui se elige la que de verdad corresponde al directorio de trabajo.
+ *
+ * SEGURIDAD
+ *
+ * El servidor escucha solo en 127.0.0.1 y la ficha lleva un token que hay que
+ * mandar en cada peticion. Sin eso, cualquier programa de la maquina podria
+ * pedirle al editor del usuario que abriera y modificara archivos. La ficha vive
+ * en el home, que es donde ya viven las credenciales.
+ */
+/** Donde deja su ficha cada ventana del editor. */
+export declare function carpetaDeFichas(): string;
+export interface FichaDeEditor {
+    /** Puerto del servidor MCP de esa ventana. */
+    puerto: number;
+    /** Secreto que hay que presentar en cada peticion. */
+    token: string;
+    /** Carpeta abierta en esa ventana. Es lo que decide cual toca. */
+    carpeta: string;
+    /** Proceso de la ventana, para saber si sigue viva. */
+    pid: number;
+    /** "Visual Studio Code", "Cursor"... solo para poder decirlo por pantalla. */
+    editor?: string;
+}
+/** Si `hijo` esta dentro de `padre` (o es el mismo). */
+export declare function estaDentro(hijo: string, padre: string): boolean;
+/**
+ * Lee las fichas que hay ahora mismo, tirando las de ventanas ya cerradas.
+ *
+ * `limpiar` borra las huerfanas del disco. Se hace de paso, no en un proceso
+ * aparte: si no, se acumulan para siempre y cada arranque tiene que descartar
+ * mas basura.
+ */
+export declare function leerFichas(dir?: string, limpiar?: boolean): FichaDeEditor[];
+/**
+ * De todas las ventanas abiertas, la que corresponde a este directorio.
+ *
+ * Nunca devuelve "la primera que haya": si ninguna contiene al directorio de
+ * trabajo, se devuelve null y el agente sigue sin editor. Conectarse a una
+ * ventana ajena seria peor que no conectarse a ninguna, porque los diffs
+ * apareceran en el proyecto equivocado y el usuario los aceptaria sin mirar.
+ *
+ * Cuando varias contienen al directorio (un monorepo abierto entero y un
+ * paquete suyo abierto aparte), gana LA MAS CERCANA: la carpeta mas larga es la
+ * mas especifica.
+ */
+export declare function elegirFicha(cwd: string, fichas: FichaDeEditor[]): FichaDeEditor | null;
+/** La configuracion de servidor MCP que representa a ese editor. */
+export declare function configDeFicha(ficha: FichaDeEditor): McpServerConfig;
+/**
+ * Lo que hay que anadir a la configuracion MCP por tener un editor delante.
+ *
+ * Devuelve un objeto vacio si no hay ninguno, que es el caso normal de quien usa
+ * solo la terminal: nadie tiene que configurar nada para que esto no le moleste.
+ */
+export declare function servidorDelEditor(cwd: string, dir?: string): {
+    config: Record<string, McpServerConfig>;
+    ficha: FichaDeEditor | null;
+};

package/dist/mcp/ide.js

@@ -0,0 +1,160 @@
+import fs from "node:fs";
+import os from "node:os";
+import path from "node:path";
+/**
+ * Encontrar el editor que hay delante, sin que el usuario configure nada.
+ *
+ * COMO SE HABLAN
+ *
+ * Al reves de lo que parece: la extension del editor es el SERVIDOR MCP y el
+ * agente es el cliente. La extension levanta un servidor en localhost y deja
+ * aqui una ficha con el puerto; el agente la lee al arrancar y se conecta solo.
+ * Asi el editor le presta al agente lo unico que el agente no puede tener por su
+ * cuenta: los diagnosticos del servidor de lenguaje, lo que hay seleccionado, y
+ * un sitio donde pintar los diffs de verdad.
+ *
+ * POR QUE UNA FICHA POR VENTANA Y NO UN PUERTO FIJO
+ *
+ * Porque casi nadie tiene un solo VSCode abierto. Con un puerto fijo, el segundo
+ * que arranca no puede escuchar, y el agente de un proyecto acabaria pintando
+ * sus diffs en la ventana de otro. Cada ventana deja su ficha con su carpeta, y
+ * aqui se elige la que de verdad corresponde al directorio de trabajo.
+ *
+ * SEGURIDAD
+ *
+ * El servidor escucha solo en 127.0.0.1 y la ficha lleva un token que hay que
+ * mandar en cada peticion. Sin eso, cualquier programa de la maquina podria
+ * pedirle al editor del usuario que abriera y modificara archivos. La ficha vive
+ * en el home, que es donde ya viven las credenciales.
+ */
+/** Donde deja su ficha cada ventana del editor. */
+export function carpetaDeFichas() {
+    return path.join(os.homedir(), ".chocolatito", "ide");
+}
+function normalizar(p) {
+    const limpio = path.resolve(p).replace(/[\\/]+$/, "");
+    // Windows no distingue mayusculas en las rutas, y comparar sin normalizar
+    // hace que "C:\Users" y "c:\users" parezcan proyectos distintos.
+    return process.platform === "win32" ? limpio.toLowerCase() : limpio;
+}
+/** Si `hijo` esta dentro de `padre` (o es el mismo). */
+export function estaDentro(hijo, padre) {
+    const h = normalizar(hijo);
+    const p = normalizar(padre);
+    if (h === p)
+        return true;
+    // El separador importa: sin el, "/proyecto-viejo" pasaria por estar dentro de
+    // "/proyecto".
+    return h.startsWith(p + path.sep) || h.startsWith(p + "/");
+}
+/** Si el proceso de esa ventana sigue vivo. Una ficha huerfana no vale. */
+function sigueViva(pid) {
+    if (!Number.isInteger(pid) || pid <= 0)
+        return false;
+    try {
+        // La senal 0 no manda nada: solo pregunta si existe y si se puede tocar.
+        process.kill(pid, 0);
+        return true;
+    }
+    catch (err) {
+        // EPERM significa que existe pero es de otro usuario: existe, que es lo que
+        // se preguntaba.
+        return err?.code === "EPERM";
+    }
+}
+function esFicha(x) {
+    return (x &&
+        Number.isInteger(x.puerto) &&
+        x.puerto > 0 &&
+        typeof x.token === "string" &&
+        x.token.length > 0 &&
+        typeof x.carpeta === "string" &&
+        x.carpeta.length > 0);
+}
+/**
+ * Lee las fichas que hay ahora mismo, tirando las de ventanas ya cerradas.
+ *
+ * `limpiar` borra las huerfanas del disco. Se hace de paso, no en un proceso
+ * aparte: si no, se acumulan para siempre y cada arranque tiene que descartar
+ * mas basura.
+ */
+export function leerFichas(dir = carpetaDeFichas(), limpiar = true) {
+    let nombres;
+    try {
+        nombres = fs.readdirSync(dir).filter((n) => n.endsWith(".json"));
+    }
+    catch {
+        return [];
+    }
+    const vivas = [];
+    for (const nombre of nombres) {
+        const completo = path.join(dir, nombre);
+        let ficha;
+        try {
+            ficha = JSON.parse(fs.readFileSync(completo, "utf-8"));
+        }
+        catch {
+            // Una ficha rota no puede impedir encontrar las buenas.
+            continue;
+        }
+        if (!esFicha(ficha))
+            continue;
+        if (!sigueViva(ficha.pid)) {
+            if (limpiar) {
+                try {
+                    fs.unlinkSync(completo);
+                }
+                catch { }
+            }
+            continue;
+        }
+        vivas.push(ficha);
+    }
+    return vivas;
+}
+/**
+ * De todas las ventanas abiertas, la que corresponde a este directorio.
+ *
+ * Nunca devuelve "la primera que haya": si ninguna contiene al directorio de
+ * trabajo, se devuelve null y el agente sigue sin editor. Conectarse a una
+ * ventana ajena seria peor que no conectarse a ninguna, porque los diffs
+ * apareceran en el proyecto equivocado y el usuario los aceptaria sin mirar.
+ *
+ * Cuando varias contienen al directorio (un monorepo abierto entero y un
+ * paquete suyo abierto aparte), gana LA MAS CERCANA: la carpeta mas larga es la
+ * mas especifica.
+ */
+export function elegirFicha(cwd, fichas) {
+    const candidatas = fichas.filter((f) => estaDentro(cwd, f.carpeta));
+    if (candidatas.length === 0)
+        return null;
+    return candidatas.sort((a, b) => normalizar(b.carpeta).length - normalizar(a.carpeta).length)[0];
+}
+/** La configuracion de servidor MCP que representa a ese editor. */
+export function configDeFicha(ficha) {
+    return {
+        type: "http",
+        // Solo el bucle local: nunca la interfaz de red, que expondria el editor
+        // del usuario a cualquiera que comparta su wifi.
+        url: `http://127.0.0.1:${ficha.puerto}/mcp`,
+        headers: { Authorization: `Bearer ${ficha.token}` },
+        // Corto a proposito: es un proceso local. Si no contesta en 5 s es que la
+        // ventana esta colgada, y esperar 20 retrasaria el arranque para nada.
+        timeout: 5000,
+    };
+}
+/**
+ * Lo que hay que anadir a la configuracion MCP por tener un editor delante.
+ *
+ * Devuelve un objeto vacio si no hay ninguno, que es el caso normal de quien usa
+ * solo la terminal: nadie tiene que configurar nada para que esto no le moleste.
+ */
+export function servidorDelEditor(cwd, dir = carpetaDeFichas()) {
+    // Puerta de salida para quien no lo quiera, y para poder reproducir fallos.
+    if (process.env.CHOCOLATITO_SIN_EDITOR === "1")
+        return { config: {}, ficha: null };
+    const ficha = elegirFicha(cwd, leerFichas(dir));
+    if (!ficha)
+        return { config: {}, ficha: null };
+    return { config: { ide: configDeFicha(ficha) }, ficha };
+}

package/dist/mcp/manager.js

@@ -2,6 +2,7 @@ import fs from "node:fs";
 import path from "node:path";
 import os from "node:os";
 import { McpClient } from "./client.js";
+import { servidorDelEditor } from "./ide.js";
 /**
  * Gestor de servidores MCP.
  *
@@ -49,6 +50,14 @@ export class McpManager {
                 // Un JSON roto no debe impedir arrancar el agente.
             }
         }
+        // El editor que haya delante se anade solo, sin que nadie lo configure. Va
+        // el ultimo a proposito: si el usuario define un servidor llamado "ide" a
+        // mano, gana el suyo. Ver ide.ts.
+        const { config: delEditor } = servidorDelEditor(this.cwd);
+        for (const [name, cfg] of Object.entries(delEditor)) {
+            if (!merged[name])
+                merged[name] = cfg;
+        }
         return merged;
     }
     /** Conecta todos los servidores configurados. Devuelve un resumen legible. */

package/dist/tools/browserExtension.js

@@ -46,6 +46,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 +56,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 +140,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 +189,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 +250,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 { }
     }

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) {