pull-request-split-advisor 3.2.3 → 3.2.4

package/README.md

@@ -27,11 +27,17 @@ La capa de IA ofrece tres puntos de enriquecimiento: **mejora de mensajes de com
 
 La v3.0.0 también mejora el **apply**: rama de respaldo con snapshot completo del working tree, re-prompt en nombres duplicados en lugar de rollback, y nomenclatura de ramas con mayúsculas en la descripción (p. ej. `feature/TEAM-123-PRUEBA-IA`). Si la IA no está configurada o falla en cualquier punto, la herramienta continúa en modo heurístico sin interrupciones.
 
+A partir de la **v3.1.0**, el proyecto incluye una **suite completa de tests** (Vitest, 199 tests, 12 suites) que cubre todos los módulos core, AI, git y configuración con mocks de dependencias externas (git, fs). A partir de la **v3.1.1**, el proveedor `copilot` solo puede activarse dentro de **Visual Studio Code** — fuera del IDE se emite un aviso y se desactiva automáticamente sin interrumpir el análisis.
+
 A partir de la **v3.2.0**, se añade el subcomando **`score`** que calcula y muestra el score del estado actual de la rama sin dividir en PRs, exportando también un reporte HTML independiente (`pr-split-score.html`) con desglose de métricas, valores brutos y detalle de archivos.
 
-A partir de la **v3.2.1**, cada archivo analizado recibe una **clasificación de origen** basada en su posición en el árbol git: `REMOTO` (cambios ya publicados en el remoto), `LOCAL` (commiteado solo en local), `WIP` (modificación sin commitear aún) o `NUEVO` (archivo sin rastrear). Esta información aparece como badge de color en la salida terminal y en la columna *Origen* de las tablas de archivos en ambos reportes HTML. El subcomando `score` utiliza exclusivamente los archivos en estado `WIP` o `NUEVO` para las métricas; si el working tree está limpio (todos los cambios ya están en commits), el comando informa y sale sin calcular un score basado en datos erróneos.
+A partir de la **v3.2.1**, cada archivo analizado recibe una **clasificación de origen** basada en su posición en el árbol git: `REMOTO` (cambios ya publicados en el remoto), `LOCAL` (commiteado solo en local), `WIP` (modificación sin commitear aún) o `NUEVO` (archivo sin rastrear). Esta información aparece como badge de color en la salida terminal y en la columna *Origen* de las tablas de archivos en ambos reportes HTML.
 
-A partir de la **v3.1.0**, el proyecto incluye una **suite completa de tests** (Vitest, 199 tests, 12 suites) que cubre todos los módulos core, AI, git y configuración con mocks de dependencias externas (git, fs). A partir de la **v3.1.1**, el proveedor `copilot` solo puede activarse dentro de **Visual Studio Code** — fuera del IDE se emite un aviso y se desactiva automáticamente sin interrumpir el análisis.
+A partir de la **v3.2.2**, el subcomando `score` evalúa **exclusivamente archivos WIP y sin rastrear**. Los archivos ya commiteados (LOCAL o REMOTO) se muestran en el reporte con su badge pero no influyen en las métricas. Si el working tree está limpio, el comando emite una advertencia y sale sin calcular un score incorrecto.
+
+A partir de la **v3.2.3**, el reporte HTML principal (`pr-split-report.html`) y el resumen en terminal calculan todos sus agregados (hero, tarjetas de resumen, footer) **solo sobre archivos WIP**. Los archivos LOCAL y REMOTO siguen apareciendo en la tabla de detalle con sus badges, acompañados de un banner informativo que los identifica como referencias no incluidas en las métricas.
+
+A partir de la **v3.2.4**, la herramienta detecta si la rama actual ya tiene commits adelantados respecto a la base antes de iniciar el análisis. En ese caso emite una **advertencia de integridad de cascada** con el comando exacto para crear la nueva rama correctamente: si existen ramas hermanas de la misma historia con commits adelantados, sugiere crear la siguiente rama desde la punta de la rama hermana más reciente (para continuar la cascada); si no, sugiere partir desde la base. El apply queda deshabilitado en esa ejecución para no romper el plan apilado. Esta versión también incluye tres correcciones internas: eliminación del doble sufijo `-wip` al sugerir nombres de rama, remplazo de `Math.max(...spread)` por `reduce` en la generación de reportes HTML (evita `RangeError` en repositorios con muchos archivos) y limpieza de un punto y coma duplicado en el cálculo de cobertura de tests.
 
 ---
 

