@hoilab/ada-cli 0.84.21 → 0.85.0

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

@@ -0,0 +1 @@
+{"version":3,"file":"reparacion.d.ts","sourceRoot":"","sources":["../../../src/core/limpieza/reparacion.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;GAcG;AAIH,OAAO,EAAe,KAAK,qBAAqB,EAAE,MAAM,8BAA8B,CAAC;AAGvF,OAAO,KAAK,EAAE,WAAW,EAAE,WAAW,EAAE,eAAe,EAAE,MAAM,YAAY,CAAC;AAE5E,mGAAkG;AAClG,wBAAgB,iBAAiB,CAAC,YAAY,EAAE,SAAS,WAAW,EAAE,GAAG,eAAe,EAAE,CAWzF;AAyBD,MAAM,WAAW,YAAY;IAC5B,MAAM,EAAE,MAAM,EAAE,CAAC;IACjB,aAAa,EAAE,WAAW,EAAE,CAAC;IAC7B,YAAY,EAAE,WAAW,EAAE,CAAC;IAC5B,MAAM,EAAE,eAAe,EAAE,CAAC;IAC1B,QAAQ,EAAE,KAAK,CAAC;QAAE,EAAE,EAAE,MAAM,CAAC;QAAC,QAAQ,EAAE,MAAM,CAAC;QAAC,MAAM,EAAE,MAAM,CAAA;KAAE,CAAC,CAAC;CAClE;AAED,2GAAuG;AACvG,wBAAsB,kBAAkB,CAAC,GAAG,EAAE,MAAM,GAAG,OAAO,CAAC,YAAY,CAAC,CAO3E;AAED,MAAM,WAAW,mBAAmB;IACnC,IAAI,CAAC,EAAE,MAAM,CAAC;IACd,QAAQ,EAAE,OAAO,CAAC;IAClB,MAAM,EAAE,MAAM,CAAC;IACf,qBAAqB,EAAE,MAAM,CAAC;IAC9B,qBAAqB,EAAE,MAAM,CAAC;IAC9B,MAAM,EAAE,WAAW,EAAE,CAAC;CACtB;AAED,MAAM,WAAW,kBAAkB;IAClC,GAAG,EAAE,MAAM,CAAC;IACZ,QAAQ,EAAE,MAAM,CAAC;IACjB,WAAW,EAAE,qBAAqB,CAAC;IACnC,+GAA8G;IAC9G,UAAU,CAAC,EAAE,MAAM,CAAC;IACpB,YAAY,CAAC,EAAE,MAAM,CAAC;IACtB,cAAc,CAAC,EAAE,MAAM,GAAG,IAAI,CAAC;IAC/B,GAAG,CAAC,EAAE,CAAC,KAAK,EAAE,MAAM,KAAK,IAAI,CAAC;CAC9B;AAuHD;;;;;GAKG;AACH,wBAAsB,eAAe,CACpC,IAAI,EAAE,YAAY,EAClB,QAAQ,EAAE,kBAAkB,GAC1B,OAAO,CAAC,mBAAmB,EAAE,CAAC,CAqBhC;AAED,MAAM,MAAM,aAAa,GAAG,QAAQ,GAAG,mBAAmB,GAAG,WAAW,GAAG,mBAAmB,CAAC;AAE/F,MAAM,WAAW,gBAAgB;IAChC,MAAM,EAAE,aAAa,CAAC;IACtB,MAAM,EAAE,MAAM,EAAE,CAAC;IACjB,aAAa,EAAE,MAAM,EAAE,CAAC;IACxB,QAAQ,EAAE,KAAK,CAAC;QAAE,EAAE,EAAE,MAAM,CAAC;QAAC,QAAQ,EAAE,MAAM,CAAC;QAAC,MAAM,EAAE,MAAM,CAAA;KAAE,CAAC,CAAC;IAClE,qBAAqB,EAAE,MAAM,CAAC;IAC9B,MAAM,EAAE,eAAe,EAAE,CAAC;IAC1B,YAAY,EAAE,mBAAmB,EAAE,CAAC;IACpC,mBAAmB,EAAE,MAAM,CAAC;CAC5B;AAED,wFAAuF;AACvF,wBAAsB,eAAe,CACpC,GAAG,EAAE,MAAM,EACX,QAAQ,EAAE,IAAI,CAAC,kBAAkB,EAAE,KAAK,CAAC,GAAG;IAAE,MAAM,CAAC,EAAE,OAAO,CAAA;CAAE,GAC9D,OAAO,CAAC,gBAAgB,CAAC,CAqD3B","sourcesContent":["/**\n * Orquestación de `ada-cli cleanse`: agrupa diagnósticos por fichero (diez\n * problemas del mismo fichero en un subagente es UNA lectura, no diez),\n * lanza un subagente por fichero con `AgentRunner` bajo un tope de\n * concurrencia y, tras cada arreglo, RE-EJECUTA todos los comprobadores de\n * \"fichero\" del proyecto (no solo el que generó el diagnóstico original —\n * un arreglo de lint puede romper el typecheck del mismo fichero).\n *\n * Un arreglo se acepta solo si el diagnóstico original desapareció Y no\n * apareció ninguno nuevo en ese mismo fichero. La comparación es por firma\n * (comprobador+regla+mensaje, no por línea) porque un arreglo real desplaza\n * líneas. Si no se acepta, el fichero se revierte al contenido que tenía\n * antes del subagente — \"rechazar\" un arreglo que no se deshace no sería\n * rechazarlo, sería solo decirlo.\n */\n\nimport { existsSync, readFileSync, writeFileSync } from \"node:fs\";\nimport { join } from \"node:path\";\nimport { AgentRunner, type CreateSubagentSession } from \"../workflows/agent-runner.ts\";\nimport { createLimiter } from \"../workflows/runtime.ts\";\nimport { detectarComprobadores, ejecutarComprobadores, ejecutarComprobadoresPorId } from \"./comprobadores.ts\";\nimport type { Comprobador, Diagnostico, GrupoPorFichero } from \"./tipos.ts\";\n\n/** Agrupa diagnósticos por fichero; los de proyecto (`ruta` undefined) forman su propio grupo. */\nexport function agruparPorFichero(diagnosticos: readonly Diagnostico[]): GrupoPorFichero[] {\n\tconst grupos = new Map<string, Diagnostico[]>();\n\tfor (const d of diagnosticos) {\n\t\tconst clave = d.ruta ?? \"\";\n\t\tconst existente = grupos.get(clave);\n\t\tif (existente) existente.push(d);\n\t\telse grupos.set(clave, [d]);\n\t}\n\treturn [...grupos.entries()]\n\t\t.map(([ruta, diags]) => ({ ruta: ruta || undefined, diagnosticos: diags }))\n\t\t.sort((a, b) => (a.ruta ?? \"\").localeCompare(b.ruta ?? \"\"));\n}\n\n/** Identidad de un diagnóstico que sobrevive a que un arreglo desplace líneas. */\nfunction firma(d: Diagnostico): string {\n\treturn `${d.comprobador}::${d.regla ?? \"\"}::${d.mensaje}`;\n}\n\n/**\n * Cuenta cuántas veces aparece cada firma — MULTISET, no Set.\n *\n * Dos diagnósticos del mismo fichero con la misma regla y el mismo mensaje\n * (p.ej. la misma regla de estilo disparándose en dos líneas distintas)\n * tienen la MISMA firma. Un `Set` los habría colapsado en uno, así que un\n * arreglo que soluciona los dos habría contado solo \"1 de 2 resueltos\" y se\n * habría rechazado y revertido un arreglo perfectamente bueno.\n */\nfunction contarFirmas(diagnosticos: readonly Diagnostico[]): Map<string, number> {\n\tconst conteo = new Map<string, number>();\n\tfor (const d of diagnosticos) {\n\t\tconst f = firma(d);\n\t\tconteo.set(f, (conteo.get(f) ?? 0) + 1);\n\t}\n\treturn conteo;\n}\n\nexport interface PlanLimpieza {\n\tmirado: string[];\n\tcomprobadores: Comprobador[];\n\tdiagnosticos: Diagnostico[];\n\tgrupos: GrupoPorFichero[];\n\tfallidos: Array<{ id: string; etiqueta: string; motivo: string }>;\n}\n\n/** Detecta comprobadores y los ejecuta una vez — el plan que `--dry-run` enseña sin tocar nada más. */\nexport async function planificarLimpieza(cwd: string): Promise<PlanLimpieza> {\n\tconst { comprobadores, mirado } = detectarComprobadores(cwd);\n\tif (comprobadores.length === 0) {\n\t\treturn { mirado, comprobadores, diagnosticos: [], grupos: [], fallidos: [] };\n\t}\n\tconst { diagnosticos, fallidos } = await ejecutarComprobadores(comprobadores);\n\treturn { mirado, comprobadores, diagnosticos, grupos: agruparPorFichero(diagnosticos), fallidos };\n}\n\nexport interface ResultadoReparacion {\n\truta?: string;\n\taceptado: boolean;\n\tmotivo: string;\n\tdiagnosticosResueltos: number;\n\tdiagnosticosRestantes: number;\n\tnuevos: Diagnostico[];\n}\n\nexport interface OpcionesReparacion {\n\tcwd: string;\n\tagentDir: string;\n\tcrearSesion: CreateSubagentSession;\n\t/** \"provider/model\" explícito; si falta se usa `tier:cheap` (arreglar un lint no necesita el modelo caro). */\n\tmodeloSpec?: string;\n\tconcurrencia?: number;\n\tagentTimeoutMs?: number | null;\n\tlog?: (linea: string) => void;\n}\n\nasync function repararGrupo(\n\tgrupo: GrupoPorFichero,\n\tplan: PlanLimpieza,\n\topciones: OpcionesReparacion,\n\trunner: AgentRunner,\n\tlog: (linea: string) => void,\n): Promise<ResultadoReparacion> {\n\tconst rutaAbsoluta = grupo.ruta ? join(opciones.cwd, grupo.ruta) : undefined;\n\tconst previo = rutaAbsoluta && existsSync(rutaAbsoluta) ? readFileSync(rutaAbsoluta, \"utf-8\") : undefined;\n\t// Verificar con TODOS los comprobadores de \"fichero\" del plan, no solo el\n\t// que originó el diagnóstico: un arreglo de lint puede romper el\n\t// typecheck del mismo fichero, y si solo re-ejecutásemos lint ese error\n\t// nuevo no aparecería nunca — \"limpio\" mentiría. Los de \"proyecto\" (un\n\t// test runner) no llevan `ruta`, así que re-ejecutarlos aquí no cambiaría\n\t// `enEsteFichero`; seguimos restringiéndolos a los que ya disparó este\n\t// grupo para no pagar una suite de test entera por cada fichero.\n\tconst idsComprobadores = grupo.ruta\n\t\t? new Set(plan.comprobadores.filter((c) => c.alcance === \"fichero\").map((c) => c.id))\n\t\t: new Set(grupo.diagnosticos.map((d) => d.comprobador));\n\tconst etiqueta = grupo.ruta ?? \"<proyecto>\";\n\n\tconst listado = grupo.diagnosticos\n\t\t.map((d) => `- ${d.linea ? `línea ${d.linea}: ` : \"\"}[${d.regla ?? d.comprobador}] ${d.mensaje}`)\n\t\t.join(\"\\n\");\n\tconst prompt = grupo.ruta\n\t\t? `Arregla estos diagnósticos de \\`${grupo.ruta}\\` y NADA MÁS — no toques ningún otro fichero:\\n${listado}`\n\t\t: `Arregla estos diagnósticos de proyecto (sin fichero concreto asociado):\\n${listado}`;\n\n\tlog(`[start] ${etiqueta} (${grupo.diagnosticos.length} diagnóstico${grupo.diagnosticos.length === 1 ? \"\" : \"s\"})`);\n\n\tconst revertir = () => {\n\t\tif (previo !== undefined && rutaAbsoluta) writeFileSync(rutaAbsoluta, previo);\n\t};\n\n\ttry {\n\t\tawait runner.run({\n\t\t\tprompt,\n\t\t\tlabel: `cleanse:${etiqueta}`,\n\t\t\tmodel: opciones.modeloSpec,\n\t\t\ttier: opciones.modeloSpec ? undefined : \"cheap\",\n\t\t\tcwd: opciones.cwd,\n\t\t\tisolation: \"none\",\n\t\t});\n\t} catch (error) {\n\t\tconst motivo = `el subagente falló: ${error instanceof Error ? error.message : String(error)}`;\n\t\trevertir();\n\t\tlog(`[fail] ${etiqueta}: ${motivo}`);\n\t\treturn {\n\t\t\truta: grupo.ruta,\n\t\t\taceptado: false,\n\t\t\tmotivo,\n\t\t\tdiagnosticosResueltos: 0,\n\t\t\tdiagnosticosRestantes: grupo.diagnosticos.length,\n\t\t\tnuevos: [],\n\t\t};\n\t}\n\n\tconst { diagnosticos: trasArreglo } = await ejecutarComprobadoresPorId(plan.comprobadores, idsComprobadores);\n\tconst enEsteFichero = trasArreglo.filter((d) => d.ruta === grupo.ruta);\n\n\t// Comparación por MULTISET (no por Set): dos diagnósticos originales con la\n\t// misma firma cuentan como dos, no como uno. Se consume una firma restante\n\t// por cada original que la siga teniendo; lo que sobra en `restantes` tras\n\t// consumir todo lo original son diagnósticos NUEVOS.\n\tconst restantes = contarFirmas(enEsteFichero);\n\tlet resueltosCount = 0;\n\tfor (const d of grupo.diagnosticos) {\n\t\tconst f = firma(d);\n\t\tconst quedan = restantes.get(f) ?? 0;\n\t\tif (quedan > 0) restantes.set(f, quedan - 1);\n\t\telse resueltosCount++;\n\t}\n\tconst disponiblesOriginal = contarFirmas(grupo.diagnosticos);\n\tconst nuevos: Diagnostico[] = [];\n\tfor (const d of enEsteFichero) {\n\t\tconst f = firma(d);\n\t\tconst disponibles = disponiblesOriginal.get(f) ?? 0;\n\t\tif (disponibles > 0) disponiblesOriginal.set(f, disponibles - 1);\n\t\telse nuevos.push(d);\n\t}\n\tconst aceptado = resueltosCount === grupo.diagnosticos.length && nuevos.length === 0;\n\n\tif (!aceptado) {\n\t\trevertir();\n\t\tconst motivo =\n\t\t\tnuevos.length > 0\n\t\t\t\t? `introdujo ${nuevos.length} diagnóstico${nuevos.length === 1 ? \"\" : \"s\"} nuevo${nuevos.length === 1 ? \"\" : \"s\"}` +\n\t\t\t\t\t(rutaAbsoluta\n\t\t\t\t\t\t? \"; se revirtió el fichero\"\n\t\t\t\t\t\t: \"; SIN revertir (diagnóstico de proyecto, sin fichero único)\")\n\t\t\t\t: `${grupo.diagnosticos.length - resueltosCount} de ${grupo.diagnosticos.length} diagnóstico(s) siguen ahí` +\n\t\t\t\t\t(rutaAbsoluta\n\t\t\t\t\t\t? \"; se revirtió el fichero\"\n\t\t\t\t\t\t: \"; SIN revertir (diagnóstico de proyecto, sin fichero único)\");\n\t\tlog(`[fail] ${etiqueta}: ${motivo}`);\n\t\treturn {\n\t\t\truta: grupo.ruta,\n\t\t\taceptado: false,\n\t\t\tmotivo,\n\t\t\tdiagnosticosResueltos: resueltosCount,\n\t\t\t// Tras revertir, lo que queda de verdad es lo original: no lo que\n\t\t\t// mostraba el estado intermedio (a medio arreglar) que se acaba de tirar.\n\t\t\tdiagnosticosRestantes: rutaAbsoluta ? grupo.diagnosticos.length : enEsteFichero.length,\n\t\t\tnuevos,\n\t\t};\n\t}\n\tlog(`[done] ${etiqueta}`);\n\treturn {\n\t\truta: grupo.ruta,\n\t\taceptado: true,\n\t\tmotivo: \"limpio\",\n\t\tdiagnosticosResueltos: resueltosCount,\n\t\tdiagnosticosRestantes: 0,\n\t\tnuevos: [],\n\t};\n}\n\n/**\n * Lanza un subagente por grupo bajo un tope de concurrencia y verifica cada\n * arreglo. Los grupos de fichero corren en paralelo entre sí; los de\n * proyecto (sin fichero, comparten \"ámbito\" con todo) van después, en serie,\n * para no pisarse entre ellos ni con una verificación en marcha.\n */\nexport async function repararLimpieza(\n\tplan: PlanLimpieza,\n\topciones: OpcionesReparacion,\n): Promise<ResultadoReparacion[]> {\n\tconst log = opciones.log ?? (() => {});\n\tconst gruposDeFichero = plan.grupos.filter((g) => g.ruta !== undefined);\n\tconst gruposDeProyecto = plan.grupos.filter((g) => g.ruta === undefined);\n\tconst total = gruposDeFichero.length + gruposDeProyecto.length;\n\tif (total === 0) return [];\n\n\tconst runner = new AgentRunner({\n\t\tagentDir: opciones.agentDir,\n\t\tcreateSession: opciones.crearSesion,\n\t\tlimiter: createLimiter(Math.max(1, opciones.concurrencia ?? 4)),\n\t\tagentCounter: { count: 0 },\n\t\tmaxAgents: total,\n\t\tagentTimeoutMs: opciones.agentTimeoutMs ?? null,\n\t});\n\n\tconst resultados = await Promise.all(gruposDeFichero.map((g) => repararGrupo(g, plan, opciones, runner, log)));\n\tfor (const g of gruposDeProyecto) {\n\t\tresultados.push(await repararGrupo(g, plan, opciones, runner, log));\n\t}\n\treturn resultados;\n}\n\nexport type EstadoCleanse = \"limpio\" | \"sin_comprobadores\" | \"pendiente\" | \"arreglado_parcial\";\n\nexport interface ResultadoCleanse {\n\testado: EstadoCleanse;\n\tmirado: string[];\n\tcomprobadores: string[];\n\tfallidos: Array<{ id: string; etiqueta: string; motivo: string }>;\n\tdiagnosticosIniciales: number;\n\tgrupos: GrupoPorFichero[];\n\treparaciones: ResultadoReparacion[];\n\tdiagnosticosFinales: number;\n}\n\n/** Punto de entrada único: detecta, planifica y (salvo `dryRun`) repara y verifica. */\nexport async function ejecutarCleanse(\n\tcwd: string,\n\topciones: Omit<OpcionesReparacion, \"cwd\"> & { dryRun?: boolean },\n): Promise<ResultadoCleanse> {\n\tconst plan = await planificarLimpieza(cwd);\n\tconst comprobadoresEtiquetas = plan.comprobadores.map((c) => c.etiqueta);\n\n\tif (plan.comprobadores.length === 0) {\n\t\treturn {\n\t\t\testado: \"sin_comprobadores\",\n\t\t\tmirado: plan.mirado,\n\t\t\tcomprobadores: [],\n\t\t\tfallidos: plan.fallidos,\n\t\t\tdiagnosticosIniciales: 0,\n\t\t\tgrupos: [],\n\t\t\treparaciones: [],\n\t\t\tdiagnosticosFinales: 0,\n\t\t};\n\t}\n\tif (plan.diagnosticos.length === 0) {\n\t\treturn {\n\t\t\testado: \"limpio\",\n\t\t\tmirado: plan.mirado,\n\t\t\tcomprobadores: comprobadoresEtiquetas,\n\t\t\tfallidos: plan.fallidos,\n\t\t\tdiagnosticosIniciales: 0,\n\t\t\tgrupos: [],\n\t\t\treparaciones: [],\n\t\t\tdiagnosticosFinales: 0,\n\t\t};\n\t}\n\tif (opciones.dryRun) {\n\t\treturn {\n\t\t\testado: \"pendiente\",\n\t\t\tmirado: plan.mirado,\n\t\t\tcomprobadores: comprobadoresEtiquetas,\n\t\t\tfallidos: plan.fallidos,\n\t\t\tdiagnosticosIniciales: plan.diagnosticos.length,\n\t\t\tgrupos: plan.grupos,\n\t\t\treparaciones: [],\n\t\t\tdiagnosticosFinales: plan.diagnosticos.length,\n\t\t};\n\t}\n\n\tconst reparaciones = await repararLimpieza(plan, { ...opciones, cwd });\n\tconst diagnosticosFinales = reparaciones.reduce((suma, r) => suma + r.diagnosticosRestantes, 0);\n\treturn {\n\t\testado: diagnosticosFinales === 0 ? \"limpio\" : \"arreglado_parcial\",\n\t\tmirado: plan.mirado,\n\t\tcomprobadores: comprobadoresEtiquetas,\n\t\tfallidos: plan.fallidos,\n\t\tdiagnosticosIniciales: plan.diagnosticos.length,\n\t\tgrupos: plan.grupos,\n\t\treparaciones,\n\t\tdiagnosticosFinales,\n\t};\n}\n"]}

package/dist/core/limpieza/reparacion.js

@@ -0,0 +1,254 @@
+/**
+ * Orquestación de `ada-cli cleanse`: agrupa diagnósticos por fichero (diez
+ * problemas del mismo fichero en un subagente es UNA lectura, no diez),
+ * lanza un subagente por fichero con `AgentRunner` bajo un tope de
+ * concurrencia y, tras cada arreglo, RE-EJECUTA todos los comprobadores de
+ * "fichero" del proyecto (no solo el que generó el diagnóstico original —
+ * un arreglo de lint puede romper el typecheck del mismo fichero).
+ *
+ * Un arreglo se acepta solo si el diagnóstico original desapareció Y no
+ * apareció ninguno nuevo en ese mismo fichero. La comparación es por firma
+ * (comprobador+regla+mensaje, no por línea) porque un arreglo real desplaza
+ * líneas. Si no se acepta, el fichero se revierte al contenido que tenía
+ * antes del subagente — "rechazar" un arreglo que no se deshace no sería
+ * rechazarlo, sería solo decirlo.
+ */
+import { existsSync, readFileSync, writeFileSync } from "node:fs";
+import { join } from "node:path";
+import { AgentRunner } from "../workflows/agent-runner.js";
+import { createLimiter } from "../workflows/runtime.js";
+import { detectarComprobadores, ejecutarComprobadores, ejecutarComprobadoresPorId } from "./comprobadores.js";
+/** Agrupa diagnósticos por fichero; los de proyecto (`ruta` undefined) forman su propio grupo. */
+export function agruparPorFichero(diagnosticos) {
+    const grupos = new Map();
+    for (const d of diagnosticos) {
+        const clave = d.ruta ?? "";
+        const existente = grupos.get(clave);
+        if (existente)
+            existente.push(d);
+        else
+            grupos.set(clave, [d]);
+    }
+    return [...grupos.entries()]
+        .map(([ruta, diags]) => ({ ruta: ruta || undefined, diagnosticos: diags }))
+        .sort((a, b) => (a.ruta ?? "").localeCompare(b.ruta ?? ""));
+}
+/** Identidad de un diagnóstico que sobrevive a que un arreglo desplace líneas. */
+function firma(d) {
+    return `${d.comprobador}::${d.regla ?? ""}::${d.mensaje}`;
+}
+/**
+ * Cuenta cuántas veces aparece cada firma — MULTISET, no Set.
+ *
+ * Dos diagnósticos del mismo fichero con la misma regla y el mismo mensaje
+ * (p.ej. la misma regla de estilo disparándose en dos líneas distintas)
+ * tienen la MISMA firma. Un `Set` los habría colapsado en uno, así que un
+ * arreglo que soluciona los dos habría contado solo "1 de 2 resueltos" y se
+ * habría rechazado y revertido un arreglo perfectamente bueno.
+ */
+function contarFirmas(diagnosticos) {
+    const conteo = new Map();
+    for (const d of diagnosticos) {
+        const f = firma(d);
+        conteo.set(f, (conteo.get(f) ?? 0) + 1);
+    }
+    return conteo;
+}
+/** Detecta comprobadores y los ejecuta una vez — el plan que `--dry-run` enseña sin tocar nada más. */
+export async function planificarLimpieza(cwd) {
+    const { comprobadores, mirado } = detectarComprobadores(cwd);
+    if (comprobadores.length === 0) {
+        return { mirado, comprobadores, diagnosticos: [], grupos: [], fallidos: [] };
+    }
+    const { diagnosticos, fallidos } = await ejecutarComprobadores(comprobadores);
+    return { mirado, comprobadores, diagnosticos, grupos: agruparPorFichero(diagnosticos), fallidos };
+}
+async function repararGrupo(grupo, plan, opciones, runner, log) {
+    const rutaAbsoluta = grupo.ruta ? join(opciones.cwd, grupo.ruta) : undefined;
+    const previo = rutaAbsoluta && existsSync(rutaAbsoluta) ? readFileSync(rutaAbsoluta, "utf-8") : undefined;
+    // Verificar con TODOS los comprobadores de "fichero" del plan, no solo el
+    // que originó el diagnóstico: un arreglo de lint puede romper el
+    // typecheck del mismo fichero, y si solo re-ejecutásemos lint ese error
+    // nuevo no aparecería nunca — "limpio" mentiría. Los de "proyecto" (un
+    // test runner) no llevan `ruta`, así que re-ejecutarlos aquí no cambiaría
+    // `enEsteFichero`; seguimos restringiéndolos a los que ya disparó este
+    // grupo para no pagar una suite de test entera por cada fichero.
+    const idsComprobadores = grupo.ruta
+        ? new Set(plan.comprobadores.filter((c) => c.alcance === "fichero").map((c) => c.id))
+        : new Set(grupo.diagnosticos.map((d) => d.comprobador));
+    const etiqueta = grupo.ruta ?? "<proyecto>";
+    const listado = grupo.diagnosticos
+        .map((d) => `- ${d.linea ? `línea ${d.linea}: ` : ""}[${d.regla ?? d.comprobador}] ${d.mensaje}`)
+        .join("\n");
+    const prompt = grupo.ruta
+        ? `Arregla estos diagnósticos de \`${grupo.ruta}\` y NADA MÁS — no toques ningún otro fichero:\n${listado}`
+        : `Arregla estos diagnósticos de proyecto (sin fichero concreto asociado):\n${listado}`;
+    log(`[start] ${etiqueta} (${grupo.diagnosticos.length} diagnóstico${grupo.diagnosticos.length === 1 ? "" : "s"})`);
+    const revertir = () => {
+        if (previo !== undefined && rutaAbsoluta)
+            writeFileSync(rutaAbsoluta, previo);
+    };
+    try {
+        await runner.run({
+            prompt,
+            label: `cleanse:${etiqueta}`,
+            model: opciones.modeloSpec,
+            tier: opciones.modeloSpec ? undefined : "cheap",
+            cwd: opciones.cwd,
+            isolation: "none",
+        });
+    }
+    catch (error) {
+        const motivo = `el subagente falló: ${error instanceof Error ? error.message : String(error)}`;
+        revertir();
+        log(`[fail] ${etiqueta}: ${motivo}`);
+        return {
+            ruta: grupo.ruta,
+            aceptado: false,
+            motivo,
+            diagnosticosResueltos: 0,
+            diagnosticosRestantes: grupo.diagnosticos.length,
+            nuevos: [],
+        };
+    }
+    const { diagnosticos: trasArreglo } = await ejecutarComprobadoresPorId(plan.comprobadores, idsComprobadores);
+    const enEsteFichero = trasArreglo.filter((d) => d.ruta === grupo.ruta);
+    // Comparación por MULTISET (no por Set): dos diagnósticos originales con la
+    // misma firma cuentan como dos, no como uno. Se consume una firma restante
+    // por cada original que la siga teniendo; lo que sobra en `restantes` tras
+    // consumir todo lo original son diagnósticos NUEVOS.
+    const restantes = contarFirmas(enEsteFichero);
+    let resueltosCount = 0;
+    for (const d of grupo.diagnosticos) {
+        const f = firma(d);
+        const quedan = restantes.get(f) ?? 0;
+        if (quedan > 0)
+            restantes.set(f, quedan - 1);
+        else
+            resueltosCount++;
+    }
+    const disponiblesOriginal = contarFirmas(grupo.diagnosticos);
+    const nuevos = [];
+    for (const d of enEsteFichero) {
+        const f = firma(d);
+        const disponibles = disponiblesOriginal.get(f) ?? 0;
+        if (disponibles > 0)
+            disponiblesOriginal.set(f, disponibles - 1);
+        else
+            nuevos.push(d);
+    }
+    const aceptado = resueltosCount === grupo.diagnosticos.length && nuevos.length === 0;
+    if (!aceptado) {
+        revertir();
+        const motivo = nuevos.length > 0
+            ? `introdujo ${nuevos.length} diagnóstico${nuevos.length === 1 ? "" : "s"} nuevo${nuevos.length === 1 ? "" : "s"}` +
+                (rutaAbsoluta
+                    ? "; se revirtió el fichero"
+                    : "; SIN revertir (diagnóstico de proyecto, sin fichero único)")
+            : `${grupo.diagnosticos.length - resueltosCount} de ${grupo.diagnosticos.length} diagnóstico(s) siguen ahí` +
+                (rutaAbsoluta
+                    ? "; se revirtió el fichero"
+                    : "; SIN revertir (diagnóstico de proyecto, sin fichero único)");
+        log(`[fail] ${etiqueta}: ${motivo}`);
+        return {
+            ruta: grupo.ruta,
+            aceptado: false,
+            motivo,
+            diagnosticosResueltos: resueltosCount,
+            // Tras revertir, lo que queda de verdad es lo original: no lo que
+            // mostraba el estado intermedio (a medio arreglar) que se acaba de tirar.
+            diagnosticosRestantes: rutaAbsoluta ? grupo.diagnosticos.length : enEsteFichero.length,
+            nuevos,
+        };
+    }
+    log(`[done] ${etiqueta}`);
+    return {
+        ruta: grupo.ruta,
+        aceptado: true,
+        motivo: "limpio",
+        diagnosticosResueltos: resueltosCount,
+        diagnosticosRestantes: 0,
+        nuevos: [],
+    };
+}
+/**
+ * Lanza un subagente por grupo bajo un tope de concurrencia y verifica cada
+ * arreglo. Los grupos de fichero corren en paralelo entre sí; los de
+ * proyecto (sin fichero, comparten "ámbito" con todo) van después, en serie,
+ * para no pisarse entre ellos ni con una verificación en marcha.
+ */
+export async function repararLimpieza(plan, opciones) {
+    const log = opciones.log ?? (() => { });
+    const gruposDeFichero = plan.grupos.filter((g) => g.ruta !== undefined);
+    const gruposDeProyecto = plan.grupos.filter((g) => g.ruta === undefined);
+    const total = gruposDeFichero.length + gruposDeProyecto.length;
+    if (total === 0)
+        return [];
+    const runner = new AgentRunner({
+        agentDir: opciones.agentDir,
+        createSession: opciones.crearSesion,
+        limiter: createLimiter(Math.max(1, opciones.concurrencia ?? 4)),
+        agentCounter: { count: 0 },
+        maxAgents: total,
+        agentTimeoutMs: opciones.agentTimeoutMs ?? null,
+    });
+    const resultados = await Promise.all(gruposDeFichero.map((g) => repararGrupo(g, plan, opciones, runner, log)));
+    for (const g of gruposDeProyecto) {
+        resultados.push(await repararGrupo(g, plan, opciones, runner, log));
+    }
+    return resultados;
+}
+/** Punto de entrada único: detecta, planifica y (salvo `dryRun`) repara y verifica. */
+export async function ejecutarCleanse(cwd, opciones) {
+    const plan = await planificarLimpieza(cwd);
+    const comprobadoresEtiquetas = plan.comprobadores.map((c) => c.etiqueta);
+    if (plan.comprobadores.length === 0) {
+        return {
+            estado: "sin_comprobadores",
+            mirado: plan.mirado,
+            comprobadores: [],
+            fallidos: plan.fallidos,
+            diagnosticosIniciales: 0,
+            grupos: [],
+            reparaciones: [],
+            diagnosticosFinales: 0,
+        };
+    }
+    if (plan.diagnosticos.length === 0) {
+        return {
+            estado: "limpio",
+            mirado: plan.mirado,
+            comprobadores: comprobadoresEtiquetas,
+            fallidos: plan.fallidos,
+            diagnosticosIniciales: 0,
+            grupos: [],
+            reparaciones: [],
+            diagnosticosFinales: 0,
+        };
+    }
+    if (opciones.dryRun) {
+        return {
+            estado: "pendiente",
+            mirado: plan.mirado,
+            comprobadores: comprobadoresEtiquetas,
+            fallidos: plan.fallidos,
+            diagnosticosIniciales: plan.diagnosticos.length,
+            grupos: plan.grupos,
+            reparaciones: [],
+            diagnosticosFinales: plan.diagnosticos.length,
+        };
+    }
+    const reparaciones = await repararLimpieza(plan, { ...opciones, cwd });
+    const diagnosticosFinales = reparaciones.reduce((suma, r) => suma + r.diagnosticosRestantes, 0);
+    return {
+        estado: diagnosticosFinales === 0 ? "limpio" : "arreglado_parcial",
+        mirado: plan.mirado,
+        comprobadores: comprobadoresEtiquetas,
+        fallidos: plan.fallidos,
+        diagnosticosIniciales: plan.diagnosticos.length,
+        grupos: plan.grupos,
+        reparaciones,
+        diagnosticosFinales,
+    };
+}
+//# sourceMappingURL=reparacion.js.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"reparacion.js","sourceRoot":"","sources":["../../../src/core/limpieza/reparacion.ts"],"names":[],"mappings":"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","sourcesContent":["/**\n * Orquestación de `ada-cli cleanse`: agrupa diagnósticos por fichero (diez\n * problemas del mismo fichero en un subagente es UNA lectura, no diez),\n * lanza un subagente por fichero con `AgentRunner` bajo un tope de\n * concurrencia y, tras cada arreglo, RE-EJECUTA todos los comprobadores de\n * \"fichero\" del proyecto (no solo el que generó el diagnóstico original —\n * un arreglo de lint puede romper el typecheck del mismo fichero).\n *\n * Un arreglo se acepta solo si el diagnóstico original desapareció Y no\n * apareció ninguno nuevo en ese mismo fichero. La comparación es por firma\n * (comprobador+regla+mensaje, no por línea) porque un arreglo real desplaza\n * líneas. Si no se acepta, el fichero se revierte al contenido que tenía\n * antes del subagente — \"rechazar\" un arreglo que no se deshace no sería\n * rechazarlo, sería solo decirlo.\n */\n\nimport { existsSync, readFileSync, writeFileSync } from \"node:fs\";\nimport { join } from \"node:path\";\nimport { AgentRunner, type CreateSubagentSession } from \"../workflows/agent-runner.ts\";\nimport { createLimiter } from \"../workflows/runtime.ts\";\nimport { detectarComprobadores, ejecutarComprobadores, ejecutarComprobadoresPorId } from \"./comprobadores.ts\";\nimport type { Comprobador, Diagnostico, GrupoPorFichero } from \"./tipos.ts\";\n\n/** Agrupa diagnósticos por fichero; los de proyecto (`ruta` undefined) forman su propio grupo. */\nexport function agruparPorFichero(diagnosticos: readonly Diagnostico[]): GrupoPorFichero[] {\n\tconst grupos = new Map<string, Diagnostico[]>();\n\tfor (const d of diagnosticos) {\n\t\tconst clave = d.ruta ?? \"\";\n\t\tconst existente = grupos.get(clave);\n\t\tif (existente) existente.push(d);\n\t\telse grupos.set(clave, [d]);\n\t}\n\treturn [...grupos.entries()]\n\t\t.map(([ruta, diags]) => ({ ruta: ruta || undefined, diagnosticos: diags }))\n\t\t.sort((a, b) => (a.ruta ?? \"\").localeCompare(b.ruta ?? \"\"));\n}\n\n/** Identidad de un diagnóstico que sobrevive a que un arreglo desplace líneas. */\nfunction firma(d: Diagnostico): string {\n\treturn `${d.comprobador}::${d.regla ?? \"\"}::${d.mensaje}`;\n}\n\n/**\n * Cuenta cuántas veces aparece cada firma — MULTISET, no Set.\n *\n * Dos diagnósticos del mismo fichero con la misma regla y el mismo mensaje\n * (p.ej. la misma regla de estilo disparándose en dos líneas distintas)\n * tienen la MISMA firma. Un `Set` los habría colapsado en uno, así que un\n * arreglo que soluciona los dos habría contado solo \"1 de 2 resueltos\" y se\n * habría rechazado y revertido un arreglo perfectamente bueno.\n */\nfunction contarFirmas(diagnosticos: readonly Diagnostico[]): Map<string, number> {\n\tconst conteo = new Map<string, number>();\n\tfor (const d of diagnosticos) {\n\t\tconst f = firma(d);\n\t\tconteo.set(f, (conteo.get(f) ?? 0) + 1);\n\t}\n\treturn conteo;\n}\n\nexport interface PlanLimpieza {\n\tmirado: string[];\n\tcomprobadores: Comprobador[];\n\tdiagnosticos: Diagnostico[];\n\tgrupos: GrupoPorFichero[];\n\tfallidos: Array<{ id: string; etiqueta: string; motivo: string }>;\n}\n\n/** Detecta comprobadores y los ejecuta una vez — el plan que `--dry-run` enseña sin tocar nada más. */\nexport async function planificarLimpieza(cwd: string): Promise<PlanLimpieza> {\n\tconst { comprobadores, mirado } = detectarComprobadores(cwd);\n\tif (comprobadores.length === 0) {\n\t\treturn { mirado, comprobadores, diagnosticos: [], grupos: [], fallidos: [] };\n\t}\n\tconst { diagnosticos, fallidos } = await ejecutarComprobadores(comprobadores);\n\treturn { mirado, comprobadores, diagnosticos, grupos: agruparPorFichero(diagnosticos), fallidos };\n}\n\nexport interface ResultadoReparacion {\n\truta?: string;\n\taceptado: boolean;\n\tmotivo: string;\n\tdiagnosticosResueltos: number;\n\tdiagnosticosRestantes: number;\n\tnuevos: Diagnostico[];\n}\n\nexport interface OpcionesReparacion {\n\tcwd: string;\n\tagentDir: string;\n\tcrearSesion: CreateSubagentSession;\n\t/** \"provider/model\" explícito; si falta se usa `tier:cheap` (arreglar un lint no necesita el modelo caro). */\n\tmodeloSpec?: string;\n\tconcurrencia?: number;\n\tagentTimeoutMs?: number | null;\n\tlog?: (linea: string) => void;\n}\n\nasync function repararGrupo(\n\tgrupo: GrupoPorFichero,\n\tplan: PlanLimpieza,\n\topciones: OpcionesReparacion,\n\trunner: AgentRunner,\n\tlog: (linea: string) => void,\n): Promise<ResultadoReparacion> {\n\tconst rutaAbsoluta = grupo.ruta ? join(opciones.cwd, grupo.ruta) : undefined;\n\tconst previo = rutaAbsoluta && existsSync(rutaAbsoluta) ? readFileSync(rutaAbsoluta, \"utf-8\") : undefined;\n\t// Verificar con TODOS los comprobadores de \"fichero\" del plan, no solo el\n\t// que originó el diagnóstico: un arreglo de lint puede romper el\n\t// typecheck del mismo fichero, y si solo re-ejecutásemos lint ese error\n\t// nuevo no aparecería nunca — \"limpio\" mentiría. Los de \"proyecto\" (un\n\t// test runner) no llevan `ruta`, así que re-ejecutarlos aquí no cambiaría\n\t// `enEsteFichero`; seguimos restringiéndolos a los que ya disparó este\n\t// grupo para no pagar una suite de test entera por cada fichero.\n\tconst idsComprobadores = grupo.ruta\n\t\t? new Set(plan.comprobadores.filter((c) => c.alcance === \"fichero\").map((c) => c.id))\n\t\t: new Set(grupo.diagnosticos.map((d) => d.comprobador));\n\tconst etiqueta = grupo.ruta ?? \"<proyecto>\";\n\n\tconst listado = grupo.diagnosticos\n\t\t.map((d) => `- ${d.linea ? `línea ${d.linea}: ` : \"\"}[${d.regla ?? d.comprobador}] ${d.mensaje}`)\n\t\t.join(\"\\n\");\n\tconst prompt = grupo.ruta\n\t\t? `Arregla estos diagnósticos de \\`${grupo.ruta}\\` y NADA MÁS — no toques ningún otro fichero:\\n${listado}`\n\t\t: `Arregla estos diagnósticos de proyecto (sin fichero concreto asociado):\\n${listado}`;\n\n\tlog(`[start] ${etiqueta} (${grupo.diagnosticos.length} diagnóstico${grupo.diagnosticos.length === 1 ? \"\" : \"s\"})`);\n\n\tconst revertir = () => {\n\t\tif (previo !== undefined && rutaAbsoluta) writeFileSync(rutaAbsoluta, previo);\n\t};\n\n\ttry {\n\t\tawait runner.run({\n\t\t\tprompt,\n\t\t\tlabel: `cleanse:${etiqueta}`,\n\t\t\tmodel: opciones.modeloSpec,\n\t\t\ttier: opciones.modeloSpec ? undefined : \"cheap\",\n\t\t\tcwd: opciones.cwd,\n\t\t\tisolation: \"none\",\n\t\t});\n\t} catch (error) {\n\t\tconst motivo = `el subagente falló: ${error instanceof Error ? error.message : String(error)}`;\n\t\trevertir();\n\t\tlog(`[fail] ${etiqueta}: ${motivo}`);\n\t\treturn {\n\t\t\truta: grupo.ruta,\n\t\t\taceptado: false,\n\t\t\tmotivo,\n\t\t\tdiagnosticosResueltos: 0,\n\t\t\tdiagnosticosRestantes: grupo.diagnosticos.length,\n\t\t\tnuevos: [],\n\t\t};\n\t}\n\n\tconst { diagnosticos: trasArreglo } = await ejecutarComprobadoresPorId(plan.comprobadores, idsComprobadores);\n\tconst enEsteFichero = trasArreglo.filter((d) => d.ruta === grupo.ruta);\n\n\t// Comparación por MULTISET (no por Set): dos diagnósticos originales con la\n\t// misma firma cuentan como dos, no como uno. Se consume una firma restante\n\t// por cada original que la siga teniendo; lo que sobra en `restantes` tras\n\t// consumir todo lo original son diagnósticos NUEVOS.\n\tconst restantes = contarFirmas(enEsteFichero);\n\tlet resueltosCount = 0;\n\tfor (const d of grupo.diagnosticos) {\n\t\tconst f = firma(d);\n\t\tconst quedan = restantes.get(f) ?? 0;\n\t\tif (quedan > 0) restantes.set(f, quedan - 1);\n\t\telse resueltosCount++;\n\t}\n\tconst disponiblesOriginal = contarFirmas(grupo.diagnosticos);\n\tconst nuevos: Diagnostico[] = [];\n\tfor (const d of enEsteFichero) {\n\t\tconst f = firma(d);\n\t\tconst disponibles = disponiblesOriginal.get(f) ?? 0;\n\t\tif (disponibles > 0) disponiblesOriginal.set(f, disponibles - 1);\n\t\telse nuevos.push(d);\n\t}\n\tconst aceptado = resueltosCount === grupo.diagnosticos.length && nuevos.length === 0;\n\n\tif (!aceptado) {\n\t\trevertir();\n\t\tconst motivo =\n\t\t\tnuevos.length > 0\n\t\t\t\t? `introdujo ${nuevos.length} diagnóstico${nuevos.length === 1 ? \"\" : \"s\"} nuevo${nuevos.length === 1 ? \"\" : \"s\"}` +\n\t\t\t\t\t(rutaAbsoluta\n\t\t\t\t\t\t? \"; se revirtió el fichero\"\n\t\t\t\t\t\t: \"; SIN revertir (diagnóstico de proyecto, sin fichero único)\")\n\t\t\t\t: `${grupo.diagnosticos.length - resueltosCount} de ${grupo.diagnosticos.length} diagnóstico(s) siguen ahí` +\n\t\t\t\t\t(rutaAbsoluta\n\t\t\t\t\t\t? \"; se revirtió el fichero\"\n\t\t\t\t\t\t: \"; SIN revertir (diagnóstico de proyecto, sin fichero único)\");\n\t\tlog(`[fail] ${etiqueta}: ${motivo}`);\n\t\treturn {\n\t\t\truta: grupo.ruta,\n\t\t\taceptado: false,\n\t\t\tmotivo,\n\t\t\tdiagnosticosResueltos: resueltosCount,\n\t\t\t// Tras revertir, lo que queda de verdad es lo original: no lo que\n\t\t\t// mostraba el estado intermedio (a medio arreglar) que se acaba de tirar.\n\t\t\tdiagnosticosRestantes: rutaAbsoluta ? grupo.diagnosticos.length : enEsteFichero.length,\n\t\t\tnuevos,\n\t\t};\n\t}\n\tlog(`[done] ${etiqueta}`);\n\treturn {\n\t\truta: grupo.ruta,\n\t\taceptado: true,\n\t\tmotivo: \"limpio\",\n\t\tdiagnosticosResueltos: resueltosCount,\n\t\tdiagnosticosRestantes: 0,\n\t\tnuevos: [],\n\t};\n}\n\n/**\n * Lanza un subagente por grupo bajo un tope de concurrencia y verifica cada\n * arreglo. Los grupos de fichero corren en paralelo entre sí; los de\n * proyecto (sin fichero, comparten \"ámbito\" con todo) van después, en serie,\n * para no pisarse entre ellos ni con una verificación en marcha.\n */\nexport async function repararLimpieza(\n\tplan: PlanLimpieza,\n\topciones: OpcionesReparacion,\n): Promise<ResultadoReparacion[]> {\n\tconst log = opciones.log ?? (() => {});\n\tconst gruposDeFichero = plan.grupos.filter((g) => g.ruta !== undefined);\n\tconst gruposDeProyecto = plan.grupos.filter((g) => g.ruta === undefined);\n\tconst total = gruposDeFichero.length + gruposDeProyecto.length;\n\tif (total === 0) return [];\n\n\tconst runner = new AgentRunner({\n\t\tagentDir: opciones.agentDir,\n\t\tcreateSession: opciones.crearSesion,\n\t\tlimiter: createLimiter(Math.max(1, opciones.concurrencia ?? 4)),\n\t\tagentCounter: { count: 0 },\n\t\tmaxAgents: total,\n\t\tagentTimeoutMs: opciones.agentTimeoutMs ?? null,\n\t});\n\n\tconst resultados = await Promise.all(gruposDeFichero.map((g) => repararGrupo(g, plan, opciones, runner, log)));\n\tfor (const g of gruposDeProyecto) {\n\t\tresultados.push(await repararGrupo(g, plan, opciones, runner, log));\n\t}\n\treturn resultados;\n}\n\nexport type EstadoCleanse = \"limpio\" | \"sin_comprobadores\" | \"pendiente\" | \"arreglado_parcial\";\n\nexport interface ResultadoCleanse {\n\testado: EstadoCleanse;\n\tmirado: string[];\n\tcomprobadores: string[];\n\tfallidos: Array<{ id: string; etiqueta: string; motivo: string }>;\n\tdiagnosticosIniciales: number;\n\tgrupos: GrupoPorFichero[];\n\treparaciones: ResultadoReparacion[];\n\tdiagnosticosFinales: number;\n}\n\n/** Punto de entrada único: detecta, planifica y (salvo `dryRun`) repara y verifica. */\nexport async function ejecutarCleanse(\n\tcwd: string,\n\topciones: Omit<OpcionesReparacion, \"cwd\"> & { dryRun?: boolean },\n): Promise<ResultadoCleanse> {\n\tconst plan = await planificarLimpieza(cwd);\n\tconst comprobadoresEtiquetas = plan.comprobadores.map((c) => c.etiqueta);\n\n\tif (plan.comprobadores.length === 0) {\n\t\treturn {\n\t\t\testado: \"sin_comprobadores\",\n\t\t\tmirado: plan.mirado,\n\t\t\tcomprobadores: [],\n\t\t\tfallidos: plan.fallidos,\n\t\t\tdiagnosticosIniciales: 0,\n\t\t\tgrupos: [],\n\t\t\treparaciones: [],\n\t\t\tdiagnosticosFinales: 0,\n\t\t};\n\t}\n\tif (plan.diagnosticos.length === 0) {\n\t\treturn {\n\t\t\testado: \"limpio\",\n\t\t\tmirado: plan.mirado,\n\t\t\tcomprobadores: comprobadoresEtiquetas,\n\t\t\tfallidos: plan.fallidos,\n\t\t\tdiagnosticosIniciales: 0,\n\t\t\tgrupos: [],\n\t\t\treparaciones: [],\n\t\t\tdiagnosticosFinales: 0,\n\t\t};\n\t}\n\tif (opciones.dryRun) {\n\t\treturn {\n\t\t\testado: \"pendiente\",\n\t\t\tmirado: plan.mirado,\n\t\t\tcomprobadores: comprobadoresEtiquetas,\n\t\t\tfallidos: plan.fallidos,\n\t\t\tdiagnosticosIniciales: plan.diagnosticos.length,\n\t\t\tgrupos: plan.grupos,\n\t\t\treparaciones: [],\n\t\t\tdiagnosticosFinales: plan.diagnosticos.length,\n\t\t};\n\t}\n\n\tconst reparaciones = await repararLimpieza(plan, { ...opciones, cwd });\n\tconst diagnosticosFinales = reparaciones.reduce((suma, r) => suma + r.diagnosticosRestantes, 0);\n\treturn {\n\t\testado: diagnosticosFinales === 0 ? \"limpio\" : \"arreglado_parcial\",\n\t\tmirado: plan.mirado,\n\t\tcomprobadores: comprobadoresEtiquetas,\n\t\tfallidos: plan.fallidos,\n\t\tdiagnosticosIniciales: plan.diagnosticos.length,\n\t\tgrupos: plan.grupos,\n\t\treparaciones,\n\t\tdiagnosticosFinales,\n\t};\n}\n"]}

package/dist/core/limpieza/tipos.d.ts

@@ -0,0 +1,56 @@
+/**
+ * Tipos compartidos de `ada-cli cleanse`.
+ *
+ * Los nombres de campo van en español ({@link Diagnostico}: ruta, linea,
+ * regla, mensaje) porque ese es el contrato que pide la tarea y el que
+ * respeta el resto del módulo.
+ */
+/** Un problema accionable que reportó un comprobador del proyecto. */
+export interface Diagnostico {
+    /** id del comprobador que lo generó — permite re-ejecutar solo ese tras un arreglo. */
+    comprobador: string;
+    /** undefined = diagnóstico de proyecto entero (p.ej. un test que falla), no de un fichero. */
+    ruta?: string;
+    linea?: number;
+    columna?: number;
+    regla?: string;
+    mensaje: string;
+}
+/** Un diagnóstico sin el campo `comprobador` — lo añade quien ejecuta, no quien parsea. */
+export type DiagnosticoParcial = Omit<Diagnostico, "comprobador">;
+/** Todos los diagnósticos de un fichero (o del proyecto entero si `ruta` es undefined). */
+export interface GrupoPorFichero {
+    ruta?: string;
+    diagnosticos: Diagnostico[];
+}
+/** Salida cruda de ejecutar un comprobador. */
+export interface SalidaComando {
+    stdout: string;
+    stderr: string;
+    code: number;
+}
+/** Un comprobador detectado y listo para ejecutar. */
+export interface Comprobador {
+    id: string;
+    etiqueta: string;
+    comando: string;
+    args: string[];
+    cwd: string;
+    parsear: (salida: SalidaComando, cwd: string) => DiagnosticoParcial[];
+    /**
+     * "fichero" = sus diagnósticos vienen con `ruta` (lint, typecheck…);
+     * "proyecto" = sin `ruta`, del proyecto entero (un test runner). Decide
+     * qué comprobadores se re-ejecutan al verificar el arreglo de UN fichero:
+     * hace falta correrlos TODOS los de "fichero", no solo el que originó el
+     * diagnóstico — si no, un arreglo de lint que rompe el typecheck del mismo
+     * fichero pasaría como limpio porque nunca se vuelve a correr tsc.
+     */
+    alcance: "fichero" | "proyecto";
+}
+/** Resultado de mirar qué hay en el proyecto. */
+export interface Deteccion {
+    comprobadores: Comprobador[];
+    /** Cada sitio comprobado, se haya encontrado algo o no — para cuando no hay ninguno. */
+    mirado: string[];
+}
+//# sourceMappingURL=tipos.d.ts.map

package/dist/core/limpieza/tipos.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"tipos.d.ts","sourceRoot":"","sources":["../../../src/core/limpieza/tipos.ts"],"names":[],"mappings":"AAAA;;;;;;GAMG;AAEH,uEAAsE;AACtE,MAAM,WAAW,WAAW;IAC3B,0FAAuF;IACvF,WAAW,EAAE,MAAM,CAAC;IACpB,+FAA8F;IAC9F,IAAI,CAAC,EAAE,MAAM,CAAC;IACd,KAAK,CAAC,EAAE,MAAM,CAAC;IACf,OAAO,CAAC,EAAE,MAAM,CAAC;IACjB,KAAK,CAAC,EAAE,MAAM,CAAC;IACf,OAAO,EAAE,MAAM,CAAC;CAChB;AAED,+FAA2F;AAC3F,MAAM,MAAM,kBAAkB,GAAG,IAAI,CAAC,WAAW,EAAE,aAAa,CAAC,CAAC;AAElE,4FAA2F;AAC3F,MAAM,WAAW,eAAe;IAC/B,IAAI,CAAC,EAAE,MAAM,CAAC;IACd,YAAY,EAAE,WAAW,EAAE,CAAC;CAC5B;AAED,+CAA+C;AAC/C,MAAM,WAAW,aAAa;IAC7B,MAAM,EAAE,MAAM,CAAC;IACf,MAAM,EAAE,MAAM,CAAC;IACf,IAAI,EAAE,MAAM,CAAC;CACb;AAED,sDAAsD;AACtD,MAAM,WAAW,WAAW;IAC3B,EAAE,EAAE,MAAM,CAAC;IACX,QAAQ,EAAE,MAAM,CAAC;IACjB,OAAO,EAAE,MAAM,CAAC;IAChB,IAAI,EAAE,MAAM,EAAE,CAAC;IACf,GAAG,EAAE,MAAM,CAAC;IACZ,OAAO,EAAE,CAAC,MAAM,EAAE,aAAa,EAAE,GAAG,EAAE,MAAM,KAAK,kBAAkB,EAAE,CAAC;IACtE;;;;;;;OAOG;IACH,OAAO,EAAE,SAAS,GAAG,UAAU,CAAC;CAChC;AAED,kDAAiD;AACjD,MAAM,WAAW,SAAS;IACzB,aAAa,EAAE,WAAW,EAAE,CAAC;IAC7B,0FAAwF;IACxF,MAAM,EAAE,MAAM,EAAE,CAAC;CACjB","sourcesContent":["/**\n * Tipos compartidos de `ada-cli cleanse`.\n *\n * Los nombres de campo van en español ({@link Diagnostico}: ruta, linea,\n * regla, mensaje) porque ese es el contrato que pide la tarea y el que\n * respeta el resto del módulo.\n */\n\n/** Un problema accionable que reportó un comprobador del proyecto. */\nexport interface Diagnostico {\n\t/** id del comprobador que lo generó — permite re-ejecutar solo ese tras un arreglo. */\n\tcomprobador: string;\n\t/** undefined = diagnóstico de proyecto entero (p.ej. un test que falla), no de un fichero. */\n\truta?: string;\n\tlinea?: number;\n\tcolumna?: number;\n\tregla?: string;\n\tmensaje: string;\n}\n\n/** Un diagnóstico sin el campo `comprobador` — lo añade quien ejecuta, no quien parsea. */\nexport type DiagnosticoParcial = Omit<Diagnostico, \"comprobador\">;\n\n/** Todos los diagnósticos de un fichero (o del proyecto entero si `ruta` es undefined). */\nexport interface GrupoPorFichero {\n\truta?: string;\n\tdiagnosticos: Diagnostico[];\n}\n\n/** Salida cruda de ejecutar un comprobador. */\nexport interface SalidaComando {\n\tstdout: string;\n\tstderr: string;\n\tcode: number;\n}\n\n/** Un comprobador detectado y listo para ejecutar. */\nexport interface Comprobador {\n\tid: string;\n\tetiqueta: string;\n\tcomando: string;\n\targs: string[];\n\tcwd: string;\n\tparsear: (salida: SalidaComando, cwd: string) => DiagnosticoParcial[];\n\t/**\n\t * \"fichero\" = sus diagnósticos vienen con `ruta` (lint, typecheck…);\n\t * \"proyecto\" = sin `ruta`, del proyecto entero (un test runner). Decide\n\t * qué comprobadores se re-ejecutan al verificar el arreglo de UN fichero:\n\t * hace falta correrlos TODOS los de \"fichero\", no solo el que originó el\n\t * diagnóstico — si no, un arreglo de lint que rompe el typecheck del mismo\n\t * fichero pasaría como limpio porque nunca se vuelve a correr tsc.\n\t */\n\talcance: \"fichero\" | \"proyecto\";\n}\n\n/** Resultado de mirar qué hay en el proyecto. */\nexport interface Deteccion {\n\tcomprobadores: Comprobador[];\n\t/** Cada sitio comprobado, se haya encontrado algo o no — para cuando no hay ninguno. */\n\tmirado: string[];\n}\n"]}

