pull-request-split-advisor 3.1.2

package/dist/core/file-stats.js

@@ -0,0 +1,341 @@
+/**
+ * file-stats.ts — Recolección y enriquecimiento de estadísticas de archivos.
+ *
+ * Expone dos funciones públicas que forman los primeros dos pasos del pipeline de análisis:
+ *
+ * 1. **`gatherChangedFiles`**: obtiene la lista de archivos con cambios
+ *    (tracked modificados + untracked) filtrando lockfiles, binarios y
+ *    carpetas de build. Cuando se pasa `baseBranch` usa `git diff <base>`
+ *    en lugar del diff del working tree.
+ *
+ * 2. **`getFileStats`**: para cada archivo de la lista calcula líneas,
+ *    adiciones, eliminaciones, tipo de cambio y prioridad arquitectónica.
+ *    Usa `git diff --numstat` y `git diff --name-status` para minimizar
+ *    el número de subprocesos.
+ *
+ * ### Prioridades arquitectónicas
+ * Los archivos se clasifican en 5 niveles para que `distributeBlocks` y
+ * `buildCommitPlan` procesen primero los cambios de mayor impacto:
+ * - 1: config / types / schemas / migrations
+ * - 2: servicios / core / dominio (fallback general)
+ * - 3: infra / adapters / rutas
+ * - 4: tests
+ * - 5: docs
+ */
+import { existsSync, readFileSync } from "node:fs";
+import { basename } from "node:path";
+import { isBinaryFileSync } from "isbinaryfile";
+import { shSafe, q } from "../git/git.js";
+import { normalizePathValue, isTrackedFile } from "../shared/utils.js";
+// ---------------------------------------------------------------------------
+// Detección de archivos binarios (por contenido, no por extensión)
+// ---------------------------------------------------------------------------
+/**
+ * Detecta si un archivo es binario leyendo sus primeros bytes con `isbinaryfile`.
+ *
+ * Usar detección por contenido (no por extensión) captura archivos como `.wasm`,
+ * imágenes renombradas, o cualquier archivo sin extensión que sea binario.
+ * Devuelve `false` si el archivo no existe (puede haber sido eliminado).
+ */
+function isBinary(file) {
+    if (!existsSync(file))
+        return false;
+    try {
+        return isBinaryFileSync(file);
+    }
+    catch {
+        return false;
+    }
+}
+// ---------------------------------------------------------------------------
+// Exclusión de archivos del análisis
+// ---------------------------------------------------------------------------
+/**
+ * Determina si un archivo debe excluirse del análisis.
+ *
+ * Se excluyen archivos que:
+ * - Están en carpetas de dependencias / artefactos de build:
+ *   `node_modules/`, `dist/`, `build/`, `coverage/`, `.next/`, `target/`, `vendor/`
+ * - Son lockfiles (cuando `config.excludeLockfiles` es `true`):
+ *   `package-lock.json`, `yarn.lock`, `pnpm-lock.yaml`, `poetry.lock`, `pipfile.lock`
+ * - Son archivos generados por la propia herramienta (JSON / HTML de salida),
+ *   incluyendo los configurados en `runtimeExcludedFiles`.
+ * - Coinciden con patrones genéricos de reportes: `pr-split-*`, `reporte*`, `plan*`.
+ *
+ * @param path   - Ruta relativa del archivo a evaluar.
+ * @param config - Configuración activa con `excludeLockfiles`, `jsonOutputFile`, etc.
+ */
+function shouldExcludeFile(path, config) {
+    const normalizedPath = normalizePathValue(path);
+    const fileName = basename(normalizedPath).toLowerCase();
+    const excludedPrefixes = [
+        "node_modules/",
+        "dist/",
+        "build/",
+        "coverage/",
+        ".next/",
+        "target/",
+        "vendor/"
+    ];
+    if (excludedPrefixes.some((p) => normalizedPath.startsWith(p)))
+        return true;
+    if (config.excludeLockfiles) {
+        const lockfiles = [
+            "package-lock.json",
+            "yarn.lock",
+            "pnpm-lock.yaml",
+            "poetry.lock",
+            "pipfile.lock"
+        ];
+        if (lockfiles.includes(fileName))
+            return true;
+    }
+    // Comparar por ruta completa normalizada (no solo basename) para evitar
+    // excluir archivos legítimos que compartan nombre con archivos generados.
+    // jsonOutputFile ya está incluido en runtimeExcludedFiles (vía cli.ts).
+    // Ambas partes se normalizan a minúsculas para que la comparación sea
+    // insensible a mayúsculas en sistemas con filesystem case-sensitive (Linux).
+    const configuredGeneratedFiles = (config.runtimeExcludedFiles ?? [])
+        .filter(Boolean)
+        .map((value) => normalizePathValue(value).toLowerCase());
+    if (configuredGeneratedFiles.includes(normalizedPath.toLowerCase()))
+        return true;
+    // Patrones de archivos generados comunes (independiente de la config)
+    const generatedPatterns = [
+        /^pr-split-.*\.(json|html)$/i,
+        /^reporte.*\.(json|html)$/i,
+        /^report.*\.(json|html)$/i,
+        /^plan.*\.(json|html)$/i
+    ];
+    if (generatedPatterns.some((pattern) => pattern.test(fileName)))
+        return true;
+    return false;
+}
+// ---------------------------------------------------------------------------
+// Gather
+// ---------------------------------------------------------------------------
+/**
+ * Devuelve la lista de archivos con cambios no commiteados en el working tree.
+ *
+ * Combina `git diff --name-only` (tracked) con
+ * `git ls-files --others --exclude-standard` (untracked), elimina duplicados,
+ * excluye archivos de sistema (lockfiles, binaries, carpetas de build) y
+ * los archivos generados por la propia herramienta.
+ *
+ * @param config     - Configuración activa del proyecto.
+ * @param baseBranch - Rama base opcional. Si se proporciona, usa `git diff <baseBranch>` para
+ *                     capturar todos los cambios del PR respecto a la rama base en lugar
+ *                     de comparar solo cambios no staged del working tree.
+ * @returns          Lista de rutas relativas ordenadas alfabéticamente.
+ */
+export function gatherChangedFiles(config, baseBranch) {
+    // Archivos que difieren entre el working tree y la rama base.
+    // `git diff <branch>` compara el working tree contra <branch>, NO HEAD contra <branch>:
+    // captura tanto los cambios sin commitear como los commits propios de la rama.
+    // Consecuencia esperada: archivos ya commiteados en la rama aparecen en el análisis
+    // (la advertencia de aheadCount en cli.ts informa al usuario de este comportamiento).
+    const vsBase = baseBranch
+        ? shSafe(`git diff ${q(baseBranch)} --name-only`)
+            .split("\n")
+            .map((s) => s.trim())
+            .filter(Boolean)
+        : [];
+    // Archivos tracked modificados en el working tree (aún no commiteados).
+    const workingTree = shSafe("git diff --name-only")
+        .split("\n")
+        .map((s) => s.trim())
+        .filter(Boolean);
+    // Archivos nuevos sin seguimiento git (untracked): creados pero nunca añadidos al índice.
+    // Se incluyen siempre porque forman parte del trabajo pendiente del developer,
+    // independientemente de si se usa --base o no.
+    const untracked = shSafe("git ls-files --others --exclude-standard")
+        .split("\n")
+        .map((s) => s.trim())
+        .filter(Boolean);
+    return [...new Set([...vsBase, ...workingTree, ...untracked])]
+        .filter((f) => !shouldExcludeFile(f, config))
+        .sort();
+}
+// ---------------------------------------------------------------------------
+// Prioridad
+// ---------------------------------------------------------------------------
+/**
+ * Asigna una prioridad arquitectónica al archivo (1 = más importante, 5 = menos).
+ *
+ * La prioridad se usa para:
+ * - Ordenar bloques en `buildCommitPlan` (los más prioritarios se commitean primero).
+ * - Influir en la distribución greedy de `distributeBlocks`.
+ *
+ * Heurística basada en patrones de ruta comunes en proyectos backend/fullstack.
+ * Si ninguna regla coincide, el nivel por defecto es 2 (servicios/core).
+ *
+ * @param file - Ruta relativa del archivo.
+ * @returns    Número de prioridad entre 1 y 5.
+ */
+function getPriority(file) {
+    const f = file.toLowerCase();
+    if (/(config|configs|configuration|settings|env|schema|schemas|type|types|interface|interfaces|model|models|entity|entities|dto|dtos|migration|migrations|constant|constants)/.test(f)) {
+        return 1;
+    }
+    if (/(core|domain|service|services|usecase|usecases|controller|controllers|application|manager|handler)/.test(f)) {
+        return 2;
+    }
+    if (/(infra|infrastructure|repository|repositories|adapter|adapters|route|routes|gateway|gateways|client|clients)/.test(f)) {
+        return 3;
+    }
+    if (/(^|\/)(__tests__|tests|test)(\/|$)|(\.spec\.|\.test\.)/.test(f)) {
+        return 4;
+    }
+    if (/(^|\/)(docs|doc)(\/|$)|(^|\/)readme(\.[^/]*)?$|(^|\/)changelog(\.[^/]*)?$|(^|\/)license(\.[^/]*)?$|\.md$|\.adoc$|\.rst$/.test(f)) {
+        return 5;
+    }
+    return 2;
+}
+// ---------------------------------------------------------------------------
+// Line counting
+// ---------------------------------------------------------------------------
+/**
+ * Cuenta las líneas de un archivo nuevo (untracked) leyéndolo del disco.
+ *
+ * Solo se llama como fallback cuando `numstat` no tiene información del archivo
+ * (lo que ocurre con archivos nuevos que aún no han sido añadidos con `git add`).
+ * Para archivos binarios devuelve 0.
+ *
+ * @param file - Ruta relativa del archivo a leer.
+ * @returns    Número de líneas del archivo (0 si es binario o no se puede leer).
+ */
+function getUntrackedFileLines(file) {
+    if (isBinary(file))
+        return 0;
+    try {
+        const content = readFileSync(file, "utf8");
+        // split("\n") produce un elemento vacío final en archivos con trailing newline
+        // (la gran mayoría de archivos de texto), lo que sobrecontaría en 1 línea.
+        const lines = content.split("\n");
+        return lines[lines.length - 1] === "" ? lines.length - 1 : lines.length;
+    }
+    catch {
+        return 0;
+    }
+}
+// ---------------------------------------------------------------------------
+// Parsers de salida de git diff
+// ---------------------------------------------------------------------------
+/**
+ * Parsea la salida de `git diff --name-status` y devuelve un mapa
+ * `ruta → tipo-de-cambio` (A, M, D, R).
+ *
+ * Los archivos renombrados (tipo `R<porcentaje>\told\tnew`) se registran
+ * con la ruta nueva (`parts[2]`) como tipo `"R"`.
+ *
+ * @param baseBranch - Si se provee, usa `git diff <base>`. Si no, diff del working tree.
+ */
+function parseDiffNameStatus(baseBranch) {
+    const out = baseBranch
+        ? shSafe(`git diff ${q(baseBranch)} --name-status`)
+        : shSafe("git diff --name-status");
+    const map = new Map();
+    for (const line of out.split("\n").map((s) => s.trim()).filter(Boolean)) {
+        const parts = line.split("\t");
+        const rawType = parts[0];
+        if (rawType.startsWith("R")) {
+            const newPath = parts[2];
+            if (newPath)
+                map.set(newPath, "R");
+            continue;
+        }
+        const file = parts[1];
+        if (!file)
+            continue;
+        if (rawType === "A" || rawType === "M" || rawType === "D") {
+            map.set(file, rawType);
+        }
+    }
+    return map;
+}
+/**
+ * Parsea la salida de `git diff --numstat` y devuelve un mapa
+ * `ruta → { additions, deletions }`.
+ *
+ * Para archivos binarios git imprime `"-"` en lugar de un número; en ese caso
+ * se usa 0. Si la línea tiene menos de 3 columnas se ignora.
+ *
+ * @param baseBranch - Si se provee, usa `git diff <base>`. Si no, diff del working tree.
+ */
+function parseDiffNumstat(baseBranch) {
+    const out = baseBranch
+        ? shSafe(`git diff ${q(baseBranch)} --numstat`)
+        : shSafe("git diff --numstat");
+    const map = new Map();
+    for (const line of out.split("\n").map((s) => s.trim()).filter(Boolean)) {
+        const parts = line.split("\t");
+        if (parts.length < 3)
+            continue;
+        const addRaw = parts[0];
+        const delRaw = parts[1];
+        const file = parts.slice(2).join("\t");
+        // Manejar notación de renombrado: "old => new" o "src/{old => new}/file.ts"
+        let fileKey = file;
+        const braceMatch = file.match(/^(.*)\{(.+?) => (.+?)\}(.*)$/);
+        if (braceMatch) {
+            fileKey = braceMatch[1] + braceMatch[3] + braceMatch[4];
+        }
+        else {
+            const arrowMatch = file.match(/^.+ => (.+)$/);
+            if (arrowMatch)
+                fileKey = arrowMatch[1];
+        }
+        const additions = addRaw === "-" ? 0 : Number(addRaw || 0);
+        const deletions = delRaw === "-" ? 0 : Number(delRaw || 0);
+        map.set(fileKey, { additions, deletions });
+    }
+    return map;
+}
+// ---------------------------------------------------------------------------
+// Public
+// ---------------------------------------------------------------------------
+/**
+ * Calcula estadísticas detalladas (líneas, adiciones, eliminaciones, tipo de
+ * cambio, prioridad) para cada archivo cambiado.
+ *
+ * La prioridad se asigna según el rol del archivo en la arquitectura:
+ * config/types → 1, servicios/core → 2, infra → 3, tests → 4, docs → 5.
+ *
+ * @param files - Rutas relativas de los archivos a analizar.
+ * @returns     Array de {@link FileStat} en el mismo orden que la entrada.
+ */
+export function getFileStats(files, baseBranch) {
+    const changeTypeMap = parseDiffNameStatus(baseBranch);
+    const numstatMap = parseDiffNumstat(baseBranch);
+    return files.map((file) => {
+        const tracked = isTrackedFile(file);
+        const binary = isBinary(file);
+        const numstat = numstatMap.get(file);
+        // Preferir numstat cuando está disponible: ya tiene el diff correcto
+        // (respecto a baseBranch si se usó --base). El fallback a getUntrackedFileLines
+        // solo aplica para archivos nuevos locales (changeType U) que no aparecen en el diff.
+        const lineCount = binary
+            ? 0
+            : numstat
+                ? numstat.additions + numstat.deletions
+                : getUntrackedFileLines(file);
+        const additions = numstat?.additions ?? lineCount;
+        const deletions = numstat?.deletions ?? 0;
+        let changeType = "M";
+        if (!tracked) {
+            changeType = "U";
+        }
+        else if (changeTypeMap.has(file)) {
+            changeType = changeTypeMap.get(file);
+        }
+        return {
+            path: file,
+            lines: lineCount,
+            additions,
+            deletions,
+            changeType,
+            status: tracked ? "tracked" : "untracked",
+            priority: getPriority(file)
+        };
+    });
+}

