@hoilab/ada-cli 0.84.21 → 0.85.0

package/dist/core/edicion/parseo.js

@@ -0,0 +1,124 @@
+/**
+ * ¿Sigue parseando el fichero después de la edición?
+ *
+ * El fallo más caro de un agente que edita no es equivocarse de lógica: es
+ * dejar el fichero sintácticamente roto y seguir trabajando encima como si nada.
+ * Hasta ahora, saber si el proyecto compilaba exigía un `npm run check` que el
+ * modelo no lanza solo.
+ *
+ * Sin dependencias nuevas. Se usa el compilador de TypeScript que ya está
+ * instalado, que cubre `.ts/.tsx/.js/.jsx/.mts/.cts/.mjs/.cjs`, más `JSON.parse`
+ * para `.json`. Es el grueso de lo que edita nuestro usuario. Tree-sitter
+ * cubriría además Python, Go y Rust, pero trae binarios nativos por plataforma
+ * —el mismo problema que ya nos dio `srt` con `bun --compile`— y eso no tiene
+ * por qué estar en el camino crítico.
+ *
+ * La regla que hace esto seguro, copiada de oh-my-pi porque es la correcta:
+ * **solo se acusa a la edición si la preimagen parseaba**. Un lenguaje que no
+ * sabemos leer devuelve `null` en las dos, así que nunca produce un falso
+ * positivo; y un fichero que ya estaba roto tampoco se le atribuye a quien
+ * acaba de tocarlo.
+ */
+import ts from "typescript";
+/** Extensiones que sabe leer el compilador de TypeScript. */
+const TS_LIKE = new Set([".ts", ".tsx", ".mts", ".cts", ".js", ".jsx", ".mjs", ".cjs"]);
+function extensionDe(ruta) {
+    const punto = ruta.lastIndexOf(".");
+    return punto === -1 ? "" : ruta.slice(punto).toLowerCase();
+}
+/**
+ * `true` parsea · `false` no parsea · `null` no sabemos leer este lenguaje.
+ *
+ * Los tres valores importan. Colapsar `null` en `true` haría que un `.py` roto
+ * pareciera sano; colapsarlo en `false` acusaría a cada edición de Python.
+ */
+export function parsea(codigo, ruta) {
+    const ext = extensionDe(ruta);
+    if (ext === ".json") {
+        // Un JSON vacío no es JSON válido, pero tampoco es un fichero roto por
+        // una edición: es un fichero a medio escribir. Se trata como desconocido.
+        if (codigo.trim() === "")
+            return null;
+        try {
+            JSON.parse(codigo);
+            return true;
+        }
+        catch {
+            return false;
+        }
+    }
+    if (!TS_LIKE.has(ext))
+        return null;
+    // El fichero vacío es válido en todos los lenguajes que miramos: devolver
+    // `false` haría que crear un fichero contara como romperlo.
+    const fuente = ts.createSourceFile(ruta, codigo, ts.ScriptTarget.Latest, false);
+    // `parseDiagnostics` no está en el tipo público de `SourceFile`, y aun así es
+    // lo correcto aquí. Medido contra 10 casos: la alternativa pública
+    // (`transpileModule` con `reportDiagnostics`) falla 7 de 10 — da por rotos
+    // una coma final, un decorador, `satisfies`, el fichero vacío y hasta
+    // `export function a(x){return x+1}`, porque incluye diagnósticos de opciones
+    // del compilador que no tienen nada que ver con la sintaxis. `parseDiagnostics`
+    // acierta 10/10 e ignora los errores de TIPOS, que es justo lo que queremos:
+    // un `const a: NoExiste = 1` compila mal pero no está roto.
+    //
+    // Si TypeScript se lo lleva algún día, se devuelve `null` —"no sabemos"— y no
+    // `true`. Equivocarse hacia "no sabemos" cuesta un aviso que no sale;
+    // equivocarse hacia "parsea" cuesta dar por bueno un fichero roto.
+    const diagnosticos = fuente.parseDiagnostics;
+    if (!Array.isArray(diagnosticos))
+        return null;
+    return diagnosticos.length === 0;
+}
+/** El primer error de sintaxis, con su línea. `null` si no hay o no se sabe leer. */
+export function primerErrorDe(codigo, ruta) {
+    const ext = extensionDe(ruta);
+    if (ext === ".json") {
+        try {
+            JSON.parse(codigo);
+            return null;
+        }
+        catch (e) {
+            // El mensaje de `JSON.parse` ya trae posición ("at position 42"), que
+            // para un fichero de datos es tan útil como el número de línea.
+            return { linea: 0, mensaje: e instanceof Error ? e.message : "JSON inválido" };
+        }
+    }
+    if (!TS_LIKE.has(ext))
+        return null;
+    const fuente = ts.createSourceFile(ruta, codigo, ts.ScriptTarget.Latest, false);
+    const diagnosticos = fuente.parseDiagnostics;
+    if (!Array.isArray(diagnosticos) || diagnosticos.length === 0)
+        return null;
+    const primero = diagnosticos[0];
+    const posicion = primero.start !== undefined ? fuente.getLineAndCharacterOfPosition(primero.start) : null;
+    return {
+        linea: posicion ? posicion.line + 1 : 0,
+        mensaje: ts.flattenDiagnosticMessageText(primero.messageText, " "),
+    };
+}
+/**
+ * `true` solo si esta edición convirtió un fichero que parseaba en uno que no.
+ *
+ * Nunca es `true` cuando la preimagen no parseaba o no se sabía leer: esa
+ * precondición es la que evita acusar a quien no ha roto nada.
+ */
+export function rompioElParseo({ ruta, antes, despues }) {
+    if (antes === null || despues === null)
+        return false;
+    return parsea(antes, ruta) === true && parsea(despues, ruta) === false;
+}
+/**
+ * El aviso que se le devuelve al modelo, en su propio resultado de edición.
+ *
+ * Se le dice el qué y el siguiente paso. Un "syntax error" a secas invita a
+ * seguir editando a ciegas, que es como una edición rota se convierte en tres.
+ */
+export function avisoDeParseoRoto(ruta, error) {
+    // Con la línea y el mensaje exactos, no con un "está roto" genérico. La
+    // diferencia práctica es entre releer el fichero entero adivinando y saber
+    // que en la 42 falta una llave. Sale gratis: el compilador ya lo tenía.
+    const donde = error ? (error.linea > 0 ? ` En la línea ${error.linea}: ${error.mensaje}` : ` ${error.mensaje}`) : "";
+    return (`⚠ Esta edición ha dejado \`${ruta}\` sintácticamente roto: antes parseaba y ahora no.${donde} ` +
+        `Arréglalo antes de seguir con otra cosa.`);
+}
+//# sourceMappingURL=parseo.js.map