package/dist/cli.js

@@ -28,7 +28,7 @@ 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 { detectRemote, fetchQuiet, findCascadeParent, getCurrentBranch, localAheadCount, localBehindCount, remoteTrackingExists, requireCleanIndex, requireGitRepo } from "./git/git.js";
 import { buildBlocks, buildDependencyEdges, computeFileOrigins, findBestPlan, gatherChangedFiles, getFileStats } from "./core/planner.js";
 import { resetTrackedFilesCache } from "./shared/utils.js";
 import { exportJson, writeHtmlReport, writeScoreHtmlReport } from "./output/report.js";
@@ -108,7 +108,6 @@ function printSummary(fileStats, config, currentBranch, baseBranch) {
     const renamedFiles = statsBase.filter((f) => f.changeType === "R").length;
     const largeFiles = statsBase.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],
@@ -355,9 +354,53 @@ async function main() {
         }
         ui.ok(`Rama base '${baseBranch}' verificada en '${remote}' (última versión).`);
         const aheadCount = localAheadCount(baseBranch);
+        let branchHasCommits = false;
+        // cascadeWarning se construye aquí (scope del action) para poder pasarlo
+        // al reporte HTML aunque el usuario haya elegido continuar el análisis.
+        let cascadeWarning;
         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.`);
+            branchHasCommits = true;
+            // Buscar la última rama hermana de la cascada (mismo tipo/equipo-número)
+            // que tenga commits adelantados. Si existe, el usuario debe continuar
+            // la cascada desde esa rama; si no, debe partir desde la base.
+            const cascadeParent = findCascadeParent(currentBranch, baseBranch);
+            const branchFrom = cascadeParent ?? baseBranch;
+            const suggestedBranch = currentBranch.replace(/^(feature|fix|bugfix|hotfix|refactor|chore|docs|test|perf|ci)\/(.+?)(-wip|-backup-.+)?$/, (_, type, rest) => `${type}/${rest}-wip`);
+            cascadeWarning = { aheadCount, cascadeParent, branchFrom, suggestedBranch };
+            const cascadeLines = cascadeParent
+                ? [
+                    `Se detectó la rama '${cascadeParent}' como parte de la misma`,
+                    `cascada (mismo tipo/equipo/historia). Para mantener el orden`,
+                    `correcto de PRs apilados, la nueva rama debe crearse desde`,
+                    `esa rama y no desde la base:`,
+                ]
+                : [
+                    `No se encontraron otras ramas de la misma cascada.`,
+                    `Crea la nueva rama directamente desde la base:`,
+                ];
+            ui.card("⚠  INTEGRIDAD DEL PLAN EN CASCADA COMPROMETIDA", [
+                `La rama '${currentBranch}' ya tiene ${aheadCount} commit${aheadCount !== 1 ? "s" : ""}`,
+                `adelantados respecto a '${baseBranch}'.`,
+                "",
+                "Para que el plan de PRs en cascada funcione correctamente, cada",
+                "rama del plan debe partir desde un estado limpio relativo a la",
+                "rama base. Si esta rama ya tiene commits previos, las ramas",
+                "derivadas los heredarán todos, rompiendo la separación de cambios",
+                "y haciendo los PRs imposibles de revisar de forma aislada.",
+                "",
+                ui.badge("RECOMENDACIÓN", "yellow") + "  " + cascadeLines[0],
+                ...cascadeLines.slice(1).map((l) => "  " + l),
+                `  git checkout ${branchFrom}`,
+                `  git checkout -b ${suggestedBranch}`,
+                "",
+                "Puedes continuar para ver el análisis (sin aplicar el plan).",
+                "La opción --apply quedará deshabilitada en esta ejecución."
+            ], "red");
+            const continueAnyway = await ui.confirm("¿Deseas continuar de todas formas (solo análisis, sin aplicar)?");
+            if (!continueAnyway) {
+                closeReadlineInterface();
+                return;
+            }
         }
         // ─── Pipeline de análisis ────────────────────────────────────────────────
         ui.spinner.start("Analizando cambios del working tree...");
@@ -405,7 +448,7 @@ async function main() {
         printPlans(plans, baseBranch, currentBranch, config);
         // ─── Exportar reporte HTML ───────────────────────────────────────────────
         const wipFileStats = fileStats.filter((f) => !f.origin || f.origin === "working-tree" || f.origin === "untracked");
-        const reportInput = { currentBranch, baseBranch, config, fileStats, wipFileStats, deps, blocks, plans };
+        const reportInput = { currentBranch, baseBranch, config, fileStats, wipFileStats, deps, blocks, plans, cascadeWarning };
         const htmlFile = "pr-split-report.html";
         writeHtmlReport(htmlFile, reportInput);
         ui.ok(`Reporte HTML generado: ${htmlFile}`);
@@ -427,7 +470,9 @@ async function main() {
         // ─── 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?");
+        // Si la rama ya tenía commits adelantados, el apply quedó deshabilitado
+        // para preservar la integridad del plan en cascada.
+        const shouldApply = !branchHasCommits && (!!options.apply || await ui.confirm("¿Deseas aplicar el plan ahora?"));
         if (shouldApply) {
             await enrichCommitTickets(plans, config);
             try {
@@ -439,6 +484,11 @@ async function main() {
                 process.exit(1);
             }
         }
+        else if (branchHasCommits) {
+            ui.warn("Apply deshabilitado: la rama ya tenía commits adelantados respecto a la base.\n" +
+                "Crea una nueva rama desde la base para poder aplicar el plan sin romper\n" +
+                "la integridad de los PRs en cascada.");
+        }
         else {
             ui.info("Sin cambios en git.");
         }

package/dist/git/git.js

@@ -226,6 +226,51 @@ export function localAheadCount(baseBranch) {
     const count = shSafe(`git rev-list ${q(baseBranch)}..HEAD --count`);
     return parseInt(count, 10) || 0;
 }
+/**
+ * Busca la última rama local de la misma "familia" (mismo prefijo tipo/equipo-número)
+ * que tiene commits adelantados respecto a `baseBranch`, excluyendo `currentBranch`.
+ *
+ * Útil para sugerir al usuario que cree la siguiente rama de la cascada desde
+ * la punta de la rama hermana más reciente en lugar de desde la rama base.
+ *
+ * @param currentBranch - Rama actual (se excluye de la búsqueda).
+ * @param baseBranch    - Rama base del análisis.
+ * @returns Nombre de la rama hermana más reciente con commits adelantados, o `null`.
+ */
+export function findCascadeParent(currentBranch, baseBranch) {
+    // Extraer el prefijo familia: tipo/EQUIPO-NUMERO
+    const familyMatch = currentBranch.match(/^(feature|fix|bugfix|hotfix|refactor|chore|docs|test|perf|ci)\/([A-Z]+-\d+)/i);
+    if (!familyMatch)
+        return null;
+    const familyPrefix = `${familyMatch[1]}/${familyMatch[2].toUpperCase()}`;
+    // Listar todas las ramas locales
+    const raw = shSafe("git branch --format=%(refname:short)");
+    if (!raw)
+        return null;
+    const candidates = raw
+        .split("\n")
+        .map((b) => b.trim())
+        .filter((b) => b &&
+        b !== currentBranch &&
+        b.toUpperCase().startsWith(familyPrefix.toUpperCase()));
+    if (candidates.length === 0)
+        return null;
+    // De los candidatos, quedarnos con los que tengan commits adelantados
+    // respecto a la base y ordenarlos por committerdate descendente
+    const withAhead = candidates.filter((b) => {
+        const count = shSafe(`git rev-list ${q(baseBranch)}..${q(b)} --count`);
+        return (parseInt(count, 10) || 0) > 0;
+    });
+    if (withAhead.length === 0)
+        return null;
+    // El más reciente es el que tiene el commit más nuevo
+    const sorted = withAhead.sort((a, b) => {
+        const dateA = shSafe(`git log -1 --format=%ct ${q(a)}`);
+        const dateB = shSafe(`git log -1 --format=%ct ${q(b)}`);
+        return (parseInt(dateB, 10) || 0) - (parseInt(dateA, 10) || 0);
+    });
+    return sorted[0] ?? null;
+}
 /**
  * Hace push de una rama local al remoto indicado.
  *

package/dist/output/report.js

@@ -436,7 +436,7 @@ export function renderHtmlReport(input) {
     const optimalPlans = plans.filter((p) => p.score >= config.targetScore).length;
     const acceptablePlans = plans.filter((p) => p.score >= warnThreshold && p.score < config.targetScore).length;
     const riskPlans = plans.filter((p) => p.score < warnThreshold).length;
-    const maxLinesForBar = fileStats.length > 0 ? Math.max(...fileStats.map((f) => f.lines)) : 1;
+    const maxLinesForBar = fileStats.length > 0 ? fileStats.reduce((max, f) => f.lines > max ? f.lines : max, 0) : 1;
     const timestamp = new Date().toLocaleString("es-PE", {
         year: "numeric", month: "long", day: "numeric",
         hour: "2-digit", minute: "2-digit"
@@ -498,6 +498,32 @@ export function renderHtmlReport(input) {
       </div>
     </div>
   </header>
+  <!-- ══ AVISO DE INTEGRIDAD DE CASCADA (condicional) ════════════ -->
+  ${input.cascadeWarning ? (() => {
+        const cw = input.cascadeWarning;
+        const parentNote = cw.cascadeParent
+            ? `Se detectó la rama <code>${esc(cw.cascadeParent)}</code> como parte de la misma cascada.
+         Para mantener el orden correcto de PRs apilados, la nueva rama debe crearse desde esa rama.`
+            : `No se encontraron otras ramas de la misma cascada. Crea la nueva rama directamente desde la base.`;
+        return `<section class="disclaimer-banner" style="background:rgba(239,68,68,.12);border-color:#f87171" role="alert" aria-label="Aviso de integridad de cascada">
+    <div class="disclaimer-icon">⚠️</div>
+    <div class="disclaimer-body">
+      <strong>INTEGRIDAD DEL PLAN EN CASCADA COMPROMETIDA</strong>
+      <p>
+        La rama <strong>${esc(currentBranch)}</strong> ya tiene
+        <strong>${cw.aheadCount} commit${cw.aheadCount !== 1 ? "s" : ""}</strong>
+        adelantados respecto a <strong>${esc(baseBranch)}</strong>.
+        Las ramas derivadas heredarán esos commits, rompiendo la separación de cambios
+        y haciendo los PRs imposibles de revisar de forma aislada.
+      </p>
+      <p>${parentNote}</p>
+      <p><strong>Comandos recomendados:</strong></p>
+      <pre style="background:rgba(0,0,0,.25);padding:10px 14px;border-radius:6px;font-size:.85em;margin:8px 0 0"># Crear la siguiente rama de la cascada\ngit checkout ${esc(cw.branchFrom)}\ngit checkout -b ${esc(cw.suggestedBranch)}</pre>
+      <p class="disclaimer-footer" style="margin-top:8px">El apply estuvo deshabilitado en esta ejecución para preservar la integridad del plan.</p>
+    </div>
+  </section>`;
+    })() : ""}
+
   <!-- ══ AVISO DE RESPONSABILIDAD ═══════════════════════════════ -->
   <section class="disclaimer-banner" role="alert" aria-label="Aviso de responsabilidad">
     <div class="disclaimer-icon">⚠️</div>
@@ -748,7 +774,7 @@ export function renderScoreHtmlReport(input) {
     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 maxLinesForBar = totalFiles > 0 ? Math.max(...fileStats.map((f) => f.lines)) : 1;
+    const maxLinesForBar = totalFiles > 0 ? fileStats.reduce((max, f) => f.lines > max ? f.lines : max, 0) : 1;
     const label = scoreLabel(result.complexity, config.targetScore);
     const warnThreshold = config.targetScore > 4 ? 4 : Math.max(0, config.targetScore - 1);
     const scoreClass = result.complexity >= config.targetScore ? "green" : result.complexity >= warnThreshold ? "yellow" : "red";

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "pull-request-split-advisor",
-  "version": "3.2.3",
+  "version": "3.2.4",
   "description": "CLI that analyses your Git working tree and suggests how to split changes into smaller, reviewable pull requests and commits.",
   "keywords": [
     "git",