@hoilab/ada-cli 0.85.0 → 0.85.1

package/dist/core/revision/dispositions.d.ts

@@ -0,0 +1,86 @@
+/**
+ * Disposiciones de hallazgos: la decisión humana sobre cada hallazgo repetido.
+ *
+ * Sin esto, un escáner que encuentra lo mismo cada semana convierte el panel de
+ * seguridad en ruido y al equipo en quien aprende a ignorarlo. La disposition
+ * es el contrato que evita las dos mentiras opuestas: el hallazgo aceptado como
+ * riesgo no reaparece como NUEVO, y el corregido que vuelve a aparecer sí (es
+ * una regresión, y callarla sería peor).
+ *
+ * Los estados que cambian el comportamiento:
+ *
+ * - `pendiente`: sin decidir. Cuenta todo.
+ * - `falso-positivo` / `aceptado-riesgo`: resuelto por una persona con nombre,
+ *   fecha y justificación. No vuelve a contar como nuevo ni se publica.
+ * - `corregido`: cuenta mientras desaparezca; si REAPARECE es nuevo (regresión).
+ *
+ * Cada entrada lleva quién, cuándo y por qué porque una disposition anónima y
+ * sin motivo no es auditoría: es alguien pulsando el botón «silenciar».
+ */
+import { type Hallazgo } from "./hallazgo.ts";
+/** Nombre canónico del libro dentro del repositorio analizado. */
+export declare const NOMBRE_FICHERO_DISPOSICIONES = "revision-dispositions.json";
+export type TipoDisposicion = "pendiente" | "aceptado-riesgo" | "falso-positivo" | "corregido";
+export interface EntradaDisposicion {
+    /** Huella estable (`huellaDe`): regla + ruta + evidencia, sin línea. */
+    huella: string;
+    disposicion: TipoDisposicion;
+    quien: string;
+    cuando: string;
+    justificacion: string;
+}
+export interface LibroDisposiciones {
+    version: 1;
+    entradas: EntradaDisposicion[];
+}
+/**
+ * Lee el libro. Fichero ausente = libro vacío (primera ejecución); fichero
+ * ILEGÍBLE o corrupto lanza: escribir encima de un libro que no se pudo
+ * parsear borraría las decisiones de todo el equipo, y eso no se hace en
+ * silencio.
+ */
+export declare function cargarLibro(ruta: string): LibroDisposiciones;
+/** Persiste el libro atómicamente: o el fichero nuevo completo o el anterior. */
+export declare function guardarLibro(ruta: string, libro: LibroDisposiciones): void;
+/**
+ * Registra (o sustituye) la disposición de una huella. Última decisión gana:
+ * cambiar de opinión es legítimo; apilar decisiones contradictorias sin decir
+ * cuál vale, no.
+ */
+export declare function disponer(libro: LibroDisposiciones, entrada: {
+    huella: string;
+    disposicion: TipoDisposicion;
+    quien: string;
+    justificacion: string;
+    cuando?: string;
+}): LibroDisposiciones;
+export declare function disposicionDe(libro: LibroDisposiciones, huella: string): EntradaDisposicion | null;
+export interface AplicacionDisposiciones {
+    /** Hallazgos que siguen contando: pendientes, regresiones y sin decidir. */
+    publicables: Hallazgo[];
+    /** Hallazgos suprimidos, con la decisión que los suprimió. */
+    dispuestos: Array<{
+        hallazgo: Hallazgo;
+        entrada: EntradaDisposicion;
+    }>;
+}
+/** Separa lo publicable de lo dispuesto según el libro. */
+export declare function aplicarDisposiciones(hallazgos: readonly Hallazgo[], libro: LibroDisposiciones): AplicacionDisposiciones;
+export interface DiferenciaHallazgos {
+    /** En este scan y no en el baseline, salvo disposición que diga lo contrario. */
+    nuevos: Hallazgo[];
+    /** Estaban en el baseline y ya no están. */
+    resueltos: Hallazgo[];
+    /** En los dos scans. */
+    persistentes: Hallazgo[];
+}
+/**
+ * Diff entre scans por huella, respetando dispositions.
+ *
+ * Un hallazgo con `falso-positivo`/`aceptado-riesgo` nunca es nuevo aunque el
+ * baseline se haya perdido. Uno `corregido` que reaparece SÍ es nuevo: la
+ * corrección no aguantó, y ese caso exacto es el que un diff ingenuo calla
+ * para siempre.
+ */
+export declare function diferir(actuales: readonly Hallazgo[], previos: readonly Hallazgo[], libro: LibroDisposiciones): DiferenciaHallazgos;
+//# sourceMappingURL=dispositions.d.ts.map

package/dist/core/revision/dispositions.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"dispositions.d.ts","sourceRoot":"","sources":["../../../src/core/revision/dispositions.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;GAkBG;AAIH,OAAO,EAAE,KAAK,QAAQ,EAAY,MAAM,eAAe,CAAC;AAExD,kEAAkE;AAClE,eAAO,MAAM,4BAA4B,+BAA+B,CAAC;AAEzE,MAAM,MAAM,eAAe,GAAG,WAAW,GAAG,iBAAiB,GAAG,gBAAgB,GAAG,WAAW,CAAC;AAgB/F,MAAM,WAAW,kBAAkB;IAClC,wEAAwE;IACxE,MAAM,EAAE,MAAM,CAAC;IACf,WAAW,EAAE,eAAe,CAAC;IAC7B,KAAK,EAAE,MAAM,CAAC;IACd,MAAM,EAAE,MAAM,CAAC;IACf,aAAa,EAAE,MAAM,CAAC;CACtB;AAED,MAAM,WAAW,kBAAkB;IAClC,OAAO,EAAE,CAAC,CAAC;IACX,QAAQ,EAAE,kBAAkB,EAAE,CAAC;CAC/B;AAED;;;;;GAKG;AACH,wBAAgB,WAAW,CAAC,IAAI,EAAE,MAAM,GAAG,kBAAkB,CAoB5D;AAED,iFAAiF;AACjF,wBAAgB,YAAY,CAAC,IAAI,EAAE,MAAM,EAAE,KAAK,EAAE,kBAAkB,GAAG,IAAI,CAE1E;AAED;;;;GAIG;AACH,wBAAgB,QAAQ,CACvB,KAAK,EAAE,kBAAkB,EACzB,OAAO,EAAE;IAAE,MAAM,EAAE,MAAM,CAAC;IAAC,WAAW,EAAE,eAAe,CAAC;IAAC,KAAK,EAAE,MAAM,CAAC;IAAC,aAAa,EAAE,MAAM,CAAC;IAAC,MAAM,CAAC,EAAE,MAAM,CAAA;CAAE,GAC9G,kBAAkB,CAYpB;AAED,wBAAgB,aAAa,CAAC,KAAK,EAAE,kBAAkB,EAAE,MAAM,EAAE,MAAM,GAAG,kBAAkB,GAAG,IAAI,CAElG;AAED,MAAM,WAAW,uBAAuB;IACvC,4EAA4E;IAC5E,WAAW,EAAE,QAAQ,EAAE,CAAC;IACxB,8DAA8D;IAC9D,UAAU,EAAE,KAAK,CAAC;QAAE,QAAQ,EAAE,QAAQ,CAAC;QAAC,OAAO,EAAE,kBAAkB,CAAA;KAAE,CAAC,CAAC;CACvE;AAED,2DAA2D;AAC3D,wBAAgB,oBAAoB,CACnC,SAAS,EAAE,SAAS,QAAQ,EAAE,EAC9B,KAAK,EAAE,kBAAkB,GACvB,uBAAuB,CASzB;AAED,MAAM,WAAW,mBAAmB;IACnC,iFAAiF;IACjF,MAAM,EAAE,QAAQ,EAAE,CAAC;IACnB,4CAA4C;IAC5C,SAAS,EAAE,QAAQ,EAAE,CAAC;IACtB,wBAAwB;IACxB,YAAY,EAAE,QAAQ,EAAE,CAAC;CACzB;AAED;;;;;;;GAOG;AACH,wBAAgB,OAAO,CACtB,QAAQ,EAAE,SAAS,QAAQ,EAAE,EAC7B,OAAO,EAAE,SAAS,QAAQ,EAAE,EAC5B,KAAK,EAAE,kBAAkB,GACvB,mBAAmB,CAgBrB"}

package/dist/core/revision/dispositions.js