package/dist/core/edicion/parseo.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"parseo.js","sourceRoot":"","sources":["../../../src/core/edicion/parseo.ts"],"names":[],"mappings":"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","sourcesContent":["/**\n * ¿Sigue parseando el fichero después de la edición?\n *\n * El fallo más caro de un agente que edita no es equivocarse de lógica: es\n * dejar el fichero sintácticamente roto y seguir trabajando encima como si nada.\n * Hasta ahora, saber si el proyecto compilaba exigía un `npm run check` que el\n * modelo no lanza solo.\n *\n * Sin dependencias nuevas. Se usa el compilador de TypeScript que ya está\n * instalado, que cubre `.ts/.tsx/.js/.jsx/.mts/.cts/.mjs/.cjs`, más `JSON.parse`\n * para `.json`. Es el grueso de lo que edita nuestro usuario. Tree-sitter\n * cubriría además Python, Go y Rust, pero trae binarios nativos por plataforma\n * —el mismo problema que ya nos dio `srt` con `bun --compile`— y eso no tiene\n * por qué estar en el camino crítico.\n *\n * La regla que hace esto seguro, copiada de oh-my-pi porque es la correcta:\n * **solo se acusa a la edición si la preimagen parseaba**. Un lenguaje que no\n * sabemos leer devuelve `null` en las dos, así que nunca produce un falso\n * positivo; y un fichero que ya estaba roto tampoco se le atribuye a quien\n * acaba de tocarlo.\n */\n\nimport ts from \"typescript\";\n\n/** Extensiones que sabe leer el compilador de TypeScript. */\nconst TS_LIKE = new Set([\".ts\", \".tsx\", \".mts\", \".cts\", \".js\", \".jsx\", \".mjs\", \".cjs\"]);\n\nfunction extensionDe(ruta: string): string {\n\tconst punto = ruta.lastIndexOf(\".\");\n\treturn punto === -1 ? \"\" : ruta.slice(punto).toLowerCase();\n}\n\n/**\n * `true` parsea · `false` no parsea · `null` no sabemos leer este lenguaje.\n *\n * Los tres valores importan. Colapsar `null` en `true` haría que un `.py` roto\n * pareciera sano; colapsarlo en `false` acusaría a cada edición de Python.\n */\nexport function parsea(codigo: string, ruta: string): boolean | null {\n\tconst ext = extensionDe(ruta);\n\n\tif (ext === \".json\") {\n\t\t// Un JSON vacío no es JSON válido, pero tampoco es un fichero roto por\n\t\t// una edición: es un fichero a medio escribir. Se trata como desconocido.\n\t\tif (codigo.trim() === \"\") return null;\n\t\ttry {\n\t\t\tJSON.parse(codigo);\n\t\t\treturn true;\n\t\t} catch {\n\t\t\treturn false;\n\t\t}\n\t}\n\n\tif (!TS_LIKE.has(ext)) return null;\n\n\t// El fichero vacío es válido en todos los lenguajes que miramos: devolver\n\t// `false` haría que crear un fichero contara como romperlo.\n\tconst fuente = ts.createSourceFile(ruta, codigo, ts.ScriptTarget.Latest, false);\n\n\t// `parseDiagnostics` no está en el tipo público de `SourceFile`, y aun así es\n\t// lo correcto aquí. Medido contra 10 casos: la alternativa pública\n\t// (`transpileModule` con `reportDiagnostics`) falla 7 de 10 — da por rotos\n\t// una coma final, un decorador, `satisfies`, el fichero vacío y hasta\n\t// `export function a(x){return x+1}`, porque incluye diagnósticos de opciones\n\t// del compilador que no tienen nada que ver con la sintaxis. `parseDiagnostics`\n\t// acierta 10/10 e ignora los errores de TIPOS, que es justo lo que queremos:\n\t// un `const a: NoExiste = 1` compila mal pero no está roto.\n\t//\n\t// Si TypeScript se lo lleva algún día, se devuelve `null` —\"no sabemos\"— y no\n\t// `true`. Equivocarse hacia \"no sabemos\" cuesta un aviso que no sale;\n\t// equivocarse hacia \"parsea\" cuesta dar por bueno un fichero roto.\n\tconst diagnosticos = (fuente as ts.SourceFile & { parseDiagnostics?: unknown }).parseDiagnostics;\n\tif (!Array.isArray(diagnosticos)) return null;\n\treturn diagnosticos.length === 0;\n}\n\n/** El primer error de sintaxis, con su línea. `null` si no hay o no se sabe leer. */\nexport function primerErrorDe(codigo: string, ruta: string): { linea: number; mensaje: string } | null {\n\tconst ext = extensionDe(ruta);\n\tif (ext === \".json\") {\n\t\ttry {\n\t\t\tJSON.parse(codigo);\n\t\t\treturn null;\n\t\t} catch (e) {\n\t\t\t// El mensaje de `JSON.parse` ya trae posición (\"at position 42\"), que\n\t\t\t// para un fichero de datos es tan útil como el número de línea.\n\t\t\treturn { linea: 0, mensaje: e instanceof Error ? e.message : \"JSON inválido\" };\n\t\t}\n\t}\n\tif (!TS_LIKE.has(ext)) return null;\n\tconst fuente = ts.createSourceFile(ruta, codigo, ts.ScriptTarget.Latest, false);\n\tconst diagnosticos = (fuente as ts.SourceFile & { parseDiagnostics?: unknown }).parseDiagnostics;\n\tif (!Array.isArray(diagnosticos) || diagnosticos.length === 0) return null;\n\tconst primero = diagnosticos[0] as ts.Diagnostic;\n\tconst posicion = primero.start !== undefined ? fuente.getLineAndCharacterOfPosition(primero.start) : null;\n\treturn {\n\t\tlinea: posicion ? posicion.line + 1 : 0,\n\t\tmensaje: ts.flattenDiagnosticMessageText(primero.messageText, \" \"),\n\t};\n}\n\nexport interface Edicion {\n\truta: string;\n\t/** Contenido antes. `null` si el fichero no existía. */\n\tantes: string | null;\n\t/** Contenido después. `null` si se borró. */\n\tdespues: string | null;\n}\n\n/**\n * `true` solo si esta edición convirtió un fichero que parseaba en uno que no.\n *\n * Nunca es `true` cuando la preimagen no parseaba o no se sabía leer: esa\n * precondición es la que evita acusar a quien no ha roto nada.\n */\nexport function rompioElParseo({ ruta, antes, despues }: Edicion): boolean {\n\tif (antes === null || despues === null) return false;\n\treturn parsea(antes, ruta) === true && parsea(despues, ruta) === false;\n}\n\n/**\n * El aviso que se le devuelve al modelo, en su propio resultado de edición.\n *\n * Se le dice el qué y el siguiente paso. Un \"syntax error\" a secas invita a\n * seguir editando a ciegas, que es como una edición rota se convierte en tres.\n */\nexport function avisoDeParseoRoto(ruta: string, error?: { linea: number; mensaje: string } | null): string {\n\t// Con la línea y el mensaje exactos, no con un \"está roto\" genérico. La\n\t// diferencia práctica es entre releer el fichero entero adivinando y saber\n\t// que en la 42 falta una llave. Sale gratis: el compilador ya lo tenía.\n\tconst donde = error ? (error.linea > 0 ? ` En la línea ${error.linea}: ${error.mensaje}` : ` ${error.mensaje}`) : \"\";\n\treturn (\n\t\t`⚠ Esta edición ha dejado \\`${ruta}\\` sintácticamente roto: antes parseaba y ahora no.${donde} ` +\n\t\t`Arréglalo antes de seguir con otra cosa.`\n\t);\n}\n"]}

package/dist/core/edicion/reparacion.d.ts