package/dist/core/limpieza/tipos.js

@@ -0,0 +1,9 @@
+/**
+ * Tipos compartidos de `ada-cli cleanse`.
+ *
+ * Los nombres de campo van en español ({@link Diagnostico}: ruta, linea,
+ * regla, mensaje) porque ese es el contrato que pide la tarea y el que
+ * respeta el resto del módulo.
+ */
+export {};
+//# sourceMappingURL=tipos.js.map

package/dist/core/limpieza/tipos.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"tipos.js","sourceRoot":"","sources":["../../../src/core/limpieza/tipos.ts"],"names":[],"mappings":"AAAA;;;;;;GAMG","sourcesContent":["/**\n * Tipos compartidos de `ada-cli cleanse`.\n *\n * Los nombres de campo van en español ({@link Diagnostico}: ruta, linea,\n * regla, mensaje) porque ese es el contrato que pide la tarea y el que\n * respeta el resto del módulo.\n */\n\n/** Un problema accionable que reportó un comprobador del proyecto. */\nexport interface Diagnostico {\n\t/** id del comprobador que lo generó — permite re-ejecutar solo ese tras un arreglo. */\n\tcomprobador: string;\n\t/** undefined = diagnóstico de proyecto entero (p.ej. un test que falla), no de un fichero. */\n\truta?: string;\n\tlinea?: number;\n\tcolumna?: number;\n\tregla?: string;\n\tmensaje: string;\n}\n\n/** Un diagnóstico sin el campo `comprobador` — lo añade quien ejecuta, no quien parsea. */\nexport type DiagnosticoParcial = Omit<Diagnostico, \"comprobador\">;\n\n/** Todos los diagnósticos de un fichero (o del proyecto entero si `ruta` es undefined). */\nexport interface GrupoPorFichero {\n\truta?: string;\n\tdiagnosticos: Diagnostico[];\n}\n\n/** Salida cruda de ejecutar un comprobador. */\nexport interface SalidaComando {\n\tstdout: string;\n\tstderr: string;\n\tcode: number;\n}\n\n/** Un comprobador detectado y listo para ejecutar. */\nexport interface Comprobador {\n\tid: string;\n\tetiqueta: string;\n\tcomando: string;\n\targs: string[];\n\tcwd: string;\n\tparsear: (salida: SalidaComando, cwd: string) => DiagnosticoParcial[];\n\t/**\n\t * \"fichero\" = sus diagnósticos vienen con `ruta` (lint, typecheck…);\n\t * \"proyecto\" = sin `ruta`, del proyecto entero (un test runner). Decide\n\t * qué comprobadores se re-ejecutan al verificar el arreglo de UN fichero:\n\t * hace falta correrlos TODOS los de \"fichero\", no solo el que originó el\n\t * diagnóstico — si no, un arreglo de lint que rompe el typecheck del mismo\n\t * fichero pasaría como limpio porque nunca se vuelve a correr tsc.\n\t */\n\talcance: \"fichero\" | \"proyecto\";\n}\n\n/** Resultado de mirar qué hay en el proyecto. */\nexport interface Deteccion {\n\tcomprobadores: Comprobador[];\n\t/** Cada sitio comprobado, se haya encontrado algo o no — para cuando no hay ninguno. */\n\tmirado: string[];\n}\n"]}

