@hoilab/ada-cli 0.84.21 → 0.85.0

package/dist/core/commit/diff.d.ts

@@ -0,0 +1,56 @@
+/**
+ * Trocea un diff unificado por fichero y mide cuánta SUSTANCIA hay en cada uno.
+ *
+ * El motivo de que esto exista aparte del modelo: en un diff de 25 ficheros lo
+ * normal es que 24 sean ruido —un import movido, el lockfile, el número de
+ * versión— y uno solo contenga el cambio de verdad. Si los 25 resúmenes entran
+ * al reduce con el mismo peso y en orden alfabético, el mensaje que sale es
+ * «actualiza varios ficheros»: literalmente cierto y completamente inútil.
+ *
+ * Ordenar por sustancia ANTES de llamar al modelo es lo que hace que la primera
+ * puerta se pueda comprobar sin red: sobre un diff preparado donde solo un
+ * fichero cambia algo, ese fichero tiene que salir el primero.
+ */
+/** Un fichero del diff, ya separado del resto. */
+export interface TrozoDeFichero {
+    /** Ruta destino (o la de origen si el fichero se borra). */
+    ruta: string;
+    /** El diff de ESE fichero, cabecera incluida. */
+    diff: string;
+    /** Líneas añadidas/borradas que dicen algo. Ver `puntuarSustancia`. */
+    sustancia: number;
+    /** Ficheros generados que nadie escribe a mano: lockfiles, minificados, dist. */
+    ruido: boolean;
+}
+export declare function esRuido(ruta: string): boolean;
+/**
+ * Cuántas líneas con contenido cambia este trozo.
+ *
+ * No pretende ser una métrica de complejidad: solo tiene que separar «aquí pasa
+ * algo» de «aquí se movió una coma», que es la única decisión que toma.
+ */
+export declare function puntuarSustancia(diff: string): number;
+/**
+ * Parte `git diff` en un trozo por fichero.
+ *
+ * Devuelve `[]` solo cuando el diff está vacío de verdad. Quien llama tiene que
+ * distinguir eso de «no he podido leer el diff»; aquí no se puede inventar esa
+ * diferencia, así que la entrada vacía se devuelve vacía y el CLI decide.
+ */
+export declare function trocearPorFichero(diff: string): TrozoDeFichero[];
+/**
+ * De más sustancia a menos; el ruido siempre al final.
+ *
+ * Empate deshecho por ruta para que dos ejecuciones sobre el mismo diff den el
+ * mismo orden: un mensaje de commit que cambia según el humor del `sort` no se
+ * puede depurar.
+ */
+export declare function ordenarPorSustancia(trozos: TrozoDeFichero[]): TrozoDeFichero[];
+/**
+ * Recorta un trozo para que quepa en la llamada de map.
+ *
+ * Se recorta por el final y se dice que se ha recortado: un resumen hecho sobre
+ * medio fichero sin avisar es un resumen que miente sobre su cobertura.
+ */
+export declare function recortar(diff: string, maxCaracteres?: number): string;
+//# sourceMappingURL=diff.d.ts.map

package/dist/core/commit/diff.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"diff.d.ts","sourceRoot":"","sources":["../../../src/core/commit/diff.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;GAYG;AAEH,kDAAkD;AAClD,MAAM,WAAW,cAAc;IAC9B,4DAA4D;IAC5D,IAAI,EAAE,MAAM,CAAC;IACb,iDAAiD;IACjD,IAAI,EAAE,MAAM,CAAC;IACb,yEAAuE;IACvE,SAAS,EAAE,MAAM,CAAC;IAClB,iFAAiF;IACjF,KAAK,EAAE,OAAO,CAAC;CACf;AASD,wBAAgB,OAAO,CAAC,IAAI,EAAE,MAAM,GAAG,OAAO,CAE7C;AAgBD;;;;;GAKG;AACH,wBAAgB,gBAAgB,CAAC,IAAI,EAAE,MAAM,GAAG,MAAM,CAQrD;AAuCD;;;;;;GAMG;AACH,wBAAgB,iBAAiB,CAAC,IAAI,EAAE,MAAM,GAAG,cAAc,EAAE,CAehE;AAED;;;;;;GAMG;AACH,wBAAgB,mBAAmB,CAAC,MAAM,EAAE,cAAc,EAAE,GAAG,cAAc,EAAE,CAM9E;AAED;;;;;GAKG;AACH,wBAAgB,QAAQ,CAAC,IAAI,EAAE,MAAM,EAAE,aAAa,SAAS,GAAG,MAAM,CAGrE","sourcesContent":["/**\n * Trocea un diff unificado por fichero y mide cuánta SUSTANCIA hay en cada uno.\n *\n * El motivo de que esto exista aparte del modelo: en un diff de 25 ficheros lo\n * normal es que 24 sean ruido —un import movido, el lockfile, el número de\n * versión— y uno solo contenga el cambio de verdad. Si los 25 resúmenes entran\n * al reduce con el mismo peso y en orden alfabético, el mensaje que sale es\n * «actualiza varios ficheros»: literalmente cierto y completamente inútil.\n *\n * Ordenar por sustancia ANTES de llamar al modelo es lo que hace que la primera\n * puerta se pueda comprobar sin red: sobre un diff preparado donde solo un\n * fichero cambia algo, ese fichero tiene que salir el primero.\n */\n\n/** Un fichero del diff, ya separado del resto. */\nexport interface TrozoDeFichero {\n\t/** Ruta destino (o la de origen si el fichero se borra). */\n\truta: string;\n\t/** El diff de ESE fichero, cabecera incluida. */\n\tdiff: string;\n\t/** Líneas añadidas/borradas que dicen algo. Ver `puntuarSustancia`. */\n\tsustancia: number;\n\t/** Ficheros generados que nadie escribe a mano: lockfiles, minificados, dist. */\n\truido: boolean;\n}\n\n/**\n * Ficheros que se regeneran solos. Resumirlos con el modelo es pagar por leer\n * 4.000 líneas de hashes para acabar escribiendo «se actualizó el lockfile».\n */\nconst RUTAS_DE_RUIDO =\n\t/(^|\\/)(package-lock\\.json|npm-shrinkwrap\\.json|pnpm-lock\\.yaml|yarn\\.lock|bun\\.lockb?|Cargo\\.lock|go\\.sum|composer\\.lock|Gemfile\\.lock|poetry\\.lock|uv\\.lock)$|(^|\\/)(dist|build|vendor|node_modules)\\/|\\.min\\.(js|css)$|\\.(snap|lock)$/;\n\nexport function esRuido(ruta: string): boolean {\n\treturn RUTAS_DE_RUIDO.test(ruta);\n}\n\n/**\n * Líneas que cambian sin cambiar nada: en blanco, imports movidos, cierres de\n * bloque sueltos. Se excluyen del recuento porque son justo lo que un\n * reordenado masivo genera a puñados, y sin excluirlas 24 ficheros con un\n * import tocado le ganan por goleada al único que trae la función nueva.\n */\nfunction esLineaTrivial(cuerpo: string): boolean {\n\tconst t = cuerpo.trim();\n\tif (t === \"\") return true;\n\tif (/^(import|export\\s+\\*|export\\s+\\{|from|require|use|using|#include|package)\\b/.test(t)) return true;\n\tif (/^[{}()[\\];,]+$/.test(t)) return true;\n\treturn false;\n}\n\n/**\n * Cuántas líneas con contenido cambia este trozo.\n *\n * No pretende ser una métrica de complejidad: solo tiene que separar «aquí pasa\n * algo» de «aquí se movió una coma», que es la única decisión que toma.\n */\nexport function puntuarSustancia(diff: string): number {\n\tlet n = 0;\n\tfor (const linea of diff.split(\"\\n\")) {\n\t\tif (linea.startsWith(\"+++\") || linea.startsWith(\"---\")) continue;\n\t\tif (linea[0] !== \"+\" && linea[0] !== \"-\") continue;\n\t\tif (!esLineaTrivial(linea.slice(1))) n++;\n\t}\n\treturn n;\n}\n\n/**\n * La ruta que toca enseñar: la de destino, salvo que el fichero se borre.\n *\n * El `\\t?$` no es defensa contra un caso raro: es el formato NORMAL de git en\n * cuanto la ruta lleva un espacio. `git diff` termina las líneas `---`/`+++`\n * con un TABULADOR cuando el nombre tiene espacios, para que se pueda saber\n * dónde acaba:\n *\n *     --- a/mi app/package-lock.json\\t\n *     +++ b/mi app/package-lock.json\\t\n *\n * Sin quitarlo, la ruta se queda en `mi app/package-lock.json\\t` y `esRuido`\n * —que casa con `$`— deja de reconocerlo. Medido ejecutando `ada-cli commit\n * --detalle` por la ruta real sobre un índice con `mi app/package-lock.json`\n * (200 dependencias) y `mi app/codigo.ts`:\n *\n *     • mi app/package-lock.json<TAB> (802): ...\n *     • mi app/codigo.ts<TAB> (2): ...\n *\n * El lockfile con el punto (·) de generado convertido en bala (•): se le gastó\n * una llamada al modelo con 12.000 caracteres de hashes Y, por sus 802 líneas,\n * se ordenó DELANTE del único fichero con código. O sea, el ruido llegando el\n * primero al reduce, que es exactamente lo que este módulo existe para impedir.\n *\n * No lo cazó nadie porque el corpus de pruebas eran diffs escritos a mano, y a\n * mano nadie escribe el tabulador que pone git.\n */\nfunction rutaDelTrozo(diff: string): string {\n\tconst destino = diff.match(/^\\+\\+\\+ b\\/(.+?)\\t?$/m);\n\tif (destino && destino[1] !== \"/dev/null\") return destino[1];\n\tconst origen = diff.match(/^--- a\\/(.+?)\\t?$/m);\n\tif (origen && origen[1] !== \"/dev/null\") return origen[1];\n\t// Renombrados y cambios de modo no traen `---`/`+++`; la cabecera sí.\n\tconst cabecera = diff.match(/^diff --git a\\/(.+?) b\\/(.+)$/m);\n\treturn cabecera ? cabecera[2] : \"(desconocido)\";\n}\n\n/**\n * Parte `git diff` en un trozo por fichero.\n *\n * Devuelve `[]` solo cuando el diff está vacío de verdad. Quien llama tiene que\n * distinguir eso de «no he podido leer el diff»; aquí no se puede inventar esa\n * diferencia, así que la entrada vacía se devuelve vacía y el CLI decide.\n */\nexport function trocearPorFichero(diff: string): TrozoDeFichero[] {\n\tconst trozos: TrozoDeFichero[] = [];\n\t// El separador es la cabecera de git. Se parte con lookahead para no perderla.\n\tfor (const bruto of diff.split(/^(?=diff --git )/m)) {\n\t\tconst texto = bruto.trimEnd();\n\t\tif (!texto.startsWith(\"diff --git \")) continue;\n\t\tconst ruta = rutaDelTrozo(texto);\n\t\ttrozos.push({\n\t\t\truta,\n\t\t\tdiff: texto,\n\t\t\tsustancia: puntuarSustancia(texto),\n\t\t\truido: esRuido(ruta),\n\t\t});\n\t}\n\treturn trozos;\n}\n\n/**\n * De más sustancia a menos; el ruido siempre al final.\n *\n * Empate deshecho por ruta para que dos ejecuciones sobre el mismo diff den el\n * mismo orden: un mensaje de commit que cambia según el humor del `sort` no se\n * puede depurar.\n */\nexport function ordenarPorSustancia(trozos: TrozoDeFichero[]): TrozoDeFichero[] {\n\treturn [...trozos].sort((a, b) => {\n\t\tif (a.ruido !== b.ruido) return a.ruido ? 1 : -1;\n\t\tif (a.sustancia !== b.sustancia) return b.sustancia - a.sustancia;\n\t\treturn a.ruta.localeCompare(b.ruta);\n\t});\n}\n\n/**\n * Recorta un trozo para que quepa en la llamada de map.\n *\n * Se recorta por el final y se dice que se ha recortado: un resumen hecho sobre\n * medio fichero sin avisar es un resumen que miente sobre su cobertura.\n */\nexport function recortar(diff: string, maxCaracteres = 12_000): string {\n\tif (diff.length <= maxCaracteres) return diff;\n\treturn `${diff.slice(0, maxCaracteres)}\\n[...recortado: el fichero cambia ${diff.length} caracteres y solo se han leído los primeros ${maxCaracteres}]`;\n}\n"]}