@@ -0,0 +1,67 @@
+/**
+ * Auto-reparación de una edición que rompió el parseo.
+ *
+ * Cuando `parseo.ts` detecta que una edición convirtió un fichero que
+ * parseaba en uno que no, esto intenta arreglarlo solo: localiza el conjunto
+ * mínimo de hunks (líneas cambiadas) cuya reversión restaura el parseo, le
+ * pide al modelo que arregle SOLO esa región mostrándole la versión sin
+ * romper como referencia, y acepta el resultado únicamente si (a) el
+ * fichero entero vuelve a parsear Y (b) lo que devolvió el modelo no es,
+ * quitando espacios, un calco de la referencia — es decir, no es una simple
+ * reversión del cambio que el usuario pidió.
+ *
+ * La idea y el reparto de responsabilidades vienen de `oh-my-pi`
+ * (packages/coding-agent/src/edit/auto-repair.ts): localizar antes de
+ * preguntar, y rechazar la reversión aunque parsee. Lo que cambia aquí es la
+ * implementación: sin tree-sitter (usamos el mismo `parsea()` de
+ * `parseo.ts`, que ya cubre lo que este fork edita) y con el paquete `diff`
+ * que este proyecto ya trae en vez de un diff de líneas propio.
+ */
+/** La región rota localizada, con su referencia (culpables revertidos) para enseñarle al modelo. */
+export interface RegionDeReparacion {
+    /** Tramo de líneas sustituido en el fichero roto, `[bInicio, bFin)`. */
+    bInicio: number;
+    bFin: number;
+    /** La región tal cual está en el fichero roto. */
+    textoRoto: string;
+    /** La misma región con los hunks culpables revertidos: empalmarla restaura el parseo. */
+    textoReferencia: string;
+}
+/**
+ * Localiza la rotura de `antes → despues` a una región de líneas acotada.
+ * `undefined` cuando no se puede aislar o cuando la región supera
+ * {@link MAX_LINEAS_REGION} — quien llama se queda entonces con el aviso de
+ * parseo roto normal.
+ */
+export declare function calcularRegionDeReparacion(instantanea: {
+    ruta: string;
+    antes: string;
+    despues: string;
+}): RegionDeReparacion | undefined;
+/** Qué pasó al intentar reparar. Nunca colapsa "no pude intentarlo" con "lo intenté y no valió". */
+export type ResultadoReparacion = {
+    estado: "reparado";
+    contenido: string;
+    intentos: number;
+}
+/** No había con qué preguntar (sin modelo) o la rotura no se pudo aislar/acotar. */
+ | {
+    estado: "no-aplicable";
+}
+/** Se preguntó al modelo pero ningún intento cumplió las dos condiciones de aceptación. */
+ | {
+    estado: "rechazada";
+};
+/**
+ * Intenta reparar una edición que rompió el parseo, preguntándole a `completar`.
+ *
+ * `completar` devuelve `null` cuando no pudo completarse (sin modelo, sin
+ * red, error de la API…): eso es "no-aplicable", nunca "rechazada" — una
+ * reparación rechazada es una que SE INTENTÓ y no sirvió.
+ */
+export declare function intentarReparar(instantanea: {
+    ruta: string;
+    antes: string;
+    despues: string;
+}, completar?: (prompt: string) => Promise<string | null>): Promise<ResultadoReparacion>;
+//# sourceMappingURL=reparacion.d.ts.map

