@hoilab/ada-cli 0.84.22 → 0.85.1

package/dist/core/lectura/sniffer.js

@@ -0,0 +1,106 @@
+/**
+ * Sniffer binario: clasifica un fichero como binario/texto por CONTENIDO antes
+ * de decodificarlo como UTF-8 y mostrárselo al modelo.
+ *
+ * EL BUG QUE MOTIVA ESTO: `read.ts:275` hace `buffer.toString("utf-8")` sobre
+ * cualquier fichero que no sea imagen. Un .wasm, un .png sin extensión, un
+ * .so, un .db — el decode es lossy: NUL bytes y secuencias inválidas se
+ * convierten en U+FFFD y caracteres de control, quemando el contexto con
+ * mojibake que el modelo no puede usar. omp lo resuelve con el mismo
+ * heurístico de git: sniffea los primeros 8 KB.
+ *
+ * REGLA (espejo de git):
+ *   · NUL byte en la cabecera → binario (true binary + UTF-16/32 cuyo rango
+ *     ASCII lleva padding NUL).
+ *   · Decode UTF-8 estricto (fatal) falla → binario (secuencia inválida real;
+ *     streaming mode tolera multibyte truncado en el borde de la cabecera).
+ *   · Todo lo demás → texto.
+ *
+ * FICHERO VACÍO → texto (no binario): un fichero de 0 bytes no produce
+ * mojibake y el modelo necesita saber que existe y está vacío.
+ */
+import { open } from "node:fs/promises";
+import { isAbsolute, join } from "node:path";
+/** Cabecera sniffeada: espejo de los 8.000 bytes de git. */
+export const BINARY_SNIFF_BYTES = 8192;
+/**
+ * Clasifica una cabecera en memoria como binaria (no texto UTF-8).
+ *
+ * Binario cuando la cabecera contiene un byte NUL (true binary, más texto
+ * UTF-16/32 cuyo rango ASCII lleva padding NUL) o cuando no es UTF-8 válido.
+ * El decode corre en modo streaming para que una secuencia multibyte
+ * truncada en el borde de la cabecera se tolere, mientras que cualquier byte
+ * genuinamente inválido falla — igual que el decode `fatal` estricto que las
+ * rutas de lectura `local://`/`ssh://` ya usan.
+ */
+export function esCabeceraBinaria(cabecera) {
+    if (cabecera.indexOf(0) !== -1)
+        return true;
+    try {
+        new TextDecoder("utf-8", { fatal: true }).decode(cabecera, { stream: true });
+        return false;
+    }
+    catch {
+        return true;
+    }
+}
+/**
+ * Sniffea los primeros {@link BINARY_SNIFF_BYTES} de `ruta` y devuelve si es
+ * binario. Abre el fichero, lee la cabecera y cierra — nunca lee el fichero
+ * entero solo para clasificarlo.
+ */
+export async function esProbablementeBinario(ruta, maxBytes = BINARY_SNIFF_BYTES) {
+    const manejador = await open(ruta, "r");
+    try {
+        const cabecera = Buffer.alloc(Math.min(maxBytes, BINARY_SNIFF_BYTES));
+        const { bytesRead } = await manejador.read(cabecera, 0, cabecera.length, 0);
+        return esCabeceraBinaria(cabecera.subarray(0, bytesRead));
+    }
+    finally {
+        await manejador.close();
+    }
+}
+/**
+ * Envuelve la definición de `read` ya construida para que un fichero binario
+ * devuelva un aviso limpio en vez de mojibake que quema el contexto. Mismo
+ * patrón que `envolverReadConPdf` y `envolverReadConUrlsInternas`: read.ts es
+ * de upstream y el presupuesto de sync está al tope.
+ *
+ * Orden de composición: el sniffer va MÁS ADENTRO que el PDF wrapper (un PDF
+ * es binario por el sniffer, pero el PDF wrapper lo maneja con su propio
+ * mensaje más útil; el sniffer solo actúa sobre binarios que NADIE más
+ * maneja).
+ */
+export function envolverReadConSniffer(base, cwd) {
+    return {
+        ...base,
+        async execute(toolCallId, params, signal, onUpdate, ctx) {
+            const rutaCruda = typeof params === "object" && params !== null && "path" in params ? params.path : undefined;
+            if (typeof rutaCruda !== "string" || rutaCruda === "" || rutaCruda.includes("://")) {
+                return base.execute(toolCallId, params, signal, onUpdate, ctx);
+            }
+            const absoluta = isAbsolute(rutaCruda) ? rutaCruda : join(cwd, rutaCruda);
+            try {
+                if (await esProbablementeBinario(absoluta)) {
+                    const { stat } = await import("node:fs/promises");
+                    const info = await stat(absoluta);
+                    return {
+                        content: [
+                            {
+                                type: "text",
+                                text: `[Fichero binario: ${info.size} bytes. No se decodifica como texto para no quemar el contexto con mojibake. Usa bash para inspeccionarlo: file, xxd, strings, hexdump.]`,
+                            },
+                        ],
+                        details: { binary: true, size: info.size },
+                    };
+                }
+            }
+            catch {
+                // Que el error de acceso lo cuente `read` con SU mensaje.
+                return base.execute(toolCallId, params, signal, onUpdate, ctx);
+            }
+            return base.execute(toolCallId, params, signal, onUpdate, ctx);
+        },
+    };
+}
+//# sourceMappingURL=sniffer.js.map