package/dist/core/lsp/cliente.d.ts

@@ -0,0 +1,52 @@
+/**
+ * Cliente JSON-RPC sobre stdio contra un servidor de lenguaje (LSP).
+ *
+ * Fichero nuestro (coste cero de fork): el LanguageService de TypeScript en
+ * `core/edicion/tipos.ts` cubre un único lenguaje sin salir de proceso; esto
+ * es lo que hace falta para los demás — hablar el protocolo LSP con un
+ * binario externo que arranca y para por comando.
+ *
+ * Decisión deliberada de diseño (ponytail): un servidor por LLAMADA, no un
+ * pool de servidores vivos entre llamadas. Arrancar `gopls`/`rust-analyzer`
+ * cuesta cientos de ms, pero un servidor que sobrevive a la llamada que lo
+ * arrancó es exactamente el "proceso huérfano" que la puerta de este hueco
+ * prohíbe, y mantener un pool con temporizador de inactividad es la mitad de
+ * `client.ts` del competidor (1601 líneas) para un problema que aquí no
+ * existe todavía. Subir a un pool es la mejora natural si el coste de
+ * relanzar por llamada llega a notarse.
+ */
+/** Lo que de verdad puede fallar al hablar con el servidor: nunca se colapsa en un único "error". */
+export declare class ErrorLsp extends Error {
+    readonly tipo: "proceso_murio" | "timeout" | "rpc" | "cierre";
+    constructor(message: string, tipo: "proceso_murio" | "timeout" | "rpc" | "cierre");
+}
+/** Conexión JSON-RPC ya inicializada (handshake `initialize`/`initialized` hecho) contra un servidor LSP. */
+export interface ClienteLsp {
+    /** Petición LSP que espera respuesta. Rechaza con `ErrorLsp` si el proceso muere o se agota el tiempo. */
+    enviar<T>(metodo: string, params: unknown, timeoutMs?: number): Promise<T>;
+    /** Notificación LSP sin respuesta (p. ej. `textDocument/didOpen`). */
+    notificar(metodo: string, params: unknown): void;
+    /**
+     * Cierre limpio: `shutdown` (petición) → `exit` (notificación) → espera a que
+     * el proceso termine solo → `SIGKILL` si no lo ha hecho a tiempo.
+     * Al resolver, el proceso YA NO existe — es la garantía que pide la puerta
+     * de "ningún servidor queda vivo al terminar".
+     */
+    cerrar(): Promise<void>;
+    /** PID del proceso del servidor. Solo para diagnóstico/pruebas: comprobar que no queda vivo tras `cerrar()`. */
+    readonly pid: number | undefined;
+}
+declare function uriDeRuta(ruta: string): string;
+/**
+ * Arranca `comando` como servidor LSP, hace el handshake `initialize` +
+ * `initialized` y devuelve un cliente listo para usar.
+ *
+ * Lanza `ErrorLsp` (nunca falla en silencio) si el binario no arranca o el
+ * `initialize` no responde a tiempo — quien llama distingue "no se pudo
+ * hablar con el servidor" de "el servidor contestó vacío".
+ */
+export declare function conectar(comando: string, args: string[], cwd: string, opciones?: {
+    timeoutInicializacionMs?: number;
+}): Promise<ClienteLsp>;
+export { uriDeRuta };
+//# sourceMappingURL=cliente.d.ts.map