package/dist/core/edicion/reparacion.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"reparacion.d.ts","sourceRoot":"","sources":["../../../src/core/edicion/reparacion.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;GAkBG;AAmGH,sGAAoG;AACpG,MAAM,WAAW,kBAAkB;IAClC,yEAAwE;IACxE,OAAO,EAAE,MAAM,CAAC;IAChB,IAAI,EAAE,MAAM,CAAC;IACb,oDAAkD;IAClD,SAAS,EAAE,MAAM,CAAC;IAClB,0FAAyF;IACzF,eAAe,EAAE,MAAM,CAAC;CACxB;AAED;;;;;GAKG;AACH,wBAAgB,0BAA0B,CAAC,WAAW,EAAE;IACvD,IAAI,EAAE,MAAM,CAAC;IACb,KAAK,EAAE,MAAM,CAAC;IACd,OAAO,EAAE,MAAM,CAAC;CAChB,GAAG,kBAAkB,GAAG,SAAS,CA4BjC;AAkCD,wGAAoG;AACpG,MAAM,MAAM,mBAAmB,GAC5B;IAAE,MAAM,EAAE,UAAU,CAAC;IAAC,SAAS,EAAE,MAAM,CAAC;IAAC,QAAQ,EAAE,MAAM,CAAA;CAAE;AAC7D,sFAAoF;GAClF;IAAE,MAAM,EAAE,cAAc,CAAA;CAAE;AAC5B,+FAA2F;GACzF;IAAE,MAAM,EAAE,WAAW,CAAA;CAAE,CAAC;AAE3B;;;;;;GAMG;AACH,wBAAsB,eAAe,CACpC,WAAW,EAAE;IAAE,IAAI,EAAE,MAAM,CAAC;IAAC,KAAK,EAAE,MAAM,CAAC;IAAC,OAAO,EAAE,MAAM,CAAA;CAAE,EAC7D,SAAS,CAAC,EAAE,CAAC,MAAM,EAAE,MAAM,KAAK,OAAO,CAAC,MAAM,GAAG,IAAI,CAAC,GACpD,OAAO,CAAC,mBAAmB,CAAC,CA2B9B","sourcesContent":["/**\n * Auto-reparación de una edición que rompió el parseo.\n *\n * Cuando `parseo.ts` detecta que una edición convirtió un fichero que\n * parseaba en uno que no, esto intenta arreglarlo solo: localiza el conjunto\n * mínimo de hunks (líneas cambiadas) cuya reversión restaura el parseo, le\n * pide al modelo que arregle SOLO esa región mostrándole la versión sin\n * romper como referencia, y acepta el resultado únicamente si (a) el\n * fichero entero vuelve a parsear Y (b) lo que devolvió el modelo no es,\n * quitando espacios, un calco de la referencia — es decir, no es una simple\n * reversión del cambio que el usuario pidió.\n *\n * La idea y el reparto de responsabilidades vienen de `oh-my-pi`\n * (packages/coding-agent/src/edit/auto-repair.ts): localizar antes de\n * preguntar, y rechazar la reversión aunque parsee. Lo que cambia aquí es la\n * implementación: sin tree-sitter (usamos el mismo `parsea()` de\n * `parseo.ts`, que ya cubre lo que este fork edita) y con el paquete `diff`\n * que este proyecto ya trae en vez de un diff de líneas propio.\n */\n\nimport * as Diff from \"diff\";\nimport { parsea } from \"./parseo.ts\";\n\n/** Cuántas líneas de contexto se enseñan alrededor de los hunks culpables. */\nconst LINEAS_DE_CONTEXTO = 6;\n/** Región más grande que merece la pena mandarle a un modelo. */\nconst MAX_LINEAS_REGION = 150;\n/** Un primer intento y un reintento con el rechazo anterior como pista. */\nconst MAX_INTENTOS = 2;\n\n/** Un tramo de líneas cambiado, en coordenadas de preimagen (`a`) y posimagen (`b`). */\ninterface Hunk {\n\taInicio: number;\n\taFin: number;\n\tbInicio: number;\n\tbFin: number;\n}\n\nfunction construirHunks(antes: string, despues: string): { hunks: Hunk[]; a: string[]; b: string[] } {\n\tconst a = antes.split(\"\\n\");\n\tconst b = despues.split(\"\\n\");\n\tconst partes = Diff.diffLines(antes, despues);\n\tconst hunks: Hunk[] = [];\n\tlet ai = 0;\n\tlet bi = 0;\n\tfor (const parte of partes) {\n\t\tconst lineas = parte.count ?? 0;\n\t\tif (!parte.added && !parte.removed) {\n\t\t\tai += lineas;\n\t\t\tbi += lineas;\n\t\t\tcontinue;\n\t\t}\n\t\tconst borradas = parte.removed ? lineas : 0;\n\t\tconst anadidas = parte.added ? lineas : 0;\n\t\t// Un borrado seguido de un añadido contiguos son la misma edición\n\t\t// (una sustitución), no dos hunks distintos que reventar por separado.\n\t\tconst ultimo = hunks.at(-1);\n\t\tif (ultimo && ultimo.aFin === ai && ultimo.bFin === bi) {\n\t\t\tultimo.aFin += borradas;\n\t\t\tultimo.bFin += anadidas;\n\t\t} else {\n\t\t\thunks.push({ aInicio: ai, aFin: ai + borradas, bInicio: bi, bFin: bi + anadidas });\n\t\t}\n\t\tai += borradas;\n\t\tbi += anadidas;\n\t}\n\treturn { hunks, a, b };\n}\n\n/** La posimagen con el conjunto `indices` de hunks revertidos a sus líneas de preimagen. */\nfunction revertirHunks(a: string[], b: string[], hunks: Hunk[], indices: readonly number[]): string {\n\tconst ordenados = [...indices].sort((x, y) => x - y);\n\tconst out: string[] = [];\n\tlet bi = 0;\n\tfor (const i of ordenados) {\n\t\tconst h = hunks[i];\n\t\tout.push(...b.slice(bi, h.bInicio), ...a.slice(h.aInicio, h.aFin));\n\t\tbi = h.bFin;\n\t}\n\tout.push(...b.slice(bi));\n\treturn out.join(\"\\n\");\n}\n\n/**\n * El conjunto de hunks cuya reversión conjunta restaura el parseo, o\n * `undefined` si no se puede aislar (incluye el caso \"revertirlos todos\n * tampoco parsea\", que solo pasaría si la preimagen ya estaba rota — y eso\n * ya lo descarta quien llama antes de invocar este módulo).\n */\nfunction aislarHunksCulpables(ruta: string, a: string[], b: string[], hunks: Hunk[]): number[] | undefined {\n\tconst n = hunks.length;\n\tif (n === 0) return undefined;\n\n\t// Camino rápido: la inmensa mayoría de roturas son un solo hunk.\n\tfor (let i = 0; i < n; i++) {\n\t\tif (parsea(revertirHunks(a, b, hunks, [i]), ruta) === true) return [i];\n\t}\n\n\t// ponytail: sin la búsqueda acotada de PARES de oh-my-pi antes de esto —\n\t// el pelado voraz de abajo ya encuentra un conjunto que funciona para\n\t// roturas de varios hunks, solo que no siempre es el par más pequeño\n\t// posible. Si algún caso real lo echa en falta, se añade aquí.\n\t//\n\t// Pelado voraz: se parte de \"revertir todos\" (que parsea, porque\n\t// reconstruye la preimagen) y se intenta, hunk a hunk, DEJARLO sin\n\t// revertir; si el resto sigue parseando, ese hunk no era culpable.\n\tconst conservar = new Set<number>(Array.from({ length: n }, (_, i) => i));\n\tfor (let i = 0; i < n; i++) {\n\t\tconst prueba = new Set(conservar);\n\t\tprueba.delete(i);\n\t\tif (parsea(revertirHunks(a, b, hunks, [...prueba]), ruta) === true) conservar.delete(i);\n\t}\n\tif (conservar.size === 0) return undefined;\n\tif (parsea(revertirHunks(a, b, hunks, [...conservar]), ruta) !== true) return undefined;\n\treturn [...conservar];\n}\n\n/** La región rota localizada, con su referencia (culpables revertidos) para enseñarle al modelo. */\nexport interface RegionDeReparacion {\n\t/** Tramo de líneas sustituido en el fichero roto, `[bInicio, bFin)`. */\n\tbInicio: number;\n\tbFin: number;\n\t/** La región tal cual está en el fichero roto. */\n\ttextoRoto: string;\n\t/** La misma región con los hunks culpables revertidos: empalmarla restaura el parseo. */\n\ttextoReferencia: string;\n}\n\n/**\n * Localiza la rotura de `antes → despues` a una región de líneas acotada.\n * `undefined` cuando no se puede aislar o cuando la región supera\n * {@link MAX_LINEAS_REGION} — quien llama se queda entonces con el aviso de\n * parseo roto normal.\n */\nexport function calcularRegionDeReparacion(instantanea: {\n\truta: string;\n\tantes: string;\n\tdespues: string;\n}): RegionDeReparacion | undefined {\n\tconst { ruta, antes, despues } = instantanea;\n\tconst { hunks, a, b } = construirHunks(antes, despues);\n\tconst culpables = aislarHunksCulpables(ruta, a, b, hunks);\n\tif (!culpables) return undefined;\n\n\tconst hs = culpables.map((i) => hunks[i]).sort((x, y) => x.bInicio - y.bInicio);\n\tconst bInicio = Math.max(0, hs[0].bInicio - LINEAS_DE_CONTEXTO);\n\tconst bFin = Math.min(b.length, (hs.at(-1) as Hunk).bFin + LINEAS_DE_CONTEXTO);\n\tif (bFin - bInicio > MAX_LINEAS_REGION) return undefined;\n\n\t// Referencia = la región rota con cada hunk culpable cambiado por sus\n\t// líneas de preimagen, así que empalmarla reproduce exactamente esa\n\t// reversión (que parsea por construcción).\n\tconst ref: string[] = [];\n\tlet bi = bInicio;\n\tfor (const h of hs) {\n\t\tref.push(...b.slice(bi, h.bInicio), ...a.slice(h.aInicio, h.aFin));\n\t\tbi = h.bFin;\n\t}\n\tref.push(...b.slice(bi, bFin));\n\n\treturn {\n\t\tbInicio,\n\t\tbFin,\n\t\ttextoRoto: b.slice(bInicio, bFin).join(\"\\n\"),\n\t\ttextoReferencia: ref.join(\"\\n\"),\n\t};\n}\n\nfunction empalmarRegion(b: string[], region: RegionDeReparacion, texto: string): string {\n\treturn [...b.slice(0, region.bInicio), ...texto.split(\"\\n\"), ...b.slice(region.bFin)].join(\"\\n\");\n}\n\n/** Quita una valla de código markdown envolvente, si la hay. */\nfunction quitarValla(texto: string): string {\n\tconst recortado = texto.trim();\n\tconst m = recortado.match(/^```[^\\n]*\\n([\\s\\S]*?)\\n?```$/);\n\treturn m ? m[1] : recortado;\n}\n\n/** Espacios colapsados para comparar sin que un reindentado cuente como cambio real. */\nfunction normalizarParaComparar(texto: string): string {\n\treturn texto.replace(/\\s+/g, \" \").trim();\n}\n\nfunction construirPrompt(region: RegionDeReparacion, ruta: string, intentoPrevio?: string): string {\n\tconst previo = intentoPrevio\n\t\t? `\\n\\nINTENTO ANTERIOR (rechazado — o seguía roto, o era un simple calco de la referencia):\\n\\`\\`\\`\\n${intentoPrevio}\\n\\`\\`\\`\\n`\n\t\t: \"\";\n\treturn (\n\t\t`El fichero ${ruta} quedó con un error de sintaxis tras una edición. Tu tarea es arreglar SOLO ` +\n\t\t`la sintaxis, sin deshacer el cambio que se pretendía.\\n\\n` +\n\t\t`REFERENCIA (parsea bien; es el cambio pretendido con la rotura revertida — NO la copies tal cual, ` +\n\t\t`solo es para que veas qué había antes):\\n\\`\\`\\`\\n${region.textoReferencia}\\n\\`\\`\\`\\n\\n` +\n\t\t`ROTO (esto es lo que hay que arreglar, conservando su intención):\\n\\`\\`\\`\\n${region.textoRoto}\\n\\`\\`\\`\\n` +\n\t\t`${previo}\\n` +\n\t\t`Devuelve SOLO el bloque de código que sustituye la sección ROTO, ya arreglado. Sin explicaciones, sin ` +\n\t\t`numerar líneas, sin nada fuera del bloque.`\n\t);\n}\n\n/** Qué pasó al intentar reparar. Nunca colapsa \"no pude intentarlo\" con \"lo intenté y no valió\". */\nexport type ResultadoReparacion =\n\t| { estado: \"reparado\"; contenido: string; intentos: number }\n\t/** No había con qué preguntar (sin modelo) o la rotura no se pudo aislar/acotar. */\n\t| { estado: \"no-aplicable\" }\n\t/** Se preguntó al modelo pero ningún intento cumplió las dos condiciones de aceptación. */\n\t| { estado: \"rechazada\" };\n\n/**\n * Intenta reparar una edición que rompió el parseo, preguntándole a `completar`.\n *\n * `completar` devuelve `null` cuando no pudo completarse (sin modelo, sin\n * red, error de la API…): eso es \"no-aplicable\", nunca \"rechazada\" — una\n * reparación rechazada es una que SE INTENTÓ y no sirvió.\n */\nexport async function intentarReparar(\n\tinstantanea: { ruta: string; antes: string; despues: string },\n\tcompletar?: (prompt: string) => Promise<string | null>,\n): Promise<ResultadoReparacion> {\n\tif (!completar) return { estado: \"no-aplicable\" };\n\tconst region = calcularRegionDeReparacion(instantanea);\n\tif (!region) return { estado: \"no-aplicable\" };\n\n\tconst b = instantanea.despues.split(\"\\n\");\n\tconst referenciaNormalizada = normalizarParaComparar(region.textoReferencia);\n\n\tlet intentoPrevio: string | undefined;\n\tfor (let intento = 1; intento <= MAX_INTENTOS; intento++) {\n\t\tconst respuesta = await completar(construirPrompt(region, instantanea.ruta, intentoPrevio));\n\t\tif (respuesta === null) return { estado: intento === 1 ? \"no-aplicable\" : \"rechazada\" };\n\n\t\tconst candidato = quitarValla(respuesta);\n\t\tintentoPrevio = candidato;\n\n\t\t// La regla que evita que la \"reparación\" deshaga el trabajo del\n\t\t// usuario: un candidato que, sin espacios, es un calco de la\n\t\t// referencia es una reversión pura y se descarta aunque parseara.\n\t\tif (normalizarParaComparar(candidato) === referenciaNormalizada) continue;\n\n\t\tconst contenido = empalmarRegion(b, region, candidato);\n\t\tif (parsea(contenido, instantanea.ruta) === true) {\n\t\t\treturn { estado: \"reparado\", contenido, intentos: intento };\n\t\t}\n\t}\n\treturn { estado: \"rechazada\" };\n}\n"]}

