pull-request-split-advisor 3.1.2

package/dist/cli.js

@@ -0,0 +1,442 @@
+#!/usr/bin/env node
+/**
+ * cli.ts — Punto de entrada del CLI `pr-split-advisor`.
+ *
+ * ### Pipeline de análisis
+ * ```
+ * 1.  Parsear argumentos CLI (Commander).
+ * 2.  Cargar y validar configuración (loadConfig).
+ * 3.  Verificar repositorio git limpio (requireGitRepo, requireCleanIndex).
+ * 4.  Detectar rama actual; validar nomenclatura (obligatorio).
+ * 5.  Validar rama base en el remoto (fetch + remoteTrackingExists + localBehindCount).
+ * 6.  Recopilar archivos cambiados (gatherChangedFiles).
+ * 7.  Calcular stats, dependencias, bloques y plan óptimo.
+ * 8.  Imprimir resumen, archivos, dependencias, bloques y plan.
+ * 9.  Exportar JSON si exportJson es true en el config.
+ * 10. Exportar reporte HTML.
+ * 11. Guardar historial de scores.
+ * ```
+ *
+ * ### Modos de ejecución
+ * | Flag      | Comportamiento                                         |
+ * |-----------|--------------------------------------------------------|
+ * | (ninguno) | Muestra el plan completo de división de PRs             |
+ * | `--stats` | Muestra historial de scores y sale                     |
+ */
+import { Command } from "commander";
+import { parseAndValidateWorkingBranch } from "./git/branch-naming.js";
+import { loadConfig } from "./config/config.js";
+import { APP_BIN, APP_NAME, APP_VERSION } from "./shared/constants.js";
+import { applyPlan } from "./git/executor.js";
+import { detectRemote, fetchQuiet, getCurrentBranch, localAheadCount, localBehindCount, remoteTrackingExists, requireCleanIndex, requireGitRepo } from "./git/git.js";
+import { buildBlocks, buildDependencyEdges, findBestPlan, gatherChangedFiles, getFileStats } from "./core/planner.js";
+import { exportJson, writeHtmlReport } from "./output/report.js";
+import { appendHistory, readHistory } from "./core/history.js";
+import { buildSuggestedMessage } from "./core/commit-planner.js";
+import { ui, closeReadlineInterface } from "./output/ui.js";
+import { changeTypeLabel } from "./shared/utils.js";
+import { aiEnrichPlans } from "./ai/enricher.js";
+import { isAiEnabled, PROVIDER_REGISTRY } from "./ai/provider.js";
+import { runConfigWizard, runConfigWithKey } from "./ai/config-wizard.js";
+function normalizeStoryNumber(value) {
+    return value.trim().replace(/[^0-9]/g, "");
+}
+/**
+ * Pide al usuario el número de subtarea para cada commit del plan y rellena
+ * `commit.ticketCode` y `commit.suggestedMessage` con el resultado.
+ *
+ * Si no hay contexto de nomenclatura (teamCode/storyNumber) la función retorna
+ * sin modificar los planes (el mensaje sugerido original se mantiene).
+ */
+async function enrichCommitTickets(plans, config) {
+    const teamCode = config.branchNamingContext?.teamCode;
+    const baseStoryNumber = config.branchNamingContext?.storyNumber;
+    if (!teamCode || !baseStoryNumber)
+        return;
+    const defaultTicket = `${teamCode}-${baseStoryNumber}`;
+    ui.section("CAPTURA DE NUMEROS PARA COMMITS", "#");
+    ui.info("Ingresa solo el numero de subtarea para cada commit. Si presionas Enter, se usara el numero de la historia base.");
+    ui.kv("Codigo de equipo", teamCode);
+    ui.kv("Numero por defecto", baseStoryNumber);
+    ui.kv("Ticket por defecto", defaultTicket);
+    for (const plan of plans) {
+        ui.subsection(plan.isExistingBaseBranch
+            ? `Rama base existente: ${plan.name}`
+            : `Rama derivada: ${plan.name}`);
+        for (const commit of plan.commitPlan) {
+            const preview = `${commit.suggestedType}(${commit.suggestedScope}): ${commit.suggestedSubject}`;
+            ui.muted(`Commit ${commit.index}`);
+            ui.muted(`Titulo base: ${preview}`);
+            const enteredNumber = await ui.prompt(`Numero de subtarea para commit ${commit.index}`, baseStoryNumber);
+            const normalizedNumber = normalizeStoryNumber(enteredNumber) || baseStoryNumber;
+            const finalTicket = `${teamCode}-${normalizedNumber}`;
+            commit.ticketCode = finalTicket;
+            commit.suggestedMessage = buildSuggestedMessage(commit.suggestedType, commit.suggestedScope, commit.suggestedSubject, finalTicket);
+            ui.ok(`Commit ${commit.index}: ${commit.suggestedMessage}`);
+        }
+    }
+}
+/**
+ * Calcula el porcentaje de archivos de test/spec dentro del conjunto cambiado.
+ * Considera test si la ruta contiene `test`, `spec`, `__tests__` o `__mocks__`.
+ */
+function computeTestCoveragePercent(fileStats) {
+    if (fileStats.length === 0)
+        return 0;
+    const testFiles = fileStats.filter((f) => /\.(test|spec)\.[a-z]+$/.test(f.path) ||
+        f.path.includes("__tests__") ||
+        f.path.includes("__mocks__") ||
+        /\/tests?\//.test(f.path)).length;
+    return Math.round((testFiles / fileStats.length) * 100);
+}
+function printSummary(fileStats, config, currentBranch, baseBranch) {
+    const totalFiles = fileStats.length;
+    const totalLines = fileStats.reduce((sum, f) => sum + f.lines, 0);
+    const totalAdditions = fileStats.reduce((sum, f) => sum + f.additions, 0);
+    const totalDeletions = fileStats.reduce((sum, f) => sum + f.deletions, 0);
+    const createdFiles = fileStats.filter((f) => f.changeType === "A" || f.changeType === "U").length;
+    const updatedFiles = fileStats.filter((f) => f.changeType === "M").length;
+    const deletedFiles = fileStats.filter((f) => f.changeType === "D").length;
+    const renamedFiles = fileStats.filter((f) => f.changeType === "R").length;
+    const largeFiles = fileStats.filter((f) => f.lines > config.largeFileThreshold).length;
+    const testCoveragePercent = config.testCoveragePercent;
+    ui.header(APP_NAME.toUpperCase(), "Asesor de División de PRs", [
+        ["Rama actual", currentBranch],
+        ["Rama base del PR", baseBranch],
+        ["Score objetivo", config.targetScore],
+        ["Estrategia", "Puntuación máxima / división segura"],
+        ["Tipo de rama", config.branchNamingContext?.branchType ?? "N/A"],
+        ["Código de equipo", config.branchNamingContext?.teamCode ?? "N/A"],
+        ["Número de historia", config.branchNamingContext?.storyNumber ?? "N/A"]
+    ]);
+    ui.section("RESUMEN DE CAMBIOS", "#");
+    ui.dashboard([
+        ["Total de archivos", totalFiles, "blue"],
+        ["Lineas agregadas", totalAdditions, "green"],
+        ["Lineas borradas", totalDeletions, "red"],
+        ["Archivos creados", createdFiles, createdFiles > 0 ? "green" : "cyan"],
+        ["Archivos actualizados", updatedFiles, "blue"],
+        ["Archivos eliminados", deletedFiles, deletedFiles > 0 ? "yellow" : "cyan"],
+        ["Archivos renombrados", renamedFiles, renamedFiles > 0 ? "yellow" : "cyan"],
+        [`Archivos > ${config.largeFileThreshold} lineas`, largeFiles, largeFiles > 0 ? "yellow" : "green"],
+        ["Cobertura de tests", `${testCoveragePercent}%`, testCoveragePercent >= 20 ? "green" : testCoveragePercent > 0 ? "yellow" : "red"],
+        ["Max archivos por commit", config.maxFilesPerCommit, "cyan"],
+        ["Max lineas por commit ideal", config.maxLinesPerCommitIdeal, "cyan"],
+        ["Ideal lineas por PR", config.idealLinesPerPR, "cyan"],
+        ["Total de lineas tocadas", totalLines, "blue"]
+    ]);
+}
+function printFileStats(fileStats) {
+    ui.section("DETALLE DE ARCHIVOS", "#");
+    ui.table(["Marca", "Archivo", "Lineas", "+", "-", "Prioridad"], fileStats.map((f) => [
+        changeTypeLabel(f.changeType),
+        ui.truncateMiddle(f.path, 55),
+        f.lines,
+        f.additions,
+        f.deletions,
+        f.priority
+    ]), true);
+}
+function printDependencies(edges) {
+    ui.section("DEPENDENCIAS HEURISTICAS", "#");
+    if (!edges.length) {
+        ui.info("No se detectaron dependencias heuristicas.");
+        return;
+    }
+    ui.table(["Archivo origen", "Archivo dependencia"], edges.map((e) => [
+        ui.truncateMiddle(e.from, 45),
+        ui.truncateMiddle(e.to, 45)
+    ]), true);
+}
+function printBlocks(blocks) {
+    ui.section("BLOQUES DETECTADOS", "#");
+    ui.table(["Bloque", "Prioridad", "Divisible", "Lineas", "Archivos", "Dependencias"], blocks.map((b) => [
+        ui.blockLabel(b.id),
+        b.priority,
+        b.divisible ? "Si" : "No",
+        b.lines,
+        b.files.length,
+        b.depScore
+    ]), true);
+}
+function printPlans(plans, baseBranch, currentBranch, config) {
+    ui.section("PLAN RECOMENDADO", "#");
+    ui.kv("Rama actual", currentBranch);
+    ui.kv("Rama base del PR", baseBranch);
+    ui.kv("Total de PRs sugeridos", plans.length);
+    ui.kv("Ramas nuevas a crear", Math.max(plans.length - 1, 0));
+    for (const plan of plans) {
+        const scoreColor = ui.scoreColor(plan.score, config.targetScore);
+        const warnThreshold = config.targetScore > 4 ? 4 : Math.max(0, config.targetScore - 1);
+        const statusBadge = plan.score >= config.targetScore
+            ? ui.badge("ÓPTIMO", "green")
+            : plan.score >= warnThreshold
+                ? ui.badge("ACEPTABLE", "yellow")
+                : ui.badge("RIESGO", "red");
+        const riskBadge = plan.reason === "OK"
+            ? ui.badge("SIN ALERTAS", "green")
+            : ui.badge("CON ALERTAS", "yellow");
+        const title = plan.isExistingBaseBranch
+            ? `Rama existente base: ${plan.name}`
+            : `Rama sugerida a crear: ${plan.name}`;
+        ui.card(title, [
+            `${statusBadge} ${riskBadge} ${plan.isExistingBaseBranch ? ui.badge("BASE EXISTENTE", "cyan") : ui.badge("NUEVA RAMA", "blue")}`,
+            "",
+            `Archivos: ${plan.files}`,
+            `Lineas: ${plan.lines}`,
+            `Commits sugeridos: ${plan.commits}`,
+            `Promedio de archivos por commit: ${plan.filesPerCommit} (${plan.files} archivos / ${plan.commits} commits)`,
+            `Promedio de lineas por commit: ${plan.linesPerCommit} (${plan.lines} lineas / ${plan.commits} commits)`,
+            ...(plan.excludedCommitTypes?.length
+                ? [`⚠  M1.4 y M1.5 excluyen commits tipo: ${plan.excludedCommitTypes.join(", ")} (M1.3 y M3.2 usan todos los commits)`]
+                : []),
+            `Score estimado: ${ui.score(plan.score, config.targetScore)}`,
+            `Observacion: ${plan.reason}`,
+            `Metricas: ${Object.entries(plan.metrics).map(([k, v]) => `${k}=${v}`).join(", ")}`,
+            `Recomendacion: ${plan.recommendation ?? "N/A"}`
+        ], scoreColor, plan.isExistingBaseBranch
+            ? "Esta rama ya existe y debe usarse como el primer PR."
+            : "Esta rama debe crearse como PR derivado de la rama base existente.");
+        ui.subsection("Bloques de esta rama");
+        ui.table(["Bloque", "Prioridad", "Divisible", "Lineas", "Archivos", "Dependencias"], plan.blocks.map((block) => [
+            ui.blockLabel(block.id),
+            block.priority,
+            block.divisible ? "Si" : "No",
+            block.lines,
+            block.files.length,
+            block.depScore
+        ]), true);
+        ui.subsection("Plan de commits");
+        ui.table(["Commit", "Archivos", "Lineas", "Mensaje sugerido"], plan.commitPlan.map((commit) => [
+            commit.index,
+            commit.files.length,
+            commit.totalLines,
+            commit.suggestedMessage
+        ]), true);
+        for (const commit of plan.commitPlan) {
+            ui.muted(`  Commit ${commit.index}`);
+            ui.muted(`  Mensaje sugerido: ${commit.suggestedMessage}`);
+            ui.fileList(commit.files, 95);
+        }
+        ui.divider();
+    }
+    const avgScore = plans.length > 0
+        ? plans.reduce((sum, p) => sum + p.score, 0) / plans.length
+        : 0;
+    ui.summaryCard("Resumen final del plan", [
+        ["Cantidad total de PRs", plans.length, "blue"],
+        ["Ramas nuevas a crear", Math.max(plans.length - 1, 0), "cyan"],
+        ["Score promedio", avgScore.toFixed(2), ui.scoreColor(avgScore, config.targetScore)],
+        [
+            "Ramas por debajo del objetivo",
+            plans.filter((p) => p.score < config.targetScore).length,
+            plans.some((p) => p.score < config.targetScore) ? "yellow" : "green"
+        ],
+        [
+            "Ramas grandes indivisibles",
+            plans.filter((p) => p.reason.includes("indivisible")).length,
+            plans.some((p) => p.reason.includes("indivisible")) ? "yellow" : "green"
+        ]
+    ]);
+}
+async function main() {
+    const program = new Command();
+    program
+        .name(APP_BIN)
+        .description("Analiza cambios y opcionalmente crea ramas y commits")
+        .version(APP_VERSION, "-v, --version", "muestra la version actual")
+        .option("-b, --base <branch>", "rama base para analizar cambios del PR")
+        .option("--apply", "aplica el plan: crea ramas y commits (Enter acepta el valor sugerido)")
+        .option("--stats", "muestra el historial de scores y sale");
+    // ─── Acción principal (análisis de PRs) ─────────────────────────────────
+    // Se registra como .action() del programa raíz para que Commander la ejecute
+    // cuando no se pasa ningún subcomando. Sin esto, Commander muestra el help.
+    program.action(async (options) => {
+        const config = loadConfig();
+        // ─── --stats: mostrar historial y salir ─────────────────────────────────
+        if (options.stats) {
+            const history = readHistory(config);
+            if (history.length === 0) {
+                ui.info(`No hay historial de scores. El archivo se crea en la primera ejecución.`);
+                ui.muted(`Archivo: ${config.historyFile}`);
+                closeReadlineInterface();
+                return;
+            }
+            ui.section("HISTORIAL DE SCORES", "#");
+            ui.table(["Fecha", "Rama", "Base", "Score Prom.", "Ramas", "Archivos", "Líneas"], history.slice(-20).reverse().map((e) => [
+                new Date(e.timestamp).toLocaleString("es-PE"),
+                ui.truncateMiddle(e.branch, 35),
+                e.baseBranch,
+                e.avgScore.toFixed(2),
+                e.totalBranches,
+                e.totalFiles,
+                e.totalLines
+            ]), true);
+            closeReadlineInterface();
+            return;
+        }
+        config.runtimeExcludedFiles = [
+            config.jsonOutputFile,
+            "pr-split-advisor.config.json",
+            "pr-split-report.html",
+            config.historyFile
+        ].filter(Boolean);
+        if (config.verbose) {
+            ui.muted(`[verbose] targetScore: ${config.targetScore}`);
+        }
+        try {
+            requireGitRepo();
+            requireCleanIndex();
+        }
+        catch (error) {
+            ui.error(error.message);
+            closeReadlineInterface();
+            process.exit(1);
+        }
+        const baseBranch = options.base || config.baseBranch || "main";
+        const currentBranch = getCurrentBranch();
+        try {
+            config.branchNamingContext = parseAndValidateWorkingBranch(currentBranch);
+        }
+        catch (error) {
+            ui.error(error.message);
+            closeReadlineInterface();
+            process.exit(1);
+        }
+        // ─── Aviso de responsabilidad ────────────────────────────────────────────
+        ui.card("⚠️  AVISO DE RESPONSABILIDAD", [
+            "Esta herramienta genera un plan de distribución de cambios.",
+            "No ejecuta compilaciones ni suites de pruebas.",
+            "",
+            "Antes de implementar el plan, confirme que:",
+            "  • El proyecto compile sin errores            (ej: npm run build)",
+            "  • Todas las pruebas finalicen correctamente  (ej: npm test)",
+            "",
+            "La verificación de la integridad del código es responsabilidad del equipo de desarrollo.",
+        ], "yellow");
+        // ─── Validar rama base en el remoto ─────────────────────────────────────
+        const remote = detectRemote(currentBranch);
+        try {
+            fetchQuiet(remote, baseBranch);
+        }
+        catch {
+            ui.warn(`git fetch ${remote} ${baseBranch} falló. Se usará la info local del remoto.`);
+        }
+        if (!remoteTrackingExists(baseBranch, remote)) {
+            ui.error(`La rama base '${baseBranch}' no existe en el remoto '${remote}'.\n` +
+                `Publícala primero antes de continuar:\n` +
+                `  git push ${remote} ${baseBranch}`);
+            closeReadlineInterface();
+            process.exit(1);
+        }
+        const behind = localBehindCount(baseBranch, remote);
+        if (behind > 0) {
+            ui.error(`La rama '${baseBranch}' tiene ${behind} commit(s) pendiente(s) de '${remote}/${baseBranch}'.\n` +
+                `Actualizála antes de continuar:\n` +
+                `  git pull --rebase ${remote} ${baseBranch}`);
+            closeReadlineInterface();
+            process.exit(1);
+        }
+        ui.ok(`Rama base '${baseBranch}' verificada en '${remote}' (última versión).`);
+        const aheadCount = localAheadCount(baseBranch);
+        if (aheadCount > 0) {
+            ui.warn(`La rama '${currentBranch}' ya tiene ${aheadCount} commit(s) adelantados respecto a '${baseBranch}'.\n` +
+                `Los archivos ya commiteados aparecerán en el análisis pero no podrán re-commitearse al aplicar el plan.`);
+        }
+        // ─── Pipeline de análisis ────────────────────────────────────────────────
+        ui.spinner.start("Analizando cambios del working tree...");
+        const changedFiles = gatherChangedFiles(config, baseBranch);
+        if (!changedFiles.length) {
+            ui.spinner.stop();
+            ui.warn("No hay cambios sin commit en el working tree.");
+            closeReadlineInterface();
+            return;
+        }
+        const fileStats = getFileStats(changedFiles, baseBranch);
+        const deps = buildDependencyEdges(changedFiles);
+        const blocks = buildBlocks(fileStats, config, deps);
+        if (config.verbose) {
+            ui.muted(`[verbose] Archivos detectados: ${fileStats.length}`);
+            ui.muted(`[verbose] Dependencias heurísticas: ${deps.length}`);
+            ui.muted(`[verbose] Bloques formados: ${blocks.length}`);
+        }
+        const plans = findBestPlan(blocks, currentBranch, config, deps);
+        config.testCoveragePercent = computeTestCoveragePercent(fileStats);
+        ui.spinner.stop("Analisis completado.");
+        // ─── Enriquecimiento con IA (opcional) ───────────────────────────────────
+        // Si la IA no está habilitada o configurada, `aiEnrichPlans` retorna
+        // de inmediato sin modificar los planes (modo heurístico puro).
+        if (isAiEnabled(config)) {
+            const providerId = config.ai?.provider ?? "groq";
+            const providerLabel = PROVIDER_REGISTRY.get(providerId)?.label ?? providerId;
+            ui.info(`Modo IA activo: ${providerLabel} / ${config.ai?.model ?? "llama-3.3-70b-versatile"}`);
+        }
+        await aiEnrichPlans(plans, config, currentBranch);
+        printSummary(fileStats, config, currentBranch, baseBranch);
+        printFileStats(fileStats);
+        printDependencies(deps);
+        printBlocks(blocks);
+        printPlans(plans, baseBranch, currentBranch, config);
+        // ─── Exportar reporte HTML ───────────────────────────────────────────────
+        const reportInput = { currentBranch, baseBranch, config, fileStats, deps, blocks, plans };
+        const htmlFile = "pr-split-report.html";
+        writeHtmlReport(htmlFile, reportInput);
+        ui.ok(`Reporte HTML generado: ${htmlFile}`);
+        if (config.exportJson) {
+            exportJson(plans, currentBranch, baseBranch, config);
+            ui.ok(`Plan exportado a JSON: ${config.jsonOutputFile}`);
+        }
+        // ─── Guardar historial de scores ──────────────────────────────────────────
+        // Se guarda ANTES del apply: el análisis ya está completo en este punto.
+        // Si apply falla y llama process.exit(1), el historial ya fue persistido.
+        try {
+            appendHistory(plans, currentBranch, baseBranch, fileStats, config);
+            if (config.verbose)
+                ui.muted(`[verbose] Historial actualizado en: ${config.historyFile}`);
+        }
+        catch {
+            // El historial es best-effort; no debe interrumpir el flujo
+        }
+        // ─── Decidir si aplicar el plan ───────────────────────────────────────────
+        // --apply omite la pregunta y ejecuta directamente (modo no interactivo/CI).
+        // Sin el flag, siempre se pregunta al usuario tras ver el reporte y el HTML.
+        const shouldApply = !!options.apply || await ui.confirm("¿Deseas aplicar el plan ahora?");
+        if (shouldApply) {
+            await enrichCommitTickets(plans, config);
+            try {
+                await applyPlan(plans, config);
+            }
+            catch {
+                // El error ya fue impreso y el rollback ejecutado dentro de applyPlan.
+                closeReadlineInterface();
+                process.exit(1);
+            }
+        }
+        else {
+            ui.info("Sin cambios en git.");
+        }
+        closeReadlineInterface();
+    });
+    // ─── Subcomando: config ──────────────────────────────────────────────────
+    program
+        .command("config")
+        .description("Configura las opciones de la herramienta interactivamente (IA, etc.)")
+        .option("--api-key <key>", "API key del proveedor (omite el wizard interactivo)")
+        .option("--provider <id>", "Proveedor de IA: groq, copilot (predeterminado: groq)")
+        .action(async (opts) => {
+        if (opts.apiKey) {
+            await runConfigWithKey(opts.apiKey, opts.provider ?? "groq");
+        }
+        else {
+            await runConfigWizard();
+        }
+        closeReadlineInterface();
+        process.exit(0);
+    });
+    await program.parseAsync(process.argv);
+}
+main().catch((error) => {
+    ui.error(error.message);
+    closeReadlineInterface();
+    process.exit(1);
+});