package/dist/core/lectura/sniffer.js.map

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

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

@@ -0,0 +1,42 @@
+/**
+ * Detección y ejecución de comprobadores — MIRANDO lo que hay en el
+ * proyecto, nunca inventando uno. `detectarComprobadores` documenta en
+ * `mirado` cada sitio que ha comprobado, se haya encontrado algo o no: es lo
+ * que distingue "no he mirado" de "he mirado y no hay nada" cuando no
+ * aparece ningún comprobador ejecutable.
+ */
+import type { Comprobador, Deteccion, Diagnostico, OpcionesCleanse, SalidaComando } from "./tipos.ts";
+/**
+ * Mira qué hay en el proyecto y arma la lista de comprobadores ejecutables.
+ * Prioridad por lenguaje: la config específica (biome/eslint/tsconfig) gana
+ * sobre el script de package.json genérico, porque sabemos parsear su salida.
+ */
+export declare function detectarComprobadores(cwd: string, opciones?: OpcionesCleanse): Deteccion;
+export interface ResultadoEjecucion {
+    diagnosticos: Diagnostico[];
+    /** Comprobadores que NO se pudieron ejecutar (ejecutable ausente, timeout…) — no confundir con "corrió limpio". */
+    fallidos: Array<{
+        id: string;
+        etiqueta: string;
+        motivo: string;
+    }>;
+}
+/** Ejecuta comprobadores en paralelo y agrega sus diagnósticos. */
+export declare function ejecutarComprobadores(comprobadores: readonly Comprobador[]): Promise<ResultadoEjecucion>;
+/**
+ * Ejecuta un único comprobador en modo streaming: emite diagnósticos
+ * incrementalmente cortando en última \n (exactly-once) cada chunk / 5s.
+ */
+export declare function ejecutarComprobadorStreaming(comprobador: Comprobador, onNuevos: (diagnosticos: Diagnostico[]) => void, timeoutMs?: number): Promise<{
+    ok: true;
+    salida: SalidaComando;
+    diagnosticos: Diagnostico[];
+} | {
+    ok: false;
+    motivo: string;
+}>;
+/** Ejecuta comprobadores con streaming opcional y board; mantiene compat con ejecutarComprobadores. */
+export declare function ejecutarComprobadoresConStreaming(comprobadores: readonly Comprobador[], onNuevos?: (diagnosticos: Diagnostico[]) => void, onEstado?: (id: string, estado: "start" | "done" | "fail", info?: string) => void): Promise<ResultadoEjecucion>;
+/** Re-ejecuta solo los comprobadores pedidos (por id) — la verificación tras un arreglo. */
+export declare function ejecutarComprobadoresPorId(comprobadores: readonly Comprobador[], ids: ReadonlySet<string>): Promise<ResultadoEjecucion>;
+//# sourceMappingURL=comprobadores.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"comprobadores.d.ts","sourceRoot":"","sources":["../../../src/core/limpieza/comprobadores.ts"],"names":[],"mappings":"AAAA;;;;;;GAMG;AAOH,OAAO,KAAK,EAAE,WAAW,EAAE,SAAS,EAAE,WAAW,EAAE,eAAe,EAAE,aAAa,EAAE,MAAM,YAAY,CAAC;AAmFtG;;;;GAIG;AACH,wBAAgB,qBAAqB,CAAC,GAAG,EAAE,MAAM,EAAE,QAAQ,CAAC,EAAE,eAAe,GAAG,SAAS,CA8OxF;AA2CD,MAAM,WAAW,kBAAkB;IAClC,YAAY,EAAE,WAAW,EAAE,CAAC;IAC5B,mHAAmH;IACnH,QAAQ,EAAE,KAAK,CAAC;QAAE,EAAE,EAAE,MAAM,CAAC;QAAC,QAAQ,EAAE,MAAM,CAAC;QAAC,MAAM,EAAE,MAAM,CAAA;KAAE,CAAC,CAAC;CAClE;AAED,mEAAmE;AACnE,wBAAsB,qBAAqB,CAAC,aAAa,EAAE,SAAS,WAAW,EAAE,GAAG,OAAO,CAAC,kBAAkB,CAAC,CAkC9G;AAED;;;GAGG;AACH,wBAAgB,4BAA4B,CAC3C,WAAW,EAAE,WAAW,EACxB,QAAQ,EAAE,CAAC,YAAY,EAAE,WAAW,EAAE,KAAK,IAAI,EAC/C,SAAS,SAAU,GACjB,OAAO,CAAC;IAAE,EAAE,EAAE,IAAI,CAAC;IAAC,MAAM,EAAE,aAAa,CAAC;IAAC,YAAY,EAAE,WAAW,EAAE,CAAA;CAAE,GAAG;IAAE,EAAE,EAAE,KAAK,CAAC;IAAC,MAAM,EAAE,MAAM,CAAA;CAAE,CAAC,CAsD3G;AAED,uGAAuG;AACvG,wBAAsB,iCAAiC,CACtD,aAAa,EAAE,SAAS,WAAW,EAAE,EACrC,QAAQ,CAAC,EAAE,CAAC,YAAY,EAAE,WAAW,EAAE,KAAK,IAAI,EAChD,QAAQ,CAAC,EAAE,CAAC,EAAE,EAAE,MAAM,EAAE,MAAM,EAAE,OAAO,GAAG,MAAM,GAAG,MAAM,EAAE,IAAI,CAAC,EAAE,MAAM,KAAK,IAAI,GAC/E,OAAO,CAAC,kBAAkB,CAAC,CA8B7B;AAED,4FAA4F;AAC5F,wBAAgB,0BAA0B,CACzC,aAAa,EAAE,SAAS,WAAW,EAAE,EACrC,GAAG,EAAE,WAAW,CAAC,MAAM,CAAC,GACtB,OAAO,CAAC,kBAAkB,CAAC,CAE7B"}