package/dist/core/edicion/reparacion.js

@@ -0,0 +1,202 @@
+/**
+ * Auto-reparación de una edición que rompió el parseo.
+ *
+ * Cuando `parseo.ts` detecta que una edición convirtió un fichero que
+ * parseaba en uno que no, esto intenta arreglarlo solo: localiza el conjunto
+ * mínimo de hunks (líneas cambiadas) cuya reversión restaura el parseo, le
+ * pide al modelo que arregle SOLO esa región mostrándole la versión sin
+ * romper como referencia, y acepta el resultado únicamente si (a) el
+ * fichero entero vuelve a parsear Y (b) lo que devolvió el modelo no es,
+ * quitando espacios, un calco de la referencia — es decir, no es una simple
+ * reversión del cambio que el usuario pidió.
+ *
+ * La idea y el reparto de responsabilidades vienen de `oh-my-pi`
+ * (packages/coding-agent/src/edit/auto-repair.ts): localizar antes de
+ * preguntar, y rechazar la reversión aunque parsee. Lo que cambia aquí es la
+ * implementación: sin tree-sitter (usamos el mismo `parsea()` de
+ * `parseo.ts`, que ya cubre lo que este fork edita) y con el paquete `diff`
+ * que este proyecto ya trae en vez de un diff de líneas propio.
+ */
+import * as Diff from "diff";
+import { parsea } from "./parseo.js";
+/** Cuántas líneas de contexto se enseñan alrededor de los hunks culpables. */
+const LINEAS_DE_CONTEXTO = 6;
+/** Región más grande que merece la pena mandarle a un modelo. */
+const MAX_LINEAS_REGION = 150;
+/** Un primer intento y un reintento con el rechazo anterior como pista. */
+const MAX_INTENTOS = 2;
+function construirHunks(antes, despues) {
+    const a = antes.split("\n");
+    const b = despues.split("\n");
+    const partes = Diff.diffLines(antes, despues);
+    const hunks = [];
+    let ai = 0;
+    let bi = 0;
+    for (const parte of partes) {
+        const lineas = parte.count ?? 0;
+        if (!parte.added && !parte.removed) {
+            ai += lineas;
+            bi += lineas;
+            continue;
+        }
+        const borradas = parte.removed ? lineas : 0;
+        const anadidas = parte.added ? lineas : 0;
+        // Un borrado seguido de un añadido contiguos son la misma edición
+        // (una sustitución), no dos hunks distintos que reventar por separado.
+        const ultimo = hunks.at(-1);
+        if (ultimo && ultimo.aFin === ai && ultimo.bFin === bi) {
+            ultimo.aFin += borradas;
+            ultimo.bFin += anadidas;
+        }
+        else {
+            hunks.push({ aInicio: ai, aFin: ai + borradas, bInicio: bi, bFin: bi + anadidas });
+        }
+        ai += borradas;
+        bi += anadidas;
+    }
+    return { hunks, a, b };
+}
+/** La posimagen con el conjunto `indices` de hunks revertidos a sus líneas de preimagen. */
+function revertirHunks(a, b, hunks, indices) {
+    const ordenados = [...indices].sort((x, y) => x - y);
+    const out = [];
+    let bi = 0;
+    for (const i of ordenados) {
+        const h = hunks[i];
+        out.push(...b.slice(bi, h.bInicio), ...a.slice(h.aInicio, h.aFin));
+        bi = h.bFin;
+    }
+    out.push(...b.slice(bi));
+    return out.join("\n");
+}
+/**
+ * El conjunto de hunks cuya reversión conjunta restaura el parseo, o
+ * `undefined` si no se puede aislar (incluye el caso "revertirlos todos
+ * tampoco parsea", que solo pasaría si la preimagen ya estaba rota — y eso
+ * ya lo descarta quien llama antes de invocar este módulo).
+ */
+function aislarHunksCulpables(ruta, a, b, hunks) {
+    const n = hunks.length;
+    if (n === 0)
+        return undefined;
+    // Camino rápido: la inmensa mayoría de roturas son un solo hunk.
+    for (let i = 0; i < n; i++) {
+        if (parsea(revertirHunks(a, b, hunks, [i]), ruta) === true)
+            return [i];
+    }
+    // ponytail: sin la búsqueda acotada de PARES de oh-my-pi antes de esto —
+    // el pelado voraz de abajo ya encuentra un conjunto que funciona para
+    // roturas de varios hunks, solo que no siempre es el par más pequeño
+    // posible. Si algún caso real lo echa en falta, se añade aquí.
+    //
+    // Pelado voraz: se parte de "revertir todos" (que parsea, porque
+    // reconstruye la preimagen) y se intenta, hunk a hunk, DEJARLO sin
+    // revertir; si el resto sigue parseando, ese hunk no era culpable.
+    const conservar = new Set(Array.from({ length: n }, (_, i) => i));
+    for (let i = 0; i < n; i++) {
+        const prueba = new Set(conservar);
+        prueba.delete(i);
+        if (parsea(revertirHunks(a, b, hunks, [...prueba]), ruta) === true)
+            conservar.delete(i);
+    }
+    if (conservar.size === 0)
+        return undefined;
+    if (parsea(revertirHunks(a, b, hunks, [...conservar]), ruta) !== true)
+        return undefined;
+    return [...conservar];
+}
+/**
+ * Localiza la rotura de `antes → despues` a una región de líneas acotada.
+ * `undefined` cuando no se puede aislar o cuando la región supera
+ * {@link MAX_LINEAS_REGION} — quien llama se queda entonces con el aviso de
+ * parseo roto normal.
+ */
+export function calcularRegionDeReparacion(instantanea) {
+    const { ruta, antes, despues } = instantanea;
+    const { hunks, a, b } = construirHunks(antes, despues);
+    const culpables = aislarHunksCulpables(ruta, a, b, hunks);
+    if (!culpables)
+        return undefined;
+    const hs = culpables.map((i) => hunks[i]).sort((x, y) => x.bInicio - y.bInicio);
+    const bInicio = Math.max(0, hs[0].bInicio - LINEAS_DE_CONTEXTO);
+    const bFin = Math.min(b.length, hs.at(-1).bFin + LINEAS_DE_CONTEXTO);
+    if (bFin - bInicio > MAX_LINEAS_REGION)
+        return undefined;
+    // Referencia = la región rota con cada hunk culpable cambiado por sus
+    // líneas de preimagen, así que empalmarla reproduce exactamente esa
+    // reversión (que parsea por construcción).
+    const ref = [];
+    let bi = bInicio;
+    for (const h of hs) {
+        ref.push(...b.slice(bi, h.bInicio), ...a.slice(h.aInicio, h.aFin));
+        bi = h.bFin;
+    }
+    ref.push(...b.slice(bi, bFin));
+    return {
+        bInicio,
+        bFin,
+        textoRoto: b.slice(bInicio, bFin).join("\n"),
+        textoReferencia: ref.join("\n"),
+    };
+}
+function empalmarRegion(b, region, texto) {
+    return [...b.slice(0, region.bInicio), ...texto.split("\n"), ...b.slice(region.bFin)].join("\n");
+}
+/** Quita una valla de código markdown envolvente, si la hay. */
+function quitarValla(texto) {
+    const recortado = texto.trim();
+    const m = recortado.match(/^```[^\n]*\n([\s\S]*?)\n?```$/);
+    return m ? m[1] : recortado;
+}
+/** Espacios colapsados para comparar sin que un reindentado cuente como cambio real. */
+function normalizarParaComparar(texto) {
+    return texto.replace(/\s+/g, " ").trim();
+}
+function construirPrompt(region, ruta, intentoPrevio) {
+    const previo = intentoPrevio
+        ? `\n\nINTENTO ANTERIOR (rechazado — o seguía roto, o era un simple calco de la referencia):\n\`\`\`\n${intentoPrevio}\n\`\`\`\n`
+        : "";
+    return (`El fichero ${ruta} quedó con un error de sintaxis tras una edición. Tu tarea es arreglar SOLO ` +
+        `la sintaxis, sin deshacer el cambio que se pretendía.\n\n` +
+        `REFERENCIA (parsea bien; es el cambio pretendido con la rotura revertida — NO la copies tal cual, ` +
+        `solo es para que veas qué había antes):\n\`\`\`\n${region.textoReferencia}\n\`\`\`\n\n` +
+        `ROTO (esto es lo que hay que arreglar, conservando su intención):\n\`\`\`\n${region.textoRoto}\n\`\`\`\n` +
+        `${previo}\n` +
+        `Devuelve SOLO el bloque de código que sustituye la sección ROTO, ya arreglado. Sin explicaciones, sin ` +
+        `numerar líneas, sin nada fuera del bloque.`);
+}
+/**
+ * Intenta reparar una edición que rompió el parseo, preguntándole a `completar`.
+ *
+ * `completar` devuelve `null` cuando no pudo completarse (sin modelo, sin
+ * red, error de la API…): eso es "no-aplicable", nunca "rechazada" — una
+ * reparación rechazada es una que SE INTENTÓ y no sirvió.
+ */
+export async function intentarReparar(instantanea, completar) {
+    if (!completar)
+        return { estado: "no-aplicable" };
+    const region = calcularRegionDeReparacion(instantanea);
+    if (!region)
+        return { estado: "no-aplicable" };
+    const b = instantanea.despues.split("\n");
+    const referenciaNormalizada = normalizarParaComparar(region.textoReferencia);
+    let intentoPrevio;
+    for (let intento = 1; intento <= MAX_INTENTOS; intento++) {
+        const respuesta = await completar(construirPrompt(region, instantanea.ruta, intentoPrevio));
+        if (respuesta === null)
+            return { estado: intento === 1 ? "no-aplicable" : "rechazada" };
+        const candidato = quitarValla(respuesta);
+        intentoPrevio = candidato;
+        // La regla que evita que la "reparación" deshaga el trabajo del
+        // usuario: un candidato que, sin espacios, es un calco de la
+        // referencia es una reversión pura y se descarta aunque parseara.
+        if (normalizarParaComparar(candidato) === referenciaNormalizada)
+            continue;
+        const contenido = empalmarRegion(b, region, candidato);
+        if (parsea(contenido, instantanea.ruta) === true) {
+            return { estado: "reparado", contenido, intentos: intento };
+        }
+    }
+    return { estado: "rechazada" };
+}
+//# sourceMappingURL=reparacion.js.map

