pull-request-split-advisor 3.1.2 → 3.2.1

package/README.md

@@ -27,6 +27,8 @@ 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.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.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.
 
 ---
@@ -38,6 +40,7 @@ A partir de la **v3.1.0**, el proyecto incluye una **suite completa de tests** (
 - Cálculo de score de calidad por rama (0–5) con factores ponderados
 - Generación de nombres de rama y mensajes de commit convencionales
 - Reporte HTML interactivo exportado automáticamente (8 secciones: hero ejecutivo, resumen de cambios, TOC con barras de score, detalle de archivos, dependencias, bloques, plan de commits con línea de tiempo y comandos git listos para ejecutar) — ver [formato completo](docs/FEATURES.md#reporte-html-interactivo)
+- **`score`**: subcomando (v3.2.0+) que calcula el score del estado actual sin dividir y genera `pr-split-score.html` con desglose completo de métricas
 - Exportación del plan en formato JSON para integraciones externas
 - Historial de scores con seguimiento entre análisis
 - Validaciones de nomenclatura de ramas y estado del working tree
@@ -74,6 +77,10 @@ pr-split-advisor --apply
 # Especificar rama base de forma explícita
 pr-split-advisor --base develop
 
+# Ver el score actual de la rama sin dividir en PRs
+pr-split-advisor score
+pr-split-advisor score --base develop
+
 # Consultar historial de análisis anteriores
 pr-split-advisor --stats
 

package/dist/ai/config-wizard.js

@@ -60,7 +60,7 @@ async function testApiKeyConnection(provider, model, apiKey, apiKeyEnvVar) {
             model,
             apiKey,
             apiKeyEnvVar,
-            features: { commitMessages: false, branchDescriptions: false },
+            features: { commitMessages: false, branchDescriptions: false, planRebalance: false },
             timeoutMs: 10000,
             maxTokens: 16,
         },
@@ -227,7 +227,7 @@ export async function runConfigWizard() {
  * Valida la key contra el proveedor antes de guardar. Si falla, aborta con error.
  *
  * @param apiKey   - La API key del proveedor (literal, no nombre de env var).
- * @param provider - ID del proveedor: "groq" | "github" | "copilot". Predeterminado: "groq".
+ * @param provider - ID del proveedor: "groq" | "copilot". Predeterminado: "groq".
  */
 export async function runConfigWithKey(apiKey, provider = "groq") {
     const configPath = resolve(process.cwd(), CONFIG_FILE);

package/dist/cli.js

@@ -30,9 +30,10 @@ 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 { exportJson, writeHtmlReport, writeScoreHtmlReport } from "./output/report.js";
 import { appendHistory, readHistory } from "./core/history.js";
 import { buildSuggestedMessage } from "./core/commit-planner.js";
+import { scorePullRequest } from "./core/scoring.js";
 import { ui, closeReadlineInterface } from "./output/ui.js";
 import { changeTypeLabel } from "./shared/utils.js";
 import { aiEnrichPlans } from "./ai/enricher.js";
@@ -279,6 +280,7 @@ async function main() {
             config.jsonOutputFile,
             "pr-split-advisor.config.json",
             "pr-split-report.html",
+            "pr-split-score.html",
             config.historyFile
         ].filter(Boolean);
         if (config.verbose) {
@@ -417,6 +419,85 @@ async function main() {
         }
         closeReadlineInterface();
     });
+    // ─── Subcomando: score ───────────────────────────────────────────────────
+    program
+        .command("score")
+        .description("Muestra el score del estado actual de la rama sin dividir")
+        .option("-b, --base <branch>", "rama base para calcular los cambios")
+        .action(async (opts) => {
+        const config = loadConfig();
+        try {
+            requireGitRepo();
+        }
+        catch (error) {
+            ui.error(error.message);
+            closeReadlineInterface();
+            process.exit(1);
+        }
+        const baseBranch = opts.base ?? config.baseBranch ?? "main";
+        const currentBranch = getCurrentBranch();
+        config.runtimeExcludedFiles = [
+            config.jsonOutputFile,
+            "pr-split-advisor.config.json",
+            "pr-split-report.html",
+            "pr-split-score.html",
+            config.historyFile
+        ].filter(Boolean);
+        ui.spinner.start("Calculando score del estado actual...");
+        const changedFiles = gatherChangedFiles(config, baseBranch);
+        if (!changedFiles.length) {
+            ui.spinner.stop();
+            ui.warn("No hay cambios respecto a la rama base.");
+            closeReadlineInterface();
+            return;
+        }
+        const fileStats = getFileStats(changedFiles, baseBranch);
+        ui.spinner.stop("Calculo completado.");
+        const totalFiles = fileStats.length;
+        const totalLines = fileStats.reduce((sum, f) => sum + f.lines, 0);
+        const aheadCommits = localAheadCount(baseBranch);
+        const commitCount = Math.max(aheadCommits, 1);
+        const filesPerCommit = Number((totalFiles / commitCount).toFixed(2));
+        const avgLinesPerCommit = Math.round(totalLines / commitCount);
+        const result = scorePullRequest({ commitCount, filesPerCommit, avgLinesPerCommit, totalLinesChanged: totalLines }, config);
+        const warnThreshold = config.targetScore > 4 ? 4 : Math.max(0, config.targetScore - 1);
+        const scoreColor = ui.scoreColor(result.complexity, config.targetScore);
+        const statusBadge = result.complexity >= config.targetScore
+            ? ui.badge("ÓPTIMO", "green")
+            : result.complexity >= warnThreshold
+                ? ui.badge("ACEPTABLE", "yellow")
+                : ui.badge("RIESGO", "red");
+        const scoreHtmlFile = "pr-split-score.html";
+        writeScoreHtmlReport(scoreHtmlFile, {
+            currentBranch,
+            baseBranch,
+            config,
+            fileStats,
+            commitCount,
+            filesPerCommit,
+            avgLinesPerCommit,
+            result
+        });
+        ui.ok(`Reporte HTML generado: ${scoreHtmlFile}`);
+        ui.card(`Score actual de la rama: ${currentBranch}`, [
+            `${statusBadge}`,
+            "",
+            `Rama base:              ${baseBranch}`,
+            `Archivos cambiados:     ${totalFiles}`,
+            `Líneas totales:         ${totalLines}`,
+            `Commits adelantados:    ${commitCount}`,
+            `Archivos por commit:    ${filesPerCommit}`,
+            `Líneas por commit (avg):${avgLinesPerCommit}`,
+            "",
+            `Score:                  ${ui.score(result.complexity, config.targetScore)}`,
+            `Score objetivo:         ${config.targetScore}`,
+            "",
+            ...Object.values(result.metrics).map((m) => `  ${m.label}: valor=${m.rawValue}  pts=${m.points}  pond=${m.weightedScore}`),
+            "",
+            `Recomendación:          ${result.recommendation}`
+        ], scoreColor);
+        closeReadlineInterface();
+    });
     // ─── Subcomando: config ──────────────────────────────────────────────────
     program
         .command("config")

package/dist/config/config.js

@@ -304,7 +304,7 @@ export function loadConfig(configPath = "pr-split-advisor.config.json") {
         }
         if (isObject(ai["features"])) {
             const f = ai["features"];
-            for (const flag of ["commitMessages", "branchDescriptions"]) {
+            for (const flag of ["commitMessages", "branchDescriptions", "planRebalance"]) {
                 if (flag in f && typeof f[flag] !== "boolean") {
                     throw new Error(`Configuración inválida: "ai.features.${flag}" debe ser true o false (recibido: ${JSON.stringify(f[flag])}).`);
                 }

package/dist/config/default-config.js

@@ -188,9 +188,8 @@ export const defaultConfig = {
     //
     // Configurar vía `pr-split-advisor config` o editando directamente el JSON.
     //
-    // Opciones de `provider` soportadas: "groq" | "github" | "copilot"
+    // Opciones de `provider` soportadas: "groq" | "copilot"
     //   groq    → requiere GROQ_API_KEY  (console.groq.com, free tier)
-    //   github  → requiere GITHUB_TOKEN  (github.com/marketplace/models, free)
     //   copilot → sin token — usa automáticamente credenciales de gh CLI
     //
     // API key: preferir `apiKeyEnvVar` (ej: GROQ_API_KEY) antes que literal `apiKey`.

package/dist/output/report.js

@@ -706,6 +706,141 @@ function handleCopy(btn) {
 export function writeHtmlReport(filePath, input) {
     writeFileSync(filePath, renderHtmlReport(input), "utf8");
 }
+/**
+ * Genera el reporte HTML del subcomando `score` como string.
+ * Muestra el score actual de la rama sin dividir, con desglose de métricas y detalle de archivos.
+ */
+export function renderScoreHtmlReport(input) {
+    const { currentBranch, baseBranch, config, fileStats, commitCount, filesPerCommit, avgLinesPerCommit, result } = input;
+    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 maxLinesForBar = totalFiles > 0 ? Math.max(...fileStats.map((f) => f.lines)) : 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";
+    const timestamp = new Date().toLocaleString("es-PE", {
+        year: "numeric", month: "long", day: "numeric",
+        hour: "2-digit", minute: "2-digit"
+    });
+    const metricRows = Object.values(result.metrics).map((m) => {
+        const ptsPct = Math.round((m.points / 5) * 100);
+        const barColor = m.points >= 4 ? "#16a34a" : m.points >= 3 ? "#d97706" : "#dc2626";
+        const ptsClass = m.points >= 4 ? "pts-good" : m.points >= 3 ? "pts-warn" : "pts-bad";
+        return `<tr>
+      <td><code class="metric-code">${esc(m.code)}</code></td>
+      <td class="metric-label">${esc(m.label)}</td>
+      <td class="metric-value">${m.rawValue}</td>
+      <td>
+        <div class="pts-bar-wrap"><div class="pts-bar" style="width:${ptsPct}%;background:${barColor}"></div></div>
+        <span class="${ptsClass}">${m.points} / 5</span>
+      </td>
+      <td class="metric-weight">${(m.weight * 100).toFixed(0)}%</td>
+      <td class="metric-contrib">${m.weightedScore.toFixed(3)}</td>
+    </tr>`;
+    }).join("");
+    return `<!doctype html>
+<html lang="es">
+<head>
+  <meta charset="utf-8" />
+  <meta name="viewport" content="width=device-width, initial-scale=1" />
+  <title>Score actual – ${esc(currentBranch)}</title>
+  <style>${buildReportStyles()}</style>
+</head>
+<body>
+<div class="container">
+
+  <header class="hero">
+    <div class="hero-top">
+      <div class="hero-title-area">
+        <h1>📊 Score actual de la rama</h1>
+        <p>Análisis del estado presente sin dividir en múltiples PRs.</p>
+      </div>
+      <div class="hero-timestamp">📅 ${timestamp}</div>
+    </div>
+    <div class="hero-grid">
+      <div class="hero-item"><div class="label">Rama analizada</div><div class="value">⎇ ${esc(currentBranch)}</div></div>
+      <div class="hero-item"><div class="label">Rama base</div><div class="value">⎇ ${esc(baseBranch)}</div></div>
+      <div class="hero-item"><div class="label">Score actual</div><div class="value">${result.complexity.toFixed(2)}</div></div>
+      <div class="hero-item"><div class="label">Score objetivo</div><div class="value">${config.targetScore} / 5.00</div></div>
+      <div class="hero-item"><div class="label">Archivos</div><div class="value">${totalFiles}</div></div>
+      <div class="hero-item"><div class="label">Líneas totales</div><div class="value">${totalLines}</div></div>
+      <div class="hero-item"><div class="label">Commits adelantados</div><div class="value">${commitCount}</div></div>
+      <div class="hero-item"><div class="label">Estado</div><div class="value score-label-${scoreClass}">${esc(label)}</div></div>
+    </div>
+  </header>
+
+  <section class="section">
+    <h2 class="section-heading">🎯 Score</h2>
+    <div class="card" style="display:flex;align-items:center;gap:32px;padding:24px">
+      ${buildScoreGaugeSvg(result.complexity, config.targetScore)}
+      <div>
+        <div style="font-size:2rem;font-weight:800;color:${result.complexity >= config.targetScore ? "#16a34a" : result.complexity >= warnThreshold ? "#d97706" : "#dc2626"}">${result.complexity.toFixed(2)} / 5.00</div>
+        <div class="badge ${scoreClass}" style="margin-top:8px">${esc(label)}</div>
+        <p style="margin-top:12px;color:#64748b">${esc(result.recommendation)}</p>
+      </div>
+    </div>
+  </section>
+
+  <section class="section">
+    <h2 class="section-heading">📊 Desglose de métricas</h2>
+    <table class="metrics-table">
+      <thead>
+        <tr><th>Cód.</th><th>Métrica</th><th>Valor medido</th><th>Puntos</th><th>Peso</th><th>Aporte</th></tr>
+      </thead>
+      <tbody>
+        ${metricRows}
+        <tr class="metrics-total-row">
+          <td colspan="5" style="text-align:right;font-weight:700;">Score total</td>
+          <td class="metric-total-value">${result.complexity.toFixed(3)}</td>
+        </tr>
+      </tbody>
+    </table>
+  </section>
+
+  <section class="section">
+    <h2 class="section-heading">📈 Valores brutos usados</h2>
+    <div class="summary-grid">
+      <div class="stat-card blue"><div class="label">Commits</div><div class="value">${commitCount}</div></div>
+      <div class="stat-card blue"><div class="label">Archivos / commit</div><div class="value">${filesPerCommit}</div></div>
+      <div class="stat-card blue"><div class="label">Líneas / commit (avg)</div><div class="value">${avgLinesPerCommit}</div></div>
+      <div class="stat-card blue"><div class="label">Total de líneas</div><div class="value">${totalLines}</div></div>
+      <div class="stat-card green"><div class="label">Líneas agregadas</div><div class="value">+${totalAdditions}</div></div>
+      <div class="stat-card red"><div class="label">Líneas eliminadas</div><div class="value">-${totalDeletions}</div></div>
+    </div>
+  </section>
+
+  <section class="section">
+    <h2 class="section-heading">📄 Detalle de archivos</h2>
+    <table>
+      <thead>
+        <tr><th>Tipo</th><th>Archivo</th><th>Líneas</th><th>Cambios (+/-)</th><th>Prioridad</th></tr>
+      </thead>
+      <tbody>
+        ${fileStats.map((f) => buildFilesBarsRow(f, maxLinesForBar)).join("")}
+      </tbody>
+    </table>
+  </section>
+
+  <footer class="footer">
+    <p>Generado por <strong>${APP_REPORT_TITLE}</strong> · ${timestamp}</p>
+    <p>Rama: <strong>${esc(currentBranch)}</strong> vs <strong>${esc(baseBranch)}</strong> · Score: <strong>${result.complexity.toFixed(2)}</strong> · Objetivo: <strong>${config.targetScore}</strong></p>
+  </footer>
+
+</div>
+</body>
+</html>`;
+}
+/**
+ * Genera el reporte HTML de score puntual y lo escribe en disco.
+ *
+ * @param filePath - Ruta de destino del archivo HTML.
+ * @param input    - Datos del análisis de score.
+ */
+export function writeScoreHtmlReport(filePath, input) {
+    writeFileSync(filePath, renderScoreHtmlReport(input), "utf8");
+}
 /**
  * Genera el JSON serializado del plan.
  * @param plans         - Lista de planes de rama.

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "pull-request-split-advisor",
-  "version": "3.1.2",
+  "version": "3.2.1",
   "description": "CLI that analyses your Git working tree and suggests how to split changes into smaller, reviewable pull requests and commits.",
   "keywords": [
     "git",
@@ -33,7 +33,7 @@
   ],
   "scripts": {
     "build:styles": "node scripts/compile-styles.cjs",
-    "build": "npm run build:styles && tsc -p tsconfig.json",
+    "build": "npm run build:styles && tsc -p tsconfig.build.json",
     "prepare": "npm run build",
     "dev": "tsx src/cli.ts",
     "start": "node dist/cli.js",

package/scripts/postinstall.cjs

@@ -83,30 +83,56 @@ async function main() {
     );
   }
 
-  // ── Añadir la entrada al .gitignore del proyecto consumidor ─────────────
+  // ── Añadir entradas al .gitignore del proyecto consumidor ──────────────
   // La config es local por equipo/desarrollador y no debe versionarse.
-  const gitignorePath  = join(targetDir, ".gitignore");
-  const gitignoreEntry = "pr-split-advisor.config.json";
+  // Los artefactos generados (reportes HTML, plan JSON, historial) tampoco.
+  const gitignorePath = join(targetDir, ".gitignore");
+
+  const gitignoreEntries = [
+    {
+      entry: "pr-split-advisor.config.json",
+      comment: "# pr-split-advisor — config local (no compartir en el repositorio)"
+    },
+    { entry: "pr-split-report.html",   comment: null },
+    { entry: "pr-split-score.html",    comment: null },
+    { entry: "pr-split-plan.json",     comment: null },
+    { entry: ".pr-split-history.json", comment: null }
+  ];
+
+  // Cabecera del grupo de artefactos: solo se añade si al menos uno de ellos
+  // no está ya en el .gitignore, y solo una vez para todo el grupo.
+  const artifactEntries = ["pr-split-report.html", "pr-split-score.html", "pr-split-plan.json", ".pr-split-history.json"];
 
   try {
     const currentContent = existsSync(gitignorePath)
       ? readFileSync(gitignorePath, "utf-8")
       : "";
 
-    const alreadyIgnored = currentContent
-      .split("\n")
-      .map((l) => l.trim())
-      .includes(gitignoreEntry);
+    const existingLines = currentContent.split("\n").map((l) => l.trim());
+    let block = currentContent.length && !currentContent.endsWith("\n") ? "\n" : "";
+    let addedAny = false;
+    let artifactHeaderAdded = false;
+
+    for (const { entry, comment } of gitignoreEntries) {
+      if (existingLines.includes(entry)) continue;
 
-    if (!alreadyIgnored) {
-      const block =
-        (currentContent.length && !currentContent.endsWith("\n") ? "\n" : "") +
-        "\n# pr-split-advisor — config local (no compartir en el repositorio)\n" +
-        gitignoreEntry + "\n";
+      const isArtifact = artifactEntries.includes(entry);
+      if (isArtifact && !artifactHeaderAdded && !comment) {
+        // Escribir la cabecera de artefactos la primera vez que haya uno nuevo
+        block += "\n# pr-split-advisor \u2014 artefactos generados\n";
+        artifactHeaderAdded = true;
+      } else if (comment) {
+        block += "\n" + comment + "\n";
+      }
+
+      block += entry + "\n";
+      addedAny = true;
+    }
 
+    if (addedAny) {
       appendFileSync(gitignorePath, block, "utf-8");
       console.log(
-        "[pr-split-advisor] ✔ Añadido pr-split-advisor.config.json al .gitignore"
+        "[pr-split-advisor] ✔ Añadidas entradas de pr-split-advisor al .gitignore"
       );
     }
   } catch (err) {