@hoilab/ada-cli 0.84.22 → 0.85.0

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

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

@@ -0,0 +1 @@
+{"version":3,"file":"sangria.d.ts","sourceRoot":"","sources":["../../../src/core/edicion/sangria.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAkDG;AAEH,+DAA+D;AAC/D,MAAM,WAAW,gBAAgB;IAChC,qEAAqE;IACrE,MAAM,EAAE,MAAM,CAAC;IACf,kDAAiD;IACjD,QAAQ,EAAE,MAAM,CAAC;IACjB,8DAA6D;IAC7D,UAAU,EAAE,MAAM,CAAC;CACnB;AAOD;;;;;GAKG;AACH,wBAAgB,QAAQ,CAAC,MAAM,EAAE,SAAS,MAAM,EAAE,GAAG;IAAE,QAAQ,EAAE,MAAM,CAAC;IAAC,KAAK,EAAE,MAAM,CAAA;CAAE,CAQvF;AAuCD;;;;;;;;GAQG;AACH,wBAAgB,qBAAqB,CAAC,MAAM,EAAE,SAAS,MAAM,EAAE,EAAE,MAAM,EAAE,SAAS,MAAM,EAAE,GAAG,MAAM,EAAE,CAWpG;AAuBD;;;;;;GAMG;AACH,wBAAgB,qBAAqB,CAAC,SAAS,EAAE,MAAM,EAAE,OAAO,EAAE,MAAM,EAAE,OAAO,EAAE,MAAM,GAAG,gBAAgB,GAAG,IAAI,CAuHlH;AAED;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA8BG;AACH,wBAAgB,oBAAoB,CAAC,cAAc,EAAE,MAAM,EAAE,UAAU,EAAE,MAAM,GAAG,MAAM,CAwCvF","sourcesContent":["/**\n * Casar una edición cuando el modelo se equivoca con la SANGRÍA.\n *\n * EL CASO. Ada se indenta con tabuladores y los modelos emiten espacios sin\n * parar. Medido sobre el banco de cargas mal formadas: de once cargas\n * recuperables, el motor entraba en tres, y varias de las que rechazaba eran de\n * sangría — el error más frecuente que existe.\n *\n * Un rechazo cuesta un turno entero: el modelo tiene que releer el fichero y\n * volver a escribir el bloque a ciegas, y muchas veces repite el mismo error.\n *\n * LO QUE ESTE MÓDULO NO HACE, y es la parte importante. No basta con encontrar\n * el sitio: hay que escribir el reemplazo con la sangría DEL FICHERO. oh-my-pi\n * casa más cargas que nosotros pero de las diez que aplica, tres corrompen — dos\n * de ellas dejando la sangría mal. Aplicar no es aplicar bien:\n *\n *     antes:  →app.listen(puerto);\n *     mal:        app.listen(PUERTO);     ← entró, y dejó espacios en un\n *                                            fichero de tabuladores\n *\n * En TypeScript eso es cosmético. En Python es un error de sintaxis, o peor: una\n * línea que se sale del bloque `if` y cambia la semántica sin romper nada.\n *\n * DOS INVARIANTES QUE LO HACEN SEGURO:\n *\n * 1. **Una sola posición.** Si el patrón sin sangría casa en dos sitios, se\n *    devuelve `null`. Quitar la sangría hace el patrón MENOS específico, así que\n *    puede volver ambiguo algo que no lo era — y elegir por el modelo cuál de\n *    los dos editar es peor que rechazar.\n * 2. **La sangría sale del fichero, nunca del patrón.** Se mide la del bloque\n *    casado y se reconstruye el reemplazo con su carácter y su unidad,\n *    conservando la profundidad RELATIVA que el modelo expresó.\n *\n * EL ESPACIADO INTERNO, que es el mismo error una columna más adentro. El\n * fichero tiene `let suma = 0;` y el modelo manda `let suma  = 0;`. No es un\n * problema de sangría —la sangría está bien— y sin embargo cuesta un turno\n * entero igual. Se recupera con una SEGUNDA pasada de comparación que colapsa\n * los espacios y tabuladores interiores.\n *\n * Y aquí está la trampa que hay que ver antes de tocar esto. Colapsar espacios\n * en `normalizeForFuzzyMatch` (en `core/tools/edit-diff.ts`) sería mucho más\n * corto y estaría MAL: esa forma normalizada se convierte en la base de\n * escritura cuando alguna edición del lote es difusa, y su traducción de\n * posiciones exige que cada sustitución sea de un carácter por otro. `[ \\t]+` a\n * un espacio no lo es. Ya nos costó una corrupción silenciosa por el mismo\n * camino: `“`→`\"` en una línea que nadie pidió tocar, dejando ficheros que ni\n * compilan. Aquí el colapso vive SOLO en la comparación —una función que se\n * llama para decidir si dos líneas son la misma— y nunca en el texto que se\n * escribe: el reemplazo se construye desde el `newText` del modelo y desde los\n * bytes del bloque original, jamás desde la forma colapsada.\n */\n\n/** Un bloque casado, con lo que hace falta para empalmarlo. */\nexport interface CasadoPorSangria {\n\t/** Desplazamiento del inicio del bloque en el contenido original. */\n\tindice: number;\n\t/** Cuántos caracteres ocupa el bloque casado. */\n\tlongitud: number;\n\t/** El reemplazo, ya re-sangrado a la sangría del fichero. */\n\ttextoNuevo: string;\n}\n\n/** La sangría de una línea: su texto literal. `\"\"` si empieza en la columna 0. */\nfunction sangriaDe(linea: string): string {\n\treturn linea.match(/^[ \\t]*/)?.[0] ?? \"\";\n}\n\n/**\n * Qué unidad de sangría usa un bloque: el carácter y cuántos por nivel.\n *\n * Se deduce del propio bloque casado y no de todo el fichero, porque un fichero\n * mixto —los hay— daría una respuesta que no vale para la región que se toca.\n */\nexport function unidadDe(lineas: readonly string[]): { caracter: string; ancho: number } {\n\tconst sangrias = lineas.filter((l) => l.trim() !== \"\").map(sangriaDe);\n\tif (sangrias.some((s) => s.includes(\"\\t\"))) return { caracter: \"\\t\", ancho: 1 };\n\tconst anchos = sangrias.map((s) => s.length).filter((n) => n > 0);\n\tif (anchos.length === 0) return { caracter: \" \", ancho: 4 };\n\t// El menor salto no nulo es la unidad. Con una sola línea sangrada no hay\n\t// salto que medir, así que su propia sangría hace de unidad.\n\treturn { caracter: \" \", ancho: Math.min(...anchos) };\n}\n\n/**\n * Profundidad de una línea contando LOS DOS caracteres.\n *\n * `profundidad()` decide por una unidad única del bloque, y eso falla cuando es\n * el TEXTO DEL MODELO el que mezcla: si una línea lleva 4 espacios y la\n * siguiente 2 tabuladores, mirar solo los tabuladores da 0 y 2, cuando lo que\n * el modelo quiso decir es 1 y 2.\n *\n * Medido: con eso, el cuerpo de un método Python salía a 12 espacios en vez de\n * 8. Contando cada línea por su propio carácter sale la profundidad que el\n * modelo quiso expresar, que es la única información suya aprovechable.\n */\nfunction profundidadMixta(linea: string, anchoEspacios: number): number {\n\tconst s = sangriaDe(linea);\n\tconst tabs = (s.match(/\\t/g) ?? []).length;\n\tconst espacios = s.length - tabs;\n\treturn tabs + Math.floor(espacios / Math.max(1, anchoEspacios));\n}\n\n/** Profundidad de una línea en unidades, redondeando hacia abajo. */\nfunction profundidad(linea: string, unidad: { caracter: string; ancho: number }): number {\n\tconst s = sangriaDe(linea);\n\tif (unidad.caracter === \"\\t\") return (s.match(/\\t/g) ?? []).length;\n\treturn Math.floor(s.length / Math.max(1, unidad.ancho));\n}\n\n/**\n * La forma de una línea para COMPARAR: sin sangría y con el espaciado interior\n * colapsado.\n *\n * Nunca se escribe. Es la mitad permisiva de la comparación y solo entra en\n * juego cuando la estricta no ha encontrado nada.\n */\nfunction colapsado(linea: string): string {\n\treturn linea.trim().replace(/[ \\t]+/g, \" \");\n}\n\n/**\n * Re-emite `nuevas` con la sangría del BLOQUE destino, conservando la\n * profundidad relativa que expresó el modelo.\n *\n * Vive aquí y se exporta porque el camino del hueco elidido (`./hueco.ts`)\n * necesita exactamente esto: escribía el `newText` tal cual y metía un\n * tabulador en un fichero de cuatro espacios, que es el invariante 2 de este\n * módulo roto en el camino de al lado.\n */\nexport function reSangrarComoElBloque(nuevas: readonly string[], bloque: readonly string[]): string[] {\n\tconst unidad = unidadDe(bloque);\n\tconst base = sangriaDe(bloque[0]);\n\tconst unidadDelModelo = unidadDe(nuevas);\n\tconst primeraNoVacia = nuevas.find((l) => l.trim() !== \"\");\n\tconst baseDelModelo = primeraNoVacia === undefined ? 0 : profundidad(primeraNoVacia, unidadDelModelo);\n\treturn nuevas.map((linea) => {\n\t\tif (linea.trim() === \"\") return \"\";\n\t\tconst relativa = profundidad(linea, unidadDelModelo) - baseDelModelo;\n\t\treturn base + unidad.caracter.repeat(Math.max(0, relativa) * unidad.ancho) + linea.trim();\n\t});\n}\n\n/** Índices de las ventanas donde el patrón casa línea a línea bajo `forma`. */\nfunction ventanasQueCasan(\n\tlineas: readonly string[],\n\tpatron: readonly string[],\n\tforma: (l: string) => string,\n): number[] {\n\tconst buscado = patron.map(forma);\n\tconst posiciones: number[] = [];\n\tfor (let i = 0; i + buscado.length <= lineas.length; i++) {\n\t\tlet casa = true;\n\t\tfor (let j = 0; j < buscado.length; j++) {\n\t\t\tif (forma(lineas[i + j]) !== buscado[j]) {\n\t\t\t\tcasa = false;\n\t\t\t\tbreak;\n\t\t\t}\n\t\t}\n\t\tif (casa) posiciones.push(i);\n\t}\n\treturn posiciones;\n}\n\n/**\n * Casa `oldText` contra `contenido` ignorando la sangría, y re-sangra `newText`.\n *\n * Devuelve `null` cuando no casa, cuando casa en más de un sitio, o cuando el\n * patrón está vacío. `null` significa «no puedo», nunca «no hay»: quien llama\n * debe seguir con su propio error, no dar la edición por aplicada.\n */\nexport function casarIgnorandoSangria(contenido: string, oldText: string, newText: string): CasadoPorSangria | null {\n\tconst patron = oldText.split(\"\\n\");\n\t// Líneas vacías al principio o al final son ruido de copiado.\n\twhile (patron.length > 0 && patron[0].trim() === \"\") patron.shift();\n\twhile (patron.length > 0 && patron[patron.length - 1].trim() === \"\") patron.pop();\n\tif (patron.length === 0) return null;\n\n\tconst lineas = contenido.split(\"\\n\");\n\n\t// Dos pasadas, de la estricta a la permisiva. La segunda SOLO se intenta si\n\t// la primera no encontró nada: colapsar espacios no puede desambiguar —\n\t// cualquier par de líneas iguales al recortarlas lo sigue siendo al\n\t// colapsarlas—, así que si la estricta ya casaba en dos sitios, la permisiva\n\t// casaría en dos o más y el resultado es el mismo `null`. Intentarla solo\n\t// desde cero deja escrito que esto añade alcance y no permisividad.\n\tlet posiciones = ventanasQueCasan(lineas, patron, (l) => l.trim());\n\t// Si la estricta casó, el modelo reprodujo el espaciado interior TAL CUAL\n\t// está en el fichero. Hace falta saberlo para el invariante 3.\n\tlet caseColapsando = false;\n\tif (posiciones.length === 0) {\n\t\tposiciones = ventanasQueCasan(lineas, patron, colapsado);\n\t\tcaseColapsando = true;\n\t}\n\t// Invariante 1: una sola posición, o nada.\n\tif (posiciones.length !== 1) return null;\n\n\tconst inicio = posiciones[0];\n\tconst bloque = lineas.slice(inicio, inicio + patron.length);\n\n\t// Invariante 2: la sangría sale del FICHERO.\n\tconst unidad = unidadDe(bloque);\n\tconst nuevas = newText.split(\"\\n\");\n\tconst unidadDelModelo = unidadDe(nuevas);\n\tconst primeraNoVacia = nuevas.find((l) => l.trim() !== \"\");\n\tconst baseDelModelo = primeraNoVacia === undefined ? 0 : profundidad(primeraNoVacia, unidadDelModelo);\n\n\t// ¿El modelo aportó ALGUNA información de estructura?\n\t//\n\t// Si mandó todas las líneas pegadas al margen, su profundidad relativa es\n\t// cero en todas y no dice nada sobre el anidamiento. Re-emitirlas todas al\n\t// mismo nivel es INVENTARSE la estructura, y eso es exactamente lo que\n\t// corrompe. Medido: con el bloque\n\t//\n\t//     for (const it of items) {\n\t//     suma += it.precio;        ← el modelo la manda pegada al margen\n\t//     }\n\t//\n\t// la primera versión de esta función dejaba `suma += …` al nivel del `for`\n\t// en vez de dentro, y el banco lo marcó como CORRUPTO. Un rechazo cuesta un\n\t// turno; esto costaba un fichero mal indentado sin avisar.\n\tconst modeloAportaEstructura = nuevas.some(\n\t\t(l) => l.trim() !== \"\" && profundidad(l, unidadDelModelo) - baseDelModelo !== 0,\n\t);\n\tconst bloqueTieneEstructura = bloque.some(\n\t\t(l) => l.trim() !== \"\" && profundidad(l, unidad) !== profundidad(bloque[0], unidad),\n\t);\n\n\tlet reSangradas: string[];\n\tif (modeloAportaEstructura || !bloqueTieneEstructura) {\n\t\t// El modelo dijo la profundidad, o el bloque es plano y no hay nada que\n\t\t// preservar. En los dos casos su información basta.\n\t\treSangradas = reSangrarComoElBloque(nuevas, bloque);\n\t} else if (nuevas.length === bloque.length) {\n\t\t// El modelo no aportó estructura pero el bloque sí la tiene, y hay el\n\t\t// mismo número de líneas: la plantilla es el BLOQUE ORIGINAL. El modelo\n\t\t// cambió el contenido, no la forma, así que cada línea hereda la sangría\n\t\t// literal de la que sustituye.\n\t\treSangradas = nuevas.map((linea, i) => (linea.trim() === \"\" ? \"\" : sangriaDe(bloque[i]) + linea.trim()));\n\t} else {\n\t\t// Ni el modelo dice la estructura, ni se puede heredar línea a línea.\n\t\t// Cualquier sangría que pusiéramos sería adivinada, así que se rechaza:\n\t\t// «no puedo» dicho a tiempo vale más que un fichero mal indentado.\n\t\treturn null;\n\t}\n\n\t// Invariante 3: una línea que el modelo RETECLEÓ sin cambiarla conserva sus\n\t// bytes originales.\n\t//\n\t// Es la misma lección que el `“`→`\"` de `normalizeForFuzzyMatch`, aplicada\n\t// línea a línea. Al casar por espaciado colapsado, el fichero puede tener\n\t// `const s = \"a  b\";` y el modelo mandar `const s = \"a b\";` dentro de un\n\t// bloque cuya única intención era cambiar OTRA línea. Escribir la versión del\n\t// modelo colapsaría un espacio dentro de una cadena que nadie pidió tocar.\n\t// Si al colapsar las dos líneas son la misma, la que gana es la del fichero.\n\t//\n\t// Y SOLO cuando el casado ha necesitado colapsar. Este invariante existe para\n\t// neutralizar la igualdad FALSA que introduce el colapso; si casó la pasada\n\t// estricta, el modelo reprodujo el espaciado interior tal cual, así que una\n\t// diferencia en el `newText` es un cambio DELIBERADO y hay que escribirlo.\n\t// Medido, con el fichero `\\tlet suma  = 0;` y el modelo pidiendo\n\t// `let suma = 0;` con la sangría en espacios (el error de sangría más\n\t// frecuente que existe, el que este módulo entero viene a arreglar):\n\t//\n\t//   sin la puerta:  la edición se descarta y sale «No changes made … the text\n\t//                   not existing as expected» — un «no puedo» disfrazado de\n\t//                   «no existe», y el texto SÍ existía y SÍ había casado\n\t//   con la puerta:  entra, y queda `\\tlet suma = 0;`\n\t//\n\t// Sin esto, ningún arreglo cuyo único cambio sea «N espacios → uno» puede\n\t// entrar nunca por este camino: alinear un `=`, quitar un espacio doble o\n\t// convertir un tabulador interior en espacio.\n\t//\n\t// Y hasta dónde llega, que no es hasta donde parece: «bytes originales» son\n\t// los del `contenido` que nos han pasado, y cuando alguna OTRA edición del\n\t// mismo lote es difusa, ese contenido es la forma normalizada. Comprobado:\n\t// con un fichero `const s = “a  b”;` y un lote así, en disco queda\n\t// `const s = \"a  b\";` — el doble espacio se salva y las comillas\n\t// tipográficas no. No es peor que escribir la línea del modelo (que también\n\t// las trae rectas), pero la promesa es más pequeña de lo que suena.\n\tif (caseColapsando && nuevas.length === bloque.length) {\n\t\treSangradas = reSangradas.map((linea, i) => (colapsado(linea) === colapsado(bloque[i]) ? bloque[i] : linea));\n\t}\n\n\t// Desplazamientos en el contenido original: hay que contar los saltos.\n\tlet indice = 0;\n\tfor (let i = 0; i < inicio; i++) indice += lineas[i].length + 1;\n\tconst longitud = bloque.reduce((n, l) => n + l.length + 1, 0) - 1;\n\n\treturn { indice, longitud, textoNuevo: reSangradas.join(\"\\n\") };\n}\n\n/**\n * ¿El texto nuevo mete un carácter de sangría que el fichero no usa?\n *\n * EL CASO, encontrado auditando y reproducido ejecutando. Cuando el `oldText`\n * casa EXACTO, el motor escribe el `newText` tal cual y se salta toda la lógica\n * de sangría de arriba. Si el modelo teclea el bloque nuevo con tabuladores en\n * un fichero de espacios —cosa que hace constantemente— la mezcla entra sin que\n * nadie la mire:\n *\n *     class Carro:\n *         def total(self, items):     ← 4 espacios, del fichero\n *     →→→→s = 0                       ← tabuladores, del modelo\n *\n * En Python eso es un `TabError` y el fichero no arranca. Y no lo caza nadie:\n * `core/edicion/parseo.ts` solo cubre TypeScript y JSON, así que para `.py`\n * devuelve `null` y la red de reparación ni se despierta.\n *\n * En TypeScript no rompe la sintaxis, pero deja un fichero con dos estilos que\n * el siguiente `edit` va a casar peor. Es la misma familia que perseguimos:\n * la edición ENTRA, así que se lee como éxito.\n *\n * POR QUÉ AQUÍ Y NO EN UN COMPROBADOR POR LENGUAJE. Esto no necesita gramática\n * de nada: se compara el carácter de sangría del bloque que se sustituye con el\n * del texto que entra. Un comprobador de Python arreglaría Python; esto arregla\n * cualquier lenguaje sensible a la sangría, presentes y futuros.\n *\n * QUÉ NO HACE: no toca el texto cuando el bloque original ya mezcla —ahí no hay\n * un estilo del fichero que respetar, y elegir uno sería inventárselo—. omp, en\n * ese caso, abandona y escribe el texto crudo (`normalize.ts:325`); nosotros\n * hacemos lo mismo, pero solo en ese caso.\n */\nexport function coherenteConElBloque(bloqueOriginal: string, textoNuevo: string): string {\n\tconst lineasOrig = bloqueOriginal.split(\"\\n\").filter((l) => l.trim() !== \"\");\n\tconst lineasNuevas = textoNuevo.split(\"\\n\");\n\tif (lineasOrig.length === 0) return textoNuevo;\n\n\tconst sangriasOrig = lineasOrig.map(sangriaDe).filter((s) => s.length > 0);\n\tif (sangriasOrig.length === 0) return textoNuevo;\n\n\tconst origConTab = sangriasOrig.some((s) => s.includes(\"\\t\"));\n\tconst origConEspacio = sangriasOrig.some((s) => s.includes(\" \"));\n\t// El bloque original ya mezcla: no hay estilo que respetar.\n\tif (origConTab && origConEspacio) return textoNuevo;\n\n\tconst sangriasNuevas = lineasNuevas.filter((l) => l.trim() !== \"\").map(sangriaDe);\n\tconst nuevoConTab = sangriasNuevas.some((s) => s.includes(\"\\t\"));\n\tconst nuevoConEspacio = sangriasNuevas.some((s) => s.includes(\" \"));\n\t// Coincide con el fichero, o no sangra nada: no hay nada que arreglar.\n\tif (origConTab && !nuevoConEspacio) return textoNuevo;\n\tif (origConEspacio && !nuevoConTab) return textoNuevo;\n\n\t// Hay conflicto. Se reescribe la sangría del texto nuevo al estilo del\n\t// bloque, conservando la profundidad RELATIVA que el modelo expresó — que es\n\t// la única información suya que vale.\n\tconst unidad = unidadDe(lineasOrig);\n\t// El ancho del bloque original es el que convierte espacios en niveles: si el\n\t// fichero sangra de 4 en 4, ocho espacios del modelo son dos niveles.\n\tconst ancho =\n\t\tunidad.caracter === \"\\t\"\n\t\t\t? (unidadDe(lineasOrig.filter((l) => !sangriaDe(l).includes(\"\\t\"))).ancho ?? 4)\n\t\t\t: unidad.ancho;\n\tconst primera = lineasNuevas.find((l) => l.trim() !== \"\");\n\tconst base = primera === undefined ? 0 : profundidadMixta(primera, ancho);\n\treturn lineasNuevas\n\t\t.map((linea) => {\n\t\t\tif (linea.trim() === \"\") return \"\";\n\t\t\tconst relativa = Math.max(0, profundidadMixta(linea, ancho) - base);\n\t\t\tconst baseDelBloque = sangriaDe(lineasOrig[0]);\n\t\t\treturn baseDelBloque + unidad.caracter.repeat(relativa * unidad.ancho) + linea.trim();\n\t\t})\n\t\t.join(\"\\n\");\n}\n"]}