package/dist/core/lsp/cliente.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"cliente.d.ts","sourceRoot":"","sources":["../../../src/core/lsp/cliente.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;GAgBG;AAaH,sGAAqG;AACrG,qBAAa,QAAS,SAAQ,KAAK;IAGlC,QAAQ,CAAC,IAAI,EAAE,eAAe,GAAG,SAAS,GAAG,KAAK,GAAG,QAAQ,CAAC;IAE9D,YAAY,OAAO,EAAE,MAAM,EAAE,IAAI,EAAE,eAAe,GAAG,SAAS,GAAG,KAAK,GAAG,QAAQ,EAIhF;CACD;AAED,8GAA6G;AAC7G,MAAM,WAAW,UAAU;IAC1B,2GAA0G;IAC1G,MAAM,CAAC,CAAC,EAAE,MAAM,EAAE,MAAM,EAAE,MAAM,EAAE,OAAO,EAAE,SAAS,CAAC,EAAE,MAAM,GAAG,OAAO,CAAC,CAAC,CAAC,CAAC;IAC3E,uEAAsE;IACtE,SAAS,CAAC,MAAM,EAAE,MAAM,EAAE,MAAM,EAAE,OAAO,GAAG,IAAI,CAAC;IACjD;;;;;OAKG;IACH,MAAM,IAAI,OAAO,CAAC,IAAI,CAAC,CAAC;IACxB,iHAAgH;IAChH,QAAQ,CAAC,GAAG,EAAE,MAAM,GAAG,SAAS,CAAC;CACjC;AAgFD,iBAAS,SAAS,CAAC,IAAI,EAAE,MAAM,GAAG,MAAM,CAGvC;AAED;;;;;;;GAOG;AACH,wBAAsB,QAAQ,CAC7B,OAAO,EAAE,MAAM,EACf,IAAI,EAAE,MAAM,EAAE,EACd,GAAG,EAAE,MAAM,EACX,QAAQ,CAAC,EAAE;IAAE,uBAAuB,CAAC,EAAE,MAAM,CAAA;CAAE,GAC7C,OAAO,CAAC,UAAU,CAAC,CAuHrB;AAED,OAAO,EAAE,SAAS,EAAE,CAAC","sourcesContent":["/**\n * Cliente JSON-RPC sobre stdio contra un servidor de lenguaje (LSP).\n *\n * Fichero nuestro (coste cero de fork): el LanguageService de TypeScript en\n * `core/edicion/tipos.ts` cubre un único lenguaje sin salir de proceso; esto\n * es lo que hace falta para los demás — hablar el protocolo LSP con un\n * binario externo que arranca y para por comando.\n *\n * Decisión deliberada de diseño (ponytail): un servidor por LLAMADA, no un\n * pool de servidores vivos entre llamadas. Arrancar `gopls`/`rust-analyzer`\n * cuesta cientos de ms, pero un servidor que sobrevive a la llamada que lo\n * arrancó es exactamente el \"proceso huérfano\" que la puerta de este hueco\n * prohíbe, y mantener un pool con temporizador de inactividad es la mitad de\n * `client.ts` del competidor (1601 líneas) para un problema que aquí no\n * existe todavía. Subir a un pool es la mejora natural si el coste de\n * relanzar por llamada llega a notarse.\n */\n\nimport { type ChildProcessWithoutNullStreams, spawn } from \"node:child_process\";\n\n/** Cabecera LSP: los mensajes van precedidos de `Content-Length` en BYTES, no en caracteres. */\nconst SEPARADOR = \"\\r\\n\\r\\n\";\nconst PATRON_LONGITUD = /Content-Length:\\s*(\\d+)/i;\n\ninterface PeticionPendiente {\n\tresolver: (valor: unknown) => void;\n\trechazar: (error: Error) => void;\n}\n\n/** Lo que de verdad puede fallar al hablar con el servidor: nunca se colapsa en un único \"error\". */\nexport class ErrorLsp extends Error {\n\t// Campo explícito, no propiedad de parámetro: el proyecto compila con\n\t// `erasableSyntaxOnly`, que prohíbe la forma corta por no ser borrable.\n\treadonly tipo: \"proceso_murio\" | \"timeout\" | \"rpc\" | \"cierre\";\n\n\tconstructor(message: string, tipo: \"proceso_murio\" | \"timeout\" | \"rpc\" | \"cierre\") {\n\t\tsuper(message);\n\t\tthis.name = \"ErrorLsp\";\n\t\tthis.tipo = tipo;\n\t}\n}\n\n/** Conexión JSON-RPC ya inicializada (handshake `initialize`/`initialized` hecho) contra un servidor LSP. */\nexport interface ClienteLsp {\n\t/** Petición LSP que espera respuesta. Rechaza con `ErrorLsp` si el proceso muere o se agota el tiempo. */\n\tenviar<T>(metodo: string, params: unknown, timeoutMs?: number): Promise<T>;\n\t/** Notificación LSP sin respuesta (p. ej. `textDocument/didOpen`). */\n\tnotificar(metodo: string, params: unknown): void;\n\t/**\n\t * Cierre limpio: `shutdown` (petición) → `exit` (notificación) → espera a que\n\t * el proceso termine solo → `SIGKILL` si no lo ha hecho a tiempo.\n\t * Al resolver, el proceso YA NO existe — es la garantía que pide la puerta\n\t * de \"ningún servidor queda vivo al terminar\".\n\t */\n\tcerrar(): Promise<void>;\n\t/** PID del proceso del servidor. Solo para diagnóstico/pruebas: comprobar que no queda vivo tras `cerrar()`. */\n\treadonly pid: number | undefined;\n}\n\nfunction escribirMensaje(proc: ChildProcessWithoutNullStreams, cuerpo: unknown): void {\n\tconst json = JSON.stringify(cuerpo);\n\t// Content-Length cuenta BYTES UTF-8, no unidades de código: un símbolo o\n\t// comentario no-ASCII en el nombre nuevo de un rename lo desincroniza si se\n\t// mide en caracteres.\n\tconst bytes = Buffer.byteLength(json, \"utf-8\");\n\tproc.stdin.write(`Content-Length: ${bytes}${SEPARADOR}${json}`);\n}\n\n/** Trocea el flujo de stdout del servidor en mensajes JSON-RPC completos, cabecera incluida. */\nclass Trocador {\n\tprivate buffer = Buffer.alloc(0);\n\n\tagregar(chunk: Buffer): unknown[] {\n\t\tthis.buffer = Buffer.concat([this.buffer, chunk]);\n\t\tconst mensajes: unknown[] = [];\n\t\tfor (;;) {\n\t\t\tconst finCabecera = this.buffer.indexOf(SEPARADOR);\n\t\t\tif (finCabecera === -1) return mensajes;\n\t\t\tconst cabecera = this.buffer.subarray(0, finCabecera).toString(\"utf-8\");\n\t\t\tconst coincidencia = cabecera.match(PATRON_LONGITUD);\n\t\t\tif (!coincidencia) {\n\t\t\t\t// Cabecera sin Content-Length: no hay forma fiable de saber dónde\n\t\t\t\t// empieza el siguiente mensaje. Se descarta hasta el separador y se\n\t\t\t\t// sigue — un servidor mal comportado no debe colgar el cliente.\n\t\t\t\tthis.buffer = this.buffer.subarray(finCabecera + SEPARADOR.length);\n\t\t\t\tcontinue;\n\t\t\t}\n\t\t\tconst longitud = Number(coincidencia[1]);\n\t\t\tconst inicioCuerpo = finCabecera + SEPARADOR.length;\n\t\t\tif (this.buffer.length < inicioCuerpo + longitud) return mensajes; // cuerpo incompleto, esperar más datos\n\t\t\tconst cuerpo = this.buffer.subarray(inicioCuerpo, inicioCuerpo + longitud).toString(\"utf-8\");\n\t\t\tthis.buffer = this.buffer.subarray(inicioCuerpo + longitud);\n\t\t\ttry {\n\t\t\t\tmensajes.push(JSON.parse(cuerpo));\n\t\t\t} catch {\n\t\t\t\t// JSON roto de un servidor concreto no debe tirar abajo al cliente:\n\t\t\t\t// se ignora ese mensaje y se sigue troceando el resto del flujo.\n\t\t\t}\n\t\t}\n\t}\n}\n\nconst ESPERA_SALIDA_MS = 2000;\n\n/** Espera a que el proceso emita `exit`, o hasta `timeoutMs`. `true` = salió solo. */\nfunction esperarSalida(proc: ChildProcessWithoutNullStreams, timeoutMs: number): Promise<boolean> {\n\tif (proc.exitCode !== null || proc.signalCode !== null) return Promise.resolve(true);\n\treturn new Promise((resolver) => {\n\t\tconst temporizador = setTimeout(() => {\n\t\t\tproc.off(\"exit\", alSalir);\n\t\t\tresolver(false);\n\t\t}, timeoutMs);\n\t\tfunction alSalir() {\n\t\t\tclearTimeout(temporizador);\n\t\t\tresolver(true);\n\t\t}\n\t\tproc.once(\"exit\", alSalir);\n\t});\n}\n\n/** Capacidades mínimas que necesitan rename/symbols/definition/references. Ampliar aquí, no en cada tool. */\nconst CAPACIDADES_CLIENTE = {\n\ttextDocument: {\n\t\tsynchronization: { didSave: true, dynamicRegistration: false },\n\t\tdefinition: { dynamicRegistration: false, linkSupport: false },\n\t\treferences: { dynamicRegistration: false },\n\t\tdocumentSymbol: { dynamicRegistration: false, hierarchicalDocumentSymbolSupport: true },\n\t\trename: { dynamicRegistration: false, prepareSupport: false },\n\t},\n\tworkspace: {\n\t\tapplyEdit: false, // el cliente aplica el WorkspaceEdit él mismo (edits.ts); no delega en el servidor\n\t\tworkspaceEdit: { documentChanges: true, resourceOperations: [] },\n\t\tworkspaceFolders: true,\n\t\tsymbol: { dynamicRegistration: false },\n\t},\n} as const;\n\nfunction uriDeRuta(ruta: string): string {\n\t// file:// + porcentaje-escapado, igual que hace cualquier cliente LSP normal.\n\treturn `file://${encodeURI(ruta).replace(/#/g, \"%23\")}`;\n}\n\n/**\n * Arranca `comando` como servidor LSP, hace el handshake `initialize` +\n * `initialized` y devuelve un cliente listo para usar.\n *\n * Lanza `ErrorLsp` (nunca falla en silencio) si el binario no arranca o el\n * `initialize` no responde a tiempo — quien llama distingue \"no se pudo\n * hablar con el servidor\" de \"el servidor contestó vacío\".\n */\nexport async function conectar(\n\tcomando: string,\n\targs: string[],\n\tcwd: string,\n\topciones?: { timeoutInicializacionMs?: number },\n): Promise<ClienteLsp> {\n\tconst proc = spawn(comando, args, { cwd, stdio: [\"pipe\", \"pipe\", \"pipe\"] });\n\n\tconst pendientes = new Map<number, PeticionPendiente>();\n\tlet siguienteId = 1;\n\tlet cerrado = false;\n\n\tconst trocador = new Trocador();\n\tproc.stdout.on(\"data\", (chunk: Buffer) => {\n\t\tfor (const mensaje of trocador.agregar(chunk)) manejarMensaje(mensaje as Record<string, unknown>);\n\t});\n\n\t// stderr de un servidor LSP suele ser su log, no un fallo: se descarta salvo\n\t// que el proceso muera, momento en el que sí importa para el mensaje de error.\n\tlet ultimoStderr = \"\";\n\tproc.stderr.on(\"data\", (chunk: Buffer) => {\n\t\tultimoStderr = chunk.toString(\"utf-8\").slice(-2000);\n\t});\n\n\tfunction manejarMensaje(mensaje: Record<string, unknown>): void {\n\t\tif (typeof mensaje.id !== \"number\") return; // notificación del servidor (p. ej. publishDiagnostics): se ignora, no la necesitamos\n\t\tconst pendiente = pendientes.get(mensaje.id);\n\t\tif (!pendiente) return;\n\t\tpendientes.delete(mensaje.id);\n\t\tif (mensaje.error) {\n\t\t\tconst err = mensaje.error as { message?: string; code?: number };\n\t\t\tpendiente.rechazar(\n\t\t\t\tnew ErrorLsp(`el servidor respondió un error: ${err.message ?? JSON.stringify(err)}`, \"rpc\"),\n\t\t\t);\n\t\t} else {\n\t\t\tpendiente.resolver(mensaje.result);\n\t\t}\n\t}\n\n\tfunction rechazarTodoPendiente(error: Error): void {\n\t\tfor (const p of pendientes.values()) p.rechazar(error);\n\t\tpendientes.clear();\n\t}\n\n\tlet procesoMuerto: Error | null = null;\n\tproc.once(\"exit\", (codigo, senal) => {\n\t\tif (!cerrado) {\n\t\t\tprocesoMuerto = new ErrorLsp(\n\t\t\t\t`el servidor de lenguaje terminó solo (código ${codigo}, señal ${senal}): ${ultimoStderr || \"sin salida en stderr\"}`,\n\t\t\t\t\"proceso_murio\",\n\t\t\t);\n\t\t\trechazarTodoPendiente(procesoMuerto);\n\t\t}\n\t});\n\tproc.once(\"error\", (error) => {\n\t\tprocesoMuerto = new ErrorLsp(`no se pudo arrancar «${comando}»: ${error.message}`, \"proceso_murio\");\n\t\trechazarTodoPendiente(procesoMuerto);\n\t});\n\n\tfunction enviar<T>(metodo: string, params: unknown, timeoutMs = 30_000): Promise<T> {\n\t\tif (procesoMuerto) return Promise.reject(procesoMuerto);\n\t\tconst id = siguienteId++;\n\t\treturn new Promise<T>((resolver, rechazar) => {\n\t\t\tconst temporizador = setTimeout(() => {\n\t\t\t\tpendientes.delete(id);\n\t\t\t\trechazar(new ErrorLsp(`«${metodo}» no respondió en ${timeoutMs}ms`, \"timeout\"));\n\t\t\t}, timeoutMs);\n\t\t\tpendientes.set(id, {\n\t\t\t\tresolver: (v) => {\n\t\t\t\t\tclearTimeout(temporizador);\n\t\t\t\t\tresolver(v as T);\n\t\t\t\t},\n\t\t\t\trechazar: (e) => {\n\t\t\t\t\tclearTimeout(temporizador);\n\t\t\t\t\trechazar(e);\n\t\t\t\t},\n\t\t\t});\n\t\t\tescribirMensaje(proc, { jsonrpc: \"2.0\", id, method: metodo, params });\n\t\t});\n\t}\n\n\tfunction notificar(metodo: string, params: unknown): void {\n\t\tif (procesoMuerto) return;\n\t\tescribirMensaje(proc, { jsonrpc: \"2.0\", method: metodo, params });\n\t}\n\n\tasync function cerrar(): Promise<void> {\n\t\tif (cerrado) return;\n\t\tcerrado = true;\n\t\tif (!procesoMuerto) {\n\t\t\t// Handshake formal primero: le da al servidor la oportunidad de soltar\n\t\t\t// ficheros de bloqueo, sockets, etc. antes del kill.\n\t\t\tawait enviar(\"shutdown\", null, 3000).catch(() => {});\n\t\t\tnotificar(\"exit\", undefined);\n\t\t}\n\t\trechazarTodoPendiente(new ErrorLsp(\"cliente LSP cerrado\", \"cierre\"));\n\t\tif (await esperarSalida(proc, ESPERA_SALIDA_MS)) return;\n\t\tproc.kill(\"SIGKILL\");\n\t\tawait esperarSalida(proc, ESPERA_SALIDA_MS);\n\t\t// Si tras SIGKILL sigue sin confirmar salida (proceso zombi, señal\n\t\t// bloqueada) no hay nada más que este cliente pueda hacer: se ha hecho\n\t\t// lo posible y se devuelve el control. Quien orquesta varios clientes\n\t\t// puede comprobar el pid con `process.kill(-1, 0)` para decidir si avisa.\n\t}\n\n\ttry {\n\t\tconst timeoutInit = opciones?.timeoutInicializacionMs ?? 15_000;\n\t\tawait enviar(\n\t\t\t\"initialize\",\n\t\t\t{\n\t\t\t\tprocessId: process.pid,\n\t\t\t\trootUri: uriDeRuta(cwd),\n\t\t\t\tworkspaceFolders: [{ uri: uriDeRuta(cwd), name: cwd }],\n\t\t\t\tcapabilities: CAPACIDADES_CLIENTE,\n\t\t\t},\n\t\t\ttimeoutInit,\n\t\t);\n\t\tnotificar(\"initialized\", {});\n\t} catch (error) {\n\t\tawait cerrar();\n\t\tthrow error;\n\t}\n\n\treturn { enviar, notificar, cerrar, pid: proc.pid };\n}\n\nexport { uriDeRuta };\n"]}