pull-request-split-advisor 3.1.2

package/dist/ai/provider.js

@@ -0,0 +1,265 @@
+/**
+ * provider.ts — Cliente HTTP genérico para proveedores de IA compatibles con OpenAI.
+ *
+ * Usa `fetch` nativo de Node.js >= 18: cero dependencias adicionales.
+ *
+ * ### Registro de proveedores
+ * Cada proveedor se describe con un `ProviderDescriptor` en `PROVIDER_REGISTRY`.
+ * Añadir un nuevo proveedor = añadir una entrada al mapa: no hay if/else en el
+ * código de llamada.
+ *
+ * ### Diseño de fallback
+ * `isAiEnabled(config)` devuelve `false` si:
+ *   - `config.ai?.enabled` es false o undefined.
+ *   - No hay API key (ni literal en config ni en la variable de entorno).
+ *
+ * El caller siempre comprueba `isAiEnabled` antes de llamar a `callAI`.
+ * Si `callAI` lanza (timeout, error HTTP, JSON malformado) el enricher
+ * lo captura silenciosamente y conserva el plan heurístico.
+ */
+import { execSync } from "node:child_process";
+// ---------------------------------------------------------------------------
+// Registro de proveedores
+// ---------------------------------------------------------------------------
+/**
+ * Registro central de proveedores de IA soportados.
+ *
+ * Para añadir un nuevo proveedor basta con agregar una entrada aquí.
+ * El wizard, la validación y el cliente HTTP se adaptan automáticamente.
+ */
+export const PROVIDER_REGISTRY = new Map([
+    [
+        "groq",
+        {
+            id: "groq",
+            label: "Groq (Llama 3.3 70B)",
+            endpoint: "https://api.groq.com/openai/v1/chat/completions",
+            defaultApiKeyEnvVar: "GROQ_API_KEY",
+            defaultModel: "llama-3.3-70b-versatile",
+            apiKeyGuideUrl: "https://console.groq.com",
+            models: [
+                { value: "llama-3.3-70b-versatile", label: "Llama 3.3 70B Versatile", supportsJsonMode: true },
+            ],
+        },
+    ],
+    [
+        "copilot",
+        {
+            id: "copilot",
+            label: "GitHub Copilot (cuenta de VS Code)",
+            endpoint: "https://api.githubcopilot.com/chat/completions",
+            defaultApiKeyEnvVar: "",
+            defaultModel: "gpt-4o-mini",
+            apiKeyGuideUrl: "https://github.com/settings/copilot",
+            models: [
+                { value: "gpt-4o-mini", label: "GPT-4o Mini (gratuito)", supportsJsonMode: true },
+                { value: "gpt-4o", label: "GPT-4o (Copilot Pro)", supportsJsonMode: true },
+                { value: "claude-3.5-sonnet", label: "Claude 3.5 Sonnet (Pro)", supportsJsonMode: false },
+                { value: "o3-mini", label: "o3-mini (Pro)", supportsJsonMode: false },
+            ],
+        },
+    ],
+]);
+let _copilotTokenCache = null;
+/**
+ * Obtiene el GitHub OAuth token del contexto local:
+ *   1. Variable de entorno `GITHUB_TOKEN` (o la indicada en config).
+ *   2. Token literal en `ai.apiKey`.
+ *   3. Fallback automático: `gh auth token` (mismo token que usa VS Code / Copilot).
+ */
+function resolveGithubToken(config) {
+    const ai = config.ai;
+    const envVar = ai.apiKeyEnvVar || "GITHUB_TOKEN";
+    if (process.env[envVar])
+        return process.env[envVar];
+    if (ai.apiKey)
+        return ai.apiKey;
+    try {
+        return execSync("gh auth token", {
+            encoding: "utf-8",
+            stdio: ["pipe", "pipe", "pipe"],
+        }).trim();
+    }
+    catch {
+        return "";
+    }
+}
+/**
+ * Intercambia un GitHub OAuth token por el token efímero de la API de Copilot.
+ * El token resultante se cachea hasta 1 minuto antes de su expiración.
+ *
+ * Estrategia de resolución:
+ *  1. `copilot_internal/v2/token` — funciona para cuentas Copilot Individual.
+ *  2. Si devuelve 404, se usa el GitHub token directamente como Bearer —
+ *     Copilot Business/Enterprise acepta el OAuth token de gh CLI sin intercambio.
+ */
+async function resolveCopilotToken(githubToken, signal) {
+    const now = Date.now();
+    if (_copilotTokenCache && _copilotTokenCache.expiresAt > now + 60_000) {
+        return _copilotTokenCache.token;
+    }
+    const res = await fetch("https://api.github.com/copilot_internal/v2/token", {
+        headers: {
+            Authorization: `token ${githubToken}`,
+            "Editor-Version": "vscode/1.96.0",
+            "Editor-Plugin-Version": "copilot-chat/0.22.4",
+            "User-Agent": "GitHubCopilotChat/0.22.4",
+        },
+        signal,
+    });
+    // 404 → cuenta Business/Enterprise: el GitHub token se usa directamente
+    if (res.status === 404) {
+        return githubToken;
+    }
+    if (!res.ok) {
+        const body = await res.text().catch(() => "");
+        throw new Error(`No se pudo obtener el token de Copilot (${res.status}). ` +
+            `Verifica que tienes suscripción activa a GitHub Copilot. ${body}`);
+    }
+    const data = (await res.json());
+    const expiresAt = typeof data.expires_at === "number" && Number.isFinite(data.expires_at)
+        ? data.expires_at * 1000
+        : Date.now() + 25 * 60 * 1000; // fallback: 25 min si la API devuelve un valor inválido
+    _copilotTokenCache = { token: data.token, expiresAt };
+    return data.token;
+}
+// ---------------------------------------------------------------------------
+// Helpers de resolución de credenciales
+// ---------------------------------------------------------------------------
+/**
+ * Resuelve la API key para el proveedor configurado:
+ * - **Copilot**: obtiene el GitHub token vía env var, config literal o `gh auth token`
+ *   (el mismo token que VS Code usa para Copilot — no requiere configuración manual).
+ * - **Otros**: env var indicada en config o la default del proveedor, luego literal.
+ */
+export function resolveApiKey(config) {
+    const ai = config.ai;
+    if (!ai)
+        return "";
+    const providerId = ai.provider ?? "groq";
+    // Copilot: GitHub token resuelto automáticamente (gh CLI / env var)
+    if (providerId === "copilot") {
+        return resolveGithubToken(config);
+    }
+    // Otros proveedores: env var + literal
+    const providerDesc = PROVIDER_REGISTRY.get(providerId);
+    const defaultEnvVar = providerDesc?.defaultApiKeyEnvVar ?? "GROQ_API_KEY";
+    const envVar = ai.apiKeyEnvVar || defaultEnvVar;
+    return process.env[envVar] || ai.apiKey || "";
+}
+/**
+ * Detecta si el proceso está corriendo dentro de Visual Studio Code.
+ *
+ * VS Code inyecta estas variables de entorno en el terminal integrado y en
+ * sus procesos hijos:
+ * - `TERM_PROGRAM=vscode`  → terminal integrado de VS Code
+ * - `VSCODE_PID`           → proceso lanzado directamente por VS Code
+ * - `VSCODE_IPC_HOOK`      → hook IPC interno de VS Code
+ */
+export function isVsCodeEnvironment() {
+    return (process.env["TERM_PROGRAM"] === "vscode" ||
+        !!process.env["VSCODE_PID"] ||
+        !!process.env["VSCODE_IPC_HOOK"]);
+}
+/**
+ * Devuelve `true` solo si la IA está habilitada (`ai.enabled: true`),
+ * hay una API key disponible Y, en el caso del proveedor `copilot`,
+ * el proceso corre dentro de Visual Studio Code.
+ *
+ * Copilot requiere VS Code porque sus credenciales son gestionadas
+ * exclusivamente por la extensión GitHub Copilot del IDE.
+ */
+export function isAiEnabled(config) {
+    if (!config.ai?.enabled)
+        return false;
+    const providerId = config.ai.provider ?? "groq";
+    if (providerId === "copilot" && !isVsCodeEnvironment()) {
+        process.stderr.write("[ai warn] El proveedor \"copilot\" solo está disponible dentro de Visual Studio Code.\n" +
+            "  Cambia el proveedor a \"groq\" o \"github\" para usar la IA fuera del IDE.\n");
+        return false;
+    }
+    return !!resolveApiKey(config);
+}
+// ---------------------------------------------------------------------------
+// Cliente HTTP genérico
+// ---------------------------------------------------------------------------
+/**
+ * Realiza una llamada chat-completions al proveedor configurado en `config.ai.provider`.
+ * La API de todos los proveedores soportados es compatible con el formato OpenAI.
+ *
+ * Usa `response_format: { type: "json_object" }` solo si el modelo lo soporta
+ * (ver `supportsJsonMode` en el `ModelDescriptor`).
+ *
+ * @throws {Error} Si la respuesta HTTP no es 2xx, si hay timeout o si el
+ *                 JSON de respuesta no tiene la forma esperada.
+ */
+export async function callAI(messages, config) {
+    const ai = config.ai;
+    const apiKey = resolveApiKey(config);
+    const providerId = ai.provider ?? "groq";
+    const model = ai.model;
+    const maxTokens = ai.maxTokens ?? 1024;
+    const timeoutMs = ai.timeoutMs ?? 15000;
+    // Resolver descriptor del proveedor (fallback a groq si es desconocido)
+    const providerDesc = PROVIDER_REGISTRY.get(providerId)
+        ?? PROVIDER_REGISTRY.get("groq");
+    // Determinar si el modelo seleccionado soporta json_mode
+    const modelDesc = providerDesc.models.find((m) => m.value === model);
+    const useJsonMode = modelDesc?.supportsJsonMode ?? true;
+    const controller = new AbortController();
+    const timer = setTimeout(() => controller.abort(), timeoutMs);
+    try {
+        const body = {
+            model,
+            messages,
+            max_tokens: maxTokens,
+            temperature: 0.2,
+        };
+        if (useJsonMode) {
+            body["response_format"] = { type: "json_object" };
+        }
+        // Para Copilot: intercambiar el GitHub token por el token efímero de la API
+        const authToken = providerId === "copilot"
+            ? await resolveCopilotToken(apiKey, controller.signal)
+            : apiKey;
+        const copilotHeaders = providerId === "copilot"
+            ? {
+                "Editor-Version": "vscode/1.96.0",
+                "Editor-Plugin-Version": "copilot-chat/0.22.4",
+                "Copilot-Integration-Id": "vscode-chat",
+                "User-Agent": "GitHubCopilotChat/0.22.4",
+            }
+            : {};
+        const response = await fetch(providerDesc.endpoint, {
+            method: "POST",
+            headers: {
+                "Content-Type": "application/json",
+                Authorization: `Bearer ${authToken}`,
+                ...copilotHeaders,
+            },
+            body: JSON.stringify(body),
+            signal: controller.signal,
+        });
+        if (!response.ok) {
+            const errorText = await response.text().catch(() => "(no body)");
+            throw new Error(`${providerDesc.label} API ${response.status}: ${errorText}`);
+        }
+        const data = (await response.json());
+        const content = data.choices?.[0]?.message?.content;
+        if (typeof content !== "string") {
+            throw new Error(`Respuesta de ${providerDesc.label} sin campo choices[0].message.content`);
+        }
+        return {
+            content,
+            tokensUsed: data.usage?.total_tokens ?? 0,
+        };
+    }
+    finally {
+        clearTimeout(timer);
+    }
+}
+/**
+ * @deprecated Alias de compatibilidad — usar `callAI` en código nuevo.
+ * Eliminado en la próxima versión mayor.
+ */
+export const callGroq = callAI;