@@ -0,0 +1,137 @@
+/**
+ * Disposiciones de hallazgos: la decisión humana sobre cada hallazgo repetido.
+ *
+ * Sin esto, un escáner que encuentra lo mismo cada semana convierte el panel de
+ * seguridad en ruido y al equipo en quien aprende a ignorarlo. La disposition
+ * es el contrato que evita las dos mentiras opuestas: el hallazgo aceptado como
+ * riesgo no reaparece como NUEVO, y el corregido que vuelve a aparecer sí (es
+ * una regresión, y callarla sería peor).
+ *
+ * Los estados que cambian el comportamiento:
+ *
+ * - `pendiente`: sin decidir. Cuenta todo.
+ * - `falso-positivo` / `aceptado-riesgo`: resuelto por una persona con nombre,
+ *   fecha y justificación. No vuelve a contar como nuevo ni se publica.
+ * - `corregido`: cuenta mientras desaparezca; si REAPARECE es nuevo (regresión).
+ *
+ * Cada entrada lleva quién, cuándo y por qué porque una disposition anónima y
+ * sin motivo no es auditoría: es alguien pulsando el botón «silenciar».
+ */
+import { readFileSync } from "node:fs";
+import { writeTextAtomicSync } from "../utils/atomic-write.js";
+import { huellaDe } from "./hallazgo.js";
+/** Nombre canónico del libro dentro del repositorio analizado. */
+export const NOMBRE_FICHERO_DISPOSICIONES = "revision-dispositions.json";
+/**
+ * ¿Suprime esta disposición un hallazgo PRESENTE y/o nuevo?
+ *
+ * Solo «esto no cuenta» suprime. `corregido` NO: si el hallazgo sigue ahí o
+ * vuelve después de «corregido», es una regresión y tiene que verse.
+ * `pendiente` tampoco: no decidir no es resolver.
+ */
+const SUPRIME = {
+    pendiente: false,
+    "aceptado-riesgo": true,
+    "falso-positivo": true,
+    corregido: false,
+};
+/**
+ * Lee el libro. Fichero ausente = libro vacío (primera ejecución); fichero
+ * ILEGÍBLE o corrupto lanza: escribir encima de un libro que no se pudo
+ * parsear borraría las decisiones de todo el equipo, y eso no se hace en
+ * silencio.
+ */
+export function cargarLibro(ruta) {
+    let bruto;
+    try {
+        bruto = readFileSync(ruta, "utf8");
+    }
+    catch (error) {
+        const errno = error;
+        if (errno.code !== "ENOENT")
+            throw error;
+        return { version: 1, entradas: [] };
+    }
+    const dato = JSON.parse(bruto);
+    if (typeof dato !== "object" || dato === null)
+        throw new Error(`${ruta}: el libro de disposiciones no es un objeto`);
+    const libro = dato;
+    if (libro.version !== 1 || !Array.isArray(libro.entradas))
+        throw new Error(`${ruta}: versión o formato del libro no reconocidos`);
+    for (const e of libro.entradas) {
+        if (!e.huella || !e.disposicion || !e.quien || !e.justificacion) {
+            throw new Error(`${ruta}: entrada sin huella/disposición/quién/justificación — libro incompleto`);
+        }
+    }
+    return libro;
+}
+/** Persiste el libro atómicamente: o el fichero nuevo completo o el anterior. */
+export function guardarLibro(ruta, libro) {
+    writeTextAtomicSync(ruta, `${JSON.stringify(libro, null, 2)}\n`);
+}
+/**
+ * Registra (o sustituye) la disposición de una huella. Última decisión gana:
+ * cambiar de opinión es legítimo; apilar decisiones contradictorias sin decir
+ * cuál vale, no.
+ */
+export function disponer(libro, entrada) {
+    if (!entrada.quien.trim())
+        throw new Error("una disposition sin quién la firmó no es auditable");
+    if (!entrada.justificacion.trim())
+        throw new Error("una disposition sin justificación no es auditable");
+    const completa = {
+        huella: entrada.huella,
+        disposicion: entrada.disposicion,
+        quien: entrada.quien,
+        cuando: entrada.cuando ?? new Date().toISOString(),
+        justificacion: entrada.justificacion,
+    };
+    const resto = libro.entradas.filter((e) => e.huella !== entrada.huella);
+    return { version: 1, entradas: [...resto, completa] };
+}
+export function disposicionDe(libro, huella) {
+    return libro.entradas.find((e) => e.huella === huella) ?? null;
+}
+/** Separa lo publicable de lo dispuesto según el libro. */
+export function aplicarDisposiciones(hallazgos, libro) {
+    const publicables = [];
+    const dispuestos = [];
+    for (const h of hallazgos) {
+        const entrada = disposicionDe(libro, huellaDe(h));
+        if (entrada && SUPRIME[entrada.disposicion])
+            dispuestos.push({ hallazgo: h, entrada });
+        else
+            publicables.push(h);
+    }
+    return { publicables, dispuestos };
+}
+/**
+ * Diff entre scans por huella, respetando dispositions.
+ *
+ * Un hallazgo con `falso-positivo`/`aceptado-riesgo` nunca es nuevo aunque el
+ * baseline se haya perdido. Uno `corregido` que reaparece SÍ es nuevo: la
+ * corrección no aguantó, y ese caso exacto es el que un diff ingenuo calla
+ * para siempre.
+ */
+export function diferir(actuales, previos, libro) {
+    const huellasPrevias = new Set(previos.map(huellaDe));
+    const resultado = { nuevos: [], resueltos: [], persistentes: [] };
+    for (const h of actuales) {
+        const huella = huellaDe(h);
+        if (!huellasPrevias.has(huella)) {
+            const entrada = disposicionDe(libro, huella);
+            if (entrada && SUPRIME[entrada.disposicion])
+                continue;
+            resultado.nuevos.push(h);
+        }
+        else {
+            resultado.persistentes.push(h);
+        }
+    }
+    const huellasActuales = new Set(actuales.map(huellaDe));
+    for (const h of previos)
+        if (!huellasActuales.has(huellaDe(h)))
+            resultado.resueltos.push(h);
+    return resultado;
+}
+//# sourceMappingURL=dispositions.js.map

package/dist/core/revision/dispositions.js.map

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