package/dist/core/limpieza/comprobadores.js

@@ -0,0 +1,505 @@
+/**
+ * Detección y ejecución de comprobadores — MIRANDO lo que hay en el
+ * proyecto, nunca inventando uno. `detectarComprobadores` documenta en
+ * `mirado` cada sitio que ha comprobado, se haya encontrado algo o no: es lo
+ * que distingue "no he mirado" de "he mirado y no hay nada" cuando no
+ * aparece ningún comprobador ejecutable.
+ */
+import { spawn, spawnSync } from "node:child_process";
+import { existsSync, readdirSync, readFileSync } from "node:fs";
+import { dirname, join } from "node:path";
+import { ColectorStreaming } from "./flujo.js";
+import { parsearBiomeGithub, parsearEslint, parsearGenerico, parsearTestFallido, parsearTsc } from "./parseo.js";
+const CONFIGS_ESLINT = [
+    "eslint.config.js",
+    "eslint.config.mjs",
+    "eslint.config.cjs",
+    "eslint.config.ts",
+    ".eslintrc",
+    ".eslintrc.js",
+    ".eslintrc.cjs",
+    ".eslintrc.json",
+];
+/** Busca un binario en `node_modules/.bin` subiendo directorios — la misma resolución que usa `npm run`. */
+function resolverBinLocal(desde, nombre) {
+    let dir = desde;
+    for (;;) {
+        const candidato = join(dir, "node_modules", ".bin", nombre);
+        if (existsSync(candidato))
+            return candidato;
+        const padre = dirname(dir);
+        if (padre === dir)
+            return undefined;
+        dir = padre;
+    }
+}
+/** true si `nombre` resuelve en PATH — para herramientas ajenas a node (ruff, cargo, go). */
+function hayEnPath(nombre) {
+    const r = spawnSync(process.platform === "win32" ? "where" : "which", [nombre], { stdio: "ignore" });
+    return r.status === 0;
+}
+function leerPackageJson(cwd) {
+    const ruta = join(cwd, "package.json");
+    if (!existsSync(ruta))
+        return undefined;
+    try {
+        return JSON.parse(readFileSync(ruta, "utf-8"));
+    }
+    catch {
+        // package.json ilegible: se trata como ausente, no se inventa nada a partir de él.
+        return undefined;
+    }
+}
+function tienePyprojectRuff(cwd) {
+    const ruta = join(cwd, "pyproject.toml");
+    if (!existsSync(ruta))
+        return false;
+    try {
+        return readFileSync(ruta, "utf-8").includes("[tool.ruff]");
+    }
+    catch {
+        return false;
+    }
+}
+function resolverGradle(cwd) {
+    const wrapper = join(cwd, "gradlew");
+    if (existsSync(wrapper))
+        return { comando: wrapper, etiqueta: "check (gradlew)" };
+    // También buscar en padre (monorepo)
+    let dir = cwd;
+    for (let i = 0; i < 3; i++) {
+        const cand = join(dir, "gradlew");
+        if (existsSync(cand))
+            return { comando: cand, etiqueta: "check (gradlew)" };
+        const padre = dirname(dir);
+        if (padre === dir)
+            break;
+        dir = padre;
+    }
+    if (hayEnPath("gradle"))
+        return { comando: "gradle", etiqueta: "check (gradle)" };
+    return undefined;
+}
+function resolverMaven(cwd) {
+    const wrapper = join(cwd, "mvnw");
+    if (existsSync(wrapper))
+        return { comando: wrapper, etiqueta: "verify (mvnw)" };
+    let dir = cwd;
+    for (let i = 0; i < 3; i++) {
+        const cand = join(dir, "mvnw");
+        if (existsSync(cand))
+            return { comando: cand, etiqueta: "verify (mvnw)" };
+        const padre = dirname(dir);
+        if (padre === dir)
+            break;
+        dir = padre;
+    }
+    if (hayEnPath("mvn"))
+        return { comando: "mvn", etiqueta: "verify (mvn)" };
+    return undefined;
+}
+/**
+ * Mira qué hay en el proyecto y arma la lista de comprobadores ejecutables.
+ * Prioridad por lenguaje: la config específica (biome/eslint/tsconfig) gana
+ * sobre el script de package.json genérico, porque sabemos parsear su salida.
+ */
+export function detectarComprobadores(cwd, opciones) {
+    const mirado = [];
+    const comprobadores = [];
+    const tiene = (id) => comprobadores.some((c) => c.id === id);
+    const fix = opciones?.fix === true;
+    const pkg = leerPackageJson(cwd);
+    mirado.push(`package.json (${existsSync(join(cwd, "package.json")) ? "existe" : "no existe"})`);
+    const biomeConfig = existsSync(join(cwd, "biome.json")) || existsSync(join(cwd, "biome.jsonc"));
+    mirado.push(`biome.json / biome.jsonc (${biomeConfig ? "encontrado" : "no encontrado"})`);
+    if (biomeConfig) {
+        const bin = resolverBinLocal(cwd, "biome");
+        if (bin) {
+            comprobadores.push({
+                id: "lint",
+                etiqueta: "lint (biome)",
+                comando: bin,
+                args: ["lint", "--reporter=github", "."],
+                cwd,
+                parsear: parsearBiomeGithub,
+                alcance: "fichero",
+            });
+        }
+        else {
+            mirado.push("biome: config encontrada pero no hay node_modules/.bin/biome en el árbol de directorios");
+        }
+    }
+    const eslintConfig = CONFIGS_ESLINT.some((f) => existsSync(join(cwd, f)));
+    mirado.push(`config de eslint (${eslintConfig ? "encontrada" : "no encontrada"})`);
+    if (eslintConfig && !tiene("lint")) {
+        const bin = resolverBinLocal(cwd, "eslint");
+        if (bin) {
+            comprobadores.push({
+                id: "lint",
+                etiqueta: "lint (eslint)",
+                comando: bin,
+                args: [".", "--format", "json"],
+                cwd,
+                parsear: parsearEslint,
+                alcance: "fichero",
+            });
+        }
+        else {
+            mirado.push("eslint: config encontrada pero no hay node_modules/.bin/eslint en el árbol de directorios");
+        }
+    }
+    if (pkg?.scripts?.lint && !tiene("lint")) {
+        mirado.push("package.json → scripts.lint (encontrado, sin config de biome/eslint reconocida)");
+        comprobadores.push({
+            id: "lint",
+            etiqueta: "lint (npm run lint)",
+            comando: "npm",
+            args: ["run", "lint", "--silent"],
+            cwd,
+            parsear: parsearGenerico,
+            alcance: "fichero",
+        });
+    }
+    const tsconfig = existsSync(join(cwd, "tsconfig.json"));
+    mirado.push(`tsconfig.json (${tsconfig ? "encontrado" : "no encontrado"})`);
+    if (tsconfig) {
+        const bin = resolverBinLocal(cwd, "tsc");
+        if (bin) {
+            comprobadores.push({
+                id: "typecheck",
+                etiqueta: "typecheck (tsc)",
+                comando: bin,
+                args: ["--noEmit", "--pretty", "false"],
+                cwd,
+                parsear: parsearTsc,
+                alcance: "fichero",
+            });
+        }
+        else if (pkg?.scripts?.typecheck) {
+            comprobadores.push({
+                id: "typecheck",
+                etiqueta: "typecheck (npm run typecheck)",
+                comando: "npm",
+                args: ["run", "typecheck", "--silent"],
+                cwd,
+                parsear: parsearGenerico,
+                alcance: "fichero",
+            });
+        }
+        else {
+            mirado.push("tsconfig.json: sin node_modules/.bin/tsc ni scripts.typecheck en package.json");
+        }
+    }
+    else if (pkg?.scripts?.typecheck) {
+        mirado.push("package.json → scripts.typecheck (encontrado, sin tsconfig.json)");
+        comprobadores.push({
+            id: "typecheck",
+            etiqueta: "typecheck (npm run typecheck)",
+            comando: "npm",
+            args: ["run", "typecheck", "--silent"],
+            cwd,
+            parsear: parsearGenerico,
+            alcance: "fichero",
+        });
+    }
+    if (pkg?.scripts?.test) {
+        mirado.push("package.json → scripts.test (encontrado)");
+        comprobadores.push({
+            id: "test",
+            etiqueta: "test (npm test)",
+            comando: "npm",
+            args: ["test", "--silent"],
+            cwd,
+            parsear: (salida) => parsearTestFallido(salida),
+            alcance: "proyecto",
+        });
+    }
+    const ruffConfig = existsSync(join(cwd, "ruff.toml")) || existsSync(join(cwd, ".ruff.toml")) || tienePyprojectRuff(cwd);
+    mirado.push(`pyproject.toml [tool.ruff] / ruff.toml / .ruff.toml (${ruffConfig ? "encontrado" : "no encontrado"})`);
+    if (ruffConfig) {
+        if (hayEnPath("ruff")) {
+            comprobadores.push({
+                id: "lint-py",
+                etiqueta: "lint (ruff)",
+                comando: "ruff",
+                args: ["check", "."],
+                cwd,
+                parsear: parsearGenerico,
+                alcance: "fichero",
+            });
+        }
+        else {
+            mirado.push("ruff: config encontrada pero el ejecutable 'ruff' no está en PATH");
+        }
+    }
+    const cargoToml = existsSync(join(cwd, "Cargo.toml"));
+    mirado.push(`Cargo.toml (${cargoToml ? "encontrado" : "no encontrado"})`);
+    if (cargoToml) {
+        if (hayEnPath("cargo")) {
+            const args = fix
+                ? ["clippy", "--fix", "--allow-dirty", "--allow-staged", "--message-format=short"]
+                : ["clippy", "--message-format=short"];
+            comprobadores.push({
+                id: "lint-rs",
+                etiqueta: fix ? "lint (cargo clippy --fix)" : "lint (cargo clippy)",
+                comando: "cargo",
+                args,
+                cwd,
+                parsear: parsearGenerico,
+                alcance: "fichero",
+                mutador: fix,
+            });
+        }
+        else {
+            mirado.push("cargo clippy: Cargo.toml encontrado pero el ejecutable 'cargo' no está en PATH");
+        }
+    }
+    const goMod = existsSync(join(cwd, "go.mod"));
+    mirado.push(`go.mod (${goMod ? "encontrado" : "no encontrado"})`);
+    if (goMod) {
+        if (hayEnPath("go")) {
+            comprobadores.push({
+                id: "vet-go",
+                etiqueta: "vet (go vet)",
+                comando: "go",
+                args: ["vet", "./..."],
+                cwd,
+                parsear: parsearGenerico,
+                alcance: "fichero",
+            });
+        }
+        else {
+            mirado.push("go vet: go.mod encontrado pero el ejecutable 'go' no está en PATH");
+        }
+    }
+    const gradleInfo = resolverGradle(cwd);
+    const gradleBuild = existsSync(join(cwd, "build.gradle")) || existsSync(join(cwd, "build.gradle.kts"));
+    mirado.push(`gradle (${gradleBuild ? "build.gradle encontrado" : "no encontrado"}${gradleInfo ? `, wrapper ${gradleInfo.etiqueta}` : ""})`);
+    if (gradleBuild && gradleInfo) {
+        comprobadores.push({
+            id: "check-gradle",
+            etiqueta: gradleInfo.etiqueta,
+            comando: gradleInfo.comando,
+            args: ["check", "--continue"],
+            cwd,
+            parsear: parsearGenerico,
+            alcance: "fichero",
+        });
+    }
+    else if (gradleBuild && !gradleInfo) {
+        mirado.push("gradle: build.gradle encontrado pero ni gradlew ni gradle en PATH");
+    }
+    const pomXml = existsSync(join(cwd, "pom.xml"));
+    const mavenInfo = resolverMaven(cwd);
+    mirado.push(`maven (${pomXml ? "pom.xml encontrado" : "no encontrado"}${mavenInfo ? `, wrapper ${mavenInfo.etiqueta}` : ""})`);
+    if (pomXml && mavenInfo) {
+        comprobadores.push({
+            id: "verify-maven",
+            etiqueta: mavenInfo.etiqueta,
+            comando: mavenInfo.comando,
+            args: mavenInfo.comando.endsWith("mvnw") || mavenInfo.comando === "mvn"
+                ? ["verify", "-DskipTests=false"]
+                : ["verify"],
+            cwd,
+            parsear: parsearGenerico,
+            alcance: "fichero",
+        });
+    }
+    else if (pomXml && !mavenInfo) {
+        mirado.push("maven: pom.xml encontrado pero ni mvnw ni mvn en PATH");
+    }
+    // Shellcheck (archivos .sh)
+    const hasShFiles = (() => {
+        try {
+            const files = readdirSync(cwd);
+            return files.some((f) => f.endsWith(".sh"));
+        }
+        catch {
+            return false;
+        }
+    })();
+    if (hasShFiles && hayEnPath("shellcheck")) {
+        mirado.push("shellcheck (.sh encontrado y shellcheck en PATH)");
+        comprobadores.push({
+            id: "lint-sh",
+            etiqueta: "lint (shellcheck)",
+            comando: "shellcheck",
+            args: ["-f", "gcc", "."],
+            cwd,
+            parsear: parsearGenerico,
+            alcance: "fichero",
+        });
+    }
+    else if (hasShFiles) {
+        mirado.push("shellcheck: .sh encontrado pero shellcheck no está en PATH");
+    }
+    return { comprobadores, mirado };
+}
+/** Ejecuta un comando y distingue "no pude ejecutarlo" (ENOENT, timeout) de una ejecución real. */
+function ejecutarComando(comprobador, timeoutMs = 120_000) {
+    return new Promise((resolve) => {
+        let proc;
+        try {
+            proc = spawn(comprobador.comando, comprobador.args, {
+                cwd: comprobador.cwd,
+                shell: false,
+                stdio: ["ignore", "pipe", "pipe"],
+            });
+        }
+        catch (error) {
+            resolve({ ok: false, motivo: error instanceof Error ? error.message : String(error) });
+            return;
+        }
+        let stdout = "";
+        let stderr = "";
+        let resuelto = false;
+        const temporizador = setTimeout(() => {
+            proc.kill("SIGKILL");
+            acabar({ ok: false, motivo: `timeout tras ${timeoutMs}ms` });
+        }, timeoutMs);
+        const acabar = (r) => {
+            if (resuelto)
+                return;
+            resuelto = true;
+            clearTimeout(temporizador);
+            resolve(r);
+        };
+        proc.on("error", (error) => acabar({ ok: false, motivo: error.message }));
+        proc.stdout?.on("data", (d) => {
+            stdout += d.toString();
+        });
+        proc.stderr?.on("data", (d) => {
+            stderr += d.toString();
+        });
+        proc.on("close", (code) => acabar({ ok: true, salida: { stdout, stderr, code: code ?? 0 } }));
+    });
+}
+/** Ejecuta comprobadores en paralelo y agrega sus diagnósticos. */
+export async function ejecutarComprobadores(comprobadores) {
+    const diagnosticos = [];
+    const fallidos = [];
+    await Promise.all(comprobadores.map(async (comprobador) => {
+        const r = await ejecutarComando(comprobador);
+        if (!r.ok) {
+            fallidos.push({ id: comprobador.id, etiqueta: comprobador.etiqueta, motivo: r.motivo });
+            return;
+        }
+        const parciales = comprobador.parsear(r.salida, comprobador.cwd);
+        // Salió con error pero el parser no le sacó NINGÚN diagnóstico: no es
+        // que el proyecto esté limpio, es que el binario probablemente
+        // crasheó (lib que falta, versión incompatible…) y su salida no
+        // tiene el formato que el parser espera. Sin esto, un comprobador
+        // roto se leía como "proyecto limpio" — exit code ignorado del todo.
+        // ponytail: heurística, no perfecta — un linter que legítimamente
+        // sale con código !=0 sin issues (convención rara) contaría como
+        // fallido; el riesgo de leer "limpio" un binario roto es peor.
+        if (parciales.length === 0 && r.salida.code !== 0) {
+            const cola = `${r.salida.stdout}\n${r.salida.stderr}`.trim().split("\n").slice(-5).join("\n");
+            fallidos.push({
+                id: comprobador.id,
+                etiqueta: comprobador.etiqueta,
+                motivo: `salió con código ${r.salida.code} sin diagnósticos reconocibles:\n${cola}`,
+            });
+            return;
+        }
+        for (const parcial of parciales) {
+            diagnosticos.push({ ...parcial, comprobador: comprobador.id });
+        }
+    }));
+    return { diagnosticos, fallidos };
+}
+/**
+ * Ejecuta un único comprobador en modo streaming: emite diagnósticos
+ * incrementalmente cortando en última \n (exactly-once) cada chunk / 5s.
+ */
+export function ejecutarComprobadorStreaming(comprobador, onNuevos, timeoutMs = 120_000) {
+    return new Promise((resolve) => {
+        let proc;
+        try {
+            proc = spawn(comprobador.comando, comprobador.args, {
+                cwd: comprobador.cwd,
+                shell: false,
+                stdio: ["ignore", "pipe", "pipe"],
+            });
+        }
+        catch (error) {
+            resolve({ ok: false, motivo: error instanceof Error ? error.message : String(error) });
+            return;
+        }
+        const colector = new ColectorStreaming({
+            comprobadorId: comprobador.id,
+            cwd: comprobador.cwd,
+            parsear: comprobador.parsear,
+            onDiagnosticos: onNuevos,
+        });
+        let stdoutAcum = "";
+        let stderrAcum = "";
+        let resuelto = false;
+        const temporizador = setTimeout(() => {
+            proc.kill("SIGKILL");
+            acabar({ ok: false, motivo: `timeout tras ${timeoutMs}ms` });
+        }, timeoutMs);
+        const acabar = (r) => {
+            if (resuelto)
+                return;
+            resuelto = true;
+            clearTimeout(temporizador);
+            resolve(r);
+        };
+        proc.on("error", (error) => acabar({ ok: false, motivo: error.message }));
+        proc.stdout?.on("data", (d) => {
+            const chunk = d.toString("utf-8");
+            stdoutAcum += chunk;
+            colector.push(chunk);
+        });
+        proc.stderr?.on("data", (d) => {
+            const chunk = d.toString("utf-8");
+            stderrAcum += chunk;
+            colector.push(chunk);
+        });
+        proc.on("close", (code) => {
+            const todos = colector.finalizar("", "");
+            // Si no se emitió nada pero el proceso falló, mantener heurística de fallido sin diagnósticos
+            if (todos.length === 0 && (code ?? 0) !== 0) {
+                // No hay diagnósticos reconocibles; el caller decidirá fallido
+            }
+            acabar({ ok: true, salida: { stdout: stdoutAcum, stderr: stderrAcum, code: code ?? 0 }, diagnosticos: todos });
+        });
+    });
+}
+/** Ejecuta comprobadores con streaming opcional y board; mantiene compat con ejecutarComprobadores. */
+export async function ejecutarComprobadoresConStreaming(comprobadores, onNuevos, onEstado) {
+    const diagnosticos = [];
+    const fallidos = [];
+    await Promise.all(comprobadores.map(async (comprobador) => {
+        onEstado?.(comprobador.id, "start");
+        const r = await ejecutarComprobadorStreaming(comprobador, (nuevos) => {
+            for (const d of nuevos)
+                diagnosticos.push(d);
+            onNuevos?.(nuevos);
+        });
+        if (!r.ok) {
+            fallidos.push({ id: comprobador.id, etiqueta: comprobador.etiqueta, motivo: r.motivo });
+            onEstado?.(comprobador.id, "fail", r.motivo);
+            return;
+        }
+        // Los diagnósticos ya fueron empujados vía streaming callback (exactly-once); no duplicar con r.diagnosticos.
+        if (r.diagnosticos.length === 0 && r.salida.code !== 0) {
+            const cola = `${r.salida.stdout}\n${r.salida.stderr}`.trim().split("\n").slice(-5).join("\n");
+            fallidos.push({
+                id: comprobador.id,
+                etiqueta: comprobador.etiqueta,
+                motivo: `salió con código ${r.salida.code} sin diagnósticos reconocibles:\n${cola}`,
+            });
+            onEstado?.(comprobador.id, "fail", `código ${r.salida.code}`);
+            return;
+        }
+        onEstado?.(comprobador.id, "done", String(r.diagnosticos.length));
+    }));
+    return { diagnosticos, fallidos };
+}
+/** Re-ejecuta solo los comprobadores pedidos (por id) — la verificación tras un arreglo. */
+export function ejecutarComprobadoresPorId(comprobadores, ids) {
+    return ejecutarComprobadores(comprobadores.filter((c) => ids.has(c.id)));
+}
+//# sourceMappingURL=comprobadores.js.map