package/dist/core/edicion/reparacion.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"reparacion.js","sourceRoot":"","sources":["../../../src/core/edicion/reparacion.ts"],"names":[],"mappings":"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","sourcesContent":["/**\n * Auto-reparación de una edición que rompió el parseo.\n *\n * Cuando `parseo.ts` detecta que una edición convirtió un fichero que\n * parseaba en uno que no, esto intenta arreglarlo solo: localiza el conjunto\n * mínimo de hunks (líneas cambiadas) cuya reversión restaura el parseo, le\n * pide al modelo que arregle SOLO esa región mostrándole la versión sin\n * romper como referencia, y acepta el resultado únicamente si (a) el\n * fichero entero vuelve a parsear Y (b) lo que devolvió el modelo no es,\n * quitando espacios, un calco de la referencia — es decir, no es una simple\n * reversión del cambio que el usuario pidió.\n *\n * La idea y el reparto de responsabilidades vienen de `oh-my-pi`\n * (packages/coding-agent/src/edit/auto-repair.ts): localizar antes de\n * preguntar, y rechazar la reversión aunque parsee. Lo que cambia aquí es la\n * implementación: sin tree-sitter (usamos el mismo `parsea()` de\n * `parseo.ts`, que ya cubre lo que este fork edita) y con el paquete `diff`\n * que este proyecto ya trae en vez de un diff de líneas propio.\n */\n\nimport * as Diff from \"diff\";\nimport { parsea } from \"./parseo.ts\";\n\n/** Cuántas líneas de contexto se enseñan alrededor de los hunks culpables. */\nconst LINEAS_DE_CONTEXTO = 6;\n/** Región más grande que merece la pena mandarle a un modelo. */\nconst MAX_LINEAS_REGION = 150;\n/** Un primer intento y un reintento con el rechazo anterior como pista. */\nconst MAX_INTENTOS = 2;\n\n/** Un tramo de líneas cambiado, en coordenadas de preimagen (`a`) y posimagen (`b`). */\ninterface Hunk {\n\taInicio: number;\n\taFin: number;\n\tbInicio: number;\n\tbFin: number;\n}\n\nfunction construirHunks(antes: string, despues: string): { hunks: Hunk[]; a: string[]; b: string[] } {\n\tconst a = antes.split(\"\\n\");\n\tconst b = despues.split(\"\\n\");\n\tconst partes = Diff.diffLines(antes, despues);\n\tconst hunks: Hunk[] = [];\n\tlet ai = 0;\n\tlet bi = 0;\n\tfor (const parte of partes) {\n\t\tconst lineas = parte.count ?? 0;\n\t\tif (!parte.added && !parte.removed) {\n\t\t\tai += lineas;\n\t\t\tbi += lineas;\n\t\t\tcontinue;\n\t\t}\n\t\tconst borradas = parte.removed ? lineas : 0;\n\t\tconst anadidas = parte.added ? lineas : 0;\n\t\t// Un borrado seguido de un añadido contiguos son la misma edición\n\t\t// (una sustitución), no dos hunks distintos que reventar por separado.\n\t\tconst ultimo = hunks.at(-1);\n\t\tif (ultimo && ultimo.aFin === ai && ultimo.bFin === bi) {\n\t\t\tultimo.aFin += borradas;\n\t\t\tultimo.bFin += anadidas;\n\t\t} else {\n\t\t\thunks.push({ aInicio: ai, aFin: ai + borradas, bInicio: bi, bFin: bi + anadidas });\n\t\t}\n\t\tai += borradas;\n\t\tbi += anadidas;\n\t}\n\treturn { hunks, a, b };\n}\n\n/** La posimagen con el conjunto `indices` de hunks revertidos a sus líneas de preimagen. */\nfunction revertirHunks(a: string[], b: string[], hunks: Hunk[], indices: readonly number[]): string {\n\tconst ordenados = [...indices].sort((x, y) => x - y);\n\tconst out: string[] = [];\n\tlet bi = 0;\n\tfor (const i of ordenados) {\n\t\tconst h = hunks[i];\n\t\tout.push(...b.slice(bi, h.bInicio), ...a.slice(h.aInicio, h.aFin));\n\t\tbi = h.bFin;\n\t}\n\tout.push(...b.slice(bi));\n\treturn out.join(\"\\n\");\n}\n\n/**\n * El conjunto de hunks cuya reversión conjunta restaura el parseo, o\n * `undefined` si no se puede aislar (incluye el caso \"revertirlos todos\n * tampoco parsea\", que solo pasaría si la preimagen ya estaba rota — y eso\n * ya lo descarta quien llama antes de invocar este módulo).\n */\nfunction aislarHunksCulpables(ruta: string, a: string[], b: string[], hunks: Hunk[]): number[] | undefined {\n\tconst n = hunks.length;\n\tif (n === 0) return undefined;\n\n\t// Camino rápido: la inmensa mayoría de roturas son un solo hunk.\n\tfor (let i = 0; i < n; i++) {\n\t\tif (parsea(revertirHunks(a, b, hunks, [i]), ruta) === true) return [i];\n\t}\n\n\t// ponytail: sin la búsqueda acotada de PARES de oh-my-pi antes de esto —\n\t// el pelado voraz de abajo ya encuentra un conjunto que funciona para\n\t// roturas de varios hunks, solo que no siempre es el par más pequeño\n\t// posible. Si algún caso real lo echa en falta, se añade aquí.\n\t//\n\t// Pelado voraz: se parte de \"revertir todos\" (que parsea, porque\n\t// reconstruye la preimagen) y se intenta, hunk a hunk, DEJARLO sin\n\t// revertir; si el resto sigue parseando, ese hunk no era culpable.\n\tconst conservar = new Set<number>(Array.from({ length: n }, (_, i) => i));\n\tfor (let i = 0; i < n; i++) {\n\t\tconst prueba = new Set(conservar);\n\t\tprueba.delete(i);\n\t\tif (parsea(revertirHunks(a, b, hunks, [...prueba]), ruta) === true) conservar.delete(i);\n\t}\n\tif (conservar.size === 0) return undefined;\n\tif (parsea(revertirHunks(a, b, hunks, [...conservar]), ruta) !== true) return undefined;\n\treturn [...conservar];\n}\n\n/** La región rota localizada, con su referencia (culpables revertidos) para enseñarle al modelo. */\nexport interface RegionDeReparacion {\n\t/** Tramo de líneas sustituido en el fichero roto, `[bInicio, bFin)`. */\n\tbInicio: number;\n\tbFin: number;\n\t/** La región tal cual está en el fichero roto. */\n\ttextoRoto: string;\n\t/** La misma región con los hunks culpables revertidos: empalmarla restaura el parseo. */\n\ttextoReferencia: string;\n}\n\n/**\n * Localiza la rotura de `antes → despues` a una región de líneas acotada.\n * `undefined` cuando no se puede aislar o cuando la región supera\n * {@link MAX_LINEAS_REGION} — quien llama se queda entonces con el aviso de\n * parseo roto normal.\n */\nexport function calcularRegionDeReparacion(instantanea: {\n\truta: string;\n\tantes: string;\n\tdespues: string;\n}): RegionDeReparacion | undefined {\n\tconst { ruta, antes, despues } = instantanea;\n\tconst { hunks, a, b } = construirHunks(antes, despues);\n\tconst culpables = aislarHunksCulpables(ruta, a, b, hunks);\n\tif (!culpables) return undefined;\n\n\tconst hs = culpables.map((i) => hunks[i]).sort((x, y) => x.bInicio - y.bInicio);\n\tconst bInicio = Math.max(0, hs[0].bInicio - LINEAS_DE_CONTEXTO);\n\tconst bFin = Math.min(b.length, (hs.at(-1) as Hunk).bFin + LINEAS_DE_CONTEXTO);\n\tif (bFin - bInicio > MAX_LINEAS_REGION) return undefined;\n\n\t// Referencia = la región rota con cada hunk culpable cambiado por sus\n\t// líneas de preimagen, así que empalmarla reproduce exactamente esa\n\t// reversión (que parsea por construcción).\n\tconst ref: string[] = [];\n\tlet bi = bInicio;\n\tfor (const h of hs) {\n\t\tref.push(...b.slice(bi, h.bInicio), ...a.slice(h.aInicio, h.aFin));\n\t\tbi = h.bFin;\n\t}\n\tref.push(...b.slice(bi, bFin));\n\n\treturn {\n\t\tbInicio,\n\t\tbFin,\n\t\ttextoRoto: b.slice(bInicio, bFin).join(\"\\n\"),\n\t\ttextoReferencia: ref.join(\"\\n\"),\n\t};\n}\n\nfunction empalmarRegion(b: string[], region: RegionDeReparacion, texto: string): string {\n\treturn [...b.slice(0, region.bInicio), ...texto.split(\"\\n\"), ...b.slice(region.bFin)].join(\"\\n\");\n}\n\n/** Quita una valla de código markdown envolvente, si la hay. */\nfunction quitarValla(texto: string): string {\n\tconst recortado = texto.trim();\n\tconst m = recortado.match(/^```[^\\n]*\\n([\\s\\S]*?)\\n?```$/);\n\treturn m ? m[1] : recortado;\n}\n\n/** Espacios colapsados para comparar sin que un reindentado cuente como cambio real. */\nfunction normalizarParaComparar(texto: string): string {\n\treturn texto.replace(/\\s+/g, \" \").trim();\n}\n\nfunction construirPrompt(region: RegionDeReparacion, ruta: string, intentoPrevio?: string): string {\n\tconst previo = intentoPrevio\n\t\t? `\\n\\nINTENTO ANTERIOR (rechazado — o seguía roto, o era un simple calco de la referencia):\\n\\`\\`\\`\\n${intentoPrevio}\\n\\`\\`\\`\\n`\n\t\t: \"\";\n\treturn (\n\t\t`El fichero ${ruta} quedó con un error de sintaxis tras una edición. Tu tarea es arreglar SOLO ` +\n\t\t`la sintaxis, sin deshacer el cambio que se pretendía.\\n\\n` +\n\t\t`REFERENCIA (parsea bien; es el cambio pretendido con la rotura revertida — NO la copies tal cual, ` +\n\t\t`solo es para que veas qué había antes):\\n\\`\\`\\`\\n${region.textoReferencia}\\n\\`\\`\\`\\n\\n` +\n\t\t`ROTO (esto es lo que hay que arreglar, conservando su intención):\\n\\`\\`\\`\\n${region.textoRoto}\\n\\`\\`\\`\\n` +\n\t\t`${previo}\\n` +\n\t\t`Devuelve SOLO el bloque de código que sustituye la sección ROTO, ya arreglado. Sin explicaciones, sin ` +\n\t\t`numerar líneas, sin nada fuera del bloque.`\n\t);\n}\n\n/** Qué pasó al intentar reparar. Nunca colapsa \"no pude intentarlo\" con \"lo intenté y no valió\". */\nexport type ResultadoReparacion =\n\t| { estado: \"reparado\"; contenido: string; intentos: number }\n\t/** No había con qué preguntar (sin modelo) o la rotura no se pudo aislar/acotar. */\n\t| { estado: \"no-aplicable\" }\n\t/** Se preguntó al modelo pero ningún intento cumplió las dos condiciones de aceptación. */\n\t| { estado: \"rechazada\" };\n\n/**\n * Intenta reparar una edición que rompió el parseo, preguntándole a `completar`.\n *\n * `completar` devuelve `null` cuando no pudo completarse (sin modelo, sin\n * red, error de la API…): eso es \"no-aplicable\", nunca \"rechazada\" — una\n * reparación rechazada es una que SE INTENTÓ y no sirvió.\n */\nexport async function intentarReparar(\n\tinstantanea: { ruta: string; antes: string; despues: string },\n\tcompletar?: (prompt: string) => Promise<string | null>,\n): Promise<ResultadoReparacion> {\n\tif (!completar) return { estado: \"no-aplicable\" };\n\tconst region = calcularRegionDeReparacion(instantanea);\n\tif (!region) return { estado: \"no-aplicable\" };\n\n\tconst b = instantanea.despues.split(\"\\n\");\n\tconst referenciaNormalizada = normalizarParaComparar(region.textoReferencia);\n\n\tlet intentoPrevio: string | undefined;\n\tfor (let intento = 1; intento <= MAX_INTENTOS; intento++) {\n\t\tconst respuesta = await completar(construirPrompt(region, instantanea.ruta, intentoPrevio));\n\t\tif (respuesta === null) return { estado: intento === 1 ? \"no-aplicable\" : \"rechazada\" };\n\n\t\tconst candidato = quitarValla(respuesta);\n\t\tintentoPrevio = candidato;\n\n\t\t// La regla que evita que la \"reparación\" deshaga el trabajo del\n\t\t// usuario: un candidato que, sin espacios, es un calco de la\n\t\t// referencia es una reversión pura y se descarta aunque parseara.\n\t\tif (normalizarParaComparar(candidato) === referenciaNormalizada) continue;\n\n\t\tconst contenido = empalmarRegion(b, region, candidato);\n\t\tif (parsea(contenido, instantanea.ruta) === true) {\n\t\t\treturn { estado: \"reparado\", contenido, intentos: intento };\n\t\t}\n\t}\n\treturn { estado: \"rechazada\" };\n}\n"]}

