@alexis-reillo/git-helper 0.1.0

package/README.md

@@ -0,0 +1,91 @@
+# git-helper (CLI)
+
+Analiza Pull Requests de GitHub usando Inteligencia Artificial, directamente desde la terminal.
+
+## Instalación
+
+```bash
+# Uso puntual, sin instalar
+npx @alexis-reillo/git-helper analyze -o vercel -r next.js -p 12345
+
+# Instalación global
+npm i -g @alexis-reillo/git-helper
+git-helper analyze -o vercel -r next.js -p 12345
+```
+
+Requiere **Node.js >= 18**.
+
+## Uso
+
+### Comandos
+
+| Comando             | Alias     | Descripción                                  |
+| ------------------- | --------- | -------------------------------------------- |
+| `git-helper`        | —         | Muestra el banner y la ayuda.                |
+| `git-helper list`   | `ls`      | Lista tus Pull Requests pendientes de revisar (requiere `GITHUB_TOKEN`). |
+| `git-helper review` | `analyze` | Analiza un PR concreto con IA.               |
+| `git-helper config` | —         | Gestiona la configuración guardada (claves y tokens). |
+
+#### `review`
+
+```bash
+git-helper review --owner <owner> --repo <repo> --pr <number>
+```
+
+| Opción            | Alias | Descripción                          |
+| ----------------- | ----- | ------------------------------------ |
+| `--owner <owner>` | `-o`  | Propietario del repo (ej: `vercel`)  |
+| `--repo <repo>`   | `-r`  | Nombre del repositorio (ej: `next.js`) |
+| `--pr <number>`   | `-p`  | Número del Pull Request              |
+| `--json`          | —     | Imprime el resultado en JSON (sin formato visual) |
+
+#### `list`
+
+```bash
+export GITHUB_TOKEN=ghp_...
+git-helper list           # tabla bonita
+git-helper list --json    # salida JSON para scripts
+```
+
+#### `config`
+
+Guarda tus claves de forma persistente en `~/.config/git-helper/.env` (permisos
+`0600`), como alternativa a exportar variables de entorno cada vez.
+
+```bash
+git-helper config set GITHUB_TOKEN ghp_...
+git-helper config set AI_PROVIDER gemini
+git-helper config set GOOGLE_GENERATIVE_AI_API_KEY ...
+git-helper config list     # secretos enmascarados
+git-helper config unset OPENAI_API_KEY
+git-helper config path     # ruta del archivo
+```
+
+Prioridad de configuración: **variables de entorno reales** > `.env` del directorio
+actual > config global guardada.
+
+> **Tip visual:** la interfaz usa color truecolor y arte ASCII. Para que la
+> mascota y los iconos se vean perfectos, usa una terminal moderna (Windows
+> Terminal, iTerm2…) con una [Nerd Font](https://www.nerdfonts.com/).
+
+## Configuración (variables de entorno)
+
+La CLI lee la configuración del entorno del sistema (o de un archivo `.env` en el
+directorio actual). Necesitas, como mínimo, la clave del proveedor de IA elegido.
+
+| Variable                          | Requerida           | Descripción                                                    |
+| --------------------------------- | ------------------- | -------------------------------------------------------------- |
+| `AI_PROVIDER`                     | No (`gemini`)       | Proveedor de IA: `gemini` u `openai`.                          |
+| `GOOGLE_GENERATIVE_AI_API_KEY`    | Si `AI_PROVIDER=gemini` | Clave de [Google AI Studio](https://aistudio.google.com/apikey). |
+| `OPENAI_API_KEY`                  | Si `AI_PROVIDER=openai` | Clave de OpenAI.                                          |
+| `AI_MODEL`                        | No                  | Fuerza un modelo concreto (por defecto `gemini-2.5-flash` / `gpt-4o-mini`). |
+| `AI_ENSEMBLE_RUNS`                | No (`3`)            | Nº de ejecuciones del ensemble por análisis (mediana). `1` lo desactiva. |
+| `GITHUB_TOKEN`                    | No                  | Sube el rate limit y permite analizar repos privados.          |
+
+Ejemplo en bash:
+
+```bash
+export AI_PROVIDER=gemini
+export GOOGLE_GENERATIVE_AI_API_KEY=tu_clave
+git-helper analyze -o vercel -r next.js -p 12345
+```

package/dist/index.js

@@ -0,0 +1,658 @@
+#!/usr/bin/env node
+"use strict";
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+
+// src/index.ts
+var import_dotenv2 = __toESM(require("dotenv"));
+var import_commander = require("commander");
+var import_ora = __toESM(require("ora"));
+
+// ../../packages/core/src/index.ts
+var import_rest = require("@octokit/rest");
+var import_ai = require("ai");
+var import_openai = require("@ai-sdk/openai");
+var import_google = require("@ai-sdk/google");
+var import_zod = require("zod");
+var RECOMENDACIONES = [
+  "aprobar",
+  "cambios_menores",
+  "cambios_mayores",
+  "bloqueado"
+];
+var PRAnalysisSchema = import_zod.z.object({
+  resumen_ejecutivo: import_zod.z.string().describe("Resumen de 2 frases de lo que hace el PR"),
+  posibles_bugs: import_zod.z.array(import_zod.z.string()).describe("Lista de posibles bugs o errores l\xF3gicos"),
+  apto_para_merge: import_zod.z.boolean().describe("True si no hay bugs cr\xEDticos ni mayores"),
+  puntuacion_codigo: import_zod.z.number().min(1).max(10).describe("Puntuaci\xF3n de calidad del 1 al 10"),
+  recomendacion: import_zod.z.enum(RECOMENDACIONES).describe("Recomendaci\xF3n categ\xF3rica de revisi\xF3n")
+});
+var DEFAULT_MODELS = {
+  gemini: "gemini-2.5-flash",
+  // Rápido y con free tier en Google AI Studio
+  openai: "gpt-4o-mini"
+  // Rápido y barato
+};
+function resolveModel(provider, model) {
+  const selected = (provider ?? process.env.AI_PROVIDER ?? "gemini").toLowerCase();
+  const modelName = model ?? process.env.AI_MODEL;
+  switch (selected) {
+    case "gemini":
+    case "google":
+      if (!process.env.GOOGLE_GENERATIVE_AI_API_KEY) {
+        throw new Error(
+          'Falta la variable de entorno GOOGLE_GENERATIVE_AI_API_KEY requerida para el proveedor "gemini".'
+        );
+      }
+      return (0, import_google.google)(modelName ?? DEFAULT_MODELS.gemini);
+    case "openai":
+      if (!process.env.OPENAI_API_KEY) {
+        throw new Error(
+          'Falta la variable de entorno OPENAI_API_KEY requerida para el proveedor "openai".'
+        );
+      }
+      return (0, import_openai.openai)(modelName ?? DEFAULT_MODELS.openai);
+    default:
+      throw new Error(
+        `AI_PROVIDER desconocido: "${selected}". Valores v\xE1lidos: "gemini" u "openai".`
+      );
+  }
+}
+var SCORING_RUBRIC = `Eres un ingeniero de software Senior revisando un Pull Request. Eval\xFAa \xDANICAMENTE el diff proporcionado.
+
+Criterios a revisar, por orden de importancia (basados en el est\xE1ndar de Google):
+1. Dise\xF1o: \xBFencajan e interact\xFAan bien las piezas del cambio? \xBFpertenece aqu\xED y se integra con el resto del sistema?
+2. Complejidad / over-engineering: \xBFes m\xE1s complejo o gen\xE9rico de lo necesario? \xBFse entiende r\xE1pido al leerlo?
+3. Correctitud y bugs: errores l\xF3gicos, casos l\xEDmite, concurrencia.
+4. Seguridad: inyecci\xF3n, fuga de secretos, autenticaci\xF3n y permisos.
+5. Manejo de errores y casos l\xEDmite.
+6. Tests: \xBFhay pruebas correctas para los cambios?
+7. Legibilidad/mantenibilidad y rendimiento.
+
+Clasifica cada problema que encuentres por severidad, de forma ESTRICTA y CONSISTENTE:
+- "critico": bug que rompe funcionalidad, vulnerabilidad de seguridad, fuga de secretos, o cualquier cosa que bloquee el merge.
+- "mayor": problema notable que conviene resolver (dise\xF1o deficiente, validaci\xF3n ausente, manejo de errores pobre, deuda t\xE9cnica relevante, regresi\xF3n funcional, l\xF3gica nueva sin tests).
+- "menor": mejora opcional no bloqueante (estilo, naming, micro-optimizaci\xF3n, documentaci\xF3n).
+
+Ejemplos de calibraci\xF3n (para anclar la severidad de forma consistente):
+- "Concatena entrada del usuario en una query SQL sin parametrizar" => critico (seguridad).
+- "Expone una clave/API key o secreto en el c\xF3digo" => critico (fuga de secretos).
+- "No comprueba si el array est\xE1 vac\xEDo antes de acceder a [0]" => mayor (caso l\xEDmite no manejado).
+- "A\xF1ade una rama de error nueva pero ning\xFAn test que la cubra" => mayor (tests ausentes en l\xF3gica relevante).
+- "Abstracci\xF3n gen\xE9rica para un \xFAnico caso de uso actual" => mayor (over-engineering).
+- "Variable poco descriptiva como 'x' o falta un comentario" => menor (legibilidad).
+
+Reglas obligatorias:
+- Incluye SOLO problemas reales y concretos presentes en el diff; nada gen\xE9rico ni especulativo. Prioriza precisi\xF3n sobre exhaustividad (menos ruido, m\xE1s se\xF1al).
+- El mismo diff debe producir SIEMPRE la misma lista de problemas con la misma severidad. S\xE9 reproducible y objetivo.
+- Si el diff est\xE1 truncado, eval\xFAa solo lo visible y no penalices por lo que falte.
+- "resumen_ejecutivo": 2 frases neutrales sobre qu\xE9 hace el PR.
+- NO asignes una puntuaci\xF3n num\xE9rica: la calcula el sistema a partir de tus problemas. Tu trabajo es detectarlos y clasificarlos correctamente.`;
+var ReviewModelSchema = import_zod.z.object({
+  resumen_ejecutivo: import_zod.z.string().describe("Resumen de 2 frases de lo que hace el PR"),
+  problemas: import_zod.z.array(
+    import_zod.z.object({
+      severidad: import_zod.z.enum(["critico", "mayor", "menor"]),
+      descripcion: import_zod.z.string().describe("Problema concreto y real presente en el diff")
+    })
+  ).describe("Lista de problemas detectados; vac\xEDa si no hay ninguno")
+});
+var PENALIZACION = {
+  critico: 3,
+  mayor: 1.5,
+  menor: 0.5
+};
+function computeScore(problemas) {
+  const criticos = problemas.filter((p) => p.severidad === "critico").length;
+  const mayores = problemas.filter((p) => p.severidad === "mayor").length;
+  const menores = problemas.filter((p) => p.severidad === "menor").length;
+  const penalizacion = problemas.reduce(
+    (acc, p) => acc + PENALIZACION[p.severidad],
+    0
+  );
+  const puntuacion = Math.max(1, Math.min(10, Math.round(10 - penalizacion)));
+  let recomendacion;
+  if (criticos > 0) {
+    recomendacion = "bloqueado";
+  } else if (mayores > 0) {
+    recomendacion = "cambios_mayores";
+  } else if (menores > 0) {
+    recomendacion = "cambios_menores";
+  } else {
+    recomendacion = "aprobar";
+  }
+  const apto = criticos === 0 && mayores === 0;
+  return { puntuacion, apto, recomendacion };
+}
+var DEFAULT_ENSEMBLE_RUNS = 3;
+var GitHubAIService = class {
+  // Aceptamos el token, pero si no se pasa, funciona para repos públicos (con límite de peticiones).
+  // aiOptions permite forzar proveedor/modelo/nº de ejecuciones; si se omite, se usa la config por entorno.
+  constructor(token, aiOptions) {
+    this.token = token;
+    this.aiOptions = aiOptions;
+    this.octokit = new import_rest.Octokit({ auth: token });
+  }
+  // Obtener el diff (código añadido/borrado) de un PR
+  async getPRDiff(owner, repo, prNumber) {
+    const response = await this.octokit.pulls.get({
+      owner,
+      repo,
+      pull_number: prNumber,
+      mediaType: { format: "diff" }
+      // Mágia de Octokit para pedir el diff en texto plano
+    });
+    return response.data;
+  }
+  // Comprueba que tenemos un token antes de llamar a endpoints que requieren un usuario autenticado.
+  requireAuth(accion) {
+    if (!this.token) {
+      throw new Error(`Se requiere autenticaci\xF3n de GitHub para ${accion}.`);
+    }
+  }
+  // Obtiene los datos del usuario autenticado (sirve para verificar el token y mostrar quién está logueado)
+  async getAuthenticatedUser() {
+    this.requireAuth("obtener tu usuario de GitHub");
+    const { data } = await this.octokit.users.getAuthenticated();
+    return {
+      login: data.login,
+      name: data.name ?? null,
+      avatar_url: data.avatar_url
+    };
+  }
+  // Lista los repositorios del usuario autenticado, ordenados por última actualización
+  async listUserRepos() {
+    this.requireAuth("listar tus repositorios");
+    const { data } = await this.octokit.repos.listForAuthenticatedUser({
+      per_page: 100,
+      sort: "updated"
+    });
+    return data.map((repo) => ({
+      owner: repo.owner.login,
+      name: repo.name,
+      full_name: repo.full_name,
+      private: repo.private,
+      description: repo.description ?? null,
+      updated_at: repo.updated_at ?? null
+    }));
+  }
+  // Lista los Pull Requests abiertos de un repositorio
+  async listOpenPullRequests(owner, repo) {
+    const { data } = await this.octokit.pulls.list({
+      owner,
+      repo,
+      state: "open"
+    });
+    return data.map((pull) => ({
+      number: pull.number,
+      title: pull.title,
+      author: pull.user?.login ?? null,
+      created_at: pull.created_at,
+      url: pull.html_url
+    }));
+  }
+  // Lista los Pull Requests abiertos en los repos del usuario autenticado
+  // (los que tiene "pendientes de aceptar/revisar"). Usa la búsqueda de GitHub
+  // para resolverlo en una sola petición en lugar de iterar repo por repo.
+  async listPendingPullRequests() {
+    const { login } = await this.getAuthenticatedUser();
+    const { data } = await this.octokit.search.issuesAndPullRequests({
+      q: `is:pr is:open archived:false user:${login}`,
+      sort: "updated",
+      order: "desc",
+      per_page: 50
+    });
+    return data.items.map((item) => {
+      const segments = item.repository_url.split("/");
+      const repo = segments.pop() ?? "";
+      const owner = segments.pop() ?? "";
+      return {
+        owner,
+        repo,
+        full_name: `${owner}/${repo}`,
+        number: item.number,
+        title: item.title,
+        author: item.user?.login ?? null,
+        created_at: item.created_at,
+        url: item.html_url,
+        draft: item.draft ?? false
+      };
+    });
+  }
+  // Una única revisión: pide al modelo los problemas y deriva el análisis.
+  async runReview(model, diff) {
+    const { object } = await (0, import_ai.generateObject)({
+      model,
+      schema: ReviewModelSchema,
+      // temperature 0 = detección (casi) determinista
+      temperature: 0,
+      // Los estándares van como `system` (estable); el diff como `prompt` (variable)
+      system: SCORING_RUBRIC,
+      prompt: `Detecta y clasifica los problemas del siguiente diff siguiendo los est\xE1ndares.
+
+Diff:
+${diff}`
+    });
+    const { puntuacion, apto, recomendacion } = computeScore(object.problemas);
+    return {
+      resumen_ejecutivo: object.resumen_ejecutivo,
+      // Prefijamos cada bug con su severidad para que sea visible en la UI
+      posibles_bugs: object.problemas.map(
+        (p) => `[${p.severidad}] ${p.descripcion}`
+      ),
+      apto_para_merge: apto,
+      puntuacion_codigo: puntuacion,
+      recomendacion
+    };
+  }
+  // El método que une GitHub + IA.
+  // Ejecuta el análisis varias veces (ensemble) y se queda con el resultado
+  // de la MEDIANA por puntuación, lo que filtra ejecuciones atípicas y reduce
+  // la varianza entre sesiones (práctica recomendada en LLM-as-a-judge).
+  async analyzePR(owner, repo, prNumber) {
+    console.log(`[Core] Descargando diff de ${owner}/${repo}#${prNumber}...`);
+    const diff = await this.getPRDiff(owner, repo, prNumber);
+    const diffLimitado = diff.substring(0, 2e4);
+    if (diffLimitado.trim().length === 0) {
+      throw new Error("El PR no tiene cambios de c\xF3digo (diff vac\xEDo).");
+    }
+    const model = resolveModel(this.aiOptions?.provider, this.aiOptions?.model);
+    const envRuns = Number(process.env.AI_ENSEMBLE_RUNS);
+    const configuredRuns = this.aiOptions?.ensembleRuns ?? (Number.isFinite(envRuns) && envRuns > 0 ? envRuns : DEFAULT_ENSEMBLE_RUNS);
+    const runs = Math.max(1, configuredRuns);
+    console.log(`[Core] Analizando con ${runs} ejecuci\xF3n(es) (${diffLimitado.length} caracteres)...`);
+    const settled = await Promise.allSettled(
+      Array.from({ length: runs }, () => this.runReview(model, diffLimitado))
+    );
+    const exitosas = settled.filter(
+      (r) => r.status === "fulfilled"
+    ).map((r) => r.value);
+    if (exitosas.length === 0) {
+      const motivo = settled[0]?.status === "rejected" ? settled[0].reason : "desconocido";
+      throw new Error(
+        `No se pudo completar el an\xE1lisis: ${motivo instanceof Error ? motivo.message : motivo}`
+      );
+    }
+    exitosas.sort((a, b) => a.puntuacion_codigo - b.puntuacion_codigo);
+    return exitosas[Math.floor(exitosas.length / 2)];
+  }
+};
+
+// src/ui/banner.ts
+var import_figlet = __toESM(require("figlet"));
+
+// src/ui/theme.ts
+var import_chalk = __toESM(require("chalk"));
+var import_gradient_string = __toESM(require("gradient-string"));
+var PURPLE = "#8b5cf6";
+var PURPLE_DARK = "#6d28d9";
+var PURPLE_LIGHT = "#a78bfa";
+var c = {
+  purple: import_chalk.default.hex(PURPLE),
+  purpleBold: import_chalk.default.hex(PURPLE).bold,
+  light: import_chalk.default.hex(PURPLE_LIGHT),
+  dim: import_chalk.default.hex("#6b7280"),
+  // gray-500
+  gray: import_chalk.default.hex("#9ca3af"),
+  // gray-400
+  white: import_chalk.default.whiteBright,
+  bold: import_chalk.default.bold,
+  ok: import_chalk.default.hex("#22c55e"),
+  // green-500
+  bad: import_chalk.default.hex("#ef4444"),
+  // red-500
+  warn: import_chalk.default.hex("#f59e0b")
+  // amber-500
+};
+var purpleGradient = (text) => (0, import_gradient_string.default)([PURPLE_LIGHT, PURPLE, PURPLE_DARK]).multiline(text);
+
+// src/ui/banner.ts
+var OCTOPUS = [
+  "    _____     ",
+  "   /=====\\    ",
+  // cúpula del casco
+  "  (_________)  ",
+  // ala del casco de obra
+  "   | o   o |   ",
+  // cara
+  "    \\  ~  /    ",
+  // boca
+  "   _/|||||\\_   ",
+  // tentáculos
+  "   ~ ~ ~ ~ ~   "
+  // puntas
+];
+var TAGLINE = "Code review con IA, en tu terminal";
+function joinSideBySide(left, right, gap = 3) {
+  const height = Math.max(left.length, right.length);
+  const padBlock = (lines, width) => {
+    const top = Math.floor((height - lines.length) / 2);
+    const out = [];
+    for (let i = 0; i < height; i++) {
+      const line = lines[i - top] ?? "";
+      out.push(line.padEnd(width, " "));
+    }
+    return out;
+  };
+  const lw = Math.max(...left.map((l) => l.length));
+  const rw = Math.max(...right.map((l) => l.length));
+  const L = padBlock(left, lw);
+  const R = padBlock(right, rw);
+  return L.map((l, i) => l + " ".repeat(gap) + R[i]);
+}
+function boxify(lines) {
+  const width = Math.max(...lines.map((l) => l.length));
+  const pad = 2;
+  const inner = width + pad * 2;
+  const top = "\u256D" + "\u2500".repeat(inner) + "\u256E";
+  const bottom = "\u2570" + "\u2500".repeat(inner) + "\u256F";
+  const body = lines.map(
+    (l) => "\u2502" + " ".repeat(pad) + l.padEnd(width, " ") + " ".repeat(pad) + "\u2502"
+  );
+  return [top, ...body, bottom];
+}
+function renderBanner() {
+  const title = import_figlet.default.textSync("Git-Helper", { font: "Standard" }).replace(/\s+$/gm, "").split("\n").filter((l) => l.length > 0);
+  const composed = joinSideBySide(OCTOPUS, title, 3);
+  const blockWidth = Math.max(...composed.map((l) => l.length));
+  const tagPad = Math.max(0, Math.floor((blockWidth - TAGLINE.length) / 2));
+  const tagLine = " ".repeat(tagPad) + TAGLINE;
+  const boxed = boxify([...composed, "", tagLine]);
+  return "\n" + purpleGradient(boxed.join("\n")) + "\n";
+}
+
+// src/ui/render.ts
+var import_cli_table3 = __toESM(require("cli-table3"));
+var ANSI = /\[[0-9;]*m/g;
+var visibleLen = (s) => s.replace(ANSI, "").length;
+var padVisible = (s, w) => s + " ".repeat(Math.max(0, w - visibleLen(s)));
+var truncate = (s, max) => s.length <= max ? s : s.slice(0, max - 1) + "\u2026";
+function wrap(text, width) {
+  const words = text.split(/\s+/);
+  const lines = [];
+  let cur = "";
+  for (const w of words) {
+    if (cur && cur.length + 1 + w.length > width) {
+      lines.push(cur);
+      cur = w;
+    } else {
+      cur = cur ? `${cur} ${w}` : w;
+    }
+  }
+  if (cur) lines.push(cur);
+  return lines;
+}
+function relativeTime(iso) {
+  const diff = Date.now() - new Date(iso).getTime();
+  const m = Math.floor(diff / 6e4);
+  if (m < 60) return `${m}m`;
+  const h = Math.floor(m / 60);
+  if (h < 24) return `${h}h`;
+  return `${Math.floor(h / 24)}d`;
+}
+function box(lines, title) {
+  const inner = Math.max(
+    title ? visibleLen(title) + 4 : 0,
+    ...lines.map(visibleLen)
+  );
+  const pad = 1;
+  const total = inner + pad * 2;
+  let top;
+  if (title) {
+    const label = ` ${title} `;
+    const rest = total - visibleLen(label) - 1;
+    top = c.dim("\u256D\u2500") + c.purpleBold(label) + c.dim("\u2500".repeat(Math.max(0, rest)) + "\u256E");
+  } else {
+    top = c.dim("\u256D" + "\u2500".repeat(total) + "\u256E");
+  }
+  const bottom = c.dim("\u2570" + "\u2500".repeat(total) + "\u256F");
+  const body = lines.map(
+    (l) => c.dim("\u2502") + " ".repeat(pad) + padVisible(l, inner) + " ".repeat(pad) + c.dim("\u2502")
+  );
+  return [top, ...body, bottom].join("\n");
+}
+var RECO_STYLE = {
+  aprobar: (s) => c.ok(`\u25CF ${s}`),
+  cambios_menores: (s) => c.warn(`\u25CF ${s}`),
+  cambios_mayores: (s) => c.warn(`\u25CF ${s}`),
+  bloqueado: (s) => c.bad(`\u25CF ${s}`)
+};
+var recoLabel = {
+  aprobar: "Aprobar",
+  cambios_menores: "Cambios menores",
+  cambios_mayores: "Cambios mayores",
+  bloqueado: "Bloqueado"
+};
+function scoreBar(score) {
+  const filled = Math.max(0, Math.min(10, Math.round(score)));
+  const color = score >= 8 ? c.ok : score >= 5 ? c.warn : c.bad;
+  return color("\u2588".repeat(filled)) + c.dim("\u2591".repeat(10 - filled)) + "  " + c.bold(color(`${score}/10`));
+}
+function analysisCard(ref, a) {
+  const lines = [];
+  lines.push(c.dim("Puntuaci\xF3n  ") + scoreBar(a.puntuacion_codigo));
+  lines.push(c.dim("Veredicto   ") + RECO_STYLE[a.recomendacion](recoLabel[a.recomendacion]));
+  lines.push(
+    c.dim("Merge       ") + (a.apto_para_merge ? c.ok("\u2713 apto") : c.bad("\u2717 no apto"))
+  );
+  lines.push("");
+  wrap(a.resumen_ejecutivo, 66).forEach((l) => lines.push(c.gray(l)));
+  if (a.posibles_bugs.length > 0) {
+    lines.push("");
+    lines.push(c.warn("Posibles bugs:"));
+    a.posibles_bugs.forEach((b) => {
+      const parts = wrap(b, 62);
+      parts.forEach(
+        (l, i) => lines.push((i === 0 ? c.dim(" \u2022 ") : "   ") + c.white(l))
+      );
+    });
+  } else {
+    lines.push("");
+    lines.push(c.ok("\u2713 Sin bugs evidentes."));
+  }
+  return box(lines, ref);
+}
+function pendingTable(prs) {
+  const table = new import_cli_table3.default({
+    head: ["", "Repo", "PR", "T\xEDtulo", "Autor", "Abierto"].map(
+      (h) => c.purpleBold(h)
+    ),
+    style: { head: [], border: [], "padding-left": 1, "padding-right": 1 },
+    chars: {
+      top: "\u2500",
+      "top-mid": "\u252C",
+      "top-left": "\u256D",
+      "top-right": "\u256E",
+      bottom: "\u2500",
+      "bottom-mid": "\u2534",
+      "bottom-left": "\u2570",
+      "bottom-right": "\u256F",
+      left: "\u2502",
+      "left-mid": "\u251C",
+      mid: "\u2500",
+      "mid-mid": "\u253C",
+      right: "\u2502",
+      "right-mid": "\u2524",
+      middle: "\u2502"
+    }
+  });
+  prs.forEach((pr, i) => {
+    table.push([
+      c.dim(String(i + 1)),
+      c.white(pr.full_name),
+      c.light(`#${pr.number}`) + (pr.draft ? c.dim(" \u2311") : ""),
+      truncate(pr.title, 48),
+      c.gray(pr.author ?? "\u2014"),
+      c.dim(relativeTime(pr.created_at))
+    ]);
+  });
+  return table.toString().split("\n").map((l) => l.replace(/[╭╮╰╯─┬┴├┤┼│]/g, (ch) => c.dim(ch))).join("\n");
+}
+
+// src/config.ts
+var import_node_fs = require("fs");
+var import_node_os = require("os");
+var import_node_path = require("path");
+var import_dotenv = __toESM(require("dotenv"));
+var CONFIG_DIR = (0, import_node_path.join)((0, import_node_os.homedir)(), ".config", "git-helper");
+var CONFIG_FILE = (0, import_node_path.join)(CONFIG_DIR, ".env");
+var CONFIG_KEYS = [
+  "AI_PROVIDER",
+  "AI_MODEL",
+  "AI_ENSEMBLE_RUNS",
+  "GOOGLE_GENERATIVE_AI_API_KEY",
+  "OPENAI_API_KEY",
+  "GITHUB_TOKEN"
+];
+var SECRET_KEYS = /* @__PURE__ */ new Set([
+  "GOOGLE_GENERATIVE_AI_API_KEY",
+  "OPENAI_API_KEY",
+  "GITHUB_TOKEN"
+]);
+var isConfigKey = (k) => CONFIG_KEYS.includes(k);
+function maskValue(key, value) {
+  if (!SECRET_KEYS.has(key) || value.length <= 4) return value;
+  return "\u2022".repeat(Math.min(6, value.length - 4)) + value.slice(-4);
+}
+function loadGlobalConfig() {
+  if ((0, import_node_fs.existsSync)(CONFIG_FILE)) {
+    import_dotenv.default.config({ path: CONFIG_FILE, quiet: true });
+  }
+}
+function readConfig() {
+  if (!(0, import_node_fs.existsSync)(CONFIG_FILE)) return {};
+  return import_dotenv.default.parse((0, import_node_fs.readFileSync)(CONFIG_FILE));
+}
+function writeConfig(values) {
+  (0, import_node_fs.mkdirSync)(CONFIG_DIR, { recursive: true });
+  const body = CONFIG_KEYS.filter((k) => values[k] !== void 0).map((k) => `${k}=${values[k]}`).join("\n") + "\n";
+  (0, import_node_fs.writeFileSync)(CONFIG_FILE, body, { mode: 384 });
+}
+function setConfig(key, value) {
+  const current = readConfig();
+  current[key] = value;
+  writeConfig(current);
+}
+function unsetConfig(key) {
+  const current = readConfig();
+  if (current[key] === void 0) return;
+  delete current[key];
+  writeConfig(current);
+}
+
+// src/index.ts
+import_dotenv2.default.config({ quiet: true });
+loadGlobalConfig();
+var program = new import_commander.Command();
+program.name("git-helper").description("Code review de Pull Requests de GitHub con IA, desde la terminal").version("0.1.0", "-V, --version", "muestra la versi\xF3n").addHelpText("beforeAll", renderBanner());
+program.command("review").alias("analyze").description("Analiza un PR concreto con IA").requiredOption("-o, --owner <owner>", "propietario del repo (ej: vercel)").requiredOption("-r, --repo <repo>", "nombre del repositorio (ej: next.js)").requiredOption("-p, --pr <number>", "n\xFAmero del Pull Request", (v) => parseInt(v, 10)).option("--json", "imprime el resultado en JSON (sin formato visual)").action(async (opts) => {
+  const ref = `${opts.owner}/${opts.repo} #${opts.pr}`;
+  const spinner = opts.json ? null : (0, import_ora.default)({ text: c.gray(`Analizando ${ref} con IA\u2026`), color: "magenta" }).start();
+  const service = new GitHubAIService(process.env.GITHUB_TOKEN);
+  try {
+    const analysis = await service.analyzePR(opts.owner, opts.repo, opts.pr);
+    spinner?.stop();
+    if (opts.json) {
+      console.log(JSON.stringify(analysis, null, 2));
+    } else {
+      console.log("\n" + analysisCard(ref, analysis) + "\n");
+    }
+  } catch (error) {
+    spinner?.stop();
+    console.error("\n" + c.bad("\u2717 " + (error?.message ?? String(error))) + "\n");
+    process.exitCode = 1;
+  }
+});
+program.command("list").alias("ls").description("Lista tus Pull Requests pendientes de revisar").option("--json", "imprime la lista en JSON (sin formato visual)").action(async (opts) => {
+  if (!process.env.GITHUB_TOKEN) {
+    console.error(
+      "\n" + c.bad("\u2717 Necesitas un GITHUB_TOKEN para listar tus PRs pendientes.") + "\n" + c.dim("  Gu\xE1rdalo con  ") + c.light("git-helper config set GITHUB_TOKEN ghp_...") + "\n"
+    );
+    process.exitCode = 1;
+    return;
+  }
+  const spinner = opts.json ? null : (0, import_ora.default)({ text: c.gray("Buscando tus PRs pendientes\u2026"), color: "magenta" }).start();
+  const service = new GitHubAIService(process.env.GITHUB_TOKEN);
+  try {
+    const prs = await service.listPendingPullRequests();
+    spinner?.stop();
+    if (opts.json) {
+      console.log(JSON.stringify(prs, null, 2));
+      return;
+    }
+    if (prs.length === 0) {
+      console.log("\n" + c.ok("\u2713 No tienes PRs pendientes. \xA1Todo limpio!") + "\n");
+      return;
+    }
+    console.log("\n" + c.purpleBold(`  ${prs.length} PR pendiente${prs.length === 1 ? "" : "s"}`) + "\n");
+    console.log(pendingTable(prs));
+    console.log(
+      "\n" + c.dim("  Analiza uno con  ") + c.light("git-helper review -o <owner> -r <repo> -p <n>") + "\n"
+    );
+  } catch (error) {
+    spinner?.stop();
+    console.error("\n" + c.bad("\u2717 " + (error?.message ?? String(error))) + "\n");
+    process.exitCode = 1;
+  }
+});
+var config = program.command("config").description(`Gestiona la configuraci\xF3n guardada en ${CONFIG_FILE}`);
+config.command("set <key> <value>").description("Guarda una clave de configuraci\xF3n").action((key, value) => {
+  if (!isConfigKey(key)) {
+    console.error(
+      "\n" + c.bad(`\u2717 Clave desconocida: ${key}`) + "\n" + c.dim("  Claves v\xE1lidas: ") + c.light(CONFIG_KEYS.join(", ")) + "\n"
+    );
+    process.exitCode = 1;
+    return;
+  }
+  setConfig(key, value);
+  console.log("\n" + c.ok(`\u2713 ${key} guardada`) + c.dim(` en ${CONFIG_FILE}`) + "\n");
+});
+config.command("list").alias("get").description("Muestra la configuraci\xF3n guardada (secretos enmascarados)").action(() => {
+  const cfg = readConfig();
+  const keys = Object.keys(cfg);
+  if (keys.length === 0) {
+    console.log("\n" + c.dim("  Sin configuraci\xF3n guardada.") + "\n");
+    return;
+  }
+  console.log("");
+  for (const k of CONFIG_KEYS) {
+    if (cfg[k] === void 0) continue;
+    console.log("  " + c.purple(k.padEnd(30)) + c.white(maskValue(k, cfg[k])));
+  }
+  console.log("");
+});
+config.command("unset <key>").description("Elimina una clave de configuraci\xF3n").action((key) => {
+  if (!isConfigKey(key)) {
+    console.error("\n" + c.bad(`\u2717 Clave desconocida: ${key}`) + "\n");
+    process.exitCode = 1;
+    return;
+  }
+  unsetConfig(key);
+  console.log("\n" + c.ok(`\u2713 ${key} eliminada`) + "\n");
+});
+config.command("path").description("Muestra la ruta del archivo de configuraci\xF3n").action(() => console.log(CONFIG_FILE));
+config.action(() => config.help());
+program.action(() => {
+  program.help();
+});
+program.parse();

package/package.json

@@ -0,0 +1,49 @@
+{
+  "name": "@alexis-reillo/git-helper",
+  "version": "0.1.0",
+  "description": "Analiza Pull Requests de GitHub usando Inteligencia Artificial, desde la terminal.",
+  "license": "MIT",
+  "bin": {
+    "git-helper": "./dist/index.js"
+  },
+  "files": [
+    "dist",
+    "README.md"
+  ],
+  "engines": {
+    "node": ">=18"
+  },
+  "publishConfig": {
+    "access": "public"
+  },
+  "dependencies": {
+    "@ai-sdk/google": "^4.0.2",
+    "@ai-sdk/openai": "^4.0.1",
+    "@octokit/rest": "^22.0.1",
+    "ai": "^7.0.3",
+    "chalk": "^4.1.2",
+    "cli-table3": "^0.6.5",
+    "commander": "^15.0.0",
+    "dotenv": "^17.4.2",
+    "figlet": "^1.8.0",
+    "gradient-string": "^2.0.2",
+    "ora": "^5.4.1",
+    "zod": "^4.4.3"
+  },
+  "devDependencies": {
+    "@types/figlet": "^1.7.0",
+    "@types/gradient-string": "^1.1.6",
+    "@types/node": "^20",
+    "tsup": "^8.0.0",
+    "tsx": "^4.7.0",
+    "vitest": "^2.1.9",
+    "@repo/core": "0.0.0"
+  },
+  "scripts": {
+    "dev": "tsx watch src/index.ts",
+    "start": "tsx src/index.ts",
+    "build": "tsup",
+    "check-types": "tsc --noEmit",
+    "test": "vitest run"
+  }
+}