@hoilab/ada-cli 0.84.22 → 0.85.1

package/dist/core/edicion/hashline.js

@@ -0,0 +1,111 @@
+/**
+ * Hashline — formato de edición anclado por hash de línea.
+ *
+ * Nuestro único formato de edición hoy (`edit`, en `core/tools/edit.ts`) casa
+ * `oldText` contra el contenido actual del fichero: si el texto no está
+ * literal, la edición falla con un error de "no encontrado". No hay forma de
+ * decir "quiero cambiar las líneas 10-12 tal como las vi", así que un hunk
+ * calculado sobre una versión del fichero que ya cambió por debajo (otro
+ * proceso, otra pestaña del agente, el usuario a mano) se puede colar sobre
+ * líneas que ya no son las que el hunk cree que son, con la única defensa de
+ * que `oldText` deje de encontrarse — y si el nuevo contenido de esas líneas
+ * es distinto pero de la misma LONGITUD y forma que el viejo `oldText`
+ * (variable renombrada, número cambiado), ni eso lo detiene.
+ *
+ * Hashline cierra ese hueco por construcción: el hunk lleva un hash del
+ * contenido exacto del rango que dice tocar, calculado sobre lo que el
+ * llamante VIO. `aplicarHashline` recalcula ese mismo hash sobre el fichero
+ * tal como está AHORA y rechaza el hunk si no coincide — sin tocar el
+ * fichero — en vez de intentar adivinar dónde se movió el texto. La idea es
+ * la de `@oh-my-pi/hashline` (paquete de referencia en
+ * `/Users/31017423z/auditoria-omp/oh-my-pi/packages/hashline`): anclar cada
+ * hunk a un hash de contenido y rechazar el que ya no cuadra. Lo que cambia
+ * aquí es el alcance: ellos anclan el FICHERO ENTERO con una gramática de
+ * varias operaciones (PUT/CUT/MV…) pensada para sustituir su tool de edición
+ * completa; esto ancla cada RANGO de líneas por separado, como una quinta
+ * opción de formato de edición, no un reemplazo del `edit` que ya existe.
+ */
+import { createHash } from "node:crypto";
+/** Etiqueta de 8 hex del contenido exacto de las líneas `desde..hasta` (1-indexado, inclusive). */
+export function etiquetaDeRango(lineas, desde, hasta) {
+    const texto = lineas.slice(desde - 1, hasta).join("\n");
+    return createHash("sha256").update(texto).digest("hex").slice(0, 8);
+}
+/** Construye la cabecera `[ruta#tag]` para el rango `desde..hasta` del contenido actual. */
+export function construirCabecera(ruta, contenido, desde, hasta) {
+    return `[${ruta}#${etiquetaDeRango(contenido.split("\n"), desde, hasta)}]`;
+}
+const RE_CABECERA = /^\[(.+)#([0-9a-f]{8})\]\s*$/;
+const RE_RANGO = /^(\d+)(?:-(\d+))?\s*$/;
+/**
+ * Parsea un hunk hashline de tres partes: cabecera `[ruta#tag]`, línea de
+ * rango `A` o `A-B`, y cuerpo con cada línea de sustitución prefijada por
+ * `+` (una línea `+` sola es una línea en blanco).
+ */
+export function parsearHunk(texto) {
+    const lineas = texto.replace(/\r\n/g, "\n").split("\n");
+    // Ignora líneas en blanco iniciales/finales: son ruido de quien compone el
+    // hunk a mano, no parte del formato.
+    while (lineas.length > 0 && lineas[0].trim() === "")
+        lineas.shift();
+    while (lineas.length > 0 && lineas.at(-1)?.trim() === "")
+        lineas.pop();
+    if (lineas.length < 2)
+        return { error: "hunk vacío: hace falta cabecera y línea de rango" };
+    const cabecera = lineas[0].match(RE_CABECERA);
+    if (!cabecera)
+        return { error: `cabecera inválida: "${lineas[0]}" (se esperaba "[ruta#8hex]")` };
+    const rango = lineas[1].match(RE_RANGO);
+    if (!rango)
+        return { error: `rango inválido: "${lineas[1]}" (se esperaba "A" o "A-B")` };
+    const desde = Number(rango[1]);
+    const hasta = rango[2] !== undefined ? Number(rango[2]) : desde;
+    if (desde < 1 || hasta < desde)
+        return { error: `rango sin sentido: ${desde}-${hasta}` };
+    const cuerpo = [];
+    for (let i = 2; i < lineas.length; i++) {
+        const linea = lineas[i];
+        if (linea === "+") {
+            cuerpo.push("");
+            continue;
+        }
+        if (!linea.startsWith("+")) {
+            return { error: `línea de cuerpo sin "+": "${linea}"` };
+        }
+        cuerpo.push(linea.slice(1));
+    }
+    return { hunk: { ruta: cabecera[1], tag: cabecera[2], desde, hasta, cuerpo } };
+}
+/**
+ * Aplica un hunk ya parseado sobre `contenidoActual`. Rechaza sin tocar nada
+ * si el tag no coincide con lo que hay AHORA en ese rango — esa es toda la
+ * garantía del formato: un hunk calculado sobre una versión vieja del
+ * fichero nunca se aplica en silencio sobre líneas que ya cambiaron.
+ */
+export function aplicarHunk(contenidoActual, hunk) {
+    const lineas = contenidoActual.split("\n");
+    if (hunk.hasta > lineas.length) {
+        return {
+            ok: false,
+            motivo: `el rango ${hunk.desde}-${hunk.hasta} cae fuera del fichero (tiene ${lineas.length} líneas)`,
+        };
+    }
+    const tagActual = etiquetaDeRango(lineas, hunk.desde, hunk.hasta);
+    if (tagActual !== hunk.tag) {
+        return {
+            ok: false,
+            motivo: `tag obsoleto: el hunk trae #${hunk.tag} para las líneas ${hunk.desde}-${hunk.hasta} pero ahora mismo ` +
+                `esas líneas etiquetan #${tagActual} — el fichero cambió por debajo desde que se calculó este hunk`,
+        };
+    }
+    const resultado = [...lineas.slice(0, hunk.desde - 1), ...hunk.cuerpo, ...lineas.slice(hunk.hasta)].join("\n");
+    return { ok: true, contenido: resultado };
+}
+/** Atajo: parsea y aplica en un paso, contra el contenido actual del fichero que nombra el hunk. */
+export function aplicarHashline(contenidoActual, textoHunk) {
+    const parseado = parsearHunk(textoHunk);
+    if ("error" in parseado)
+        return { ok: false, motivo: parseado.error };
+    return aplicarHunk(contenidoActual, parseado.hunk);
+}
+//# sourceMappingURL=hashline.js.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"hashline.js","sourceRoot":"","sources":["../../../src/core/edicion/hashline.ts"],"names":[],"mappings":"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"}

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

@@ -0,0 +1,64 @@
+/**
+ * Casar una edición cuando el modelo ELIDE el medio con `...`.
+ *
+ * EL CASO. El modelo quiere reescribir una función de treinta líneas y cambia
+ * dos. Retipear las otras veintiocho es caro y, sobre todo, es donde se
+ * equivoca: cada línea retecleada es una oportunidad de meter un espacio de
+ * más. Así que hace lo natural y nombra los extremos:
+ *
+ *     function total(items: Item[]) {
+ *     ...
+ *     }
+ *
+ * Hasta ahora eso era un rechazo seguro —«el texto no coincide exactamente»— y
+ * costaba un turno entero releyendo el fichero para volver a escribir a ciegas
+ * lo que ya estaba bien.
+ *
+ * POR QUÉ ESTO ES MÁS PELIGROSO QUE LOS DEMÁS CAMINOS, y por qué las anclas se
+ * comparan con IGUALDAD EXACTA de línea. Este camino se traga líneas que el
+ * modelo NO ha nombrado: todo lo que hay entre las dos anclas desaparece. Un
+ * fallo aquí no deja un espacio mal, borra código. Con esa apuesta encima de la
+ * mesa, la comparación laxa no se paga: `casarIgnorandoSangria` puede permitirse
+ * recortar la sangría porque el bloque que sustituye está enteramente escrito
+ * por el modelo; aquí no.
+ *
+ * Y hay una razón medida, no estética. Sobre el fichero de siete líneas del
+ * banco, el ancla de cierre es `}` y aparece DOS veces si se comparan las líneas
+ * recortadas: la del `for` interior (`    }`) y la de la función (`}`). Con
+ * igualdad exacta hay una sola, y es la correcta. La comparación laxa habría
+ * convertido este caso en una moneda al aire — o en un rechazo, si se es
+ * honesto con la ambigüedad.
+ *
+ * ALCANCE MEDIDO, para que nadie se lleve una sorpresa. Con la regla de ancla
+ * única, sobre las 1173 funciones de nivel superior de `src/core/` y el patrón
+ * `cabecera` + `...` + `}`, casan 164 (14%): en la práctica solo la ÚLTIMA
+ * función de cada fichero, porque el `}` de la columna cero de cualquier función
+ * posterior vuelve ambigua el ancla de cierre. Es el lado seguro de la moneda
+ * —rechazar cuesta un turno y tragarse líneas que nadie nombró cuesta código—,
+ * pero conviene no confundir «recuperado» con «recuperado siempre»: el resto
+ * sigue costando el turno. La carga `hueco-cierre-no-unico` lo mide, para que
+ * quien lo cambie tenga que cambiar una cifra y no una intuición.
+ *
+ * TRES INVARIANTES:
+ *
+ * 1. **Anclas a los dos lados.** Un `...` al principio deja el hueco sin fondo:
+ *    el reemplazo se comería el fichero desde su inicio. Cae por el invariante 2
+ *    y no por una guarda propia — la guarda propia estaba escrita y no se podía
+ *    poner roja, así que se quitó; el detalle está en el cuerpo.
+ * 2. **Cada ancla en un solo sitio.** La primera, única en todo el fichero; las
+ *    siguientes, únicas en lo que queda por detrás de la anterior. Dos
+ *    posiciones es una moneda al aire y se rechaza.
+ * 3. **El `newText` no puede llevar elisión.** Si el modelo elide también en el
+ *    reemplazo, escribirlo dejaría un `...` literal dentro del código. Ese es el
+ *    fallo que se lee como éxito: la edición «entra» y el fichero no compila.
+ */
+import { type CasadoPorSangria } from "./sangria.ts";
+/**
+ * Casa `oldText` contra `contenido` cuando el patrón elide el medio con `...`.
+ *
+ * Devuelve `null` cuando no hay elisión, cuando alguna ancla falta, cuando
+ * alguna casa en más de un sitio, o cuando el reemplazo también elide. `null`
+ * significa «no puedo», nunca «no hay»: quien llama sigue con su propio error.
+ */
+export declare function casarHuecoElidido(contenido: string, oldText: string, newText: string): CasadoPorSangria | null;
+//# sourceMappingURL=hueco.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"hueco.d.ts","sourceRoot":"","sources":["../../../src/core/edicion/hueco.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAqDG;AAEH,OAAO,EAAE,KAAK,gBAAgB,EAAmC,MAAM,cAAc,CAAC;AAiBtF;;;;;;GAMG;AACH,wBAAgB,iBAAiB,CAAC,SAAS,EAAE,MAAM,EAAE,OAAO,EAAE,MAAM,EAAE,OAAO,EAAE,MAAM,GAAG,gBAAgB,GAAG,IAAI,CAiF9G"}

package/dist/core/edicion/hueco.js

@@ -0,0 +1,162 @@
+/**
+ * Casar una edición cuando el modelo ELIDE el medio con `...`.
+ *
+ * EL CASO. El modelo quiere reescribir una función de treinta líneas y cambia
+ * dos. Retipear las otras veintiocho es caro y, sobre todo, es donde se
+ * equivoca: cada línea retecleada es una oportunidad de meter un espacio de
+ * más. Así que hace lo natural y nombra los extremos:
+ *
+ *     function total(items: Item[]) {
+ *     ...
+ *     }
+ *
+ * Hasta ahora eso era un rechazo seguro —«el texto no coincide exactamente»— y
+ * costaba un turno entero releyendo el fichero para volver a escribir a ciegas
+ * lo que ya estaba bien.
+ *
+ * POR QUÉ ESTO ES MÁS PELIGROSO QUE LOS DEMÁS CAMINOS, y por qué las anclas se
+ * comparan con IGUALDAD EXACTA de línea. Este camino se traga líneas que el
+ * modelo NO ha nombrado: todo lo que hay entre las dos anclas desaparece. Un
+ * fallo aquí no deja un espacio mal, borra código. Con esa apuesta encima de la
+ * mesa, la comparación laxa no se paga: `casarIgnorandoSangria` puede permitirse
+ * recortar la sangría porque el bloque que sustituye está enteramente escrito
+ * por el modelo; aquí no.
+ *
+ * Y hay una razón medida, no estética. Sobre el fichero de siete líneas del
+ * banco, el ancla de cierre es `}` y aparece DOS veces si se comparan las líneas
+ * recortadas: la del `for` interior (`    }`) y la de la función (`}`). Con
+ * igualdad exacta hay una sola, y es la correcta. La comparación laxa habría
+ * convertido este caso en una moneda al aire — o en un rechazo, si se es
+ * honesto con la ambigüedad.
+ *
+ * ALCANCE MEDIDO, para que nadie se lleve una sorpresa. Con la regla de ancla
+ * única, sobre las 1173 funciones de nivel superior de `src/core/` y el patrón
+ * `cabecera` + `...` + `}`, casan 164 (14%): en la práctica solo la ÚLTIMA
+ * función de cada fichero, porque el `}` de la columna cero de cualquier función
+ * posterior vuelve ambigua el ancla de cierre. Es el lado seguro de la moneda
+ * —rechazar cuesta un turno y tragarse líneas que nadie nombró cuesta código—,
+ * pero conviene no confundir «recuperado» con «recuperado siempre»: el resto
+ * sigue costando el turno. La carga `hueco-cierre-no-unico` lo mide, para que
+ * quien lo cambie tenga que cambiar una cifra y no una intuición.
+ *
+ * TRES INVARIANTES:
+ *
+ * 1. **Anclas a los dos lados.** Un `...` al principio deja el hueco sin fondo:
+ *    el reemplazo se comería el fichero desde su inicio. Cae por el invariante 2
+ *    y no por una guarda propia — la guarda propia estaba escrita y no se podía
+ *    poner roja, así que se quitó; el detalle está en el cuerpo.
+ * 2. **Cada ancla en un solo sitio.** La primera, única en todo el fichero; las
+ *    siguientes, únicas en lo que queda por detrás de la anterior. Dos
+ *    posiciones es una moneda al aire y se rechaza.
+ * 3. **El `newText` no puede llevar elisión.** Si el modelo elide también en el
+ *    reemplazo, escribirlo dejaría un `...` literal dentro del código. Ese es el
+ *    fallo que se lee como éxito: la edición «entra» y el fichero no compila.
+ */
+import { reSangrarComoElBloque, unidadDe } from "./sangria.js";
+/**
+ * Una línea que es SOLO una elisión, con el comentario que los modelos le
+ * cuelgan delante (`// ...`, `# ...`, `-- ...`, o abierto y cerrado de bloque) o
+ * sin él.
+ *
+ * Tiene que ser la línea entera. `...props,` es código real y no casa, que es
+ * justo lo que se quiere: la elisión es un gesto deliberado del modelo y ocupa
+ * su propia línea.
+ */
+const ELISION = /^\s*(?:\/\/|#|--|\/\*)?\s*(?:\.{3}|…)\s*(?:\*\/)?\s*$/;
+function esLineaDeElision(linea) {
+    return ELISION.test(linea);
+}
+/**
+ * Casa `oldText` contra `contenido` cuando el patrón elide el medio con `...`.
+ *
+ * Devuelve `null` cuando no hay elisión, cuando alguna ancla falta, cuando
+ * alguna casa en más de un sitio, o cuando el reemplazo también elide. `null`
+ * significa «no puedo», nunca «no hay»: quien llama sigue con su propio error.
+ */
+export function casarHuecoElidido(contenido, oldText, newText) {
+    const patron = oldText.split("\n");
+    // Líneas vacías de los extremos: ruido de copiado, igual que en la sangría.
+    while (patron.length > 0 && patron[0].trim() === "")
+        patron.shift();
+    while (patron.length > 0 && patron[patron.length - 1].trim() === "")
+        patron.pop();
+    if (!patron.some(esLineaDeElision))
+        return null;
+    // Invariante 3: si el reemplazo elide, no hay nada que escribir sin inventar.
+    if (newText.split("\n").some(esLineaDeElision))
+        return null;
+    // El patrón partido por sus elisiones. Un trozo vacío significa una elisión
+    // pegada a un extremo o a otra elisión — el hueco sin fondo del invariante 1.
+    //
+    // Aquí había una guarda explícita contra los trozos vacíos y la QUITÉ, porque
+    // no se podía poner roja: la rompí a propósito y la puerta siguió en verde.
+    // La razón es que el invariante 2 ya la cubre, y se demuestra: un ancla vacía
+    // casa en TODAS las posiciones desde `desde`, o sea `lineas.length - desde + 1`
+    // de ellas. Para una elisión delantera `desde` es 0 y eso son al menos dos
+    // posiciones en cualquier fichero, luego «una sola posición» la rechaza
+    // siempre. Una guarda que no se puede poner roja es una invariante declarada y
+    // no comprobada, que es peor que no declararla.
+    const anclas = [[]];
+    for (const linea of patron) {
+        if (esLineaDeElision(linea))
+            anclas.push([]);
+        else
+            anclas[anclas.length - 1].push(linea);
+    }
+    const lineas = contenido.split("\n");
+    // Invariante 2: cada ancla en un solo sitio, y por detrás de la anterior.
+    let desde = 0;
+    let primeraLinea = -1;
+    let ultimaLinea = -1;
+    for (const ancla of anclas) {
+        const posiciones = [];
+        for (let i = desde; i + ancla.length <= lineas.length; i++) {
+            let casa = true;
+            for (let j = 0; j < ancla.length; j++) {
+                if (lineas[i + j] !== ancla[j]) {
+                    casa = false;
+                    break;
+                }
+            }
+            if (casa)
+                posiciones.push(i);
+        }
+        if (posiciones.length !== 1)
+            return null;
+        if (primeraLinea === -1)
+            primeraLinea = posiciones[0];
+        ultimaLinea = posiciones[0] + ancla.length - 1;
+        desde = ultimaLinea + 1;
+    }
+    // Desplazamientos en el contenido original: hay que contar los saltos.
+    let indice = 0;
+    for (let i = 0; i < primeraLinea; i++)
+        indice += lineas[i].length + 1;
+    let longitud = 0;
+    for (let i = primeraLinea; i <= ultimaLinea; i++)
+        longitud += lineas[i].length + 1;
+    longitud -= 1;
+    // El CARÁCTER de sangría sale del fichero, igual que en `casarIgnorandoSangria`.
+    //
+    // Aquí se escribía el `newText` tal cual, y eso rompía en este camino el
+    // invariante 2 del módulo de al lado. Medido con la carga `hueco-elidido`: el
+    // fichero se sangra con cuatro espacios, el modelo elide y manda
+    // `\treturn 0;`, y entraba un TABULADOR en un fichero de espacios. Es una de
+    // las dos formas exactas en las que corrompe oh-my-pi —«aplica y deja la
+    // sangría mal»—, y el banco la daba por correcta. En TypeScript es cosmético;
+    // en Python es un error de sintaxis, o peor, una línea que se sale del bloque
+    // `if` sin romper nada.
+    //
+    // Se re-sangra SOLO si el carácter no coincide, y por qué: cuando el modelo ya
+    // usa el del fichero, reescribir la sangría de todas sus líneas tocaría bytes
+    // que nadie ha pedido tocar — el interior de una plantilla multilínea es
+    // contenido, no estructura. Con el carácter equivocado no hay elección: esas
+    // líneas ya están mal.
+    const bloque = lineas.slice(primeraLinea, ultimaLinea + 1);
+    const nuevas = newText.split("\n");
+    const textoNuevo = unidadDe(bloque).caracter === unidadDe(nuevas).caracter
+        ? newText
+        : reSangrarComoElBloque(nuevas, bloque).join("\n");
+    return { indice, longitud, textoNuevo };
+}
+//# sourceMappingURL=hueco.js.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"hueco.js","sourceRoot":"","sources":["../../../src/core/edicion/hueco.ts"],"names":[],"mappings":"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"}

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

@@ -0,0 +1,51 @@
+/**
+ * Editar notebooks de Jupyter (.ipynb) sin destruirlos.
+ *
+ * EL PROBLEMA. Un .ipynb es un JSON con el código metido en cadenas dentro de
+ * arrays de líneas. El modelo lo trata como texto plano: una edición que toque
+ * una comilla escapa el JSON entero y el notebook deja de abrirse. Y aunque
+ * acierte, reescribirlo a mano cambia la indentación y el orden de claves, y
+ * el diff del usuario se llena de ruido en un fichero que él solo ha abierto
+ * para ejecutar celdas.
+ *
+ * LO QUE COPIAMOS DE oh-my-pi (edit/notebook.ts) Y LO QUE NO: la idea de
+ * editar por celdas sobre el JSON parseado es suya y es correcta. Aquí además:
+ *
+ *   1. **Re-serialización estable.** Mismo orden de claves (el que traía el
+ *      fichero: JSON.parse las conserva y JSON.stringify no reordena),
+ *      indentación 1 — la que usa Jupyter. El diff solo muestra la celda tocada.
+ *   2. **Validación al salir.** El resultado se vuelve a parsear antes de
+ *      escribirlo: un editor de notebooks que escribe JSON roto es peor que no
+ *      existir. Es el mismo contrato de `parseo.ts`, aplicado al contenedor.
+ *   3. **Sin dependencias nuevas.** `JSON.parse`/`stringify` nativos.
+ *
+ * WIRING PENDIENTE (patrón C01/D07): `src/core/tools/edit.ts` tiene hunks
+ * upstream vivos, así que el enganche no se hace aquí. Cuando toque, el
+ * despacho es una línea antes de leer el fichero: si `ruta.endsWith(".ipynb")`,
+ * llamar `aplicarEdicionNotebook(ruta, edits)` en vez del camino de texto
+ * plano. La API ya está expuesta por `core/ada.ts`.
+ */
+/** Una edición sobre una celda: `viejo` → `nuevo`. Sin `viejo`, reemplaza el source entero. */
+export interface EdicionCelda {
+    /** Índice de la celda en `nb.cells` (0 = primera). */
+    celda: number;
+    /** Texto a sustituir dentro del source de la celda. Si falta, se reemplaza todo. */
+    viejo?: string;
+    nuevo: string;
+}
+export interface ResultadoNotebook {
+    /** El notebook re-serializado, listo para escribir. Ya validado contra re-parseo. */
+    contenido: string;
+    /** Cuántas celdas tiene el notebook. */
+    celdas: number;
+}
+/** Versión pura: aplica las ediciones sobre el contenido de un notebook y valida el resultado. */
+export declare function aplicarEdicionesAContenido(contenido: string, edits: readonly EdicionCelda[]): ResultadoNotebook;
+/**
+ * Lee `ruta`, aplica las ediciones por celda, valida y reescribe. Lanza con un
+ * mensaje accionable ante notebook inválido, celda fuera de rango o `viejo`
+ * ausente — y en ningún caso deja el fichero a medias: solo escribe tras
+ * validar el resultado completo.
+ */
+export declare function aplicarEdicionNotebook(ruta: string, edits: readonly EdicionCelda[]): Promise<ResultadoNotebook>;
+//# sourceMappingURL=ipynb.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"ipynb.d.ts","sourceRoot":"","sources":["../../../src/core/edicion/ipynb.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;GA0BG;AAIH,+FAA+F;AAC/F,MAAM,WAAW,YAAY;IAC5B,sDAAsD;IACtD,KAAK,EAAE,MAAM,CAAC;IACd,oFAAoF;IACpF,KAAK,CAAC,EAAE,MAAM,CAAC;IACf,KAAK,EAAE,MAAM,CAAC;CACd;AAED,MAAM,WAAW,iBAAiB;IACjC,qFAAqF;IACrF,SAAS,EAAE,MAAM,CAAC;IAClB,wCAAwC;IACxC,MAAM,EAAE,MAAM,CAAC;CACf;AA0BD,kGAAkG;AAClG,wBAAgB,0BAA0B,CAAC,SAAS,EAAE,MAAM,EAAE,KAAK,EAAE,SAAS,YAAY,EAAE,GAAG,iBAAiB,CAsD/G;AAED;;;;;GAKG;AACH,wBAAsB,sBAAsB,CAAC,IAAI,EAAE,MAAM,EAAE,KAAK,EAAE,SAAS,YAAY,EAAE,GAAG,OAAO,CAAC,iBAAiB,CAAC,CAKrH"}

package/dist/core/edicion/ipynb.js

@@ -0,0 +1,110 @@
+/**
+ * Editar notebooks de Jupyter (.ipynb) sin destruirlos.
+ *
+ * EL PROBLEMA. Un .ipynb es un JSON con el código metido en cadenas dentro de
+ * arrays de líneas. El modelo lo trata como texto plano: una edición que toque
+ * una comilla escapa el JSON entero y el notebook deja de abrirse. Y aunque
+ * acierte, reescribirlo a mano cambia la indentación y el orden de claves, y
+ * el diff del usuario se llena de ruido en un fichero que él solo ha abierto
+ * para ejecutar celdas.
+ *
+ * LO QUE COPIAMOS DE oh-my-pi (edit/notebook.ts) Y LO QUE NO: la idea de
+ * editar por celdas sobre el JSON parseado es suya y es correcta. Aquí además:
+ *
+ *   1. **Re-serialización estable.** Mismo orden de claves (el que traía el
+ *      fichero: JSON.parse las conserva y JSON.stringify no reordena),
+ *      indentación 1 — la que usa Jupyter. El diff solo muestra la celda tocada.
+ *   2. **Validación al salir.** El resultado se vuelve a parsear antes de
+ *      escribirlo: un editor de notebooks que escribe JSON roto es peor que no
+ *      existir. Es el mismo contrato de `parseo.ts`, aplicado al contenedor.
+ *   3. **Sin dependencias nuevas.** `JSON.parse`/`stringify` nativos.
+ *
+ * WIRING PENDIENTE (patrón C01/D07): `src/core/tools/edit.ts` tiene hunks
+ * upstream vivos, así que el enganche no se hace aquí. Cuando toque, el
+ * despacho es una línea antes de leer el fichero: si `ruta.endsWith(".ipynb")`,
+ * llamar `aplicarEdicionNotebook(ruta, edits)` en vez del camino de texto
+ * plano. La API ya está expuesta por `core/ada.ts`.
+ */
+import { readFile, writeFile } from "node:fs/promises";
+/** El source de una celda, unido a texto editable. Devuelve `null` si no es ni string ni array de strings. */
+function sourceATexto(source) {
+    if (typeof source === "string")
+        return source;
+    if (Array.isArray(source)) {
+        for (const linea of source) {
+            if (typeof linea !== "string")
+                return null;
+        }
+        return source.join("");
+    }
+    return null;
+}
+/** Texto → array de líneas con `\n` preservado (convención de Jupyter: todas menos la última). */
+function textoASource(texto) {
+    if (texto === "")
+        return [];
+    const partes = texto.split("\n");
+    const lineas = partes.slice(0, -1).map((l) => `${l}\n`);
+    if (partes[partes.length - 1] !== "")
+        lineas.push(partes[partes.length - 1]);
+    return lineas;
+}
+/** Versión pura: aplica las ediciones sobre el contenido de un notebook y valida el resultado. */
+export function aplicarEdicionesAContenido(contenido, edits) {
+    let nb;
+    try {
+        const parseado = JSON.parse(contenido);
+        if (typeof parseado !== "object" || parseado === null || !Array.isArray(parseado.cells)) {
+            throw new Error("no tiene la forma de un notebook (falta «cells»)");
+        }
+        nb = parseado;
+    }
+    catch (e) {
+        const motivo = e instanceof SyntaxError ? e.message : e instanceof Error ? e.message : String(e);
+        throw new Error(`El fichero no es un notebook válido: ${motivo}`);
+    }
+    for (const edit of edits) {
+        const celda = nb.cells[edit.celda];
+        if (!celda) {
+            throw new Error(`La celda ${edit.celda} no existe: el notebook tiene ${nb.cells.length} celdas (índices 0–${nb.cells.length - 1}).`);
+        }
+        const actual = sourceATexto(celda.source);
+        if (actual === null) {
+            throw new Error(`La celda ${edit.celda} tiene un «source» que no es texto ni lista de líneas; no se toca.`);
+        }
+        const reemplazo = edit.viejo === undefined
+            ? edit.nuevo
+            : actual.includes(edit.viejo)
+                ? actual.replace(edit.viejo, () => edit.nuevo)
+                : (() => {
+                    throw new Error(`El texto a sustituir no está en la celda ${edit.celda}. Empieza por: ${JSON.stringify(actual.slice(0, 60))}${actual.length > 60 ? "…" : ""}`);
+                })();
+        celda.source =
+            typeof celda.source === "string"
+                ? reemplazo // la celda era una cadena plana: se queda siendo cadena plana
+                : textoASource(reemplazo);
+    }
+    const serializado = JSON.stringify(nb, null, 1);
+    // Validación al salir: si esto falla hay un bug nuestro, no del modelo.
+    const reverificado = JSON.parse(serializado);
+    if (typeof reverificado !== "object" ||
+        reverificado === null ||
+        !Array.isArray(reverificado.cells) ||
+        reverificado.cells.length !== nb.cells.length) {
+        throw new Error("Error interno: el notebook re-serializado no re-parsea igual; no se escribe nada.");
+    }
+    return { contenido: serializado, celdas: nb.cells.length };
+}
+/**
+ * Lee `ruta`, aplica las ediciones por celda, valida y reescribe. Lanza con un
+ * mensaje accionable ante notebook inválido, celda fuera de rango o `viejo`
+ * ausente — y en ningún caso deja el fichero a medias: solo escribe tras
+ * validar el resultado completo.
+ */
+export async function aplicarEdicionNotebook(ruta, edits) {
+    const contenido = await readFile(ruta, "utf-8");
+    const resultado = aplicarEdicionesAContenido(contenido, edits);
+    await writeFile(ruta, resultado.contenido, "utf-8");
+    return resultado;
+}
+//# sourceMappingURL=ipynb.js.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"ipynb.js","sourceRoot":"","sources":["../../../src/core/edicion/ipynb.ts"],"names":[],"mappings":"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"}

package/dist/core/edicion/limpiar-carga.d.ts

@@ -0,0 +1,39 @@
+/**
+ * Quitarle a un `oldText` el ruido que no es código.
+ *
+ * EL CASO MÁS VERGONZOSO ES EL NUESTRO. Nuestro propio `read` añade al final de
+ * lo que devuelve una línea como:
+ *
+ *     [Showing lines 1-5 of 5. Use offset=6 to continue.]
+ *
+ * El modelo lee un fichero, copia el bloque que quiere cambiar —cabecera
+ * incluida, porque venía pegada— y nosotros rechazamos la edición porque «el
+ * texto no coincide exactamente». Generamos la contaminación y luego la
+ * castigamos.
+ *
+ * Los otros tres son ruido que los modelos añaden solos y que ninguna de las
+ * dos partes discute que sea ruido: vallas de markdown, sentinelas de sobre de
+ * parche, y los números de línea de un `grep`.
+ *
+ * LA REGLA QUE EVITA HACER DAÑO: solo se quita lo que es INEQUÍVOCO. Un `3:` al
+ * principio de una línea podría ser una etiqueta de código real, así que solo se
+ * trata como número de línea cuando TODAS las líneas lo llevan y además los
+ * números van en orden. Preferimos dejar ruido que borrar código: quitar de más
+ * cambia el patrón y lo casa en el sitio equivocado, y eso es corrupción
+ * silenciosa — la clase de fallo que más cara nos ha salido.
+ */
+/** Lo que se quitó, para poder explicarlo en un error. */
+export interface CargaLimpia {
+    texto: string;
+    /** Qué se retiró, en orden. Vacío = no había ruido. */
+    quitado: readonly string[];
+}
+/**
+ * Limpia `oldText`. Devuelve el texto y qué se quitó.
+ *
+ * Si no había nada que quitar, `quitado` viene vacío y `texto` es idéntico al
+ * de entrada — quien llama puede así distinguir «lo he limpiado» de «no había
+ * nada», sin comparar cadenas.
+ */
+export declare function limpiarCarga(oldText: string): CargaLimpia;
+//# sourceMappingURL=limpiar-carga.d.ts.map

package/dist/core/edicion/limpiar-carga.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"limpiar-carga.d.ts","sourceRoot":"","sources":["../../../src/core/edicion/limpiar-carga.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;GAuBG;AAEH,0DAA0D;AAC1D,MAAM,WAAW,WAAW;IAC3B,KAAK,EAAE,MAAM,CAAC;IACd,uDAAuD;IACvD,OAAO,EAAE,SAAS,MAAM,EAAE,CAAC;CAC3B;AAgFD;;;;;;GAMG;AACH,wBAAgB,YAAY,CAAC,OAAO,EAAE,MAAM,GAAG,WAAW,CAUzD"}