pull-request-split-advisor 3.2.6 → 3.2.7

package/dist/git/git.js

@@ -243,40 +243,73 @@ export function findCascadeParent(currentBranch, baseBranch) {
     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.
+    // Construir lista de candidatos desde tres fuentes (en orden de precedencia):
+    //   1. Ramas locales
+    //   2. Refs de tracking remoto ya descargadas (git branch -r)
+    //   3. Ramas que existen en el remoto pero nunca fueron descargadas (git ls-remote)
+    //
     // 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/…")
+    //   - name: nombre sin prefijo de remoto (para mostrar al usuario y hacer checkout)
+    //   - ref:  ref resolvible por git (local o "origin/branch")
     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. Consultar el remoto directamente con git ls-remote para descubrir
+    //    ramas que existen en el servidor pero nunca fueron descargadas.
+    //    Filtramos por el prefijo familia para que sea rápido incluso con
+    //    repositorios que tienen cientos de ramas.
+    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)) {
+        // Formato: "<sha>\trefs/heads/<name>"
+        const tabIdx = line.indexOf("\t");
+        if (tabIdx < 0)
+            continue;
+        const ref = line.slice(tabIdx + 1); // "refs/heads/feature/…"
+        const name = ref.replace(/^refs\/heads\//, "");
+        if (!name || seenNames.has(name.toUpperCase()))
+            continue;
+        // Usar "<remote>/<name>" como ref resolvible si el tracking existe,
+        // o la ref completa "refs/remotes/<remote>/<name>" como fallback.
+        // Para git rev-list y git log podemos usar directamente la ref completa.
+        const trackingRef = `refs/remotes/${remote}/${name}`;
+        const resolvedRef = shSafe(`git rev-parse --verify ${q(trackingRef)}`).trim()
+            ? `${remote}/${name}`
+            : ref; // "refs/heads/<name>" solo funciona si fue fetched; caer en ls-remote sha
+        // Si no hay tracking local, no podemos resolver commits sin fetch.
+        // En ese caso hacemos un fetch puntual de esa única rama antes de usarla.
+        if (resolvedRef === ref) {
+            // fetch puntual y silencioso de solo esta rama para obtener su historial
+            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.
     const withAhead = candidates.filter(({ ref }) => {
         const count = shSafe(`git rev-list ${q(baseBranch)}..${q(ref)} --count`);
         return (parseInt(count, 10) || 0) > 0;

package/package.json

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