package/dist/core/commit/diff.js

@@ -0,0 +1,145 @@
+/**
+ * Trocea un diff unificado por fichero y mide cuánta SUSTANCIA hay en cada uno.
+ *
+ * El motivo de que esto exista aparte del modelo: en un diff de 25 ficheros lo
+ * normal es que 24 sean ruido —un import movido, el lockfile, el número de
+ * versión— y uno solo contenga el cambio de verdad. Si los 25 resúmenes entran
+ * al reduce con el mismo peso y en orden alfabético, el mensaje que sale es
+ * «actualiza varios ficheros»: literalmente cierto y completamente inútil.
+ *
+ * Ordenar por sustancia ANTES de llamar al modelo es lo que hace que la primera
+ * puerta se pueda comprobar sin red: sobre un diff preparado donde solo un
+ * fichero cambia algo, ese fichero tiene que salir el primero.
+ */
+/**
+ * Ficheros que se regeneran solos. Resumirlos con el modelo es pagar por leer
+ * 4.000 líneas de hashes para acabar escribiendo «se actualizó el lockfile».
+ */
+const RUTAS_DE_RUIDO = /(^|\/)(package-lock\.json|npm-shrinkwrap\.json|pnpm-lock\.yaml|yarn\.lock|bun\.lockb?|Cargo\.lock|go\.sum|composer\.lock|Gemfile\.lock|poetry\.lock|uv\.lock)$|(^|\/)(dist|build|vendor|node_modules)\/|\.min\.(js|css)$|\.(snap|lock)$/;
+export function esRuido(ruta) {
+    return RUTAS_DE_RUIDO.test(ruta);
+}
+/**
+ * Líneas que cambian sin cambiar nada: en blanco, imports movidos, cierres de
+ * bloque sueltos. Se excluyen del recuento porque son justo lo que un
+ * reordenado masivo genera a puñados, y sin excluirlas 24 ficheros con un
+ * import tocado le ganan por goleada al único que trae la función nueva.
+ */
+function esLineaTrivial(cuerpo) {
+    const t = cuerpo.trim();
+    if (t === "")
+        return true;
+    if (/^(import|export\s+\*|export\s+\{|from|require|use|using|#include|package)\b/.test(t))
+        return true;
+    if (/^[{}()[\];,]+$/.test(t))
+        return true;
+    return false;
+}
+/**
+ * Cuántas líneas con contenido cambia este trozo.
+ *
+ * No pretende ser una métrica de complejidad: solo tiene que separar «aquí pasa
+ * algo» de «aquí se movió una coma», que es la única decisión que toma.
+ */
+export function puntuarSustancia(diff) {
+    let n = 0;
+    for (const linea of diff.split("\n")) {
+        if (linea.startsWith("+++") || linea.startsWith("---"))
+            continue;
+        if (linea[0] !== "+" && linea[0] !== "-")
+            continue;
+        if (!esLineaTrivial(linea.slice(1)))
+            n++;
+    }
+    return n;
+}
+/**
+ * La ruta que toca enseñar: la de destino, salvo que el fichero se borre.
+ *
+ * El `\t?$` no es defensa contra un caso raro: es el formato NORMAL de git en
+ * cuanto la ruta lleva un espacio. `git diff` termina las líneas `---`/`+++`
+ * con un TABULADOR cuando el nombre tiene espacios, para que se pueda saber
+ * dónde acaba:
+ *
+ *     --- a/mi app/package-lock.json\t
+ *     +++ b/mi app/package-lock.json\t
+ *
+ * Sin quitarlo, la ruta se queda en `mi app/package-lock.json\t` y `esRuido`
+ * —que casa con `$`— deja de reconocerlo. Medido ejecutando `ada-cli commit
+ * --detalle` por la ruta real sobre un índice con `mi app/package-lock.json`
+ * (200 dependencias) y `mi app/codigo.ts`:
+ *
+ *     • mi app/package-lock.json<TAB> (802): ...
+ *     • mi app/codigo.ts<TAB> (2): ...
+ *
+ * El lockfile con el punto (·) de generado convertido en bala (•): se le gastó
+ * una llamada al modelo con 12.000 caracteres de hashes Y, por sus 802 líneas,
+ * se ordenó DELANTE del único fichero con código. O sea, el ruido llegando el
+ * primero al reduce, que es exactamente lo que este módulo existe para impedir.
+ *
+ * No lo cazó nadie porque el corpus de pruebas eran diffs escritos a mano, y a
+ * mano nadie escribe el tabulador que pone git.
+ */
+function rutaDelTrozo(diff) {
+    const destino = diff.match(/^\+\+\+ b\/(.+?)\t?$/m);
+    if (destino && destino[1] !== "/dev/null")
+        return destino[1];
+    const origen = diff.match(/^--- a\/(.+?)\t?$/m);
+    if (origen && origen[1] !== "/dev/null")
+        return origen[1];
+    // Renombrados y cambios de modo no traen `---`/`+++`; la cabecera sí.
+    const cabecera = diff.match(/^diff --git a\/(.+?) b\/(.+)$/m);
+    return cabecera ? cabecera[2] : "(desconocido)";
+}
+/**
+ * Parte `git diff` en un trozo por fichero.
+ *
+ * Devuelve `[]` solo cuando el diff está vacío de verdad. Quien llama tiene que
+ * distinguir eso de «no he podido leer el diff»; aquí no se puede inventar esa
+ * diferencia, así que la entrada vacía se devuelve vacía y el CLI decide.
+ */
+export function trocearPorFichero(diff) {
+    const trozos = [];
+    // El separador es la cabecera de git. Se parte con lookahead para no perderla.
+    for (const bruto of diff.split(/^(?=diff --git )/m)) {
+        const texto = bruto.trimEnd();
+        if (!texto.startsWith("diff --git "))
+            continue;
+        const ruta = rutaDelTrozo(texto);
+        trozos.push({
+            ruta,
+            diff: texto,
+            sustancia: puntuarSustancia(texto),
+            ruido: esRuido(ruta),
+        });
+    }
+    return trozos;
+}
+/**
+ * De más sustancia a menos; el ruido siempre al final.
+ *
+ * Empate deshecho por ruta para que dos ejecuciones sobre el mismo diff den el
+ * mismo orden: un mensaje de commit que cambia según el humor del `sort` no se
+ * puede depurar.
+ */
+export function ordenarPorSustancia(trozos) {
+    return [...trozos].sort((a, b) => {
+        if (a.ruido !== b.ruido)
+            return a.ruido ? 1 : -1;
+        if (a.sustancia !== b.sustancia)
+            return b.sustancia - a.sustancia;
+        return a.ruta.localeCompare(b.ruta);
+    });
+}
+/**
+ * Recorta un trozo para que quepa en la llamada de map.
+ *
+ * Se recorta por el final y se dice que se ha recortado: un resumen hecho sobre
+ * medio fichero sin avisar es un resumen que miente sobre su cobertura.
+ */
+export function recortar(diff, maxCaracteres = 12_000) {
+    if (diff.length <= maxCaracteres)
+        return diff;
+    return `${diff.slice(0, maxCaracteres)}\n[...recortado: el fichero cambia ${diff.length} caracteres y solo se han leído los primeros ${maxCaracteres}]`;
+}
+//# sourceMappingURL=diff.js.map

package/dist/core/commit/diff.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"diff.js","sourceRoot":"","sources":["../../../src/core/commit/diff.ts"],"names":[],"mappings":"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","sourcesContent":["/**\n * Trocea un diff unificado por fichero y mide cuánta SUSTANCIA hay en cada uno.\n *\n * El motivo de que esto exista aparte del modelo: en un diff de 25 ficheros lo\n * normal es que 24 sean ruido —un import movido, el lockfile, el número de\n * versión— y uno solo contenga el cambio de verdad. Si los 25 resúmenes entran\n * al reduce con el mismo peso y en orden alfabético, el mensaje que sale es\n * «actualiza varios ficheros»: literalmente cierto y completamente inútil.\n *\n * Ordenar por sustancia ANTES de llamar al modelo es lo que hace que la primera\n * puerta se pueda comprobar sin red: sobre un diff preparado donde solo un\n * fichero cambia algo, ese fichero tiene que salir el primero.\n */\n\n/** Un fichero del diff, ya separado del resto. */\nexport interface TrozoDeFichero {\n\t/** Ruta destino (o la de origen si el fichero se borra). */\n\truta: string;\n\t/** El diff de ESE fichero, cabecera incluida. */\n\tdiff: string;\n\t/** Líneas añadidas/borradas que dicen algo. Ver `puntuarSustancia`. */\n\tsustancia: number;\n\t/** Ficheros generados que nadie escribe a mano: lockfiles, minificados, dist. */\n\truido: boolean;\n}\n\n/**\n * Ficheros que se regeneran solos. Resumirlos con el modelo es pagar por leer\n * 4.000 líneas de hashes para acabar escribiendo «se actualizó el lockfile».\n */\nconst RUTAS_DE_RUIDO =\n\t/(^|\\/)(package-lock\\.json|npm-shrinkwrap\\.json|pnpm-lock\\.yaml|yarn\\.lock|bun\\.lockb?|Cargo\\.lock|go\\.sum|composer\\.lock|Gemfile\\.lock|poetry\\.lock|uv\\.lock)$|(^|\\/)(dist|build|vendor|node_modules)\\/|\\.min\\.(js|css)$|\\.(snap|lock)$/;\n\nexport function esRuido(ruta: string): boolean {\n\treturn RUTAS_DE_RUIDO.test(ruta);\n}\n\n/**\n * Líneas que cambian sin cambiar nada: en blanco, imports movidos, cierres de\n * bloque sueltos. Se excluyen del recuento porque son justo lo que un\n * reordenado masivo genera a puñados, y sin excluirlas 24 ficheros con un\n * import tocado le ganan por goleada al único que trae la función nueva.\n */\nfunction esLineaTrivial(cuerpo: string): boolean {\n\tconst t = cuerpo.trim();\n\tif (t === \"\") return true;\n\tif (/^(import|export\\s+\\*|export\\s+\\{|from|require|use|using|#include|package)\\b/.test(t)) return true;\n\tif (/^[{}()[\\];,]+$/.test(t)) return true;\n\treturn false;\n}\n\n/**\n * Cuántas líneas con contenido cambia este trozo.\n *\n * No pretende ser una métrica de complejidad: solo tiene que separar «aquí pasa\n * algo» de «aquí se movió una coma», que es la única decisión que toma.\n */\nexport function puntuarSustancia(diff: string): number {\n\tlet n = 0;\n\tfor (const linea of diff.split(\"\\n\")) {\n\t\tif (linea.startsWith(\"+++\") || linea.startsWith(\"---\")) continue;\n\t\tif (linea[0] !== \"+\" && linea[0] !== \"-\") continue;\n\t\tif (!esLineaTrivial(linea.slice(1))) n++;\n\t}\n\treturn n;\n}\n\n/**\n * La ruta que toca enseñar: la de destino, salvo que el fichero se borre.\n *\n * El `\\t?$` no es defensa contra un caso raro: es el formato NORMAL de git en\n * cuanto la ruta lleva un espacio. `git diff` termina las líneas `---`/`+++`\n * con un TABULADOR cuando el nombre tiene espacios, para que se pueda saber\n * dónde acaba:\n *\n *     --- a/mi app/package-lock.json\\t\n *     +++ b/mi app/package-lock.json\\t\n *\n * Sin quitarlo, la ruta se queda en `mi app/package-lock.json\\t` y `esRuido`\n * —que casa con `$`— deja de reconocerlo. Medido ejecutando `ada-cli commit\n * --detalle` por la ruta real sobre un índice con `mi app/package-lock.json`\n * (200 dependencias) y `mi app/codigo.ts`:\n *\n *     • mi app/package-lock.json<TAB> (802): ...\n *     • mi app/codigo.ts<TAB> (2): ...\n *\n * El lockfile con el punto (·) de generado convertido en bala (•): se le gastó\n * una llamada al modelo con 12.000 caracteres de hashes Y, por sus 802 líneas,\n * se ordenó DELANTE del único fichero con código. O sea, el ruido llegando el\n * primero al reduce, que es exactamente lo que este módulo existe para impedir.\n *\n * No lo cazó nadie porque el corpus de pruebas eran diffs escritos a mano, y a\n * mano nadie escribe el tabulador que pone git.\n */\nfunction rutaDelTrozo(diff: string): string {\n\tconst destino = diff.match(/^\\+\\+\\+ b\\/(.+?)\\t?$/m);\n\tif (destino && destino[1] !== \"/dev/null\") return destino[1];\n\tconst origen = diff.match(/^--- a\\/(.+?)\\t?$/m);\n\tif (origen && origen[1] !== \"/dev/null\") return origen[1];\n\t// Renombrados y cambios de modo no traen `---`/`+++`; la cabecera sí.\n\tconst cabecera = diff.match(/^diff --git a\\/(.+?) b\\/(.+)$/m);\n\treturn cabecera ? cabecera[2] : \"(desconocido)\";\n}\n\n/**\n * Parte `git diff` en un trozo por fichero.\n *\n * Devuelve `[]` solo cuando el diff está vacío de verdad. Quien llama tiene que\n * distinguir eso de «no he podido leer el diff»; aquí no se puede inventar esa\n * diferencia, así que la entrada vacía se devuelve vacía y el CLI decide.\n */\nexport function trocearPorFichero(diff: string): TrozoDeFichero[] {\n\tconst trozos: TrozoDeFichero[] = [];\n\t// El separador es la cabecera de git. Se parte con lookahead para no perderla.\n\tfor (const bruto of diff.split(/^(?=diff --git )/m)) {\n\t\tconst texto = bruto.trimEnd();\n\t\tif (!texto.startsWith(\"diff --git \")) continue;\n\t\tconst ruta = rutaDelTrozo(texto);\n\t\ttrozos.push({\n\t\t\truta,\n\t\t\tdiff: texto,\n\t\t\tsustancia: puntuarSustancia(texto),\n\t\t\truido: esRuido(ruta),\n\t\t});\n\t}\n\treturn trozos;\n}\n\n/**\n * De más sustancia a menos; el ruido siempre al final.\n *\n * Empate deshecho por ruta para que dos ejecuciones sobre el mismo diff den el\n * mismo orden: un mensaje de commit que cambia según el humor del `sort` no se\n * puede depurar.\n */\nexport function ordenarPorSustancia(trozos: TrozoDeFichero[]): TrozoDeFichero[] {\n\treturn [...trozos].sort((a, b) => {\n\t\tif (a.ruido !== b.ruido) return a.ruido ? 1 : -1;\n\t\tif (a.sustancia !== b.sustancia) return b.sustancia - a.sustancia;\n\t\treturn a.ruta.localeCompare(b.ruta);\n\t});\n}\n\n/**\n * Recorta un trozo para que quepa en la llamada de map.\n *\n * Se recorta por el final y se dice que se ha recortado: un resumen hecho sobre\n * medio fichero sin avisar es un resumen que miente sobre su cobertura.\n */\nexport function recortar(diff: string, maxCaracteres = 12_000): string {\n\tif (diff.length <= maxCaracteres) return diff;\n\treturn `${diff.slice(0, maxCaracteres)}\\n[...recortado: el fichero cambia ${diff.length} caracteres y solo se han leído los primeros ${maxCaracteres}]`;\n}\n"]}

package/dist/core/commit/mensaje.d.ts

@@ -0,0 +1,80 @@
+/**
+ * Mensaje de commit por map-reduce sobre el diff.
+ *
+ * El problema: un diff grande no cabe en contexto, y meterlo entero recortado
+ * da mensajes genéricos («actualiza varios ficheros»), que es exactamente el
+ * mensaje que nadie necesita leer porque `git show --stat` ya lo dice mejor.
+ *
+ * El reparto:
+ *   - map    → un resumen por fichero, en paralelo, cada uno con SU diff entero.
+ *   - reduce → un mensaje del conjunto a partir de esos resúmenes, ordenados por
+ *              sustancia para que el cambio de verdad llegue el primero.
+ *
+ * TRES ESTADOS, NO DOS. En cada paso se distingue «no hay» de «no puedo»:
+ * un resumen vacío o una respuesta vacía del modelo NO son «este fichero no
+ * cambia nada», son un fallo, y salen como error. Ya nos pasó en `review`:
+ * cuatro de cinco ejecuciones sobre un fallo sembrado decían «no ha encontrado
+ * nada» cuando lo que había detrás era un 429.
+ */
+export declare const PROMPT_MAP = "Resumes UN fichero de un diff de git.\n\nDevuelve UNA sola l\u00EDnea, en espa\u00F1ol, con el QU\u00C9 y el POR QU\u00C9 del cambio en ese\nfichero. Nombra lo concreto: la funci\u00F3n, la constante, el flag, el endpoint.\n\nProhibido: \"varios cambios\", \"actualizaciones\", \"mejoras\", \"refactor\" a secas,\nrepetir la ruta del fichero sin decir qu\u00E9 cambia dentro.\n\nSi el fichero solo cambia formato, imports o n\u00FAmeros de version, dilo tal cual\ny en corto: eso es informacion util para no ponerlo en el titular.\n\nSin markdown, sin comillas, sin prefijos. Solo la l\u00EDnea.";
+export declare const PROMPT_REDUCE = "Escribes el mensaje de commit de un conjunto de cambios.\n\nRecibes un resumen por fichero, YA ORDENADOS de m\u00E1s a menos sustancia. El\nprimero es el cambio de verdad; el resto suele ser acompa\u00F1amiento.\n\nFormato exacto:\n  - L\u00EDnea 1: titular imperativo, min\u00FAsculas, sin punto final, m\u00E1x. 72 caracteres.\n    Tiene que nombrar EL cambio concreto del primer fichero, no el conjunto.\n  - L\u00EDnea 2: en blanco.\n  - Cuerpo: por qu\u00E9 se hace, y qu\u00E9 arrastra el resto de ficheros. L\u00EDneas de\n    m\u00E1x. 80 caracteres.\n\nPROHIBIDO en el titular: \"actualiza varios ficheros\", \"varios cambios\",\n\"cambios varios\", \"mejoras varias\", \"actualiza el proyecto\", \"wip\", \"misc\",\no cualquier titular que valdr\u00EDa igual para otro commit distinto.\n\nSin markdown, sin bloques de c\u00F3digo, sin encabezados. Solo el mensaje.";
+/** ¿El titular vale para cualquier commit? */
+export declare function esGenerico(mensaje: string): boolean;
+/**
+ * Quita lo que el modelo añade por costumbre: vallas de código y comillas.
+ *
+ * No toca el contenido. Un mensaje que llega envuelto en ``` sigue siendo el
+ * mensaje; rechazarlo por el envoltorio sería fallar por algo que se arregla
+ * con dos líneas.
+ */
+export declare function limpiarMensaje(bruto: string): string;
+/**
+ * Lanza `tarea` sobre cada elemento con un tope de concurrencia.
+ *
+ * El tope no es decorativo: el map dispara una llamada por fichero, y sobre 40
+ * ficheros sin límite lo que se consigue es un 429 del proveedor — o sea,
+ * convertir un diff grande en un fallo garantizado justo cuando map-reduce es
+ * más necesario.
+ */
+export declare function enParalelo<T, R>(elementos: T[], tope: number, tarea: (e: T, i: number) => Promise<R>): Promise<R[]>;
+/** Lo que el CLI inyecta para poder probar todo esto sin red. */
+export interface DependenciasMensaje {
+    /** Una llamada al modelo. Debe LANZAR si falla; devolver "" es un fallo. */
+    llamar: (sistema: string, usuario: string) => Promise<string>;
+    /** Llamadas simultáneas del map. */
+    tope?: number;
+    /** Cuántos resúmenes entran al reduce. Los de más sustancia primero. */
+    maxResumenes?: number;
+}
+export interface ResumenDeFichero {
+    ruta: string;
+    sustancia: number;
+    ruido: boolean;
+    resumen: string;
+}
+export interface MensajeGenerado {
+    mensaje: string;
+    resumenes: ResumenDeFichero[];
+    /** Ficheros que NO se le pasaron al modelo por ser generados. */
+    omitidos: string[];
+}
+/**
+ * Fallo con nombre. El CLI necesita distinguir «el índice está vacío» de «el
+ * modelo se cayó» para elegir el código de salida y el texto, y una cadena
+ * dentro de un Error genérico obliga a leer prosa para tomar esa decisión.
+ */
+export type CausaDeFallo = "diff-vacio" | "diff-ilegible" | "modelo" | "generico";
+export declare class ErrorDeMensaje extends Error {
+    readonly causa: CausaDeFallo;
+    constructor(causa: CausaDeFallo, mensaje: string);
+}
+/**
+ * Map sobre cada fichero, reduce sobre los resúmenes.
+ *
+ * `llamar` tiene que LANZAR cuando el proveedor falla. Si devolviera "" en vez
+ * de lanzar, aquí se leería como «este fichero no cambia nada» y el fallo se
+ * colaría hasta el mensaje final: es el patrón exacto que nos costó cuatro
+ * revisiones falsamente limpias.
+ */
+export declare function generarMensaje(diff: string, deps: DependenciasMensaje): Promise<MensajeGenerado>;
+//# sourceMappingURL=mensaje.d.ts.map

package/dist/core/commit/mensaje.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"mensaje.d.ts","sourceRoot":"","sources":["../../../src/core/commit/mensaje.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;GAiBG;AAIH,eAAO,MAAM,UAAU,wlBAWkC,CAAC;AAE1D,eAAO,MAAM,aAAa,+2BAgB6C,CAAC;AAmBxE,+CAA8C;AAC9C,wBAAgB,UAAU,CAAC,OAAO,EAAE,MAAM,GAAG,OAAO,CAInD;AAED;;;;;;GAMG;AACH,wBAAgB,cAAc,CAAC,KAAK,EAAE,MAAM,GAAG,MAAM,CAOpD;AAED;;;;;;;GAOG;AACH,wBAAsB,UAAU,CAAC,CAAC,EAAE,CAAC,EAAE,SAAS,EAAE,CAAC,EAAE,EAAE,IAAI,EAAE,MAAM,EAAE,KAAK,EAAE,CAAC,CAAC,EAAE,CAAC,EAAE,CAAC,EAAE,MAAM,KAAK,OAAO,CAAC,CAAC,CAAC,gBAW1G;AAED,iEAAiE;AACjE,MAAM,WAAW,mBAAmB;IACnC,4EAA4E;IAC5E,MAAM,EAAE,CAAC,OAAO,EAAE,MAAM,EAAE,OAAO,EAAE,MAAM,KAAK,OAAO,CAAC,MAAM,CAAC,CAAC;IAC9D,qCAAoC;IACpC,IAAI,CAAC,EAAE,MAAM,CAAC;IACd,2EAAwE;IACxE,YAAY,CAAC,EAAE,MAAM,CAAC;CACtB;AAED,MAAM,WAAW,gBAAgB;IAChC,IAAI,EAAE,MAAM,CAAC;IACb,SAAS,EAAE,MAAM,CAAC;IAClB,KAAK,EAAE,OAAO,CAAC;IACf,OAAO,EAAE,MAAM,CAAC;CAChB;AAED,MAAM,WAAW,eAAe;IAC/B,OAAO,EAAE,MAAM,CAAC;IAChB,SAAS,EAAE,gBAAgB,EAAE,CAAC;IAC9B,iEAAiE;IACjE,QAAQ,EAAE,MAAM,EAAE,CAAC;CACnB;AAED;;;;GAIG;AACH,MAAM,MAAM,YAAY,GAAG,YAAY,GAAG,eAAe,GAAG,QAAQ,GAAG,UAAU,CAAC;AAElF,qBAAa,cAAe,SAAQ,KAAK;IACxC,QAAQ,CAAC,KAAK,EAAE,YAAY,CAAC;IAC7B,YAAY,KAAK,EAAE,YAAY,EAAE,OAAO,EAAE,MAAM,EAI/C;CACD;AAOD;;;;;;;GAOG;AACH,wBAAsB,cAAc,CAAC,IAAI,EAAE,MAAM,EAAE,IAAI,EAAE,mBAAmB,GAAG,OAAO,CAAC,eAAe,CAAC,CA6FtG","sourcesContent":["/**\n * Mensaje de commit por map-reduce sobre el diff.\n *\n * El problema: un diff grande no cabe en contexto, y meterlo entero recortado\n * da mensajes genéricos («actualiza varios ficheros»), que es exactamente el\n * mensaje que nadie necesita leer porque `git show --stat` ya lo dice mejor.\n *\n * El reparto:\n *   - map    → un resumen por fichero, en paralelo, cada uno con SU diff entero.\n *   - reduce → un mensaje del conjunto a partir de esos resúmenes, ordenados por\n *              sustancia para que el cambio de verdad llegue el primero.\n *\n * TRES ESTADOS, NO DOS. En cada paso se distingue «no hay» de «no puedo»:\n * un resumen vacío o una respuesta vacía del modelo NO son «este fichero no\n * cambia nada», son un fallo, y salen como error. Ya nos pasó en `review`:\n * cuatro de cinco ejecuciones sobre un fallo sembrado decían «no ha encontrado\n * nada» cuando lo que había detrás era un 429.\n */\n\nimport { ordenarPorSustancia, recortar, type TrozoDeFichero, trocearPorFichero } from \"./diff.ts\";\n\nexport const PROMPT_MAP = `Resumes UN fichero de un diff de git.\n\nDevuelve UNA sola línea, en español, con el QUÉ y el POR QUÉ del cambio en ese\nfichero. Nombra lo concreto: la función, la constante, el flag, el endpoint.\n\nProhibido: \"varios cambios\", \"actualizaciones\", \"mejoras\", \"refactor\" a secas,\nrepetir la ruta del fichero sin decir qué cambia dentro.\n\nSi el fichero solo cambia formato, imports o números de version, dilo tal cual\ny en corto: eso es informacion util para no ponerlo en el titular.\n\nSin markdown, sin comillas, sin prefijos. Solo la línea.`;\n\nexport const PROMPT_REDUCE = `Escribes el mensaje de commit de un conjunto de cambios.\n\nRecibes un resumen por fichero, YA ORDENADOS de más a menos sustancia. El\nprimero es el cambio de verdad; el resto suele ser acompañamiento.\n\nFormato exacto:\n  - Línea 1: titular imperativo, minúsculas, sin punto final, máx. 72 caracteres.\n    Tiene que nombrar EL cambio concreto del primer fichero, no el conjunto.\n  - Línea 2: en blanco.\n  - Cuerpo: por qué se hace, y qué arrastra el resto de ficheros. Líneas de\n    máx. 80 caracteres.\n\nPROHIBIDO en el titular: \"actualiza varios ficheros\", \"varios cambios\",\n\"cambios varios\", \"mejoras varias\", \"actualiza el proyecto\", \"wip\", \"misc\",\no cualquier titular que valdría igual para otro commit distinto.\n\nSin markdown, sin bloques de código, sin encabezados. Solo el mensaje.`;\n\n/**\n * Titulares que valdrían para cualquier commit.\n *\n * Existe porque la primera puerta de este trabajo es justo esa: sobre un diff\n * de 25 ficheros donde solo uno cambia algo, el mensaje tiene que nombrar el\n * cambio. Sin este detector, «lo nombra» es una opinión sobre la salida del\n * modelo; con él es una comprobación que se ejecuta.\n */\nconst TITULARES_VACIOS = [\n\t/\\bvarios?\\s+(ficheros?|archivos?|cambios?|m[oó]dulos?|arreglos?)\\b/i,\n\t/\\bcambios?\\s+varios\\b/i,\n\t/\\bmejoras?\\s+varias\\b/i,\n\t/\\bactualiza(?:ci[oó]n(?:es)?)?\\s+(?:el\\s+|del\\s+|de\\s+)?(?:proyecto|repositorio|c[oó]digo|ficheros?)\\b/i,\n\t/^\\s*(wip|misc|varios|updates?|update|fixes|fix|chore|cambios)\\s*[:.!]?\\s*$/i,\n\t/\\bupdate\\s+(several|various|multiple)\\b/i,\n];\n\n/** ¿El titular vale para cualquier commit? */\nexport function esGenerico(mensaje: string): boolean {\n\tconst titular = mensaje.split(\"\\n\")[0]?.trim() ?? \"\";\n\tif (titular === \"\") return true;\n\treturn TITULARES_VACIOS.some((r) => r.test(titular));\n}\n\n/**\n * Quita lo que el modelo añade por costumbre: vallas de código y comillas.\n *\n * No toca el contenido. Un mensaje que llega envuelto en ``` sigue siendo el\n * mensaje; rechazarlo por el envoltorio sería fallar por algo que se arregla\n * con dos líneas.\n */\nexport function limpiarMensaje(bruto: string): string {\n\tlet t = bruto.trim();\n\tconst valla = t.match(/^```[a-z]*\\n([\\s\\S]*?)\\n?```$/i);\n\tif (valla) t = valla[1].trim();\n\t// Los dos puntos de \"Mensaje de commit:\" que a veces se cuela delante.\n\tt = t.replace(/^(mensaje de commit|commit message)\\s*:\\s*\\n+/i, \"\");\n\treturn t.trim();\n}\n\n/**\n * Lanza `tarea` sobre cada elemento con un tope de concurrencia.\n *\n * El tope no es decorativo: el map dispara una llamada por fichero, y sobre 40\n * ficheros sin límite lo que se consigue es un 429 del proveedor — o sea,\n * convertir un diff grande en un fallo garantizado justo cuando map-reduce es\n * más necesario.\n */\nexport async function enParalelo<T, R>(elementos: T[], tope: number, tarea: (e: T, i: number) => Promise<R>) {\n\tconst resultados = new Array<R>(elementos.length);\n\tlet siguiente = 0;\n\tconst obreros = Array.from({ length: Math.min(tope, elementos.length) }, async () => {\n\t\twhile (siguiente < elementos.length) {\n\t\t\tconst i = siguiente++;\n\t\t\tresultados[i] = await tarea(elementos[i], i);\n\t\t}\n\t});\n\tawait Promise.all(obreros);\n\treturn resultados;\n}\n\n/** Lo que el CLI inyecta para poder probar todo esto sin red. */\nexport interface DependenciasMensaje {\n\t/** Una llamada al modelo. Debe LANZAR si falla; devolver \"\" es un fallo. */\n\tllamar: (sistema: string, usuario: string) => Promise<string>;\n\t/** Llamadas simultáneas del map. */\n\ttope?: number;\n\t/** Cuántos resúmenes entran al reduce. Los de más sustancia primero. */\n\tmaxResumenes?: number;\n}\n\nexport interface ResumenDeFichero {\n\truta: string;\n\tsustancia: number;\n\truido: boolean;\n\tresumen: string;\n}\n\nexport interface MensajeGenerado {\n\tmensaje: string;\n\tresumenes: ResumenDeFichero[];\n\t/** Ficheros que NO se le pasaron al modelo por ser generados. */\n\tomitidos: string[];\n}\n\n/**\n * Fallo con nombre. El CLI necesita distinguir «el índice está vacío» de «el\n * modelo se cayó» para elegir el código de salida y el texto, y una cadena\n * dentro de un Error genérico obliga a leer prosa para tomar esa decisión.\n */\nexport type CausaDeFallo = \"diff-vacio\" | \"diff-ilegible\" | \"modelo\" | \"generico\";\n\nexport class ErrorDeMensaje extends Error {\n\treadonly causa: CausaDeFallo;\n\tconstructor(causa: CausaDeFallo, mensaje: string) {\n\t\tsuper(mensaje);\n\t\tthis.name = \"ErrorDeMensaje\";\n\t\tthis.causa = causa;\n\t}\n}\n\n/** Resumen local de un fichero generado: no vale la pena gastar una llamada. */\nfunction resumirRuidoEnLocal(t: TrozoDeFichero): string {\n\treturn `fichero generado (${t.sustancia} líneas con contenido cambiadas); no se ha leído en detalle`;\n}\n\n/**\n * Map sobre cada fichero, reduce sobre los resúmenes.\n *\n * `llamar` tiene que LANZAR cuando el proveedor falla. Si devolviera \"\" en vez\n * de lanzar, aquí se leería como «este fichero no cambia nada» y el fallo se\n * colaría hasta el mensaje final: es el patrón exacto que nos costó cuatro\n * revisiones falsamente limpias.\n */\nexport async function generarMensaje(diff: string, deps: DependenciasMensaje): Promise<MensajeGenerado> {\n\tconst trozos = ordenarPorSustancia(trocearPorFichero(diff));\n\tif (trozos.length === 0) {\n\t\t// Cero trozos tiene DOS causas, y decirlas igual es el fallo de siempre.\n\t\t//\n\t\t// Sin texto no hay nada que describir. Pero si han llegado 3 KB y aun así\n\t\t// no sale ni una cabecera `diff --git `, lo que pasa es que no sabemos leer\n\t\t// ese formato, y decir «el diff no contiene ningún fichero» sobre un índice\n\t\t// LLENO es «no puedo» disfrazado de «no hay». Comprobado ejecutando: con\n\t\t// `color.ui=always` puesto, `ada-cli commit` sobre dos ficheros staged\n\t\t// contestaba exactamente eso. Los cuatro ajustes que lo provocaban los\n\t\t// apaga ya `diffDelIndice`; esto es la red por si aparece un quinto.\n\t\tif (diff.trim() === \"\") {\n\t\t\tthrow new ErrorDeMensaje(\"diff-vacio\", \"El diff no contiene ningún fichero.\");\n\t\t}\n\t\tthrow new ErrorDeMensaje(\n\t\t\t\"diff-ilegible\",\n\t\t\t`Hay diff (${diff.length} caracteres) pero no se ha reconocido ninguna cabecera 'diff --git'. ` +\n\t\t\t\t\"Suele ser configuración de git que cambia el formato: color.ui, GIT_EXTERNAL_DIFF o un diff.external.\",\n\t\t);\n\t}\n\n\tconst tope = deps.maxResumenes ?? 40;\n\tconst conSustancia = trozos.filter((t) => !t.ruido);\n\t// El corte va ANTES del map, no después.\n\t//\n\t// Estaba después: sobre 200 ficheros se pedían 200 resúmenes y se tiraban\n\t// 160 sin mirarlos. Además de pagarlos, cada uno era una oportunidad de matar\n\t// el comando entero —un resumen vacío lanza— justo en el caso para el que\n\t// existe map-reduce. Como `trozos` ya viene ordenado por sustancia, los que\n\t// se quedan fuera son los que menos cambian.\n\tconst aResumir = conSustancia.slice(0, tope);\n\tconst sinMirar = conSustancia.slice(tope);\n\tconst omitidos = trozos.filter((t) => t.ruido);\n\n\tconst resumidos = await enParalelo(aResumir, deps.tope ?? 6, async (t) => {\n\t\tconst salida = await deps.llamar(PROMPT_MAP, `Fichero: ${t.ruta}\\n\\n${recortar(t.diff)}`);\n\t\tconst resumen = salida.trim();\n\t\tif (resumen === \"\") {\n\t\t\t// Un resumen vacío NO es «este fichero no cambia nada»: el fichero está\n\t\t\t// en el diff, luego cambia. Es que no se ha podido resumir.\n\t\t\tthrow new ErrorDeMensaje(\"modelo\", `El modelo devolvió un resumen vacío para ${t.ruta}.`);\n\t\t}\n\t\treturn { ruta: t.ruta, sustancia: t.sustancia, ruido: false, resumen };\n\t});\n\n\tconst resumenes: ResumenDeFichero[] = [\n\t\t...resumidos,\n\t\t...omitidos.map((t) => ({\n\t\t\truta: t.ruta,\n\t\t\tsustancia: t.sustancia,\n\t\t\truido: true,\n\t\t\tresumen: resumirRuidoEnLocal(t),\n\t\t})),\n\t\t// Los que se quedaron fuera del tope se listan diciendo QUE NO SE HAN\n\t\t// MIRADO. Callarlos dejaría un `--detalle` que enseña 40 ficheros de un\n\t\t// commit de 200 y se lee como si fueran todos: «no lo he mirado» contado\n\t\t// como «no hay nada que contar».\n\t\t...sinMirar.map((t) => ({\n\t\t\truta: t.ruta,\n\t\t\tsustancia: t.sustancia,\n\t\t\truido: false,\n\t\t\tresumen: `no se ha resumido: por debajo del tope de ${tope} ficheros`,\n\t\t})),\n\t];\n\n\t// El corte se hace por la cola, que ya está ordenada por sustancia: si sobran\n\t// resúmenes, los que se caen son los que menos cambian. Cortar por delante o\n\t// alfabéticamente es como se pierde justo el fichero que importa.\n\tconst paraElReduce = resumenes.slice(0, tope);\n\tconst sobrantes = resumenes.length - paraElReduce.length;\n\tconst listado = paraElReduce.map((r) => `- ${r.ruta}: ${r.resumen}`).join(\"\\n\");\n\tconst cola = sobrantes > 0 ? `\\n(y ${sobrantes} fichero(s) más, todos con menos cambios)` : \"\";\n\n\tconst bruto = await deps.llamar(\n\t\tPROMPT_REDUCE,\n\t\t`${resumenes.length} fichero(s) cambiados, de más a menos sustancia:\\n\\n${listado}${cola}`,\n\t);\n\tconst mensaje = limpiarMensaje(bruto);\n\tif (mensaje === \"\") {\n\t\tthrow new ErrorDeMensaje(\"modelo\", \"El modelo devolvió un mensaje vacío.\");\n\t}\n\tif (esGenerico(mensaje)) {\n\t\t// Salir con error y no imprimirlo: un titular genérico impreso por stdout\n\t\t// se encadena a `git commit -F -` y queda en la historia para siempre. Es\n\t\t// preferible que el usuario lo escriba a mano sabiendo que lo escribe.\n\t\tthrow new ErrorDeMensaje(\n\t\t\t\"generico\",\n\t\t\t`El titular generado no nombra ningún cambio concreto: \"${mensaje.split(\"\\n\")[0]}\"`,\n\t\t);\n\t}\n\n\treturn { mensaje, resumenes, omitidos: omitidos.map((t) => t.ruta) };\n}\n"]}

package/dist/core/commit/mensaje.js

@@ -0,0 +1,207 @@
+/**
+ * Mensaje de commit por map-reduce sobre el diff.
+ *
+ * El problema: un diff grande no cabe en contexto, y meterlo entero recortado
+ * da mensajes genéricos («actualiza varios ficheros»), que es exactamente el
+ * mensaje que nadie necesita leer porque `git show --stat` ya lo dice mejor.
+ *
+ * El reparto:
+ *   - map    → un resumen por fichero, en paralelo, cada uno con SU diff entero.
+ *   - reduce → un mensaje del conjunto a partir de esos resúmenes, ordenados por
+ *              sustancia para que el cambio de verdad llegue el primero.
+ *
+ * TRES ESTADOS, NO DOS. En cada paso se distingue «no hay» de «no puedo»:
+ * un resumen vacío o una respuesta vacía del modelo NO son «este fichero no
+ * cambia nada», son un fallo, y salen como error. Ya nos pasó en `review`:
+ * cuatro de cinco ejecuciones sobre un fallo sembrado decían «no ha encontrado
+ * nada» cuando lo que había detrás era un 429.
+ */
+import { ordenarPorSustancia, recortar, trocearPorFichero } from "./diff.js";
+export const PROMPT_MAP = `Resumes UN fichero de un diff de git.
+
+Devuelve UNA sola línea, en español, con el QUÉ y el POR QUÉ del cambio en ese
+fichero. Nombra lo concreto: la función, la constante, el flag, el endpoint.
+
+Prohibido: "varios cambios", "actualizaciones", "mejoras", "refactor" a secas,
+repetir la ruta del fichero sin decir qué cambia dentro.
+
+Si el fichero solo cambia formato, imports o números de version, dilo tal cual
+y en corto: eso es informacion util para no ponerlo en el titular.
+
+Sin markdown, sin comillas, sin prefijos. Solo la línea.`;
+export const PROMPT_REDUCE = `Escribes el mensaje de commit de un conjunto de cambios.
+
+Recibes un resumen por fichero, YA ORDENADOS de más a menos sustancia. El
+primero es el cambio de verdad; el resto suele ser acompañamiento.
+
+Formato exacto:
+  - Línea 1: titular imperativo, minúsculas, sin punto final, máx. 72 caracteres.
+    Tiene que nombrar EL cambio concreto del primer fichero, no el conjunto.
+  - Línea 2: en blanco.
+  - Cuerpo: por qué se hace, y qué arrastra el resto de ficheros. Líneas de
+    máx. 80 caracteres.
+
+PROHIBIDO en el titular: "actualiza varios ficheros", "varios cambios",
+"cambios varios", "mejoras varias", "actualiza el proyecto", "wip", "misc",
+o cualquier titular que valdría igual para otro commit distinto.
+
+Sin markdown, sin bloques de código, sin encabezados. Solo el mensaje.`;
+/**
+ * Titulares que valdrían para cualquier commit.
+ *
+ * Existe porque la primera puerta de este trabajo es justo esa: sobre un diff
+ * de 25 ficheros donde solo uno cambia algo, el mensaje tiene que nombrar el
+ * cambio. Sin este detector, «lo nombra» es una opinión sobre la salida del
+ * modelo; con él es una comprobación que se ejecuta.
+ */
+const TITULARES_VACIOS = [
+    /\bvarios?\s+(ficheros?|archivos?|cambios?|m[oó]dulos?|arreglos?)\b/i,
+    /\bcambios?\s+varios\b/i,
+    /\bmejoras?\s+varias\b/i,
+    /\bactualiza(?:ci[oó]n(?:es)?)?\s+(?:el\s+|del\s+|de\s+)?(?:proyecto|repositorio|c[oó]digo|ficheros?)\b/i,
+    /^\s*(wip|misc|varios|updates?|update|fixes|fix|chore|cambios)\s*[:.!]?\s*$/i,
+    /\bupdate\s+(several|various|multiple)\b/i,
+];
+/** ¿El titular vale para cualquier commit? */
+export function esGenerico(mensaje) {
+    const titular = mensaje.split("\n")[0]?.trim() ?? "";
+    if (titular === "")
+        return true;
+    return TITULARES_VACIOS.some((r) => r.test(titular));
+}
+/**
+ * Quita lo que el modelo añade por costumbre: vallas de código y comillas.
+ *
+ * No toca el contenido. Un mensaje que llega envuelto en ``` sigue siendo el
+ * mensaje; rechazarlo por el envoltorio sería fallar por algo que se arregla
+ * con dos líneas.
+ */
+export function limpiarMensaje(bruto) {
+    let t = bruto.trim();
+    const valla = t.match(/^```[a-z]*\n([\s\S]*?)\n?```$/i);
+    if (valla)
+        t = valla[1].trim();
+    // Los dos puntos de "Mensaje de commit:" que a veces se cuela delante.
+    t = t.replace(/^(mensaje de commit|commit message)\s*:\s*\n+/i, "");
+    return t.trim();
+}
+/**
+ * Lanza `tarea` sobre cada elemento con un tope de concurrencia.
+ *
+ * El tope no es decorativo: el map dispara una llamada por fichero, y sobre 40
+ * ficheros sin límite lo que se consigue es un 429 del proveedor — o sea,
+ * convertir un diff grande en un fallo garantizado justo cuando map-reduce es
+ * más necesario.
+ */
+export async function enParalelo(elementos, tope, tarea) {
+    const resultados = new Array(elementos.length);
+    let siguiente = 0;
+    const obreros = Array.from({ length: Math.min(tope, elementos.length) }, async () => {
+        while (siguiente < elementos.length) {
+            const i = siguiente++;
+            resultados[i] = await tarea(elementos[i], i);
+        }
+    });
+    await Promise.all(obreros);
+    return resultados;
+}
+export class ErrorDeMensaje extends Error {
+    causa;
+    constructor(causa, mensaje) {
+        super(mensaje);
+        this.name = "ErrorDeMensaje";
+        this.causa = causa;
+    }
+}
+/** Resumen local de un fichero generado: no vale la pena gastar una llamada. */
+function resumirRuidoEnLocal(t) {
+    return `fichero generado (${t.sustancia} líneas con contenido cambiadas); no se ha leído en detalle`;
+}
+/**
+ * Map sobre cada fichero, reduce sobre los resúmenes.
+ *
+ * `llamar` tiene que LANZAR cuando el proveedor falla. Si devolviera "" en vez
+ * de lanzar, aquí se leería como «este fichero no cambia nada» y el fallo se
+ * colaría hasta el mensaje final: es el patrón exacto que nos costó cuatro
+ * revisiones falsamente limpias.
+ */
+export async function generarMensaje(diff, deps) {
+    const trozos = ordenarPorSustancia(trocearPorFichero(diff));
+    if (trozos.length === 0) {
+        // Cero trozos tiene DOS causas, y decirlas igual es el fallo de siempre.
+        //
+        // Sin texto no hay nada que describir. Pero si han llegado 3 KB y aun así
+        // no sale ni una cabecera `diff --git `, lo que pasa es que no sabemos leer
+        // ese formato, y decir «el diff no contiene ningún fichero» sobre un índice
+        // LLENO es «no puedo» disfrazado de «no hay». Comprobado ejecutando: con
+        // `color.ui=always` puesto, `ada-cli commit` sobre dos ficheros staged
+        // contestaba exactamente eso. Los cuatro ajustes que lo provocaban los
+        // apaga ya `diffDelIndice`; esto es la red por si aparece un quinto.
+        if (diff.trim() === "") {
+            throw new ErrorDeMensaje("diff-vacio", "El diff no contiene ningún fichero.");
+        }
+        throw new ErrorDeMensaje("diff-ilegible", `Hay diff (${diff.length} caracteres) pero no se ha reconocido ninguna cabecera 'diff --git'. ` +
+            "Suele ser configuración de git que cambia el formato: color.ui, GIT_EXTERNAL_DIFF o un diff.external.");
+    }
+    const tope = deps.maxResumenes ?? 40;
+    const conSustancia = trozos.filter((t) => !t.ruido);
+    // El corte va ANTES del map, no después.
+    //
+    // Estaba después: sobre 200 ficheros se pedían 200 resúmenes y se tiraban
+    // 160 sin mirarlos. Además de pagarlos, cada uno era una oportunidad de matar
+    // el comando entero —un resumen vacío lanza— justo en el caso para el que
+    // existe map-reduce. Como `trozos` ya viene ordenado por sustancia, los que
+    // se quedan fuera son los que menos cambian.
+    const aResumir = conSustancia.slice(0, tope);
+    const sinMirar = conSustancia.slice(tope);
+    const omitidos = trozos.filter((t) => t.ruido);
+    const resumidos = await enParalelo(aResumir, deps.tope ?? 6, async (t) => {
+        const salida = await deps.llamar(PROMPT_MAP, `Fichero: ${t.ruta}\n\n${recortar(t.diff)}`);
+        const resumen = salida.trim();
+        if (resumen === "") {
+            // Un resumen vacío NO es «este fichero no cambia nada»: el fichero está
+            // en el diff, luego cambia. Es que no se ha podido resumir.
+            throw new ErrorDeMensaje("modelo", `El modelo devolvió un resumen vacío para ${t.ruta}.`);
+        }
+        return { ruta: t.ruta, sustancia: t.sustancia, ruido: false, resumen };
+    });
+    const resumenes = [
+        ...resumidos,
+        ...omitidos.map((t) => ({
+            ruta: t.ruta,
+            sustancia: t.sustancia,
+            ruido: true,
+            resumen: resumirRuidoEnLocal(t),
+        })),
+        // Los que se quedaron fuera del tope se listan diciendo QUE NO SE HAN
+        // MIRADO. Callarlos dejaría un `--detalle` que enseña 40 ficheros de un
+        // commit de 200 y se lee como si fueran todos: «no lo he mirado» contado
+        // como «no hay nada que contar».
+        ...sinMirar.map((t) => ({
+            ruta: t.ruta,
+            sustancia: t.sustancia,
+            ruido: false,
+            resumen: `no se ha resumido: por debajo del tope de ${tope} ficheros`,
+        })),
+    ];
+    // El corte se hace por la cola, que ya está ordenada por sustancia: si sobran
+    // resúmenes, los que se caen son los que menos cambian. Cortar por delante o
+    // alfabéticamente es como se pierde justo el fichero que importa.
+    const paraElReduce = resumenes.slice(0, tope);
+    const sobrantes = resumenes.length - paraElReduce.length;
+    const listado = paraElReduce.map((r) => `- ${r.ruta}: ${r.resumen}`).join("\n");
+    const cola = sobrantes > 0 ? `\n(y ${sobrantes} fichero(s) más, todos con menos cambios)` : "";
+    const bruto = await deps.llamar(PROMPT_REDUCE, `${resumenes.length} fichero(s) cambiados, de más a menos sustancia:\n\n${listado}${cola}`);
+    const mensaje = limpiarMensaje(bruto);
+    if (mensaje === "") {
+        throw new ErrorDeMensaje("modelo", "El modelo devolvió un mensaje vacío.");
+    }
+    if (esGenerico(mensaje)) {
+        // Salir con error y no imprimirlo: un titular genérico impreso por stdout
+        // se encadena a `git commit -F -` y queda en la historia para siempre. Es
+        // preferible que el usuario lo escriba a mano sabiendo que lo escribe.
+        throw new ErrorDeMensaje("generico", `El titular generado no nombra ningún cambio concreto: "${mensaje.split("\n")[0]}"`);
+    }
+    return { mensaje, resumenes, omitidos: omitidos.map((t) => t.ruta) };
+}
+//# sourceMappingURL=mensaje.js.map

package/dist/core/commit/mensaje.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"mensaje.js","sourceRoot":"","sources":["../../../src/core/commit/mensaje.ts"],"names":[],"mappings":"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","sourcesContent":["/**\n * Mensaje de commit por map-reduce sobre el diff.\n *\n * El problema: un diff grande no cabe en contexto, y meterlo entero recortado\n * da mensajes genéricos («actualiza varios ficheros»), que es exactamente el\n * mensaje que nadie necesita leer porque `git show --stat` ya lo dice mejor.\n *\n * El reparto:\n *   - map    → un resumen por fichero, en paralelo, cada uno con SU diff entero.\n *   - reduce → un mensaje del conjunto a partir de esos resúmenes, ordenados por\n *              sustancia para que el cambio de verdad llegue el primero.\n *\n * TRES ESTADOS, NO DOS. En cada paso se distingue «no hay» de «no puedo»:\n * un resumen vacío o una respuesta vacía del modelo NO son «este fichero no\n * cambia nada», son un fallo, y salen como error. Ya nos pasó en `review`:\n * cuatro de cinco ejecuciones sobre un fallo sembrado decían «no ha encontrado\n * nada» cuando lo que había detrás era un 429.\n */\n\nimport { ordenarPorSustancia, recortar, type TrozoDeFichero, trocearPorFichero } from \"./diff.ts\";\n\nexport const PROMPT_MAP = `Resumes UN fichero de un diff de git.\n\nDevuelve UNA sola línea, en español, con el QUÉ y el POR QUÉ del cambio en ese\nfichero. Nombra lo concreto: la función, la constante, el flag, el endpoint.\n\nProhibido: \"varios cambios\", \"actualizaciones\", \"mejoras\", \"refactor\" a secas,\nrepetir la ruta del fichero sin decir qué cambia dentro.\n\nSi el fichero solo cambia formato, imports o números de version, dilo tal cual\ny en corto: eso es informacion util para no ponerlo en el titular.\n\nSin markdown, sin comillas, sin prefijos. Solo la línea.`;\n\nexport const PROMPT_REDUCE = `Escribes el mensaje de commit de un conjunto de cambios.\n\nRecibes un resumen por fichero, YA ORDENADOS de más a menos sustancia. El\nprimero es el cambio de verdad; el resto suele ser acompañamiento.\n\nFormato exacto:\n  - Línea 1: titular imperativo, minúsculas, sin punto final, máx. 72 caracteres.\n    Tiene que nombrar EL cambio concreto del primer fichero, no el conjunto.\n  - Línea 2: en blanco.\n  - Cuerpo: por qué se hace, y qué arrastra el resto de ficheros. Líneas de\n    máx. 80 caracteres.\n\nPROHIBIDO en el titular: \"actualiza varios ficheros\", \"varios cambios\",\n\"cambios varios\", \"mejoras varias\", \"actualiza el proyecto\", \"wip\", \"misc\",\no cualquier titular que valdría igual para otro commit distinto.\n\nSin markdown, sin bloques de código, sin encabezados. Solo el mensaje.`;\n\n/**\n * Titulares que valdrían para cualquier commit.\n *\n * Existe porque la primera puerta de este trabajo es justo esa: sobre un diff\n * de 25 ficheros donde solo uno cambia algo, el mensaje tiene que nombrar el\n * cambio. Sin este detector, «lo nombra» es una opinión sobre la salida del\n * modelo; con él es una comprobación que se ejecuta.\n */\nconst TITULARES_VACIOS = [\n\t/\\bvarios?\\s+(ficheros?|archivos?|cambios?|m[oó]dulos?|arreglos?)\\b/i,\n\t/\\bcambios?\\s+varios\\b/i,\n\t/\\bmejoras?\\s+varias\\b/i,\n\t/\\bactualiza(?:ci[oó]n(?:es)?)?\\s+(?:el\\s+|del\\s+|de\\s+)?(?:proyecto|repositorio|c[oó]digo|ficheros?)\\b/i,\n\t/^\\s*(wip|misc|varios|updates?|update|fixes|fix|chore|cambios)\\s*[:.!]?\\s*$/i,\n\t/\\bupdate\\s+(several|various|multiple)\\b/i,\n];\n\n/** ¿El titular vale para cualquier commit? */\nexport function esGenerico(mensaje: string): boolean {\n\tconst titular = mensaje.split(\"\\n\")[0]?.trim() ?? \"\";\n\tif (titular === \"\") return true;\n\treturn TITULARES_VACIOS.some((r) => r.test(titular));\n}\n\n/**\n * Quita lo que el modelo añade por costumbre: vallas de código y comillas.\n *\n * No toca el contenido. Un mensaje que llega envuelto en ``` sigue siendo el\n * mensaje; rechazarlo por el envoltorio sería fallar por algo que se arregla\n * con dos líneas.\n */\nexport function limpiarMensaje(bruto: string): string {\n\tlet t = bruto.trim();\n\tconst valla = t.match(/^```[a-z]*\\n([\\s\\S]*?)\\n?```$/i);\n\tif (valla) t = valla[1].trim();\n\t// Los dos puntos de \"Mensaje de commit:\" que a veces se cuela delante.\n\tt = t.replace(/^(mensaje de commit|commit message)\\s*:\\s*\\n+/i, \"\");\n\treturn t.trim();\n}\n\n/**\n * Lanza `tarea` sobre cada elemento con un tope de concurrencia.\n *\n * El tope no es decorativo: el map dispara una llamada por fichero, y sobre 40\n * ficheros sin límite lo que se consigue es un 429 del proveedor — o sea,\n * convertir un diff grande en un fallo garantizado justo cuando map-reduce es\n * más necesario.\n */\nexport async function enParalelo<T, R>(elementos: T[], tope: number, tarea: (e: T, i: number) => Promise<R>) {\n\tconst resultados = new Array<R>(elementos.length);\n\tlet siguiente = 0;\n\tconst obreros = Array.from({ length: Math.min(tope, elementos.length) }, async () => {\n\t\twhile (siguiente < elementos.length) {\n\t\t\tconst i = siguiente++;\n\t\t\tresultados[i] = await tarea(elementos[i], i);\n\t\t}\n\t});\n\tawait Promise.all(obreros);\n\treturn resultados;\n}\n\n/** Lo que el CLI inyecta para poder probar todo esto sin red. */\nexport interface DependenciasMensaje {\n\t/** Una llamada al modelo. Debe LANZAR si falla; devolver \"\" es un fallo. */\n\tllamar: (sistema: string, usuario: string) => Promise<string>;\n\t/** Llamadas simultáneas del map. */\n\ttope?: number;\n\t/** Cuántos resúmenes entran al reduce. Los de más sustancia primero. */\n\tmaxResumenes?: number;\n}\n\nexport interface ResumenDeFichero {\n\truta: string;\n\tsustancia: number;\n\truido: boolean;\n\tresumen: string;\n}\n\nexport interface MensajeGenerado {\n\tmensaje: string;\n\tresumenes: ResumenDeFichero[];\n\t/** Ficheros que NO se le pasaron al modelo por ser generados. */\n\tomitidos: string[];\n}\n\n/**\n * Fallo con nombre. El CLI necesita distinguir «el índice está vacío» de «el\n * modelo se cayó» para elegir el código de salida y el texto, y una cadena\n * dentro de un Error genérico obliga a leer prosa para tomar esa decisión.\n */\nexport type CausaDeFallo = \"diff-vacio\" | \"diff-ilegible\" | \"modelo\" | \"generico\";\n\nexport class ErrorDeMensaje extends Error {\n\treadonly causa: CausaDeFallo;\n\tconstructor(causa: CausaDeFallo, mensaje: string) {\n\t\tsuper(mensaje);\n\t\tthis.name = \"ErrorDeMensaje\";\n\t\tthis.causa = causa;\n\t}\n}\n\n/** Resumen local de un fichero generado: no vale la pena gastar una llamada. */\nfunction resumirRuidoEnLocal(t: TrozoDeFichero): string {\n\treturn `fichero generado (${t.sustancia} líneas con contenido cambiadas); no se ha leído en detalle`;\n}\n\n/**\n * Map sobre cada fichero, reduce sobre los resúmenes.\n *\n * `llamar` tiene que LANZAR cuando el proveedor falla. Si devolviera \"\" en vez\n * de lanzar, aquí se leería como «este fichero no cambia nada» y el fallo se\n * colaría hasta el mensaje final: es el patrón exacto que nos costó cuatro\n * revisiones falsamente limpias.\n */\nexport async function generarMensaje(diff: string, deps: DependenciasMensaje): Promise<MensajeGenerado> {\n\tconst trozos = ordenarPorSustancia(trocearPorFichero(diff));\n\tif (trozos.length === 0) {\n\t\t// Cero trozos tiene DOS causas, y decirlas igual es el fallo de siempre.\n\t\t//\n\t\t// Sin texto no hay nada que describir. Pero si han llegado 3 KB y aun así\n\t\t// no sale ni una cabecera `diff --git `, lo que pasa es que no sabemos leer\n\t\t// ese formato, y decir «el diff no contiene ningún fichero» sobre un índice\n\t\t// LLENO es «no puedo» disfrazado de «no hay». Comprobado ejecutando: con\n\t\t// `color.ui=always` puesto, `ada-cli commit` sobre dos ficheros staged\n\t\t// contestaba exactamente eso. Los cuatro ajustes que lo provocaban los\n\t\t// apaga ya `diffDelIndice`; esto es la red por si aparece un quinto.\n\t\tif (diff.trim() === \"\") {\n\t\t\tthrow new ErrorDeMensaje(\"diff-vacio\", \"El diff no contiene ningún fichero.\");\n\t\t}\n\t\tthrow new ErrorDeMensaje(\n\t\t\t\"diff-ilegible\",\n\t\t\t`Hay diff (${diff.length} caracteres) pero no se ha reconocido ninguna cabecera 'diff --git'. ` +\n\t\t\t\t\"Suele ser configuración de git que cambia el formato: color.ui, GIT_EXTERNAL_DIFF o un diff.external.\",\n\t\t);\n\t}\n\n\tconst tope = deps.maxResumenes ?? 40;\n\tconst conSustancia = trozos.filter((t) => !t.ruido);\n\t// El corte va ANTES del map, no después.\n\t//\n\t// Estaba después: sobre 200 ficheros se pedían 200 resúmenes y se tiraban\n\t// 160 sin mirarlos. Además de pagarlos, cada uno era una oportunidad de matar\n\t// el comando entero —un resumen vacío lanza— justo en el caso para el que\n\t// existe map-reduce. Como `trozos` ya viene ordenado por sustancia, los que\n\t// se quedan fuera son los que menos cambian.\n\tconst aResumir = conSustancia.slice(0, tope);\n\tconst sinMirar = conSustancia.slice(tope);\n\tconst omitidos = trozos.filter((t) => t.ruido);\n\n\tconst resumidos = await enParalelo(aResumir, deps.tope ?? 6, async (t) => {\n\t\tconst salida = await deps.llamar(PROMPT_MAP, `Fichero: ${t.ruta}\\n\\n${recortar(t.diff)}`);\n\t\tconst resumen = salida.trim();\n\t\tif (resumen === \"\") {\n\t\t\t// Un resumen vacío NO es «este fichero no cambia nada»: el fichero está\n\t\t\t// en el diff, luego cambia. Es que no se ha podido resumir.\n\t\t\tthrow new ErrorDeMensaje(\"modelo\", `El modelo devolvió un resumen vacío para ${t.ruta}.`);\n\t\t}\n\t\treturn { ruta: t.ruta, sustancia: t.sustancia, ruido: false, resumen };\n\t});\n\n\tconst resumenes: ResumenDeFichero[] = [\n\t\t...resumidos,\n\t\t...omitidos.map((t) => ({\n\t\t\truta: t.ruta,\n\t\t\tsustancia: t.sustancia,\n\t\t\truido: true,\n\t\t\tresumen: resumirRuidoEnLocal(t),\n\t\t})),\n\t\t// Los que se quedaron fuera del tope se listan diciendo QUE NO SE HAN\n\t\t// MIRADO. Callarlos dejaría un `--detalle` que enseña 40 ficheros de un\n\t\t// commit de 200 y se lee como si fueran todos: «no lo he mirado» contado\n\t\t// como «no hay nada que contar».\n\t\t...sinMirar.map((t) => ({\n\t\t\truta: t.ruta,\n\t\t\tsustancia: t.sustancia,\n\t\t\truido: false,\n\t\t\tresumen: `no se ha resumido: por debajo del tope de ${tope} ficheros`,\n\t\t})),\n\t];\n\n\t// El corte se hace por la cola, que ya está ordenada por sustancia: si sobran\n\t// resúmenes, los que se caen son los que menos cambian. Cortar por delante o\n\t// alfabéticamente es como se pierde justo el fichero que importa.\n\tconst paraElReduce = resumenes.slice(0, tope);\n\tconst sobrantes = resumenes.length - paraElReduce.length;\n\tconst listado = paraElReduce.map((r) => `- ${r.ruta}: ${r.resumen}`).join(\"\\n\");\n\tconst cola = sobrantes > 0 ? `\\n(y ${sobrantes} fichero(s) más, todos con menos cambios)` : \"\";\n\n\tconst bruto = await deps.llamar(\n\t\tPROMPT_REDUCE,\n\t\t`${resumenes.length} fichero(s) cambiados, de más a menos sustancia:\\n\\n${listado}${cola}`,\n\t);\n\tconst mensaje = limpiarMensaje(bruto);\n\tif (mensaje === \"\") {\n\t\tthrow new ErrorDeMensaje(\"modelo\", \"El modelo devolvió un mensaje vacío.\");\n\t}\n\tif (esGenerico(mensaje)) {\n\t\t// Salir con error y no imprimirlo: un titular genérico impreso por stdout\n\t\t// se encadena a `git commit -F -` y queda en la historia para siempre. Es\n\t\t// preferible que el usuario lo escriba a mano sabiendo que lo escribe.\n\t\tthrow new ErrorDeMensaje(\n\t\t\t\"generico\",\n\t\t\t`El titular generado no nombra ningún cambio concreto: \"${mensaje.split(\"\\n\")[0]}\"`,\n\t\t);\n\t}\n\n\treturn { mensaje, resumenes, omitidos: omitidos.map((t) => t.ruta) };\n}\n"]}