chocolatito-code 1.0.0 → 1.2.0

package/dist/tools/browserSession.d.ts

@@ -0,0 +1,23 @@
+/**
+ * ESTADO DE LA SESION DE NAVEGADOR
+ *
+ * Un solo booleano, en un modulo propio, por una razon concreta: la tabla de
+ * permisos necesita saber si hay un Chrome ya enganchado y no puede importar
+ * browserCdp para averiguarlo (arrastraria puppeteer-core entero dentro de
+ * config/, y ademas browserCdp acabaria importando permisos: ciclo).
+ *
+ * Por que hace falta el dato: browserCdp clasificaba `attach`, `tabs`,
+ * `snapshot`, `get_text`, `screenshot`, `wait_for` y `console` como "solo
+ * observar", pero TODAS pasan por ensureBrowser(), que si no encuentra un Chrome
+ * escuchando el puerto de depuracion LANZA uno con spawn(detached). O sea que la
+ * accion mas inocente de la lista arrancaba un proceso que sobrevive a la CLI, y
+ * con useSystemProfile lo arrancaba sobre el perfil real del usuario con el
+ * 9222 abierto en 127.0.0.1, sin un solo dialogo y tambien en modo plan.
+ *
+ * Mirar solo es gratis cuando NO hay nada que arrancar. Ese es el matiz que
+ * guarda este flag.
+ */
+/** Lo llama browserCdp cada vez que se conecta o se suelta un navegador. */
+export declare function setBrowserAttached(valor: boolean): void;
+/** true solo si hay una sesion CDP viva: entonces observar no arranca nada. */
+export declare function isBrowserAttached(): boolean;

package/dist/tools/browserSession.js

@@ -0,0 +1,28 @@
+/**
+ * ESTADO DE LA SESION DE NAVEGADOR
+ *
+ * Un solo booleano, en un modulo propio, por una razon concreta: la tabla de
+ * permisos necesita saber si hay un Chrome ya enganchado y no puede importar
+ * browserCdp para averiguarlo (arrastraria puppeteer-core entero dentro de
+ * config/, y ademas browserCdp acabaria importando permisos: ciclo).
+ *
+ * Por que hace falta el dato: browserCdp clasificaba `attach`, `tabs`,
+ * `snapshot`, `get_text`, `screenshot`, `wait_for` y `console` como "solo
+ * observar", pero TODAS pasan por ensureBrowser(), que si no encuentra un Chrome
+ * escuchando el puerto de depuracion LANZA uno con spawn(detached). O sea que la
+ * accion mas inocente de la lista arrancaba un proceso que sobrevive a la CLI, y
+ * con useSystemProfile lo arrancaba sobre el perfil real del usuario con el
+ * 9222 abierto en 127.0.0.1, sin un solo dialogo y tambien en modo plan.
+ *
+ * Mirar solo es gratis cuando NO hay nada que arrancar. Ese es el matiz que
+ * guarda este flag.
+ */
+let enganchado = false;
+/** Lo llama browserCdp cada vez que se conecta o se suelta un navegador. */
+export function setBrowserAttached(valor) {
+    enganchado = valor;
+}
+/** true solo si hay una sesion CDP viva: entonces observar no arranca nada. */
+export function isBrowserAttached() {
+    return enganchado;
+}

package/dist/tools/computerUse.js