package/dist/core/edicion/sangria.d.ts

@@ -0,0 +1,121 @@
+/**
+ * Casar una edición cuando el modelo se equivoca con la SANGRÍA.
+ *
+ * EL CASO. Ada se indenta con tabuladores y los modelos emiten espacios sin
+ * parar. Medido sobre el banco de cargas mal formadas: de once cargas
+ * recuperables, el motor entraba en tres, y varias de las que rechazaba eran de
+ * sangría — el error más frecuente que existe.
+ *
+ * Un rechazo cuesta un turno entero: el modelo tiene que releer el fichero y
+ * volver a escribir el bloque a ciegas, y muchas veces repite el mismo error.
+ *
+ * LO QUE ESTE MÓDULO NO HACE, y es la parte importante. No basta con encontrar
+ * el sitio: hay que escribir el reemplazo con la sangría DEL FICHERO. oh-my-pi
+ * casa más cargas que nosotros pero de las diez que aplica, tres corrompen — dos
+ * de ellas dejando la sangría mal. Aplicar no es aplicar bien:
+ *
+ *     antes:  →app.listen(puerto);
+ *     mal:        app.listen(PUERTO);     ← entró, y dejó espacios en un
+ *                                            fichero de tabuladores
+ *
+ * En TypeScript eso es cosmético. En Python es un error de sintaxis, o peor: una
+ * línea que se sale del bloque `if` y cambia la semántica sin romper nada.
+ *
+ * DOS INVARIANTES QUE LO HACEN SEGURO:
+ *
+ * 1. **Una sola posición.** Si el patrón sin sangría casa en dos sitios, se
+ *    devuelve `null`. Quitar la sangría hace el patrón MENOS específico, así que
+ *    puede volver ambiguo algo que no lo era — y elegir por el modelo cuál de
+ *    los dos editar es peor que rechazar.
+ * 2. **La sangría sale del fichero, nunca del patrón.** Se mide la del bloque
+ *    casado y se reconstruye el reemplazo con su carácter y su unidad,
+ *    conservando la profundidad RELATIVA que el modelo expresó.
+ *
+ * EL ESPACIADO INTERNO, que es el mismo error una columna más adentro. El
+ * fichero tiene `let suma = 0;` y el modelo manda `let suma  = 0;`. No es un
+ * problema de sangría —la sangría está bien— y sin embargo cuesta un turno
+ * entero igual. Se recupera con una SEGUNDA pasada de comparación que colapsa
+ * los espacios y tabuladores interiores.
+ *
+ * Y aquí está la trampa que hay que ver antes de tocar esto. Colapsar espacios
+ * en `normalizeForFuzzyMatch` (en `core/tools/edit-diff.ts`) sería mucho más
+ * corto y estaría MAL: esa forma normalizada se convierte en la base de
+ * escritura cuando alguna edición del lote es difusa, y su traducción de
+ * posiciones exige que cada sustitución sea de un carácter por otro. `[ \t]+` a
+ * un espacio no lo es. Ya nos costó una corrupción silenciosa por el mismo
+ * camino: `“`→`"` en una línea que nadie pidió tocar, dejando ficheros que ni
+ * compilan. Aquí el colapso vive SOLO en la comparación —una función que se
+ * llama para decidir si dos líneas son la misma— y nunca en el texto que se
+ * escribe: el reemplazo se construye desde el `newText` del modelo y desde los
+ * bytes del bloque original, jamás desde la forma colapsada.
+ */
+/** Un bloque casado, con lo que hace falta para empalmarlo. */
+export interface CasadoPorSangria {
+    /** Desplazamiento del inicio del bloque en el contenido original. */
+    indice: number;
+    /** Cuántos caracteres ocupa el bloque casado. */
+    longitud: number;
+    /** El reemplazo, ya re-sangrado a la sangría del fichero. */
+    textoNuevo: string;
+}
+/**
+ * Qué unidad de sangría usa un bloque: el carácter y cuántos por nivel.
+ *
+ * Se deduce del propio bloque casado y no de todo el fichero, porque un fichero
+ * mixto —los hay— daría una respuesta que no vale para la región que se toca.
+ */
+export declare function unidadDe(lineas: readonly string[]): {
+    caracter: string;
+    ancho: number;
+};
+/**
+ * Re-emite `nuevas` con la sangría del BLOQUE destino, conservando la
+ * profundidad relativa que expresó el modelo.
+ *
+ * Vive aquí y se exporta porque el camino del hueco elidido (`./hueco.ts`)
+ * necesita exactamente esto: escribía el `newText` tal cual y metía un
+ * tabulador en un fichero de cuatro espacios, que es el invariante 2 de este
+ * módulo roto en el camino de al lado.
+ */
+export declare function reSangrarComoElBloque(nuevas: readonly string[], bloque: readonly string[]): string[];
+/**
+ * Casa `oldText` contra `contenido` ignorando la sangría, y re-sangra `newText`.
+ *
+ * Devuelve `null` cuando no casa, cuando casa en más de un sitio, o cuando el
+ * patrón está vacío. `null` significa «no puedo», nunca «no hay»: quien llama
+ * debe seguir con su propio error, no dar la edición por aplicada.
+ */
+export declare function casarIgnorandoSangria(contenido: string, oldText: string, newText: string): CasadoPorSangria | null;
+/**
+ * ¿El texto nuevo mete un carácter de sangría que el fichero no usa?
+ *
+ * EL CASO, encontrado auditando y reproducido ejecutando. Cuando el `oldText`
+ * casa EXACTO, el motor escribe el `newText` tal cual y se salta toda la lógica
+ * de sangría de arriba. Si el modelo teclea el bloque nuevo con tabuladores en
+ * un fichero de espacios —cosa que hace constantemente— la mezcla entra sin que
+ * nadie la mire:
+ *
+ *     class Carro:
+ *         def total(self, items):     ← 4 espacios, del fichero
+ *     →→→→s = 0                       ← tabuladores, del modelo
+ *
+ * En Python eso es un `TabError` y el fichero no arranca. Y no lo caza nadie:
+ * `core/edicion/parseo.ts` solo cubre TypeScript y JSON, así que para `.py`
+ * devuelve `null` y la red de reparación ni se despierta.
+ *
+ * En TypeScript no rompe la sintaxis, pero deja un fichero con dos estilos que
+ * el siguiente `edit` va a casar peor. Es la misma familia que perseguimos:
+ * la edición ENTRA, así que se lee como éxito.
+ *
+ * POR QUÉ AQUÍ Y NO EN UN COMPROBADOR POR LENGUAJE. Esto no necesita gramática
+ * de nada: se compara el carácter de sangría del bloque que se sustituye con el
+ * del texto que entra. Un comprobador de Python arreglaría Python; esto arregla
+ * cualquier lenguaje sensible a la sangría, presentes y futuros.
+ *
+ * QUÉ NO HACE: no toca el texto cuando el bloque original ya mezcla —ahí no hay
+ * un estilo del fichero que respetar, y elegir uno sería inventárselo—. omp, en
+ * ese caso, abandona y escribe el texto crudo (`normalize.ts:325`); nosotros
+ * hacemos lo mismo, pero solo en ese caso.
+ */
+export declare function coherenteConElBloque(bloqueOriginal: string, textoNuevo: string): string;
+//# sourceMappingURL=sangria.d.ts.map