pull-request-split-advisor 3.2.6 → 3.2.8

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, findCascadeParent, getCurrentBranch, localAheadCount, localBehindCount, remoteTrackingExists, requireCleanIndex, requireGitRepo } from "./git/git.js";
+import { detectRemote, fetchQuiet, findCascadeSiblings, localAheadCommits, 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";
@@ -360,13 +360,14 @@ async function main() {
         let cascadeWarning;
         if (aheadCount > 0) {
             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);
+            // Descubrir todas las ramas hermanas de la cascada (local + remoto + ls-remote)
+            // y los commits que la rama actual ya tiene adelantados.
+            const siblings = findCascadeSiblings(currentBranch, baseBranch);
+            const cascadeParent = siblings.length > 0 ? (siblings[siblings.length - 1]?.name ?? null) : null;
             const branchFrom = cascadeParent ?? baseBranch;
+            const currentBranchCommits = localAheadCommits(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 };
+            cascadeWarning = { aheadCount, cascadeParent, branchFrom, suggestedBranch, siblings, currentBranchCommits };
             const cascadeLines = cascadeParent
                 ? [
                     `Se detectó la rama '${cascadeParent}' como parte de la misma`,
@@ -396,6 +397,24 @@ async function main() {
                 "El análisis continúa de forma informativa.",
                 "La opción --apply está deshabilitada en esta ejecución."
             ], "red");
+            // ─── Estado de la cascada en terminal ───────────────────────────────────
+            ui.section("ESTADO DE LA CASCADA", "#");
+            for (const sibling of siblings) {
+                ui.subsection(sibling.name);
+                if (sibling.commits.length === 0) {
+                    ui.muted("  Sin commits detectados.");
+                }
+                else {
+                    ui.table(["SHA", "Mensaje"], sibling.commits.map((c) => [c.sha, c.subject]), true);
+                }
+            }
+            ui.subsection(`${currentBranch}  ← rama actual`);
+            if (currentBranchCommits.length === 0) {
+                ui.muted("  Sin commits detectados.");
+            }
+            else {
+                ui.table(["SHA", "Mensaje"], currentBranchCommits.map((c) => [c.sha, c.subject]), true);
+            }
         }
         // ─── Pipeline de análisis ────────────────────────────────────────────────
         ui.spinner.start("Analizando cambios del working tree...");

package/dist/git/git.js

@@ -226,73 +226,123 @@ export function localAheadCount(baseBranch) {
     const count = shSafe(`git rev-list ${q(baseBranch)}..HEAD --count`);
     return parseInt(count, 10) || 0;
 }
+/** Devuelve los commits de `branchRef` que no están en `baseBranch`. */
+function getCommitsAheadOf(branchRef, baseBranch) {
+    const raw = shSafe(`git log ${q(baseBranch)}..${q(branchRef)} --pretty=format:%h%n%s`);
+    if (!raw.trim())
+        return [];
+    const lines = raw.split("\n");
+    const out = [];
+    for (let i = 0; i + 1 < lines.length; i += 2) {
+        const sha = lines[i].trim();
+        const subject = lines[i + 1]?.trim() ?? "";
+        if (sha)
+            out.push({ sha, subject });
+    }
+    return out;
+}
 /**
- * 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`.
+ * Descubre ramas hermanas de la cascada (sin `currentBranch`), ordenadas
+ * por committerdate descendente (la más reciente primero).
  */
-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()}`;
-    // Construir lista de ramas locales Y remotas para no perder ramas hermanas
-    // que existen en el remoto pero aún no han sido descargadas localmente.
-    // Para cada entrada guardamos { name, ref }:
-    //   - name: nombre de la rama sin prefijo de remoto (para mostrar al usuario y para checkout)
-    //   - ref:  ref resolvible por git (local: igual al name; remota: "origin/feature/…")
+function discoverSortedSiblings(currentBranch, baseBranch, familyPrefix) {
     const branches = [];
-    // Ramas locales
+    const seenNames = new Set();
+    // 1. Ramas locales
     const localRaw = shSafe("git branch --format=%(refname:short)");
     for (const b of localRaw.split("\n").map((s) => s.trim()).filter(Boolean)) {
         branches.push({ name: b, ref: b });
+        seenNames.add(b.toUpperCase());
     }
-    // Ramas remotas (ej. "origin/feature/FASTY-0001-xyz")
-    // Se usa el nombre sin el prefijo del remoto (primer segmento hasta "/").
-    // Si ya existe la rama localmente, se omite (la ref local tiene precedencia).
+    // 2. Ramas remotas ya cacheadas localmente (git branch -r)
     const remoteRaw = shSafe("git branch -r --format=%(refname:short)");
     for (const b of remoteRaw.split("\n").map((s) => s.trim()).filter(Boolean)) {
         const slash = b.indexOf("/");
         if (slash < 0)
             continue;
-        const name = b.slice(slash + 1); // "origin/feature/…" → "feature/…"
+        const name = b.slice(slash + 1);
         if (!name || name.startsWith("HEAD"))
             continue;
-        if (!branches.some((x) => x.name === name)) {
-            branches.push({ name, ref: b }); // ref = "origin/feature/…" (resolvible sin checkout)
+        if (!seenNames.has(name.toUpperCase())) {
+            branches.push({ name, ref: b });
+            seenNames.add(name.toUpperCase());
+        }
+    }
+    // 3. git ls-remote — ramas que existen en el remoto pero nunca fueron descargadas
+    const remote = shSafe("git remote").split("\n")[0]?.trim() || "origin";
+    const lsRemoteRaw = shSafe(`git ls-remote --heads ${q(remote)} ${q(`refs/heads/${familyPrefix}*`)}`);
+    for (const line of lsRemoteRaw.split("\n").map((s) => s.trim()).filter(Boolean)) {
+        const tabIdx = line.indexOf("\t");
+        if (tabIdx < 0)
+            continue;
+        const ref = line.slice(tabIdx + 1);
+        const name = ref.replace(/^refs\/heads\//, "");
+        if (!name || seenNames.has(name.toUpperCase()))
+            continue;
+        const trackingRef = `refs/remotes/${remote}/${name}`;
+        const resolvedRef = shSafe(`git rev-parse --verify ${q(trackingRef)}`).trim()
+            ? `${remote}/${name}`
+            : ref;
+        if (resolvedRef === ref) {
+            shSafe(`git fetch ${q(remote)} ${q(`refs/heads/${name}:refs/remotes/${remote}/${name}`)} --no-tags`);
         }
+        branches.push({ name, ref: `${remote}/${name}` });
+        seenNames.add(name.toUpperCase());
     }
     const candidates = branches.filter(({ name }) => name !== currentBranch &&
         name.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.
-    // Si la rama solo existe en el remoto, la ref "origin/feature/…" es
-    // resolvible directamente por git sin necesidad de checkout local.
+        return [];
     const withAhead = candidates.filter(({ ref }) => {
         const count = shSafe(`git rev-list ${q(baseBranch)}..${q(ref)} --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) => {
+        return [];
+    return withAhead.sort((a, b) => {
         const dateA = shSafe(`git log -1 --format=%ct ${q(a.ref)}`);
         const dateB = shSafe(`git log -1 --format=%ct ${q(b.ref)}`);
         return (parseInt(dateB, 10) || 0) - (parseInt(dateA, 10) || 0);
     });
-    // Retornar el nombre sin prefijo de remoto para que el usuario pueda usar
-    // "git checkout <name>" y git resuelva automáticamente la ref de tracking.
+}
+/**
+ * Busca la rama hermana más reciente de la misma "familia" con commits adelantados
+ * respecto a `baseBranch`, excluyendo `currentBranch`.
+ *
+ * @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) {
+    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()}`;
+    const sorted = discoverSortedSiblings(currentBranch, baseBranch, familyPrefix);
     return sorted[0]?.name ?? null;
 }
+/**
+ * Devuelve todas las ramas hermanas de la cascada en orden cronológico
+ * (la más antigua primero) con sus commits respecto a `baseBranch`.
+ */
+export function findCascadeSiblings(currentBranch, baseBranch) {
+    const familyMatch = currentBranch.match(/^(feature|fix|bugfix|hotfix|refactor|chore|docs|test|perf|ci)\/([A-Z]+-\d+)/i);
+    if (!familyMatch)
+        return [];
+    const familyPrefix = `${familyMatch[1]}/${familyMatch[2].toUpperCase()}`;
+    // reverse() porque discoverSortedSiblings devuelve la más reciente primero
+    const sorted = discoverSortedSiblings(currentBranch, baseBranch, familyPrefix).reverse();
+    return sorted.map(({ name, ref }) => ({
+        name,
+        commits: getCommitsAheadOf(ref, baseBranch),
+    }));
+}
+/**
+ * Devuelve los commits de HEAD adelantados respecto a `baseBranch`.
+ */
+export function localAheadCommits(baseBranch) {
+    return getCommitsAheadOf("HEAD", baseBranch);
+}
 /**
  * Hace push de una rama local al remoto indicado.
  *

package/dist/output/report.js

@@ -505,6 +505,21 @@ export function renderHtmlReport(input) {
             ? `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.`;
+        const allBranches = [
+            ...cw.siblings,
+            { name: currentBranch, commits: cw.currentBranchCommits, isCurrent: true }
+        ];
+        const cascadeStateHtml = allBranches.map((branch) => {
+            const commitsHtml = branch.commits.length > 0
+                ? `<ul style="margin:4px 0 0 0;padding:0;list-style:none">${branch.commits.map((c) => `<li style="font-size:.82em;padding:2px 0">` +
+                    `<code style="color:#60a5fa;margin-right:8px">${esc(c.sha)}</code>` +
+                    `<span style="opacity:.9">${esc(c.subject)}</span></li>`).join("")}</ul>`
+                : `<div style="font-size:.8em;opacity:.5;margin-top:2px">Sin commits</div>`;
+            return `<div style="margin:6px 0;padding:8px 10px;background:rgba(0,0,0,.15);border-radius:5px;border-left:3px solid ${branch.isCurrent ? "#fbbf24" : "#94a3b8"}">
+        <div style="font-weight:600;font-size:.88em;color:${branch.isCurrent ? "#fbbf24" : "#94a3b8"}">${esc(branch.name)}${branch.isCurrent ? " <span style=\"font-size:.8em;opacity:.7\">← rama actual</span>" : ""}</div>
+        ${commitsHtml}
+      </div>`;
+        }).join("");
         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">
@@ -519,6 +534,10 @@ export function renderHtmlReport(input) {
       <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>
+      <div style="margin-top:14px">
+        <p style="margin:0 0 6px;font-weight:600;font-size:.9em">Estado de la cascada:</p>
+        ${cascadeStateHtml}
+      </div>
       <p class="disclaimer-footer" style="margin-top:8px">Este reporte es informativo. El apply quedó deshabilitado en esta ejecución para preservar la integridad del plan en cascada.</p>
     </div>
   </section>`;

package/package.json

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