@@ -412,10 +412,42 @@ export async function computerUse(params, cwd = process.cwd(), apiKey) {
                 const combo = normalizeKeys(params.keys || params.key || params.text || "");
                 if (!combo)
                     return fail(action, 'indica la tecla en "keys" (ej. "Return", "ctrl+t", "alt+Tab").');
+                // Un atajo sale por SendInput, que entra SIEMPRE por la ventana con el
+                // foco. No hay atajo "de fondo": PostMessage no deja las modificadoras
+                // en el estado de teclado del destino, asi que ctrl+s llegaria como una
+                // "s" suelta. Hasta aqui `window` se aceptaba y se tiraba a la basura:
+                // el modelo pedia ctrl+w "en el Bloc de notas" y la combinacion caia en
+                // el Word que el usuario tenia delante; con alt+F4 le cerraba la
+                // aplicacion. Ahora, si se pide una ventana, se enfoca antes de teclear
+                // y si no se puede no se manda nada.
+                let destino = "la ventana enfocada";
+                if (params.window) {
+                    const elegida = await resolveWindow(params);
+                    if (!elegida.ok)
+                        return fail(action, elegida.error);
+                    // Mismo corte que focus_window: enfocar y teclear a ciegas entre
+                    // ventanas empatadas es como se cierra la que no era.
+                    if (elegida.matches > 1) {
+                        return fail(action, `"${params.window}" coincide con ${elegida.matches} ventanas (${elegida.candidates}). ` +
+                            `Un atajo no se deshace: usa list_windows y pasa un titulo mas concreto.`);
+                    }
+                    const enfocada = await winHost.send("focus_window", {
+                        ...pinned(elegida),
+                        ...(elegida.hwnd ? {} : windowArgs(params)),
+                    });
+                    if (!enfocada.ok) {
+                        return fail(action, `no se pudo poner delante "${elegida.title || params.window}" para mandarle "${combo}" ` +
+                            `(ahora manda "${enfocada.foreground || "?"}"). No se envia nada: iria a la ventana equivocada.`);
+                    }
+                    // El foco no cambia en el mismo instante en que la API dice que si:
+                    // sin esta pausa la primera pulsacion se la queda la ventana anterior.
+                    await new Promise((r) => setTimeout(r, 250));
+                    destino = `"${enfocada.title || elegida.title || params.window}"`;
+                }
                 const res = await winHost.send("key", { keys: combo, repeat: params.repeat ?? 1 });
                 if (!res.ok)
                     return fail(action, res.error || "fallo desconocido");
-                return `Tecla "${combo}"${res.repeat > 1 ? ` x${res.repeat}` : ""} enviada a la ventana enfocada.`;
+                return `Tecla "${combo}"${res.repeat > 1 ? ` x${res.repeat}` : ""} enviada a ${destino}.`;
             }
             case "open_app": {
                 const target = params.appName || params.text;

package/dist/tools/createImage.d.ts

@@ -1 +1,12 @@
+/**
+ * Genera una imagen a partir de un SVG o de un script de Python.
+ *
+ * La segunda rama no dibuja: guarda el texto que ha escrito el modelo en un .py
+ * y lo ejecuta entero. Un `shutil.rmtree(...)` metido ahi borra el arbol igual
+ * que por run_command, solo que con nombre de herramienta de dibujo. Por eso
+ * `permissions.ts` la clasifica como `exec` (pregunta salvo allowlist) y la
+ * bloquea en modo plan, y por eso el SVG se detecta con `isSvgSource`, la misma
+ * funcion que mira la tabla de permisos: dos detecciones distintas serian dos
+ * criterios distintos sobre que se ejecuta y que no.
+ */
 export declare function createImage(outputPath: string, generatorScript: string, cwd?: string): Promise<string>;

package/dist/tools/createImage.js

@@ -1,6 +1,18 @@
 import fs from "node:fs";
 import path from "node:path";
 import { execa } from "execa";
+import { isSvgSource } from "../config/permissions.js";
+/**
+ * Genera una imagen a partir de un SVG o de un script de Python.
+ *
+ * La segunda rama no dibuja: guarda el texto que ha escrito el modelo en un .py
+ * y lo ejecuta entero. Un `shutil.rmtree(...)` metido ahi borra el arbol igual
+ * que por run_command, solo que con nombre de herramienta de dibujo. Por eso
+ * `permissions.ts` la clasifica como `exec` (pregunta salvo allowlist) y la
+ * bloquea en modo plan, y por eso el SVG se detecta con `isSvgSource`, la misma
+ * funcion que mira la tabla de permisos: dos detecciones distintas serian dos
+ * criterios distintos sobre que se ejecuta y que no.
+ */
 export async function createImage(outputPath, generatorScript, cwd = process.cwd()) {
     const resolved = path.isAbsolute(outputPath) ? outputPath : path.resolve(cwd, outputPath);
     const outDir = path.dirname(resolved);
@@ -8,7 +20,7 @@ export async function createImage(outputPath, generatorScript, cwd = process.cwd
         fs.mkdirSync(outDir, { recursive: true });
     }
     // If generatorScript is SVG, save directly
-    if (generatorScript.trim().startsWith("<svg") || generatorScript.trim().startsWith("<?xml")) {
+    if (isSvgSource(generatorScript)) {
         fs.writeFileSync(resolved, generatorScript, "utf-8");
         return `✔ Imagen SVG generada y guardada en "${outputPath}" (${fs.statSync(resolved).size} bytes).`;
     }

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.",
+            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"],
@@ -226,7 +233,7 @@ export const TOOLS = [
         type: "function",
         function: {
             name: "delete_file",
-            description: "Elimina un archivo o directorio de forma segura.",
+            description: "Elimina un archivo o directorio. El borrado es permanente: /undo solo puede devolver archivos sueltos, nunca un directorio ni un archivo bloqueado por otro proceso.",
             parameters: {
                 type: "object",
                 properties: {
@@ -243,7 +250,8 @@ export const TOOLS = [
         type: "function",
         function: {
             name: "move_copy_file",
-            description: "Mueve, renombra o copia archivos y directorios.",
+            description: "Mueve, renombra o copia archivos y directorios. Si el destino ya existe la llamada se corta sin tocar el disco: " +
+                "reemplazarlo borra lo que hubiera ahi y exige overwrite=true, que el usuario tiene que confirmar.",
             parameters: {
                 type: "object",
                 properties: {
@@ -260,6 +268,11 @@ export const TOOLS = [
                         enum: ["move", "copy"],
                         description: "Operación a realizar.",
                     },
+                    overwrite: {
+                        type: "boolean",
+                        description: "Solo si de verdad quieres reemplazar un destino que ya existe: borra su contenido anterior. " +
+                            "Por defecto false, y sin él la operación se rechaza en vez de pisar nada.",
+                    },
                 },
                 required: ["sourcePath", "destinationPath"],
             },

package/dist/tools/editDiagnosis.d.ts

@@ -0,0 +1,54 @@
+/**
+ * Que se le contesta al modelo cuando un edit_file no encuentra su fragmento.
+ *
+ * El mensaje anterior era "No se encontro el fragmento de texto. Asegurate de
+ * copiar las lineas exactas": cierto, inutil y, sobre todo, IDENTICO cada vez.
+ * Un mensaje que no aporta informacion nueva invita a reintentar lo mismo, y
+ * cada reintento cuesta una iteracion y dinero de la cuota.
+ *
+ * Aider resuelve esto devolviendo el tramo real mas parecido ("did you mean
+ * these actual lines?"), y Crush pintando los espacios invisibles. Las dos
+ * cosas atacan el mismo problema: el modelo no puede corregir una diferencia
+ * que no ve.
+ */
+/**
+ * Coeficiente de Dice sobre bigramas de caracteres.
+ *
+ * Se usa en vez de una distancia de edicion porque es lineal y aqui hay que
+ * puntuar una ventana por cada linea del archivo. Da lo mismo que el ratio de
+ * SequenceMatcher para lo unico que se necesita: ordenar candidatos.
+ */
+export declare function similitud(a: string, b: string): number;
+export interface TramoParecido {
+    /** Numero de la primera linea del tramo, 1-based. */
+    primeraLinea: number;
+    lineas: string[];
+    parecido: number;
+}
+/**
+ * Ventana del archivo mas parecida al fragmento buscado.
+ *
+ * Se comparan ventanas del MISMO numero de lineas que el fragmento, deslizando
+ * una a una. Si el mejor candidato no llega al umbral, no se devuelve nada:
+ * ensenar un tramo al azar es peor que no ensenar ninguno, porque el modelo se
+ * lo cree y edita ahi.
+ */
+export declare function tramoMasParecido(contenido: string, fragmento: string, umbral?: number): TramoParecido | null;
+/**
+ * Pinta la sangria y los espacios finales, que son invisibles y son justo lo
+ * que falla. El interior de la linea se deja tal cual: marcarlo entero hace el
+ * texto ilegible y no anade informacion.
+ */
+export declare function marcarEspacios(texto: string): string;
+/**
+ * Mensaje de error de edit_file cuando no hay coincidencia.
+ *
+ * Tres piezas, en orden de utilidad:
+ *  1. "esto ya esta aplicado" corta en seco el bucle de reaplicar un cambio que
+ *     ya se hizo, que es el atasco mas caro y el mas frecuente;
+ *  2. el tramo real mas parecido, con numeros de linea y los espacios pintados;
+ *  3. que reenvie SOLO este bloque.
+ */
+export declare function diagnosticarFallo(rutaMostrada: string, contenido: string, viejo: string, nuevo: string): string;
+/** Mensaje cuando el fragmento aparece varias veces. */
+export declare function diagnosticarAmbiguedad(rutaMostrada: string, ocurrencias: number, estrategia: string): string;

package/dist/tools/editDiagnosis.js

@@ -0,0 +1,142 @@
+/**
+ * Que se le contesta al modelo cuando un edit_file no encuentra su fragmento.
+ *
+ * El mensaje anterior era "No se encontro el fragmento de texto. Asegurate de
+ * copiar las lineas exactas": cierto, inutil y, sobre todo, IDENTICO cada vez.
+ * Un mensaje que no aporta informacion nueva invita a reintentar lo mismo, y
+ * cada reintento cuesta una iteracion y dinero de la cuota.
+ *
+ * Aider resuelve esto devolviendo el tramo real mas parecido ("did you mean
+ * these actual lines?"), y Crush pintando los espacios invisibles. Las dos
+ * cosas atacan el mismo problema: el modelo no puede corregir una diferencia
+ * que no ve.
+ */
+/** Numero de lineas de contexto que se ensenan alrededor del tramo candidato. */
+const CONTEXTO = 3;
+/** Similitud minima para molestarse en ensenar un tramo. */
+const UMBRAL_PARECIDO = 0.6;
+/**
+ * Coeficiente de Dice sobre bigramas de caracteres.
+ *
+ * Se usa en vez de una distancia de edicion porque es lineal y aqui hay que
+ * puntuar una ventana por cada linea del archivo. Da lo mismo que el ratio de
+ * SequenceMatcher para lo unico que se necesita: ordenar candidatos.
+ */
+export function similitud(a, b) {
+    if (a === b)
+        return 1;
+    if (a.length < 2 || b.length < 2)
+        return 0;
+    const bigramas = new Map();
+    for (let i = 0; i < a.length - 1; i++) {
+        const par = a.slice(i, i + 2);
+        bigramas.set(par, (bigramas.get(par) || 0) + 1);
+    }
+    let comunes = 0;
+    for (let i = 0; i < b.length - 1; i++) {
+        const par = b.slice(i, i + 2);
+        const quedan = bigramas.get(par) || 0;
+        if (quedan > 0) {
+            bigramas.set(par, quedan - 1);
+            comunes++;
+        }
+    }
+    return (2 * comunes) / (a.length - 1 + b.length - 1);
+}
+/**
+ * Ventana del archivo mas parecida al fragmento buscado.
+ *
+ * Se comparan ventanas del MISMO numero de lineas que el fragmento, deslizando
+ * una a una. Si el mejor candidato no llega al umbral, no se devuelve nada:
+ * ensenar un tramo al azar es peor que no ensenar ninguno, porque el modelo se
+ * lo cree y edita ahi.
+ */
+export function tramoMasParecido(contenido, fragmento, umbral = UMBRAL_PARECIDO) {
+    const lineasArchivo = contenido.split("\n");
+    const lineasFragmento = fragmento.split("\n");
+    const ventana = lineasFragmento.length;
+    if (ventana === 0 || lineasArchivo.length < ventana)
+        return null;
+    const buscado = lineasFragmento.map((l) => l.trim()).join("\n");
+    if (!buscado.trim())
+        return null;
+    let mejor = null;
+    for (let i = 0; i + ventana <= lineasArchivo.length; i++) {
+        const trozo = lineasArchivo.slice(i, i + ventana);
+        const parecido = similitud(buscado, trozo.map((l) => l.trim()).join("\n"));
+        if (!mejor || parecido > mejor.parecido) {
+            mejor = { primeraLinea: i + 1, lineas: trozo, parecido };
+        }
+    }
+    if (!mejor || mejor.parecido < umbral)
+        return null;
+    // Se amplia con contexto para que el modelo pueda reconstruir un fragmento
+    // unico, no solo el tramo justo.
+    const desde = Math.max(0, mejor.primeraLinea - 1 - CONTEXTO);
+    const hasta = Math.min(lineasArchivo.length, mejor.primeraLinea - 1 + ventana + CONTEXTO);
+    return {
+        primeraLinea: desde + 1,
+        lineas: lineasArchivo.slice(desde, hasta),
+        parecido: mejor.parecido,
+    };
+}
+/**
+ * Pinta la sangria y los espacios finales, que son invisibles y son justo lo
+ * que falla. El interior de la linea se deja tal cual: marcarlo entero hace el
+ * texto ilegible y no anade informacion.
+ */
+export function marcarEspacios(texto) {
+    return texto
+        .split("\n")
+        .map((linea) => {
+        const inicio = linea.match(/^[ \t]*/)?.[0] ?? "";
+        const resto = linea.slice(inicio.length);
+        const finalEspacios = resto.match(/[ \t]*$/)?.[0] ?? "";
+        const cuerpo = finalEspacios ? resto.slice(0, resto.length - finalEspacios.length) : resto;
+        const pintar = (s) => s.replace(/\t/g, "→").replace(/ /g, "·");
+        return pintar(inicio) + cuerpo + pintar(finalEspacios);
+    })
+        .join("\n");
+}
+/**
+ * Mensaje de error de edit_file cuando no hay coincidencia.
+ *
+ * Tres piezas, en orden de utilidad:
+ *  1. "esto ya esta aplicado" corta en seco el bucle de reaplicar un cambio que
+ *     ya se hizo, que es el atasco mas caro y el mas frecuente;
+ *  2. el tramo real mas parecido, con numeros de linea y los espacios pintados;
+ *  3. que reenvie SOLO este bloque.
+ */
+export function diagnosticarFallo(rutaMostrada, contenido, viejo, nuevo) {
+    const partes = [
+        `Error: no se encontro el fragmento a reemplazar en "${rutaMostrada}".`,
+    ];
+    if (nuevo.trim() && contenido.includes(nuevo)) {
+        partes.push(`El texto NUEVO ya esta en el archivo: este cambio parece hecho. ` +
+            `Comprueba con view_file antes de volver a intentarlo, y si ya esta, sigue con lo siguiente.`);
+        return partes.join("\n\n");
+    }
+    const tramo = tramoMasParecido(contenido, viejo);
+    if (tramo) {
+        const numeradas = tramo.lineas
+            .map((l, i) => `${String(tramo.primeraLinea + i).padStart(5)} | ${marcarEspacios(l)}`)
+            .join("\n");
+        partes.push(`Lo mas parecido que hay en el archivo (${Math.round(tramo.parecido * 100)}% de coincidencia) ` +
+            `esta en la linea ${tramo.primeraLinea}. ¿Querias decir esto?\n\n${numeradas}`);
+        partes.push(`Los espacios se ven como "·" y los tabuladores como "→": la diferencia suele estar ahi. ` +
+            `Copia las lineas tal cual aparecen arriba.`);
+    }
+    else {
+        partes.push(`No hay ningun tramo parecido: puede que el archivo no sea el que crees, o que haya ` +
+            `cambiado. Leelo con view_file antes de volver a editar.`);
+    }
+    partes.push(`Reenvia SOLO este bloque corregido. Las demas ediciones que hayan funcionado ya estan ` +
+        `aplicadas: no las repitas.`);
+    return partes.join("\n\n");
+}
+/** Mensaje cuando el fragmento aparece varias veces. */
+export function diagnosticarAmbiguedad(rutaMostrada, ocurrencias, estrategia) {
+    return (`Error: el fragmento aparece ${ocurrencias} veces en "${rutaMostrada}" (coincidencia por ` +
+        `${estrategia}). No voy a adivinar cual. Anade lineas de alrededor —la firma de la funcion, ` +
+        `el comentario de encima— hasta que el fragmento sea unico.`);
+}

package/dist/tools/editFile.d.ts

@@ -2,4 +2,5 @@ export declare function editFile(filePath: string, oldText: string, newText: str
     success: boolean;
     message: string;
     diffText?: string;
+    estrategia?: string;
 }>;

package/dist/tools/editFile.js

@@ -1,6 +1,17 @@
 import fs from "node:fs";
 import path from "node:path";
 import { formatNumberedDiff } from "../ui/diffViewer.js";
+import { binaryRefusalReason, quickBinaryReason } from "./binary.js";
+import { localizarFragmento, esRechazo } from "./patchCascade.js";
+import { diagnosticarFallo, diagnosticarAmbiguedad } from "./editDiagnosis.js";
+/**
+ * El mensaje empieza por "Error" a proposito: es lo que mira runner.ts para no
+ * dar la edicion por buena.
+ */
+function mensajeBinario(filePath, motivo) {
+    return (`Error: "${filePath}" ${motivo}. edit_file lee y reescribe el archivo entero como texto UTF-8, ` +
+        `asi que editarlo lo dejaria irrecuperable. Usa run_command con la herramienta que corresponda.`);
+}
 export async function editFile(filePath, oldText, newText, cwd = process.cwd()) {
     const resolved = path.isAbsolute(filePath) ? filePath : path.resolve(cwd, filePath);
     if (!fs.existsSync(resolved)) {
@@ -9,80 +20,125 @@ export async function editFile(filePath, oldText, newText, cwd = process.cwd())
             message: `Error: El archivo "${filePath}" no existe.`,
         };
     }
-    const currentContent = fs.readFileSync(resolved, "utf-8");
-    // Normalize line endings for comparison
-    const normalizedCurrent = currentContent.replace(/\r\n/g, "\n");
-    const normalizedOld = oldText.replace(/\r\n/g, "\n");
-    const normalizedNew = newText.replace(/\r\n/g, "\n");
-    let matchIndex = normalizedCurrent.indexOf(normalizedOld);
-    let finalOldText = normalizedOld;
-    // Si el fragmento aparece varias veces, editar la primera ocurrencia es una
-    // apuesta: puede tocar la funcion equivocada y el usuario no se entera hasta
-    // mucho despues. Mejor negarse y pedir mas contexto.
-    if (matchIndex !== -1 && normalizedOld.length > 0) {
-        let count = 0;
-        let from = 0;
-        while (true) {
-            const at = normalizedCurrent.indexOf(normalizedOld, from);
-            if (at === -1)
-                break;
-            count++;
-            if (count > 1)
-                break;
-            from = at + normalizedOld.length;
-        }
-        if (count > 1) {
-            return {
-                success: false,
-                message: `Error: el fragmento aparece mas de una vez en "${filePath}". No voy a adivinar cual. ` +
-                    `Incluye lineas de alrededor para que el fragmento sea unico.`,
-            };
-        }
+    // Antes se leia directamente con "utf-8" y se reescribia el archivo entero
+    // desde ese string: cada byte invalido volvia al disco como EF BF BD, asi que
+    // un edit_file con exito sobre un mp4 o un png lo dejaba irrecuperable y
+    // respondia "editado exitosamente". Nadie confirma esta escritura en ningun
+    // modo de permisos, asi que la unica defensa es negarse aqui.
+    //
+    // Primero la comprobacion barata (extension y cabecera), porque el propio
+    // readFileSync de un video de 500 MB ya es el problema.
+    const motivoRapido = quickBinaryReason(resolved);
+    if (motivoRapido) {
+        return { success: false, message: mensajeBinario(filePath, motivoRapido) };
     }
-    // Fallback: If exact match fails, try line-by-line trimmed matching
-    if (matchIndex === -1) {
-        const fileLines = normalizedCurrent.split("\n");
-        const targetLines = normalizedOld.split("\n").map((l) => l.trimEnd());
-        let foundLineIdx = -1;
-        for (let i = 0; i <= fileLines.length - targetLines.length; i++) {
-            let isMatch = true;
-            for (let j = 0; j < targetLines.length; j++) {
-                if (fileLines[i + j].trimEnd() !== targetLines[j]) {
-                    isMatch = false;
-                    break;
-                }
-            }
-            if (isMatch) {
-                if (foundLineIdx === -1) {
-                    foundLineIdx = i;
-                }
-                else {
-                    // Multiple ambiguous matches found, don't guess
-                    foundLineIdx = -2;
-                    break;
-                }
+    const buffer = fs.readFileSync(resolved);
+    const motivoBinario = binaryRefusalReason(resolved, buffer);
+    if (motivoBinario) {
+        return { success: false, message: mensajeBinario(filePath, motivoBinario) };
+    }
+    const currentContent = buffer.toString("utf-8");
+    // El BOM se aparta aqui y se vuelve a poner al escribir. Si se quedara dentro,
+    // ensuciaria el primer caracter del archivo y el emparejamiento por lineas
+    // nunca casaria con la primera linea.
+    const tieneBom = currentContent.charCodeAt(0) === 0xfeff;
+    const bom = tieneBom ? currentContent[0] : "";
+    const original = bom ? currentContent.slice(1) : currentContent;
+    // Terminador dominante del archivo. Solo se usa para las lineas NUEVAS: lo que
+    // no se edita se copia byte a byte, incluidos los finales mezclados.
+    const crlfCount = (original.match(/\r\n/g) || []).length;
+    const lfCount = (original.match(/\n/g) || []).length - crlfCount;
+    const eol = crlfCount > lfCount ? "\r\n" : "\n";
+    // Normalizar a LF sirve para BUSCAR: el fragmento que manda el modelo casi
+    // nunca trae los \r. Pero antes se escribia esa version normalizada, asi que
+    // tocar tres lineas de un repo con CRLF reescribia el archivo entero y el diff
+    // salia completo. Ahora se guarda a que posicion del original corresponde cada
+    // caracter del normalizado, para recortar sobre el original y dejar intacto
+    // todo lo que no se edita.
+    //
+    // Un "\n" que venia de un "\r\n" apunta al "\r", no al "\n": asi un fragmento
+    // que termina justo antes del salto no deja huerfano el retorno de carro.
+    let normalizedCurrent;
+    let mapaOriginal = null;
+    if (crlfCount > 0) {
+        const trozos = [];
+        mapaOriginal = [];
+        for (let i = 0; i < original.length; i++) {
+            if (original.charCodeAt(i) === 13 && original.charCodeAt(i + 1) === 10) {
+                trozos.push("\n");
+                mapaOriginal.push(i);
+                i++;
+                continue;
             }
+            trozos.push(original[i]);
+            mapaOriginal.push(i);
         }
-        if (foundLineIdx >= 0) {
-            const matchedBlock = fileLines.slice(foundLineIdx, foundLineIdx + targetLines.length).join("\n");
-            matchIndex = normalizedCurrent.indexOf(matchedBlock);
-            finalOldText = matchedBlock;
-        }
+        normalizedCurrent = trozos.join("");
+    }
+    else {
+        normalizedCurrent = original;
+    }
+    /** Posicion en el archivo original del caracter normalizado numero idx. */
+    const aPosicionOriginal = (idx) => {
+        if (!mapaOriginal)
+            return Math.min(idx, original.length);
+        return idx < mapaOriginal.length ? mapaOriginal[idx] : original.length;
+    };
+    const normalizedOld = oldText.replace(/\r\n/g, "\n");
+    const normalizedNew = newText.replace(/\r\n/g, "\n");
+    // Un oldText vacio no identifica ningun sitio: "reemplaza la nada" es una
+    // orden sin respuesta. Antes se resolvia con indexOf("") === 0, que inserta al
+    // principio del archivo y responde "editado exitosamente" en un sitio que
+    // nadie ha pedido.
+    if (normalizedOld.length === 0) {
+        return {
+            success: false,
+            message: `Error: oldText esta vacio, asi que no señala ningun sitio del archivo. ` +
+                `Si quieres anadir texto, incluye en oldText la linea de alrededor donde va (y repitela ` +
+                `en newText); si quieres crear o reescribir el archivo entero, usa write_file.`,
+        };
+    }
+    // La busqueda ya no es un indexOf con un parche detras, sino una cascada de
+    // estrategias que va de la mas estricta a la mas flexible (ver patchCascade).
+    // Cada una lleva su propio cerrojo de unicidad, asi que tolerar mas formas de
+    // equivocarse no relaja la garantia de "o el sitio es inequivoco, o no se
+    // escribe".
+    const coincidencia = localizarFragmento(normalizedCurrent, normalizedOld, normalizedNew);
+    if (esRechazo(coincidencia)) {
+        return {
+            success: false,
+            message: diagnosticarAmbiguedad(filePath, coincidencia.ocurrencias, coincidencia.estrategia),
+        };
     }
-    if (matchIndex === -1) {
+    if (!coincidencia) {
+        // Antes se devolvia siempre el mismo texto generico, que no le decia al
+        // modelo nada que no supiera y le invitaba a reintentar identico.
         return {
             success: false,
-            message: `Error: No se encontró el fragmento de texto en "${filePath}". Asegúrate de copiar las líneas exactas a reemplazar.`,
+            message: diagnosticarFallo(filePath, normalizedCurrent, normalizedOld, normalizedNew),
         };
     }
+    const { inicio, fin, textoNuevo: reemplazo, estrategia } = coincidencia;
+    const finalOldText = normalizedCurrent.slice(inicio, fin);
     // Calculate real starting line number in the original file
-    const startLine = normalizedCurrent.slice(0, matchIndex).split("\n").length;
-    const updatedContent = normalizedCurrent.slice(0, matchIndex) + normalizedNew + normalizedCurrent.slice(matchIndex + finalOldText.length);
+    const startLine = normalizedCurrent.slice(0, inicio).split("\n").length;
+    // Se recorta sobre el ORIGINAL, no sobre el normalizado: lo de fuera del
+    // fragmento vuelve al disco tal cual estaba. Solo el texto nuevo se escribe con
+    // el terminador dominante.
+    const inicioOriginal = aPosicionOriginal(inicio);
+    const finOriginal = aPosicionOriginal(fin);
+    const textoNuevo = eol === "\n" ? reemplazo : reemplazo.replace(/\n/g, "\r\n");
+    const updatedContent = bom + original.slice(0, inicioOriginal) + textoNuevo + original.slice(finOriginal);
     fs.writeFileSync(resolved, updatedContent, "utf-8");
-    const diffText = formatNumberedDiff(path.relative(cwd, resolved) || filePath, finalOldText, normalizedNew, startLine);
+    const diffText = formatNumberedDiff(path.relative(cwd, resolved) || filePath, finalOldText, reemplazo, startLine);
+    // Que estrategia acerto no es cosmetico: si el modelo empieza a depender del
+    // ancla de bloque es que esta copiando mal los fragmentos, y eso se puede
+    // medir en vez de intuirlo.
+    const nota = estrategia === "exacta" ? "" : ` [coincidencia por ${estrategia}]`;
     return {
         success: true,
-        message: `✔ Archivo "${filePath}" editado exitosamente (Línea ${startLine}+).`,
+        message: `✔ Archivo "${filePath}" editado exitosamente (Línea ${startLine}+).${nota}`,
         diffText,
+        estrategia,
     };
 }

package/dist/tools/findFiles.d.ts

@@ -1 +1,22 @@
+/**
+ * Traduce lo que escribe el modelo al glob que fast-glob necesita.
+ *
+ * Dos trampas, y las dos daban cero resultados sin decir nada:
+ *
+ *  1. En glob, `*.ts` significa ".ts en el nivel raiz", no "en todo el arbol".
+ *     La descripcion de la herramienta pone `'*.tsx'` como ejemplo, asi que el
+ *     modelo lo escribe tal cual, recibe cero y concluye que el proyecto no
+ *     tiene TypeScript. El codigo viejo hacia justo lo contrario de lo que hace
+ *     falta: solo volvia recursivos los patrones SIN comodin.
+ *
+ *  2. fast-glob trata `\` como caracter de escape, no como separador. Un
+ *     patron con rutas de Windows (`src\**\*.ts`) se convertia en `src**.ts` y
+ *     no casaba con nada.
+ *
+ * Devuelve una lista porque para un patron con ruta se prueban dos: la ruta tal
+ * cual (relativa a la carpeta de busqueda) y la misma anclada a cualquier nivel,
+ * que es lo que suele querer decir quien escribe `src/*.ts` sin saber desde
+ * donde se esta buscando. fast-glob deduplica.
+ */
+export declare function normalizarPatron(pattern: string): string[];
 export declare function findFiles(pattern: string, searchDirectory?: string, cwd?: string): Promise<string>;