package/dist/core/history.js

@@ -0,0 +1,72 @@
+/**
+ * history.ts — Historial de scores por ejecución.
+ *
+ * Cada vez que el CLI analiza un repositorio guarda una entrada en el archivo
+ * `.advisor-history.json` (configurable con `historyFile`). El flag `--stats`
+ * lee ese archivo y muestra las últimas N entradas con su evolución de score.
+ *
+ * ### Estructura del archivo JSON
+ * ```json
+ * [
+ *   {
+ *     "timestamp": "2026-04-03T12:00:00.000Z",
+ *     "branch": "feature/ABC-123-add-login",
+ *     "baseBranch": "main",
+ *     "avgScore": 4.35,
+ *     "totalBranches": 2,
+ *     "totalFiles": 12,
+ *     "totalLines": 480
+ *   }
+ * ]
+ * ```
+ */
+import { existsSync, readFileSync, writeFileSync } from "node:fs";
+import path from "node:path";
+/**
+ * Lee el historial existente desde el archivo configurado con `config.historyFile`.
+ * Devuelve un array vacío si el archivo no existe o está corrupto.
+ */
+export function readHistory(config) {
+    const fullPath = path.resolve(process.cwd(), config.historyFile);
+    if (!existsSync(fullPath))
+        return [];
+    try {
+        const raw = readFileSync(fullPath, "utf8");
+        const parsed = JSON.parse(raw);
+        return Array.isArray(parsed) ? parsed : [];
+    }
+    catch {
+        return [];
+    }
+}
+/**
+ * Agrega una nueva entrada al historial y la persiste en disco.
+ * Si el archivo ya existe, concatena la entrada al array existente.
+ * Limita el historial a las últimas 100 entradas para evitar archivos enormes.
+ *
+ * @param plans     - Plan de ramas producido por `findBestPlan`.
+ * @param branch    - Nombre de la rama de trabajo actual.
+ * @param baseBranch - Nombre de la rama base del PR.
+ * @param fileStats - Lista de estadísticas de archivos.
+ * @param config    - Configuración activa (contiene `historyFile`).
+ */
+export function appendHistory(plans, branch, baseBranch, fileStats, config) {
+    const avgScore = plans.length > 0
+        ? Math.round((plans.reduce((s, p) => s + p.score, 0) / plans.length) * 100) / 100
+        : 0;
+    const entry = {
+        timestamp: new Date().toISOString(),
+        branch,
+        baseBranch,
+        avgScore,
+        totalBranches: plans.length,
+        totalFiles: fileStats.length,
+        totalLines: fileStats.reduce((s, f) => s + f.lines, 0)
+    };
+    const history = readHistory(config);
+    history.push(entry);
+    // Conservar solo las últimas 100 entradas
+    const trimmed = history.slice(-100);
+    const fullPath = path.resolve(process.cwd(), config.historyFile);
+    writeFileSync(fullPath, JSON.stringify(trimmed, null, 2), "utf8");
+}