package/dist/core/revision/hallazgo.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"hallazgo.d.ts","sourceRoot":"","sources":["../../../src/core/revision/hallazgo.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;GAeG;AAIH,MAAM,MAAM,SAAS,GAAG,SAAS,GAAG,MAAM,GAAG,OAAO,GAAG,MAAM,GAAG,aAAa,CAAC;AAE9E,MAAM,WAAW,QAAQ;IACxB,yEAAyE;IACzE,OAAO,EAAE,MAAM,CAAC;IAChB,MAAM,EAAE,MAAM,CAAC;IACf,OAAO,EAAE,MAAM,CAAC;IAChB,SAAS,EAAE,SAAS,CAAC;IACrB,gDAA+C;IAC/C,IAAI,EAAE,MAAM,CAAC;IACb,WAAW,EAAE,MAAM,CAAC;IACpB,QAAQ,CAAC,EAAE,MAAM,CAAC;IAClB,sEAAqE;IACrE,SAAS,EAAE,MAAM,CAAC;IAClB,uDAAsD;IACtD,OAAO,CAAC,EAAE,MAAM,CAAC;IACjB,gDAAgD;IAChD,SAAS,CAAC,EAAE,MAAM,EAAE,CAAC;CACrB;AAWD,wBAAgB,YAAY,CAAC,SAAS,EAAE,SAAS,GAAG,MAAM,CAEzD;AAED,+EAA+E;AAC/E,wBAAgB,UAAU,CAAC,SAAS,EAAE,SAAS,GAAG,OAAO,GAAG,SAAS,GAAG,MAAM,GAAG,MAAM,CAYtF;AAED;;;;;;;;;GASG;AACH,wBAAgB,QAAQ,CAAC,QAAQ,EAAE,IAAI,CAAC,QAAQ,EAAE,SAAS,GAAG,MAAM,GAAG,WAAW,CAAC,GAAG,MAAM,CAG3F;AAED,+DAA+D;AAC/D,wBAAgB,YAAY,CAAC,QAAQ,EAAE,OAAO,CAAC,QAAQ,CAAC,GAAG,MAAM,GAAG,IAAI,CAWvE","sourcesContent":["/**\n * Un hallazgo de revisión, con evidencia obligatoria.\n *\n * La evidencia no es un adorno del tipo: es lo que separa una revisión de una\n * opinión. Un hallazgo que dice «esto podría tener una condición de carrera» sin\n * señalar las líneas que la producen no se puede comprobar, no se puede arreglar\n * y no se puede rebatir — y a las tres veces el equipo deja de leer la revisión\n * entera. Por eso `evidencia` es obligatoria y no opcional.\n *\n * El otro campo que importa es la HUELLA. Es lo que permite que un hallazgo\n * repetido entre ejecuciones se reconozca como el mismo aunque el fichero se\n * haya movido: se calcula sobre la regla, la ruta y la evidencia, y\n * deliberadamente NO sobre el número de línea. Un hallazgo que cambia de huella\n * cada vez que alguien añade un import aparece como nuevo en cada ejecución, y\n * eso convierte cualquier panel en ruido.\n */\n\nimport { createHash } from \"node:crypto\";\n\nexport type Severidad = \"critica\" | \"alta\" | \"media\" | \"baja\" | \"informativa\";\n\nexport interface Hallazgo {\n\t/** Identificador estable de la regla, p. ej. `ada/cruce-de-frontera`. */\n\treglaId: string;\n\ttitulo: string;\n\tresumen: string;\n\tseveridad: Severidad;\n\t/** Ruta relativa a la raíz del repositorio. */\n\truta: string;\n\tlineaInicio: number;\n\tlineaFin?: number;\n\t/** El fragmento exacto que lo justifica. Obligatorio a propósito. */\n\tevidencia: string;\n\t/** Qué hacer. Un hallazgo sin salida es una queja. */\n\tremedio?: string;\n\t/** CWE, OWASP, lo que sirva para clasificar. */\n\tetiquetas?: string[];\n}\n\n/** Puntuación 0–10, la escala que entiende GitHub en `security-severity`. */\nconst PUNTUACION: Record<Severidad, number> = {\n\tcritica: 9.5,\n\talta: 7.5,\n\tmedia: 5,\n\tbaja: 3,\n\tinformativa: 0,\n};\n\nexport function puntuacionDe(severidad: Severidad): number {\n\treturn PUNTUACION[severidad];\n}\n\n/** Nivel SARIF. `informativa` es `none`, que GitHub muestra pero no cuenta. */\nexport function nivelSarif(severidad: Severidad): \"error\" | \"warning\" | \"note\" | \"none\" {\n\tswitch (severidad) {\n\t\tcase \"critica\":\n\t\tcase \"alta\":\n\t\t\treturn \"error\";\n\t\tcase \"media\":\n\t\t\treturn \"warning\";\n\t\tcase \"baja\":\n\t\t\treturn \"note\";\n\t\tdefault:\n\t\t\treturn \"none\";\n\t}\n}\n\n/**\n * Huella estable del hallazgo.\n *\n * Sobre regla + ruta + evidencia normalizada. Sin número de línea: si lo\n * llevara, mover el bloque diez líneas más abajo crearía un hallazgo \"nuevo\" y\n * el anterior quedaría como \"resuelto\", que es mentira dos veces.\n *\n * La evidencia se normaliza en espacios porque un reformateo no cambia el\n * problema.\n */\nexport function huellaDe(hallazgo: Pick<Hallazgo, \"reglaId\" | \"ruta\" | \"evidencia\">): string {\n\tconst normalizada = hallazgo.evidencia.replace(/\\s+/g, \" \").trim();\n\treturn createHash(\"sha256\").update(`${hallazgo.reglaId}\\u0000${hallazgo.ruta}\\u0000${normalizada}`).digest(\"hex\");\n}\n\n/** Motivo por el que un hallazgo no vale, o `null` si vale. */\nexport function porQueNoVale(hallazgo: Partial<Hallazgo>): string | null {\n\tif (!hallazgo.reglaId) return \"sin reglaId: no se puede agrupar ni deduplicar\";\n\tif (!hallazgo.ruta) return \"sin ruta: no se puede anclar en el código\";\n\tif (!hallazgo.evidencia?.trim()) return \"sin evidencia: es una opinión, no un hallazgo\";\n\tif (typeof hallazgo.lineaInicio !== \"number\" || hallazgo.lineaInicio < 1) {\n\t\treturn \"sin línea de inicio válida: no se puede señalar dónde\";\n\t}\n\tif (hallazgo.lineaFin !== undefined && hallazgo.lineaFin < hallazgo.lineaInicio) {\n\t\treturn \"la línea final va antes que la inicial\";\n\t}\n\treturn null;\n}\n"]}
+{"version":3,"file":"hallazgo.d.ts","sourceRoot":"","sources":["../../../src/core/revision/hallazgo.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;GAeG;AAIH,MAAM,MAAM,SAAS,GAAG,SAAS,GAAG,MAAM,GAAG,OAAO,GAAG,MAAM,GAAG,aAAa,CAAC;AAE9E,MAAM,WAAW,QAAQ;IACxB,yEAAyE;IACzE,OAAO,EAAE,MAAM,CAAC;IAChB,MAAM,EAAE,MAAM,CAAC;IACf,OAAO,EAAE,MAAM,CAAC;IAChB,SAAS,EAAE,SAAS,CAAC;IACrB,+CAA+C;IAC/C,IAAI,EAAE,MAAM,CAAC;IACb,WAAW,EAAE,MAAM,CAAC;IACpB,QAAQ,CAAC,EAAE,MAAM,CAAC;IAClB,qEAAqE;IACrE,SAAS,EAAE,MAAM,CAAC;IAClB,sDAAsD;IACtD,OAAO,CAAC,EAAE,MAAM,CAAC;IACjB,gDAAgD;IAChD,SAAS,CAAC,EAAE,MAAM,EAAE,CAAC;CACrB;AAWD,wBAAgB,YAAY,CAAC,SAAS,EAAE,SAAS,GAAG,MAAM,CAEzD;AAED,+EAA+E;AAC/E,wBAAgB,UAAU,CAAC,SAAS,EAAE,SAAS,GAAG,OAAO,GAAG,SAAS,GAAG,MAAM,GAAG,MAAM,CAYtF;AAED;;;;;;;;;GASG;AACH,wBAAgB,QAAQ,CAAC,QAAQ,EAAE,IAAI,CAAC,QAAQ,EAAE,SAAS,GAAG,MAAM,GAAG,WAAW,CAAC,GAAG,MAAM,CAG3F;AAED,+DAA+D;AAC/D,wBAAgB,YAAY,CAAC,QAAQ,EAAE,OAAO,CAAC,QAAQ,CAAC,GAAG,MAAM,GAAG,IAAI,CAWvE"}

package/dist/core/revision/hallazgo.js.map

@@ -1 +1 @@
-{"version":3,"file":"hallazgo.js","sourceRoot":"","sources":["../../../src/core/revision/hallazgo.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;GAeG;AAEH,OAAO,EAAE,UAAU,EAAE,MAAM,aAAa,CAAC;AAsBzC,gFAA6E;AAC7E,MAAM,UAAU,GAA8B;IAC7C,OAAO,EAAE,GAAG;IACZ,IAAI,EAAE,GAAG;IACT,KAAK,EAAE,CAAC;IACR,IAAI,EAAE,CAAC;IACP,WAAW,EAAE,CAAC;CACd,CAAC;AAEF,MAAM,UAAU,YAAY,CAAC,SAAoB,EAAU;IAC1D,OAAO,UAAU,CAAC,SAAS,CAAC,CAAC;AAAA,CAC7B;AAED,+EAA+E;AAC/E,MAAM,UAAU,UAAU,CAAC,SAAoB,EAAyC;IACvF,QAAQ,SAAS,EAAE,CAAC;QACnB,KAAK,SAAS,CAAC;QACf,KAAK,MAAM;YACV,OAAO,OAAO,CAAC;QAChB,KAAK,OAAO;YACX,OAAO,SAAS,CAAC;QAClB,KAAK,MAAM;YACV,OAAO,MAAM,CAAC;QACf;YACC,OAAO,MAAM,CAAC;IAChB,CAAC;AAAA,CACD;AAED;;;;;;;;;GASG;AACH,MAAM,UAAU,QAAQ,CAAC,QAA0D,EAAU;IAC5F,MAAM,WAAW,GAAG,QAAQ,CAAC,SAAS,CAAC,OAAO,CAAC,MAAM,EAAE,GAAG,CAAC,CAAC,IAAI,EAAE,CAAC;IACnE,OAAO,UAAU,CAAC,QAAQ,CAAC,CAAC,MAAM,CAAC,GAAG,QAAQ,CAAC,OAAO,SAAS,QAAQ,CAAC,IAAI,SAAS,WAAW,EAAE,CAAC,CAAC,MAAM,CAAC,KAAK,CAAC,CAAC;AAAA,CAClH;AAED,+DAA+D;AAC/D,MAAM,UAAU,YAAY,CAAC,QAA2B,EAAiB;IACxE,IAAI,CAAC,QAAQ,CAAC,OAAO;QAAE,OAAO,gDAAgD,CAAC;IAC/E,IAAI,CAAC,QAAQ,CAAC,IAAI;QAAE,OAAO,4CAA2C,CAAC;IACvE,IAAI,CAAC,QAAQ,CAAC,SAAS,EAAE,IAAI,EAAE;QAAE,OAAO,gDAA+C,CAAC;IACxF,IAAI,OAAO,QAAQ,CAAC,WAAW,KAAK,QAAQ,IAAI,QAAQ,CAAC,WAAW,GAAG,CAAC,EAAE,CAAC;QAC1E,OAAO,2DAAuD,CAAC;IAChE,CAAC;IACD,IAAI,QAAQ,CAAC,QAAQ,KAAK,SAAS,IAAI,QAAQ,CAAC,QAAQ,GAAG,QAAQ,CAAC,WAAW,EAAE,CAAC;QACjF,OAAO,yCAAwC,CAAC;IACjD,CAAC;IACD,OAAO,IAAI,CAAC;AAAA,CACZ","sourcesContent":["/**\n * Un hallazgo de revisión, con evidencia obligatoria.\n *\n * La evidencia no es un adorno del tipo: es lo que separa una revisión de una\n * opinión. Un hallazgo que dice «esto podría tener una condición de carrera» sin\n * señalar las líneas que la producen no se puede comprobar, no se puede arreglar\n * y no se puede rebatir — y a las tres veces el equipo deja de leer la revisión\n * entera. Por eso `evidencia` es obligatoria y no opcional.\n *\n * El otro campo que importa es la HUELLA. Es lo que permite que un hallazgo\n * repetido entre ejecuciones se reconozca como el mismo aunque el fichero se\n * haya movido: se calcula sobre la regla, la ruta y la evidencia, y\n * deliberadamente NO sobre el número de línea. Un hallazgo que cambia de huella\n * cada vez que alguien añade un import aparece como nuevo en cada ejecución, y\n * eso convierte cualquier panel en ruido.\n */\n\nimport { createHash } from \"node:crypto\";\n\nexport type Severidad = \"critica\" | \"alta\" | \"media\" | \"baja\" | \"informativa\";\n\nexport interface Hallazgo {\n\t/** Identificador estable de la regla, p. ej. `ada/cruce-de-frontera`. */\n\treglaId: string;\n\ttitulo: string;\n\tresumen: string;\n\tseveridad: Severidad;\n\t/** Ruta relativa a la raíz del repositorio. */\n\truta: string;\n\tlineaInicio: number;\n\tlineaFin?: number;\n\t/** El fragmento exacto que lo justifica. Obligatorio a propósito. */\n\tevidencia: string;\n\t/** Qué hacer. Un hallazgo sin salida es una queja. */\n\tremedio?: string;\n\t/** CWE, OWASP, lo que sirva para clasificar. */\n\tetiquetas?: string[];\n}\n\n/** Puntuación 0–10, la escala que entiende GitHub en `security-severity`. */\nconst PUNTUACION: Record<Severidad, number> = {\n\tcritica: 9.5,\n\talta: 7.5,\n\tmedia: 5,\n\tbaja: 3,\n\tinformativa: 0,\n};\n\nexport function puntuacionDe(severidad: Severidad): number {\n\treturn PUNTUACION[severidad];\n}\n\n/** Nivel SARIF. `informativa` es `none`, que GitHub muestra pero no cuenta. */\nexport function nivelSarif(severidad: Severidad): \"error\" | \"warning\" | \"note\" | \"none\" {\n\tswitch (severidad) {\n\t\tcase \"critica\":\n\t\tcase \"alta\":\n\t\t\treturn \"error\";\n\t\tcase \"media\":\n\t\t\treturn \"warning\";\n\t\tcase \"baja\":\n\t\t\treturn \"note\";\n\t\tdefault:\n\t\t\treturn \"none\";\n\t}\n}\n\n/**\n * Huella estable del hallazgo.\n *\n * Sobre regla + ruta + evidencia normalizada. Sin número de línea: si lo\n * llevara, mover el bloque diez líneas más abajo crearía un hallazgo \"nuevo\" y\n * el anterior quedaría como \"resuelto\", que es mentira dos veces.\n *\n * La evidencia se normaliza en espacios porque un reformateo no cambia el\n * problema.\n */\nexport function huellaDe(hallazgo: Pick<Hallazgo, \"reglaId\" | \"ruta\" | \"evidencia\">): string {\n\tconst normalizada = hallazgo.evidencia.replace(/\\s+/g, \" \").trim();\n\treturn createHash(\"sha256\").update(`${hallazgo.reglaId}\\u0000${hallazgo.ruta}\\u0000${normalizada}`).digest(\"hex\");\n}\n\n/** Motivo por el que un hallazgo no vale, o `null` si vale. */\nexport function porQueNoVale(hallazgo: Partial<Hallazgo>): string | null {\n\tif (!hallazgo.reglaId) return \"sin reglaId: no se puede agrupar ni deduplicar\";\n\tif (!hallazgo.ruta) return \"sin ruta: no se puede anclar en el código\";\n\tif (!hallazgo.evidencia?.trim()) return \"sin evidencia: es una opinión, no un hallazgo\";\n\tif (typeof hallazgo.lineaInicio !== \"number\" || hallazgo.lineaInicio < 1) {\n\t\treturn \"sin línea de inicio válida: no se puede señalar dónde\";\n\t}\n\tif (hallazgo.lineaFin !== undefined && hallazgo.lineaFin < hallazgo.lineaInicio) {\n\t\treturn \"la línea final va antes que la inicial\";\n\t}\n\treturn null;\n}\n"]}
+{"version":3,"file":"hallazgo.js","sourceRoot":"","sources":["../../../src/core/revision/hallazgo.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;GAeG;AAEH,OAAO,EAAE,UAAU,EAAE,MAAM,aAAa,CAAC;AAsBzC,6EAA6E;AAC7E,MAAM,UAAU,GAA8B;IAC7C,OAAO,EAAE,GAAG;IACZ,IAAI,EAAE,GAAG;IACT,KAAK,EAAE,CAAC;IACR,IAAI,EAAE,CAAC;IACP,WAAW,EAAE,CAAC;CACd,CAAC;AAEF,MAAM,UAAU,YAAY,CAAC,SAAoB;IAChD,OAAO,UAAU,CAAC,SAAS,CAAC,CAAC;AAC9B,CAAC;AAED,+EAA+E;AAC/E,MAAM,UAAU,UAAU,CAAC,SAAoB;IAC9C,QAAQ,SAAS,EAAE,CAAC;QACnB,KAAK,SAAS,CAAC;QACf,KAAK,MAAM;YACV,OAAO,OAAO,CAAC;QAChB,KAAK,OAAO;YACX,OAAO,SAAS,CAAC;QAClB,KAAK,MAAM;YACV,OAAO,MAAM,CAAC;QACf;YACC,OAAO,MAAM,CAAC;IAChB,CAAC;AACF,CAAC;AAED;;;;;;;;;GASG;AACH,MAAM,UAAU,QAAQ,CAAC,QAA0D;IAClF,MAAM,WAAW,GAAG,QAAQ,CAAC,SAAS,CAAC,OAAO,CAAC,MAAM,EAAE,GAAG,CAAC,CAAC,IAAI,EAAE,CAAC;IACnE,OAAO,UAAU,CAAC,QAAQ,CAAC,CAAC,MAAM,CAAC,GAAG,QAAQ,CAAC,OAAO,SAAS,QAAQ,CAAC,IAAI,SAAS,WAAW,EAAE,CAAC,CAAC,MAAM,CAAC,KAAK,CAAC,CAAC;AACnH,CAAC;AAED,+DAA+D;AAC/D,MAAM,UAAU,YAAY,CAAC,QAA2B;IACvD,IAAI,CAAC,QAAQ,CAAC,OAAO;QAAE,OAAO,gDAAgD,CAAC;IAC/E,IAAI,CAAC,QAAQ,CAAC,IAAI;QAAE,OAAO,2CAA2C,CAAC;IACvE,IAAI,CAAC,QAAQ,CAAC,SAAS,EAAE,IAAI,EAAE;QAAE,OAAO,+CAA+C,CAAC;IACxF,IAAI,OAAO,QAAQ,CAAC,WAAW,KAAK,QAAQ,IAAI,QAAQ,CAAC,WAAW,GAAG,CAAC,EAAE,CAAC;QAC1E,OAAO,uDAAuD,CAAC;IAChE,CAAC;IACD,IAAI,QAAQ,CAAC,QAAQ,KAAK,SAAS,IAAI,QAAQ,CAAC,QAAQ,GAAG,QAAQ,CAAC,WAAW,EAAE,CAAC;QACjF,OAAO,wCAAwC,CAAC;IACjD,CAAC;IACD,OAAO,IAAI,CAAC;AACb,CAAC"}

package/dist/core/revision/procedencia.d.ts

@@ -0,0 +1,63 @@
+/**
+ * Procedencia del scan: qué herramienta, sobre qué commit y con qué reglas.
+ *
+ * Un SARIF sin procedencia es un informe sin firma: no se puede saber si el
+ * scan cubría el código que se está juzgando ni si las reglas eran las
+ * acordadas. El manifiesto lo fija en el momento del scan y se encadena por
+ * hash como el libro de sesión (src/core/audit/libro.ts): cada registro lleva
+ * el hash del anterior, así que editar un scan antiguo rompe TODA la cadena
+ * posterior — no hace falta saber cuál era para notarlo.
+ *
+ * `verificarProcedencia` recomputa la cadena entera. Sirve tanto para detectar
+ * manipulación deliberada como el accidente mundano: alguien arreglando a mano
+ * un JSON y dejándolo a medias.
+ */
+export interface RegistroProcedencia {
+    herramienta: string;
+    version: string;
+    /** Commit analizado (`git rev-parse HEAD` del repositorio escaneado). */
+    commit: string;
+    timestamp: string;
+    /** Pin del ruleset: hash estable del conjunto de reglas usado. */
+    pinReglas: string;
+    /** Hash de este registro encadenado con el anterior. */
+    hash: string;
+    prevHash: string | null;
+}
+export interface ManifiestoProcedencia {
+    version: 1;
+    scans: RegistroProcedencia[];
+}
+export type CargaProcedencia = Omit<RegistroProcedencia, "hash" | "prevHash">;
+export interface VeredictoProcedencia {
+    valido: boolean;
+    comprobados: number;
+    /** Índice (0-based) del primer registro que no cuadra. */
+    alteradoEn?: number;
+    /** Por qué no verifica, en una frase estable. */
+    motivo?: string;
+}
+/**
+ * Pin del ruleset. Ordenado y deduplicado a propósito: el mismo conjunto de
+ * reglas da el mismo pin se pase en el orden que se pase, porque dos ejecuciones
+ * que solo difieren en orden no deberían parecer scans distintos.
+ */
+export declare function pinDeReglas(reglas: readonly string[]): string;
+export declare function abrirManifiesto(): ManifiestoProcedencia;
+/**
+ * Registra un scan encadenándolo al último. Devuelve un manifiesto NUEVO: el
+ * manifiesto es inmutable por diseño, «añadir» es crear la cadena siguiente.
+ */
+export declare function registrarScan(manifiesto: ManifiestoProcedencia, carga: CargaProcedencia): ManifiestoProcedencia;
+/**
+ * Recomputa la cadena completa. Detecta los tres casos que importan: contenido
+ * retocado (el hash no recomputa), hash re-firmado tras retocar (el enlace con
+ * el siguiente rompe), y registro añadido o quitado del medio (idem).
+ */
+export declare function verificarProcedencia(manifiesto: ManifiestoProcedencia): VeredictoProcedencia;
+/**
+ * Commit actual del repositorio analizado. Lanza fuera de un repo git: quien
+ * llama decide si eso es fatal o si el scan venía de otro sitio.
+ */
+export declare function commitActual(raizRepo: string): string;
+//# sourceMappingURL=procedencia.d.ts.map

package/dist/core/revision/procedencia.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"procedencia.d.ts","sourceRoot":"","sources":["../../../src/core/revision/procedencia.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;GAaG;AAKH,MAAM,WAAW,mBAAmB;IACnC,WAAW,EAAE,MAAM,CAAC;IACpB,OAAO,EAAE,MAAM,CAAC;IAChB,yEAAyE;IACzE,MAAM,EAAE,MAAM,CAAC;IACf,SAAS,EAAE,MAAM,CAAC;IAClB,kEAAkE;IAClE,SAAS,EAAE,MAAM,CAAC;IAClB,wDAAwD;IACxD,IAAI,EAAE,MAAM,CAAC;IACb,QAAQ,EAAE,MAAM,GAAG,IAAI,CAAC;CACxB;AAED,MAAM,WAAW,qBAAqB;IACrC,OAAO,EAAE,CAAC,CAAC;IACX,KAAK,EAAE,mBAAmB,EAAE,CAAC;CAC7B;AAED,MAAM,MAAM,gBAAgB,GAAG,IAAI,CAAC,mBAAmB,EAAE,MAAM,GAAG,UAAU,CAAC,CAAC;AAE9E,MAAM,WAAW,oBAAoB;IACpC,MAAM,EAAE,OAAO,CAAC;IAChB,WAAW,EAAE,MAAM,CAAC;IACpB,0DAA0D;IAC1D,UAAU,CAAC,EAAE,MAAM,CAAC;IACpB,iDAAiD;IACjD,MAAM,CAAC,EAAE,MAAM,CAAC;CAChB;AAQD;;;;GAIG;AACH,wBAAgB,WAAW,CAAC,MAAM,EAAE,SAAS,MAAM,EAAE,GAAG,MAAM,CAG7D;AAED,wBAAgB,eAAe,IAAI,qBAAqB,CAEvD;AAED;;;GAGG;AACH,wBAAgB,aAAa,CAAC,UAAU,EAAE,qBAAqB,EAAE,KAAK,EAAE,gBAAgB,GAAG,qBAAqB,CAO/G;AAED;;;;GAIG;AACH,wBAAgB,oBAAoB,CAAC,UAAU,EAAE,qBAAqB,GAAG,oBAAoB,CAa5F;AAED;;;GAGG;AACH,wBAAgB,YAAY,CAAC,QAAQ,EAAE,MAAM,GAAG,MAAM,CAErD"}

package/dist/core/revision/procedencia.js

@@ -0,0 +1,72 @@
+/**
+ * Procedencia del scan: qué herramienta, sobre qué commit y con qué reglas.
+ *
+ * Un SARIF sin procedencia es un informe sin firma: no se puede saber si el
+ * scan cubría el código que se está juzgando ni si las reglas eran las
+ * acordadas. El manifiesto lo fija en el momento del scan y se encadena por
+ * hash como el libro de sesión (src/core/audit/libro.ts): cada registro lleva
+ * el hash del anterior, así que editar un scan antiguo rompe TODA la cadena
+ * posterior — no hace falta saber cuál era para notarlo.
+ *
+ * `verificarProcedencia` recomputa la cadena entera. Sirve tanto para detectar
+ * manipulación deliberada como el accidente mundano: alguien arreglando a mano
+ * un JSON y dejándolo a medias.
+ */
+import { execFileSync } from "node:child_process";
+import { createHash } from "node:crypto";
+function hashDe(prevHash, carga) {
+    return createHash("sha256")
+        .update(JSON.stringify({ prevHash, ...carga }))
+        .digest("hex");
+}
+/**
+ * Pin del ruleset. Ordenado y deduplicado a propósito: el mismo conjunto de
+ * reglas da el mismo pin se pase en el orden que se pase, porque dos ejecuciones
+ * que solo difieren en orden no deberían parecer scans distintos.
+ */
+export function pinDeReglas(reglas) {
+    const canonico = [...new Set(reglas)].sort().join("\u0000");
+    return createHash("sha256").update(canonico).digest("hex");
+}
+export function abrirManifiesto() {
+    return { version: 1, scans: [] };
+}
+/**
+ * Registra un scan encadenándolo al último. Devuelve un manifiesto NUEVO: el
+ * manifiesto es inmutable por diseño, «añadir» es crear la cadena siguiente.
+ */
+export function registrarScan(manifiesto, carga) {
+    const previo = manifiesto.scans.at(-1) ?? null;
+    const prevHash = previo ? previo.hash : null;
+    return {
+        version: 1,
+        scans: [...manifiesto.scans, { ...carga, prevHash, hash: hashDe(prevHash, carga) }],
+    };
+}
+/**
+ * Recomputa la cadena completa. Detecta los tres casos que importan: contenido
+ * retocado (el hash no recomputa), hash re-firmado tras retocar (el enlace con
+ * el siguiente rompe), y registro añadido o quitado del medio (idem).
+ */
+export function verificarProcedencia(manifiesto) {
+    for (let i = 0; i < manifiesto.scans.length; i++) {
+        const actual = manifiesto.scans[i];
+        const { hash: _hash, prevHash: _prevHash, ...carga } = actual;
+        const prevEsperado = i === 0 ? null : manifiesto.scans[i - 1].hash;
+        if (actual.prevHash !== prevEsperado) {
+            return { valido: false, comprobados: i, alteradoEn: i, motivo: "enlace roto con el registro anterior" };
+        }
+        if (hashDe(actual.prevHash, carga) !== actual.hash) {
+            return { valido: false, comprobados: i, alteradoEn: i, motivo: "el contenido no corresponde a su hash" };
+        }
+    }
+    return { valido: true, comprobados: manifiesto.scans.length };
+}
+/**
+ * Commit actual del repositorio analizado. Lanza fuera de un repo git: quien
+ * llama decide si eso es fatal o si el scan venía de otro sitio.
+ */
+export function commitActual(raizRepo) {
+    return execFileSync("git", ["rev-parse", "HEAD"], { cwd: raizRepo, encoding: "utf8" }).trim();
+}
+//# sourceMappingURL=procedencia.js.map

package/dist/core/revision/procedencia.js.map

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

package/dist/core/revision/publicar.d.ts

@@ -0,0 +1,26 @@
+/**
+ * Publicación firmada del SARIF.
+ *
+ * Un SARIF que viaja al panel de seguridad es una afirmación («este código, en
+ * este estado, tiene estos hallazgos»). Sin firma, cualquiera con acceso de
+ * escritura al fichero puede quitar un hallazgo crítico y nadie lo notaría.
+ * El sobre es HMAC-SHA256 sobre los bytes EXACTOS del documento: la firma va a
+ * un `.sig` aparte para que el documento siga siendo SARIF ingerible tal cual
+ * y la verificación sea sobre lo que hay en disco, no sobre una
+ * re-serialización que podría no coincidir byte a byte.
+ */
+export interface SarifFirmado {
+    /** El documento exacto que hay que escribir (y cuyo hash se firmó). */
+    documento: string;
+    /** Firma hex para el `<documento>.sig`. */
+    firma: string;
+}
+export declare function firmarDocumento(documento: string, clave: string): string;
+/**
+ * Serializa y firma de una vez. El `documento` devuelto es el que hay que
+ * escribir — re-serializar aparte rompe la garantía byte a byte.
+ */
+export declare function firmarSarif(sarif: unknown, clave: string): SarifFirmado;
+/** Verifica la firma sobre los bytes exactos del documento publicado. */
+export declare function verificarFirma(documento: string, firma: string, clave: string): boolean;
+//# sourceMappingURL=publicar.d.ts.map

package/dist/core/revision/publicar.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"publicar.d.ts","sourceRoot":"","sources":["../../../src/core/revision/publicar.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;GAUG;AAIH,MAAM,WAAW,YAAY;IAC5B,uEAAuE;IACvE,SAAS,EAAE,MAAM,CAAC;IAClB,2CAA2C;IAC3C,KAAK,EAAE,MAAM,CAAC;CACd;AAED,wBAAgB,eAAe,CAAC,SAAS,EAAE,MAAM,EAAE,KAAK,EAAE,MAAM,GAAG,MAAM,CAGxE;AAED;;;GAGG;AACH,wBAAgB,WAAW,CAAC,KAAK,EAAE,OAAO,EAAE,KAAK,EAAE,MAAM,GAAG,YAAY,CAGvE;AAED,yEAAyE;AACzE,wBAAgB,cAAc,CAAC,SAAS,EAAE,MAAM,EAAE,KAAK,EAAE,MAAM,EAAE,KAAK,EAAE,MAAM,GAAG,OAAO,CAKvF"}

package/dist/core/revision/publicar.js

@@ -0,0 +1,34 @@
+/**
+ * Publicación firmada del SARIF.
+ *
+ * Un SARIF que viaja al panel de seguridad es una afirmación («este código, en
+ * este estado, tiene estos hallazgos»). Sin firma, cualquiera con acceso de
+ * escritura al fichero puede quitar un hallazgo crítico y nadie lo notaría.
+ * El sobre es HMAC-SHA256 sobre los bytes EXACTOS del documento: la firma va a
+ * un `.sig` aparte para que el documento siga siendo SARIF ingerible tal cual
+ * y la verificación sea sobre lo que hay en disco, no sobre una
+ * re-serialización que podría no coincidir byte a byte.
+ */
+import { createHmac, timingSafeEqual } from "node:crypto";
+export function firmarDocumento(documento, clave) {
+    if (!clave)
+        throw new Error("firmar sin clave es decoración: la clave es obligatoria");
+    return createHmac("sha256", clave).update(documento, "utf8").digest("hex");
+}
+/**
+ * Serializa y firma de una vez. El `documento` devuelto es el que hay que
+ * escribir — re-serializar aparte rompe la garantía byte a byte.
+ */
+export function firmarSarif(sarif, clave) {
+    const documento = `${JSON.stringify(sarif, null, 2)}\n`;
+    return { documento, firma: firmarDocumento(documento, clave) };
+}
+/** Verifica la firma sobre los bytes exactos del documento publicado. */
+export function verificarFirma(documento, firma, clave) {
+    const esperada = firmarDocumento(documento, clave);
+    // Buffer.from("hex") trunca en silencio ante basura: validar forma antes.
+    if (!/^[0-9a-f]{64}$/.test(firma))
+        return false;
+    return timingSafeEqual(Buffer.from(firma, "hex"), Buffer.from(esperada, "hex"));
+}
+//# sourceMappingURL=publicar.js.map

package/dist/core/revision/publicar.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"publicar.js","sourceRoot":"","sources":["../../../src/core/revision/publicar.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;GAUG;AAEH,OAAO,EAAE,UAAU,EAAE,eAAe,EAAE,MAAM,aAAa,CAAC;AAS1D,MAAM,UAAU,eAAe,CAAC,SAAiB,EAAE,KAAa;IAC/D,IAAI,CAAC,KAAK;QAAE,MAAM,IAAI,KAAK,CAAC,yDAAyD,CAAC,CAAC;IACvF,OAAO,UAAU,CAAC,QAAQ,EAAE,KAAK,CAAC,CAAC,MAAM,CAAC,SAAS,EAAE,MAAM,CAAC,CAAC,MAAM,CAAC,KAAK,CAAC,CAAC;AAC5E,CAAC;AAED;;;GAGG;AACH,MAAM,UAAU,WAAW,CAAC,KAAc,EAAE,KAAa;IACxD,MAAM,SAAS,GAAG,GAAG,IAAI,CAAC,SAAS,CAAC,KAAK,EAAE,IAAI,EAAE,CAAC,CAAC,IAAI,CAAC;IACxD,OAAO,EAAE,SAAS,EAAE,KAAK,EAAE,eAAe,CAAC,SAAS,EAAE,KAAK,CAAC,EAAE,CAAC;AAChE,CAAC;AAED,yEAAyE;AACzE,MAAM,UAAU,cAAc,CAAC,SAAiB,EAAE,KAAa,EAAE,KAAa;IAC7E,MAAM,QAAQ,GAAG,eAAe,CAAC,SAAS,EAAE,KAAK,CAAC,CAAC;IACnD,0EAA0E;IAC1E,IAAI,CAAC,gBAAgB,CAAC,IAAI,CAAC,KAAK,CAAC;QAAE,OAAO,KAAK,CAAC;IAChD,OAAO,eAAe,CAAC,MAAM,CAAC,IAAI,CAAC,KAAK,EAAE,KAAK,CAAC,EAAE,MAAM,CAAC,IAAI,CAAC,QAAQ,EAAE,KAAK,CAAC,CAAC,CAAC;AACjF,CAAC"}

package/dist/core/revision/revisor.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"revisor.d.ts","sourceRoot":"","sources":["../../../src/core/revision/revisor.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;GAYG;AAEH,OAAO,EAAE,KAAK,QAAQ,EAAgC,MAAM,eAAe,CAAC;AAS5E;;;;;;GAMG;AACH,wBAAgB,cAAc,CAAC,IAAI,EAAE,MAAM,GAAG,MAAM,EAAE,CAKrD;AAED;;;;;GAKG;AACH,wBAAgB,WAAW,CAAC,SAAS,EAAE,MAAM,EAAE,IAAI,EAAE,MAAM,GAAG,OAAO,CAIpE;AAED,MAAM,WAAW,QAAQ;IACxB,QAAQ,EAAE,OAAO,CAAC,QAAQ,CAAC,CAAC;IAC5B,MAAM,EAAE,MAAM,CAAC;CACf;AAED,MAAM,WAAW,OAAO;IACvB,SAAS,EAAE,QAAQ,EAAE,CAAC;IACtB,WAAW,EAAE,QAAQ,EAAE,CAAC;CACxB;AAED;;;;;;GAMG;AACH,wBAAgB,MAAM,CAAC,UAAU,EAAE,KAAK,CAAC,OAAO,CAAC,QAAQ,CAAC,CAAC,EAAE,IAAI,EAAE,MAAM,GAAG,OAAO,CAoBlF;AAED;;;;;;;;;;;;;GAaG;AACH,MAAM,MAAM,UAAU,GAAG;IAAE,EAAE,EAAE,IAAI,CAAC;IAAC,UAAU,EAAE,KAAK,CAAC,OAAO,CAAC,QAAQ,CAAC,CAAC,CAAA;CAAE,GAAG;IAAE,EAAE,EAAE,KAAK,CAAC;IAAC,MAAM,EAAE,MAAM,CAAA;CAAE,CAAC;AAQ5G;;;;;;;;;;GAUG;AACH,wBAAgB,iBAAiB,CAAC,MAAM,EAAE,MAAM,GAAG,UAAU,CAiB5D;AAED,mCAAmC;AACnC,eAAO,MAAM,eAAe,QAsBhB,CAAC","sourcesContent":["/**\n * Revisión de un diff, con los hallazgos anclados al código.\n *\n * Lo que separa esto de «pídele al modelo que revise» es el ANCLAJE: un\n * hallazgo cuya evidencia no aparece en el diff se descarta, se cuente lo\n * convincente que se cuente. Un revisor que inventa una línea plausible es peor\n * que no tener revisor, porque cuesta tiempo comprobar que no existe y quema la\n * confianza del equipo en la herramienta entera.\n *\n * El anclaje también es lo que hace la puerta de esta fase comprobable: sobre un\n * diff limpio, un revisor honesto devuelve cero, y uno que inventa no puede\n * porque no hay dónde anclar.\n */\n\nimport { type Hallazgo, porQueNoVale, type Severidad } from \"./hallazgo.ts\";\n\nconst SEVERIDADES: Severidad[] = [\"critica\", \"alta\", \"media\", \"baja\", \"informativa\"];\n\n/** Espacios normalizados: un reformateo no debe romper el anclaje. */\nfunction normalizar(texto: string): string {\n\treturn texto.replace(/\\s+/g, \" \").trim();\n}\n\n/**\n * Las líneas AÑADIDAS de un diff unificado, sin el `+` inicial.\n *\n * Solo las añadidas: revisar lo que el diff borra es señalar un problema que la\n * propia edición ya resolvió, y ese ruido es de los que hacen que se deje de\n * leer la revisión.\n */\nexport function lineasAnadidas(diff: string): string[] {\n\treturn diff\n\t\t.split(\"\\n\")\n\t\t.filter((l) => l.startsWith(\"+\") && !l.startsWith(\"+++\"))\n\t\t.map((l) => l.slice(1));\n}\n\n/**\n * ¿La evidencia existe de verdad en lo que se ha añadido?\n *\n * Se compara sobre el texto normalizado y completo, y no línea a línea, porque\n * una evidencia legítima puede abarcar varias.\n */\nexport function estaAnclado(evidencia: string, diff: string): boolean {\n\tconst aguja = normalizar(evidencia);\n\tif (aguja.length < 3) return false;\n\treturn normalizar(lineasAnadidas(diff).join(\" \")).includes(aguja);\n}\n\nexport interface Descarte {\n\thallazgo: Partial<Hallazgo>;\n\tmotivo: string;\n}\n\nexport interface Cribado {\n\taceptados: Hallazgo[];\n\tdescartados: Descarte[];\n}\n\n/**\n * Deja pasar solo lo comprobable.\n *\n * Los descartes se devuelven, no se tiran: sin ellos no hay forma de saber si\n * el revisor está afinado o si está tirando la mitad de lo que encuentra, y esa\n * diferencia solo se ve con los números delante.\n */\nexport function cribar(candidatos: Array<Partial<Hallazgo>>, diff: string): Cribado {\n\tconst aceptados: Hallazgo[] = [];\n\tconst descartados: Descarte[] = [];\n\tfor (const c of candidatos) {\n\t\tconst problema = porQueNoVale(c);\n\t\tif (problema) {\n\t\t\tdescartados.push({ hallazgo: c, motivo: problema });\n\t\t\tcontinue;\n\t\t}\n\t\tif (!SEVERIDADES.includes(c.severidad as Severidad)) {\n\t\t\tdescartados.push({ hallazgo: c, motivo: `severidad desconocida: ${String(c.severidad)}` });\n\t\t\tcontinue;\n\t\t}\n\t\tif (!estaAnclado(c.evidencia as string, diff)) {\n\t\t\tdescartados.push({ hallazgo: c, motivo: \"la evidencia no aparece en el diff: no se puede comprobar\" });\n\t\t\tcontinue;\n\t\t}\n\t\taceptados.push(c as Hallazgo);\n\t}\n\treturn { aceptados, descartados };\n}\n\n/**\n * Resultado de leer la respuesta del modelo. Tres estados, no dos.\n *\n * `ok: false` es «NO HE PODIDO LEERLO», que no es lo mismo que «no hay\n * hallazgos». Antes las dos cosas volvían como `[]` y el comando imprimía «El\n * revisor no ha encontrado nada en este diff» con código 0 — la misma frase, el\n * mismo código de salida y los mismos bytes que un diff genuinamente limpio.\n * Medido ejecutando el comando: con el modelo contestando «No puedo ayudarte con\n * eso.» y con el modelo contestando `[]`, la salida era IDÉNTICA.\n *\n * Es el defecto que este repositorio persigue —un fallo que se lee como éxito—\n * y aquí era el peor de los casos: un certificado de limpieza sobre un diff que\n * nadie revisó.\n */\nexport type Extraccion = { ok: true; candidatos: Array<Partial<Hallazgo>> } | { ok: false; motivo: string };\n\n/** Un trozo de la respuesta, para que el motivo diga QUÉ llegó y no solo que no valía. */\nfunction recorte(texto: string): string {\n\tconst limpio = normalizar(texto);\n\treturn limpio.length > 160 ? `${limpio.slice(0, 160)}…` : limpio;\n}\n\n/**\n * Saca el JSON de la respuesta del modelo.\n *\n * Tolera que venga envuelto en un bloque de código o con texto alrededor,\n * porque eso pasa a menudo y fallar por ello convertiría una revisión buena en\n * un error. Lo que NO hace es inventarse la estructura: si no hay un array, eso\n * es un fallo de contrato y sale como fallo, no como «cero hallazgos».\n *\n * `[]` sigue siendo una respuesta válida y frecuente: es `ok: true` con la lista\n * vacía. La diferencia entre esa y la de abajo es justo lo que hay que conservar.\n */\nexport function extraerCandidatos(salida: string): Extraccion {\n\tconst cercado = salida.match(/```(?:json)?\\s*([\\s\\S]*?)```/);\n\tconst bruto = cercado ? cercado[1] : salida;\n\tconst inicio = bruto.indexOf(\"[\");\n\tconst fin = bruto.lastIndexOf(\"]\");\n\tif (inicio === -1 || fin <= inicio) {\n\t\treturn { ok: false, motivo: `la respuesta no traía ningún array JSON. Llegó esto: ${recorte(salida)}` };\n\t}\n\ttry {\n\t\t// El trozo empieza en `[` y acaba en `]`, así que si analiza es un array:\n\t\t// no hace falta una rama para «analizó pero no es array», que nunca se\n\t\t// dispararía.\n\t\treturn { ok: true, candidatos: JSON.parse(bruto.slice(inicio, fin + 1)) as Array<Partial<Hallazgo>> };\n\t} catch (error) {\n\t\tconst detalle = error instanceof Error ? error.message : String(error);\n\t\treturn { ok: false, motivo: `el array JSON venía roto (${detalle}). Llegó esto: ${recorte(salida)}` };\n\t}\n}\n\n/** Lo que se le pide al modelo. */\nexport const PROMPT_REVISION = [\n\t\"Eres un revisor de código. Revisas SOLO el diff que se te da.\",\n\t\"\",\n\t\"Devuelve un array JSON de hallazgos, y NADA más. Cada hallazgo:\",\n\t'  { \"reglaId\": \"ada/<categoria>\", \"titulo\": \"...\", \"resumen\": \"...\",',\n\t'    \"severidad\": \"critica|alta|media|baja|informativa\",',\n\t'    \"ruta\": \"<ruta del fichero>\", \"lineaInicio\": <n>, \"lineaFin\": <n>,',\n\t'    \"evidencia\": \"<el fragmento EXACTO del diff, copiado literalmente>\",',\n\t'    \"remedio\": \"<qué hacer>\" }',\n\t\"\",\n\t\"Reglas que no se negocian:\",\n\t\"- `evidencia` tiene que estar COPIADA LITERALMENTE de una línea añadida del\",\n\t\"  diff. Si no puedes copiarla, no tienes hallazgo: no lo inventes.\",\n\t\"- Revisa solo lo AÑADIDO. Señalar algo que el diff borra es ruido.\",\n\t\"- Si el diff está limpio, devuelve `[]`. Un array vacío es una respuesta\",\n\t\"  correcta y frecuente; rellenar con hallazgos menores para parecer útil es\",\n\t\"  la forma más rápida de que dejen de leer las revisiones.\",\n\t\"\",\n\t\"Qué buscar, por orden: fallos de corrección · fugas de seguridad o de\",\n\t\"secretos · errores que se tragan en silencio · cruces de frontera sin\",\n\t\"validar (dato externo que llega a una ruta de fichero, una consulta o un\",\n\t\"comando) · condiciones de carrera · recursos que no se cierran.\",\n].join(\"\\n\");\n"]}
+{"version":3,"file":"revisor.d.ts","sourceRoot":"","sources":["../../../src/core/revision/revisor.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;GAYG;AAEH,OAAO,EAAE,KAAK,QAAQ,EAAgC,MAAM,eAAe,CAAC;AAS5E;;;;;;GAMG;AACH,wBAAgB,cAAc,CAAC,IAAI,EAAE,MAAM,GAAG,MAAM,EAAE,CAKrD;AAED;;;;;GAKG;AACH,wBAAgB,WAAW,CAAC,SAAS,EAAE,MAAM,EAAE,IAAI,EAAE,MAAM,GAAG,OAAO,CAIpE;AAED,MAAM,WAAW,QAAQ;IACxB,QAAQ,EAAE,OAAO,CAAC,QAAQ,CAAC,CAAC;IAC5B,MAAM,EAAE,MAAM,CAAC;CACf;AAED,MAAM,WAAW,OAAO;IACvB,SAAS,EAAE,QAAQ,EAAE,CAAC;IACtB,WAAW,EAAE,QAAQ,EAAE,CAAC;CACxB;AAED;;;;;;GAMG;AACH,wBAAgB,MAAM,CAAC,UAAU,EAAE,KAAK,CAAC,OAAO,CAAC,QAAQ,CAAC,CAAC,EAAE,IAAI,EAAE,MAAM,GAAG,OAAO,CAoBlF;AAED;;;;;;;;;;;;;GAaG;AACH,MAAM,MAAM,UAAU,GAAG;IAAE,EAAE,EAAE,IAAI,CAAC;IAAC,UAAU,EAAE,KAAK,CAAC,OAAO,CAAC,QAAQ,CAAC,CAAC,CAAA;CAAE,GAAG;IAAE,EAAE,EAAE,KAAK,CAAC;IAAC,MAAM,EAAE,MAAM,CAAA;CAAE,CAAC;AAQ5G;;;;;;;;;;GAUG;AACH,wBAAgB,iBAAiB,CAAC,MAAM,EAAE,MAAM,GAAG,UAAU,CAiB5D;AAED,mCAAmC;AACnC,eAAO,MAAM,eAAe,QAsBhB,CAAC"}

package/dist/core/revision/revisor.js.map

@@ -1 +1 @@
-{"version":3,"file":"revisor.js","sourceRoot":"","sources":["../../../src/core/revision/revisor.ts"],"names":[],"mappings":"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","sourcesContent":["/**\n * Revisión de un diff, con los hallazgos anclados al código.\n *\n * Lo que separa esto de «pídele al modelo que revise» es el ANCLAJE: un\n * hallazgo cuya evidencia no aparece en el diff se descarta, se cuente lo\n * convincente que se cuente. Un revisor que inventa una línea plausible es peor\n * que no tener revisor, porque cuesta tiempo comprobar que no existe y quema la\n * confianza del equipo en la herramienta entera.\n *\n * El anclaje también es lo que hace la puerta de esta fase comprobable: sobre un\n * diff limpio, un revisor honesto devuelve cero, y uno que inventa no puede\n * porque no hay dónde anclar.\n */\n\nimport { type Hallazgo, porQueNoVale, type Severidad } from \"./hallazgo.ts\";\n\nconst SEVERIDADES: Severidad[] = [\"critica\", \"alta\", \"media\", \"baja\", \"informativa\"];\n\n/** Espacios normalizados: un reformateo no debe romper el anclaje. */\nfunction normalizar(texto: string): string {\n\treturn texto.replace(/\\s+/g, \" \").trim();\n}\n\n/**\n * Las líneas AÑADIDAS de un diff unificado, sin el `+` inicial.\n *\n * Solo las añadidas: revisar lo que el diff borra es señalar un problema que la\n * propia edición ya resolvió, y ese ruido es de los que hacen que se deje de\n * leer la revisión.\n */\nexport function lineasAnadidas(diff: string): string[] {\n\treturn diff\n\t\t.split(\"\\n\")\n\t\t.filter((l) => l.startsWith(\"+\") && !l.startsWith(\"+++\"))\n\t\t.map((l) => l.slice(1));\n}\n\n/**\n * ¿La evidencia existe de verdad en lo que se ha añadido?\n *\n * Se compara sobre el texto normalizado y completo, y no línea a línea, porque\n * una evidencia legítima puede abarcar varias.\n */\nexport function estaAnclado(evidencia: string, diff: string): boolean {\n\tconst aguja = normalizar(evidencia);\n\tif (aguja.length < 3) return false;\n\treturn normalizar(lineasAnadidas(diff).join(\" \")).includes(aguja);\n}\n\nexport interface Descarte {\n\thallazgo: Partial<Hallazgo>;\n\tmotivo: string;\n}\n\nexport interface Cribado {\n\taceptados: Hallazgo[];\n\tdescartados: Descarte[];\n}\n\n/**\n * Deja pasar solo lo comprobable.\n *\n * Los descartes se devuelven, no se tiran: sin ellos no hay forma de saber si\n * el revisor está afinado o si está tirando la mitad de lo que encuentra, y esa\n * diferencia solo se ve con los números delante.\n */\nexport function cribar(candidatos: Array<Partial<Hallazgo>>, diff: string): Cribado {\n\tconst aceptados: Hallazgo[] = [];\n\tconst descartados: Descarte[] = [];\n\tfor (const c of candidatos) {\n\t\tconst problema = porQueNoVale(c);\n\t\tif (problema) {\n\t\t\tdescartados.push({ hallazgo: c, motivo: problema });\n\t\t\tcontinue;\n\t\t}\n\t\tif (!SEVERIDADES.includes(c.severidad as Severidad)) {\n\t\t\tdescartados.push({ hallazgo: c, motivo: `severidad desconocida: ${String(c.severidad)}` });\n\t\t\tcontinue;\n\t\t}\n\t\tif (!estaAnclado(c.evidencia as string, diff)) {\n\t\t\tdescartados.push({ hallazgo: c, motivo: \"la evidencia no aparece en el diff: no se puede comprobar\" });\n\t\t\tcontinue;\n\t\t}\n\t\taceptados.push(c as Hallazgo);\n\t}\n\treturn { aceptados, descartados };\n}\n\n/**\n * Resultado de leer la respuesta del modelo. Tres estados, no dos.\n *\n * `ok: false` es «NO HE PODIDO LEERLO», que no es lo mismo que «no hay\n * hallazgos». Antes las dos cosas volvían como `[]` y el comando imprimía «El\n * revisor no ha encontrado nada en este diff» con código 0 — la misma frase, el\n * mismo código de salida y los mismos bytes que un diff genuinamente limpio.\n * Medido ejecutando el comando: con el modelo contestando «No puedo ayudarte con\n * eso.» y con el modelo contestando `[]`, la salida era IDÉNTICA.\n *\n * Es el defecto que este repositorio persigue —un fallo que se lee como éxito—\n * y aquí era el peor de los casos: un certificado de limpieza sobre un diff que\n * nadie revisó.\n */\nexport type Extraccion = { ok: true; candidatos: Array<Partial<Hallazgo>> } | { ok: false; motivo: string };\n\n/** Un trozo de la respuesta, para que el motivo diga QUÉ llegó y no solo que no valía. */\nfunction recorte(texto: string): string {\n\tconst limpio = normalizar(texto);\n\treturn limpio.length > 160 ? `${limpio.slice(0, 160)}…` : limpio;\n}\n\n/**\n * Saca el JSON de la respuesta del modelo.\n *\n * Tolera que venga envuelto en un bloque de código o con texto alrededor,\n * porque eso pasa a menudo y fallar por ello convertiría una revisión buena en\n * un error. Lo que NO hace es inventarse la estructura: si no hay un array, eso\n * es un fallo de contrato y sale como fallo, no como «cero hallazgos».\n *\n * `[]` sigue siendo una respuesta válida y frecuente: es `ok: true` con la lista\n * vacía. La diferencia entre esa y la de abajo es justo lo que hay que conservar.\n */\nexport function extraerCandidatos(salida: string): Extraccion {\n\tconst cercado = salida.match(/```(?:json)?\\s*([\\s\\S]*?)```/);\n\tconst bruto = cercado ? cercado[1] : salida;\n\tconst inicio = bruto.indexOf(\"[\");\n\tconst fin = bruto.lastIndexOf(\"]\");\n\tif (inicio === -1 || fin <= inicio) {\n\t\treturn { ok: false, motivo: `la respuesta no traía ningún array JSON. Llegó esto: ${recorte(salida)}` };\n\t}\n\ttry {\n\t\t// El trozo empieza en `[` y acaba en `]`, así que si analiza es un array:\n\t\t// no hace falta una rama para «analizó pero no es array», que nunca se\n\t\t// dispararía.\n\t\treturn { ok: true, candidatos: JSON.parse(bruto.slice(inicio, fin + 1)) as Array<Partial<Hallazgo>> };\n\t} catch (error) {\n\t\tconst detalle = error instanceof Error ? error.message : String(error);\n\t\treturn { ok: false, motivo: `el array JSON venía roto (${detalle}). Llegó esto: ${recorte(salida)}` };\n\t}\n}\n\n/** Lo que se le pide al modelo. */\nexport const PROMPT_REVISION = [\n\t\"Eres un revisor de código. Revisas SOLO el diff que se te da.\",\n\t\"\",\n\t\"Devuelve un array JSON de hallazgos, y NADA más. Cada hallazgo:\",\n\t'  { \"reglaId\": \"ada/<categoria>\", \"titulo\": \"...\", \"resumen\": \"...\",',\n\t'    \"severidad\": \"critica|alta|media|baja|informativa\",',\n\t'    \"ruta\": \"<ruta del fichero>\", \"lineaInicio\": <n>, \"lineaFin\": <n>,',\n\t'    \"evidencia\": \"<el fragmento EXACTO del diff, copiado literalmente>\",',\n\t'    \"remedio\": \"<qué hacer>\" }',\n\t\"\",\n\t\"Reglas que no se negocian:\",\n\t\"- `evidencia` tiene que estar COPIADA LITERALMENTE de una línea añadida del\",\n\t\"  diff. Si no puedes copiarla, no tienes hallazgo: no lo inventes.\",\n\t\"- Revisa solo lo AÑADIDO. Señalar algo que el diff borra es ruido.\",\n\t\"- Si el diff está limpio, devuelve `[]`. Un array vacío es una respuesta\",\n\t\"  correcta y frecuente; rellenar con hallazgos menores para parecer útil es\",\n\t\"  la forma más rápida de que dejen de leer las revisiones.\",\n\t\"\",\n\t\"Qué buscar, por orden: fallos de corrección · fugas de seguridad o de\",\n\t\"secretos · errores que se tragan en silencio · cruces de frontera sin\",\n\t\"validar (dato externo que llega a una ruta de fichero, una consulta o un\",\n\t\"comando) · condiciones de carrera · recursos que no se cierran.\",\n].join(\"\\n\");\n"]}
+{"version":3,"file":"revisor.js","sourceRoot":"","sources":["../../../src/core/revision/revisor.ts"],"names":[],"mappings":"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"}

package/dist/core/revision/sarif.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"sarif.d.ts","sourceRoot":"","sources":["../../../src/core/revision/sarif.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;GAmBG;AAGH,OAAO,EAAE,KAAK,QAAQ,EAAsC,MAAM,eAAe,CAAC;AAElF,MAAM,WAAW,aAAa;IAC7B,wDAAuD;IACvD,QAAQ,EAAE,MAAM,CAAC;IACjB,WAAW,CAAC,EAAE,MAAM,CAAC;IACrB,OAAO,CAAC,EAAE,MAAM,CAAC;IACjB,cAAc,CAAC,EAAE,MAAM,CAAC;CACxB;AAED,wBAAgB,MAAM,CAAC,SAAS,EAAE,QAAQ,EAAE,EAAE,QAAQ,EAAE,aAAa,GAAG,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CA0D9F","sourcesContent":["/**\n * Exportación a SARIF 2.1.0.\n *\n * SARIF es el formato que ingieren GitHub Code Scanning y Azure DevOps. Sin él,\n * los hallazgos de una revisión se quedan en la terminal de quien la lanzó: no\n * entran en el proceso de seguridad de la empresa, no aparecen en la pestaña de\n * la pull request y no cuentan para una homologación. Es un requisito de\n * compra, no una mejora.\n *\n * oh-my-pi lo tiene solo para su escáner de seguridad. Aquí vale para CUALQUIER\n * revisión, que es la diferencia entre «tenemos un escáner que exporta» y\n * «nuestro agente habla el idioma de tu proceso».\n *\n * Dos cosas que hacen que GitHub lo acepte y que se pierden fácil:\n *\n * - **Toda regla citada en `results` tiene que estar en `driver.rules`.** Si\n *   falta, el resultado se ingiere sin descripción ni severidad, o se rechaza.\n * - **`originalUriBaseIds` con la raíz del repositorio**, para que las rutas\n *   relativas se resuelvan contra el árbol y no contra la máquina que lo generó.\n */\n\nimport { pathToFileURL } from \"node:url\";\nimport { type Hallazgo, huellaDe, nivelSarif, puntuacionDe } from \"./hallazgo.ts\";\n\nexport interface OpcionesSarif {\n\t/** Raíz del repositorio, para `originalUriBaseIds`. */\n\traizRepo: string;\n\therramienta?: string;\n\tversion?: string;\n\turiInformacion?: string;\n}\n\nexport function aSarif(hallazgos: Hallazgo[], opciones: OpcionesSarif): Record<string, unknown> {\n\t// Una regla por `reglaId`, con la descripción del primer hallazgo que la usa.\n\tconst reglas = new Map<string, Hallazgo>();\n\tfor (const h of hallazgos) if (!reglas.has(h.reglaId)) reglas.set(h.reglaId, h);\n\n\treturn {\n\t\t$schema: \"https://json.schemastore.org/sarif-2.1.0.json\",\n\t\tversion: \"2.1.0\",\n\t\truns: [\n\t\t\t{\n\t\t\t\ttool: {\n\t\t\t\t\tdriver: {\n\t\t\t\t\t\tname: opciones.herramienta ?? \"Ada\",\n\t\t\t\t\t\tversion: opciones.version ?? \"0.0.0\",\n\t\t\t\t\t\tinformationUri: opciones.uriInformacion ?? \"https://hoilab.com/ada\",\n\t\t\t\t\t\trules: [...reglas.values()].map((h) => ({\n\t\t\t\t\t\t\tid: h.reglaId,\n\t\t\t\t\t\t\tname: h.reglaId,\n\t\t\t\t\t\t\tshortDescription: { text: h.titulo },\n\t\t\t\t\t\t\tfullDescription: { text: h.resumen },\n\t\t\t\t\t\t\t...(h.remedio ? { help: { text: h.remedio } } : {}),\n\t\t\t\t\t\t\tproperties: {\n\t\t\t\t\t\t\t\ttags: h.etiquetas ?? [],\n\t\t\t\t\t\t\t\t\"security-severity\": String(puntuacionDe(h.severidad)),\n\t\t\t\t\t\t\t},\n\t\t\t\t\t\t})),\n\t\t\t\t\t},\n\t\t\t\t},\n\t\t\t\tresults: hallazgos.map((h) => ({\n\t\t\t\t\truleId: h.reglaId,\n\t\t\t\t\tlevel: nivelSarif(h.severidad),\n\t\t\t\t\tmessage: { text: h.resumen },\n\t\t\t\t\tlocations: [\n\t\t\t\t\t\t{\n\t\t\t\t\t\t\tphysicalLocation: {\n\t\t\t\t\t\t\t\tartifactLocation: { uri: h.ruta, uriBaseId: \"%SRCROOT%\" },\n\t\t\t\t\t\t\t\tregion: {\n\t\t\t\t\t\t\t\t\tstartLine: h.lineaInicio,\n\t\t\t\t\t\t\t\t\tendLine: h.lineaFin ?? h.lineaInicio,\n\t\t\t\t\t\t\t\t\t// La evidencia viaja como fragmento de la región: es lo\n\t\t\t\t\t\t\t\t\t// que hace que el hallazgo sea comprobable desde el panel\n\t\t\t\t\t\t\t\t\t// sin abrir el repositorio.\n\t\t\t\t\t\t\t\t\tsnippet: { text: h.evidencia },\n\t\t\t\t\t\t\t\t},\n\t\t\t\t\t\t\t},\n\t\t\t\t\t\t},\n\t\t\t\t\t],\n\t\t\t\t\t// Lo que permite a GitHub reconocer el mismo hallazgo entre\n\t\t\t\t\t// ejecuciones aunque el fichero se haya movido.\n\t\t\t\t\tpartialFingerprints: { \"ada/v1\": huellaDe(h) },\n\t\t\t\t\tproperties: { severidad: h.severidad, \"security-severity\": String(puntuacionDe(h.severidad)) },\n\t\t\t\t})),\n\t\t\t\toriginalUriBaseIds: {\n\t\t\t\t\t\"%SRCROOT%\": { uri: pathToFileURL(opciones.raizRepo).href.replace(/\\/?$/, \"/\") },\n\t\t\t\t},\n\t\t\t},\n\t\t],\n\t};\n}\n"]}
+{"version":3,"file":"sarif.d.ts","sourceRoot":"","sources":["../../../src/core/revision/sarif.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;GAmBG;AAGH,OAAO,EAAE,KAAK,QAAQ,EAAsC,MAAM,eAAe,CAAC;AAElF,MAAM,WAAW,aAAa;IAC7B,uDAAuD;IACvD,QAAQ,EAAE,MAAM,CAAC;IACjB,WAAW,CAAC,EAAE,MAAM,CAAC;IACrB,OAAO,CAAC,EAAE,MAAM,CAAC;IACjB,cAAc,CAAC,EAAE,MAAM,CAAC;CACxB;AAED,wBAAgB,MAAM,CAAC,SAAS,EAAE,QAAQ,EAAE,EAAE,QAAQ,EAAE,aAAa,GAAG,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CA0D9F"}

package/dist/core/revision/sarif.js.map

@@ -1 +1 @@
-{"version":3,"file":"sarif.js","sourceRoot":"","sources":["../../../src/core/revision/sarif.ts"],"names":[],"mappings":"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","sourcesContent":["/**\n * Exportación a SARIF 2.1.0.\n *\n * SARIF es el formato que ingieren GitHub Code Scanning y Azure DevOps. Sin él,\n * los hallazgos de una revisión se quedan en la terminal de quien la lanzó: no\n * entran en el proceso de seguridad de la empresa, no aparecen en la pestaña de\n * la pull request y no cuentan para una homologación. Es un requisito de\n * compra, no una mejora.\n *\n * oh-my-pi lo tiene solo para su escáner de seguridad. Aquí vale para CUALQUIER\n * revisión, que es la diferencia entre «tenemos un escáner que exporta» y\n * «nuestro agente habla el idioma de tu proceso».\n *\n * Dos cosas que hacen que GitHub lo acepte y que se pierden fácil:\n *\n * - **Toda regla citada en `results` tiene que estar en `driver.rules`.** Si\n *   falta, el resultado se ingiere sin descripción ni severidad, o se rechaza.\n * - **`originalUriBaseIds` con la raíz del repositorio**, para que las rutas\n *   relativas se resuelvan contra el árbol y no contra la máquina que lo generó.\n */\n\nimport { pathToFileURL } from \"node:url\";\nimport { type Hallazgo, huellaDe, nivelSarif, puntuacionDe } from \"./hallazgo.ts\";\n\nexport interface OpcionesSarif {\n\t/** Raíz del repositorio, para `originalUriBaseIds`. */\n\traizRepo: string;\n\therramienta?: string;\n\tversion?: string;\n\turiInformacion?: string;\n}\n\nexport function aSarif(hallazgos: Hallazgo[], opciones: OpcionesSarif): Record<string, unknown> {\n\t// Una regla por `reglaId`, con la descripción del primer hallazgo que la usa.\n\tconst reglas = new Map<string, Hallazgo>();\n\tfor (const h of hallazgos) if (!reglas.has(h.reglaId)) reglas.set(h.reglaId, h);\n\n\treturn {\n\t\t$schema: \"https://json.schemastore.org/sarif-2.1.0.json\",\n\t\tversion: \"2.1.0\",\n\t\truns: [\n\t\t\t{\n\t\t\t\ttool: {\n\t\t\t\t\tdriver: {\n\t\t\t\t\t\tname: opciones.herramienta ?? \"Ada\",\n\t\t\t\t\t\tversion: opciones.version ?? \"0.0.0\",\n\t\t\t\t\t\tinformationUri: opciones.uriInformacion ?? \"https://hoilab.com/ada\",\n\t\t\t\t\t\trules: [...reglas.values()].map((h) => ({\n\t\t\t\t\t\t\tid: h.reglaId,\n\t\t\t\t\t\t\tname: h.reglaId,\n\t\t\t\t\t\t\tshortDescription: { text: h.titulo },\n\t\t\t\t\t\t\tfullDescription: { text: h.resumen },\n\t\t\t\t\t\t\t...(h.remedio ? { help: { text: h.remedio } } : {}),\n\t\t\t\t\t\t\tproperties: {\n\t\t\t\t\t\t\t\ttags: h.etiquetas ?? [],\n\t\t\t\t\t\t\t\t\"security-severity\": String(puntuacionDe(h.severidad)),\n\t\t\t\t\t\t\t},\n\t\t\t\t\t\t})),\n\t\t\t\t\t},\n\t\t\t\t},\n\t\t\t\tresults: hallazgos.map((h) => ({\n\t\t\t\t\truleId: h.reglaId,\n\t\t\t\t\tlevel: nivelSarif(h.severidad),\n\t\t\t\t\tmessage: { text: h.resumen },\n\t\t\t\t\tlocations: [\n\t\t\t\t\t\t{\n\t\t\t\t\t\t\tphysicalLocation: {\n\t\t\t\t\t\t\t\tartifactLocation: { uri: h.ruta, uriBaseId: \"%SRCROOT%\" },\n\t\t\t\t\t\t\t\tregion: {\n\t\t\t\t\t\t\t\t\tstartLine: h.lineaInicio,\n\t\t\t\t\t\t\t\t\tendLine: h.lineaFin ?? h.lineaInicio,\n\t\t\t\t\t\t\t\t\t// La evidencia viaja como fragmento de la región: es lo\n\t\t\t\t\t\t\t\t\t// que hace que el hallazgo sea comprobable desde el panel\n\t\t\t\t\t\t\t\t\t// sin abrir el repositorio.\n\t\t\t\t\t\t\t\t\tsnippet: { text: h.evidencia },\n\t\t\t\t\t\t\t\t},\n\t\t\t\t\t\t\t},\n\t\t\t\t\t\t},\n\t\t\t\t\t],\n\t\t\t\t\t// Lo que permite a GitHub reconocer el mismo hallazgo entre\n\t\t\t\t\t// ejecuciones aunque el fichero se haya movido.\n\t\t\t\t\tpartialFingerprints: { \"ada/v1\": huellaDe(h) },\n\t\t\t\t\tproperties: { severidad: h.severidad, \"security-severity\": String(puntuacionDe(h.severidad)) },\n\t\t\t\t})),\n\t\t\t\toriginalUriBaseIds: {\n\t\t\t\t\t\"%SRCROOT%\": { uri: pathToFileURL(opciones.raizRepo).href.replace(/\\/?$/, \"/\") },\n\t\t\t\t},\n\t\t\t},\n\t\t],\n\t};\n}\n"]}
+{"version":3,"file":"sarif.js","sourceRoot":"","sources":["../../../src/core/revision/sarif.ts"],"names":[],"mappings":"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"}

package/dist/core/router-uris/index.d.ts

@@ -0,0 +1,12 @@
+/**
+ * Alias para el router de URIs internas.
+ *
+ * El contrato de SYS-01 permite `src/core/rutas/*` o `src/core/router-uris/*`.
+ * Para no obligar al revisor a adivinar la carpeta elegida, este índice
+ * re-exporta el router canónico de `core/rutas/`. Es 0 hunks en ambos
+ * ficheros porque ninguno existe en upstream.
+ */
+export * from "../rutas/envoltorio.ts";
+export * from "../rutas/index.ts";
+export * from "../rutas/router.ts";
+//# sourceMappingURL=index.d.ts.map

package/dist/core/router-uris/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../src/core/router-uris/index.ts"],"names":[],"mappings":"AAAA;;;;;;;GAOG;AAEH,cAAc,wBAAwB,CAAC;AACvC,cAAc,mBAAmB,CAAC;AAClC,cAAc,oBAAoB,CAAC"}

package/dist/core/router-uris/index.js

@@ -0,0 +1,12 @@
+/**
+ * Alias para el router de URIs internas.
+ *
+ * El contrato de SYS-01 permite `src/core/rutas/*` o `src/core/router-uris/*`.
+ * Para no obligar al revisor a adivinar la carpeta elegida, este índice
+ * re-exporta el router canónico de `core/rutas/`. Es 0 hunks en ambos
+ * ficheros porque ninguno existe en upstream.
+ */
+export * from "../rutas/envoltorio.js";
+export * from "../rutas/index.js";
+export * from "../rutas/router.js";
+//# sourceMappingURL=index.js.map