package/dist/core/planner.js

@@ -0,0 +1,25 @@
+/**
+ * planner.ts — Barrel público del pipeline de análisis.
+ *
+ * Re-exporta las cuatro funciones públicas del pipeline en el orden en que
+ * deben invocarse:
+ *
+ * ```
+ * gatherChangedFiles(config, baseBranch)
+ *   ↓
+ * getFileStats(files, baseBranch)
+ *   ↓
+ * buildDependencyEdges(files)
+ *   ↓
+ * buildBlocks(fileStats, config, deps)
+ *   ↓
+ * findBestPlan(blocks, currentBranch, config, deps)
+ * ```
+ *
+ * Importar desde este barrel en lugar de los módulos individuales reduce el
+ * acoplamiento entre `cli.ts` y la estructura interna del directorio `core/`.
+ */
+export { gatherChangedFiles, getFileStats } from "./file-stats.js";
+export { buildDependencyEdges } from "./dependency.js";
+export { buildBlocks } from "./blocks.js";
+export { findBestPlan } from "./strategy.js";

package/dist/core/scoring.js

@@ -0,0 +1,166 @@
+/**
+ * scoring.ts — Cálculo del score compuesto de un Pull Request.
+ *
+ * El score es un número entre 0 y 5 que representa la «calidad de revisión»
+ * de un PR: cuánto esfuerzo cognitivo se espera del revisor. Un score de 5
+ * indica un PR pequeño, bien estructurado y fácil de revisar.
+ *
+ * ### Fórmula
+ * ```
+ * score = Σ(points(metric) × weight(metric))
+ * ```
+ * Donde `points(metric)` es 1–5 según las reglas de scoring de la métrica.
+ *
+ * ### Métricas (orden posicional requerido en la configuración)
+ * El motor asigna valores brutos **posicionalmente** según el orden declarado
+ * en `config.metrics`. Los 4 valores brutos, en orden obligatorio, son:
+ *
+ * 1. Cantidad de commits del PR
+ * 2. Promedio de archivos por commit
+ * 3. Promedio de líneas por commit
+ * 4. Total de líneas cambiadas
+ *
+ * Los códigos de cada métrica son libres («sólo etiquetas») y cada equipo
+ * puede definir los suyos. Ver `MetricCode` en `shared/types.ts`.
+ *
+ * ### Diseño: comparador compartido
+ * `checkComparators` es reutilizado por `matchesRule` (scoring) y
+ * `matchesRecommendation` (mensajes de recomendación), garantizando que la
+ * lógica de rangos numéricos no se duplique.
+ */
+/**
+ * Evalúa si un valor numérico satisface todos los comparadores especificados.
+ *
+ * Los comparadores son aditivos: todos los presentes deben cumplirse (AND lógico).
+ * Si un comparador no está definido (`undefined`), no restringe el rango.
+ *
+ * @param value - Valor de la métrica a evaluar.
+ * @param c     - Objeto con los comparadores opcionales (lt, lte, gt, gte, eq).
+ * @returns     `true` si el valor satisface todos los comparadores presentes.
+ */
+function checkComparators(value, c) {
+    if (c.eq !== undefined && value !== c.eq)
+        return false;
+    if (c.lt !== undefined && !(value < c.lt))
+        return false;
+    if (c.lte !== undefined && !(value <= c.lte))
+        return false;
+    if (c.gt !== undefined && !(value > c.gt))
+        return false;
+    if (c.gte !== undefined && !(value >= c.gte))
+        return false;
+    return true;
+}
+/**
+ * Decide si una regla de scoring aplica a un valor dado.
+ *
+ * - Si la regla no tiene ningún comparador explícito, solo aplica si es `default: true`.
+ * - Si tiene comparadores, delega en `checkComparators`.
+ *
+ * @param value - Valor crudo de la métrica.
+ * @param rule  - Regla de scoring a evaluar.
+ */
+function matchesRule(value, rule) {
+    const hasComparator = rule.eq !== undefined ||
+        rule.lt !== undefined ||
+        rule.lte !== undefined ||
+        rule.gt !== undefined ||
+        rule.gte !== undefined;
+    // Sin comparador explícito la regla sólo aplica si está marcada como default.
+    if (!hasComparator)
+        return rule.default === true;
+    return checkComparators(value, rule);
+}
+/**
+ * Recorre las reglas de scoring de una métrica y devuelve los puntos de la primera
+ * regla que coincida con el valor. Si ninguna coincide (configuración incompleta,
+ * falta regla `default: true`), emite un aviso por stderr y devuelve 0.
+ *
+ * @param value  - Valor crudo de la métrica.
+ * @param metric - Definición de la métrica con su lista de reglas.
+ */
+function resolvePoints(value, metric) {
+    for (const rule of metric.scoring) {
+        if (matchesRule(value, rule)) {
+            return rule.points;
+        }
+    }
+    // Sin regla aplicable: indica una configuración incompleta (falta regla default).
+    // Emitimos el aviso por stderr con el mismo formato que el resto del proyecto.
+    process.stderr.write(`[scoring warn] Sin regla para valor ${value} en "${metric.label}". Revisa que la métrica tenga una regla { default: true }. Devolviendo 0 puntos.\n`);
+    return 0;
+}
+/** Reutiliza `checkComparators` para evaluar condiciones de recomendación. La lógica de rangos es idéntica a `matchesRule`. */
+function matchesRecommendation(value, condition) {
+    return checkComparators(value, condition);
+}
+/**
+ * Devuelve el mensaje de recomendación para un score compuesto evaluando las
+ * reglas en orden. Siempre debe haber una regla fallback `{ gte: 0 }` para
+ * scores fuera del rango esperado (pesos mal configurados).
+ *
+ * @param complexity - Score compuesto del PR (0–5).
+ * @param rules      - Lista de reglas de recomendación de la configuración.
+ */
+function resolveRecommendation(complexity, rules) {
+    for (const rule of rules) {
+        if (matchesRecommendation(complexity, rule.when)) {
+            return rule.message;
+        }
+    }
+    return "Sin recomendación disponible para este score";
+}
+/** Redondea un número a 2 decimales usando representación de string para evitar problemas de punto flotante. */
+function round2(value) {
+    return Number(value.toFixed(2));
+}
+/**
+ * Calcula el score compuesto de un Pull Request a partir de sus métricas brutas.
+ *
+ * Las métricas M1.3, M1.4, M1.5 y M3.2 se evalúan contra las reglas definidas
+ * en `config.metrics`. Cada métrica produce una puntuación de 1-5 que se
+ * multiplica por su peso para obtener el score ponderado.
+ *
+ * @param raw    - Valores brutos del PR (commits, archivos/commit, líneas/commit, total líneas).
+ * @param config - Configuración que contiene las reglas de scoring y recomendaciones.
+ * @returns      Objeto con métricas detalladas, score compuesto (`complexity`) y recomendación.
+ */
+export function scorePullRequest(raw, config) {
+    const defs = config.metrics;
+    // Mapeo posicional: el orden declarado en config.metrics determina qué valor
+    // bruto recibe cada métrica. Convención invariante (ver MetricCode en types.ts):
+    //   posición 0 → commitCount
+    //   posición 1 → filesPerCommit
+    //   posición 2 → avgLinesPerCommit
+    //   posición 3 → totalLinesChanged
+    const rawValues = [
+        raw.commitCount,
+        raw.filesPerCommit,
+        raw.avgLinesPerCommit,
+        raw.totalLinesChanged
+    ];
+    const metrics = {};
+    // Mapeo posicional documentado (ver cabecera del módulo).
+    // deepMerge preserva siempre el orden de inserción de defaultConfig,
+    // por lo que el índice 0 → 3 es estable. El fallback a 0 protege ante
+    // configuraciones con menos de 4 métricas (ya rechazadas por loadConfig).
+    Object.entries(defs).forEach(([code, def], i) => {
+        const rawValue = i < rawValues.length ? rawValues[i] : 0;
+        const points = resolvePoints(rawValue, def);
+        metrics[code] = {
+            code,
+            label: def.label,
+            rawValue,
+            points,
+            weight: def.weight,
+            weightedScore: round2(points * def.weight)
+        };
+    });
+    const complexity = round2(Object.values(metrics).reduce((sum, m) => sum + m.weightedScore, 0));
+    const recommendation = resolveRecommendation(complexity, config.recommendationRules);
+    return {
+        metrics,
+        complexity,
+        recommendation
+    };
+}