GitHub Copilot SDK — Integración programática

import { CopilotClient, defineTool } from "@github/copilot-sdk";
import { Octokit } from "@octokit/rest";

// ── Herramienta custom: obtener diff del PR ─────────────────────────────────
const getPrDiff = defineTool("get_pr_diff", {
  description: "Fetches the full diff and metadata of a GitHub Pull Request",
  parameters: {
    type: "object",
    properties: {
      owner:  { type: "string", description: "Repo owner (org or user)" },
      repo:   { type: "string", description: "Repository name" },
      pr_num: { type: "number", description: "Pull Request number" },
    },
    required: ["owner", "repo", "pr_num"],
  },
  handler: async ({ owner, repo, pr_num }) => {
    const octokit = new Octokit({ auth: process.env.GITHUB_TOKEN });
    const [pr, files] = await Promise.all([
      octokit.pulls.get({ owner, repo, pull_number: pr_num }),
      octokit.pulls.listFiles({ owner, repo, pull_number: pr_num }),
    ]);
    return {
      title:     pr.data.title,
      author:    pr.data.user?.login,
      base:      pr.data.base.ref,
      additions: pr.data.additions,
      deletions: pr.data.deletions,
      files:     files.data.map(f => ({ filename: f.filename, patch: f.patch })),
    };
  },
});

// ── Cliente + sesión con custom agent ──────────────────────────────────────
export async function reviewPullRequest(prNumber: number) {
  const client = new CopilotClient({
    githubToken:    process.env.GITHUB_TOKEN,
    logLevel:       "info",
    autoRestart:    true,
  });

  const session = await client.createSession({
    // Sesión persistente por PR para retomar si se interrumpe
    sessionId: `tenant-cultivaia-pr-${prNumber}`,
    model:     "gpt-4.1",
    streaming: true,

    // Agente especializado en revisión de código
    customAgents: [{
      name:        "pr-reviewer",
      displayName: "PR Reviewer — CULTIVA IA",
      description: "Revisa PRs detectando bugs, issues de seguridad y deuda técnica",
      prompt: `Eres un revisor senior de código para CULTIVA IA.
Enfócate en: seguridad (OWASP Top 10), performance, mantenibilidad.
Devuelve SIEMPRE un JSON con: summary, findings (severity+title+desc), score (0-100).`,
    }],

    tools: [getPrDiff],

    hooks: {
      // Bloquear herramientas de shell por seguridad
      onPreToolUse: async (input) => {
        if (["shell", "bash", "exec"].includes(input.toolName)) {
          return { permissionDecision: "deny", permissionDecisionReason: "Shell no permitido" };
        }
        return { permissionDecision: "allow" };
      },
      // Inyectar contexto de proyecto en cada prompt
      onUserPromptSubmitted: async (input) => ({
        modifiedPrompt:    input.prompt,
        additionalContext: "Stack del cliente: TypeScript, React, PostgreSQL. Estándares: ESLint+Prettier, convencional commits.",
      }),
      onSessionEnd: async (input, inv) => {
        console.log(`[PR-${prNumber}] Sesión terminada: ${inv.sessionId} (${input.reason})`);
        return null;
      },
    },

    systemMessage: {
      content: "Responde siempre en español. Sé directo y accionable. Usa severidades: critical/high/medium/low.",
    },

    // Sesiones largas con compactación automática
    infiniteSessions: {
      enabled: true,
      backgroundCompactionThreshold: 0.80,
      bufferExhaustionThreshold:     0.95,
    },
  });

  // Streaming del informe
  session.on("assistant.message_delta", (event) => {
    process.stdout.write(event.data.deltaContent);
  });

  session.on("assistant.usage", (event) => {
    console.log(`\n│ Tokens: in=${event.data.inputTokens} out=${event.data.outputTokens}`);
  });

  const response = await session.sendAndWait({
    prompt: `Revisa el PR #${prNumber} del repositorio cultivaia-org/plataforma-clientes.
Usa la herramienta get_pr_diff para obtener el diff y genera un informe completo.`,
  });

  await client.stop();
  return JSON.parse(response?.data.content ?? "{}");
}

const SENSITIVE_PATTERNS = [
  new RegExp(`(password|secret|token|api_key)\\s*[=:]\\s*\\S+`, "gi"),
  new RegExp(`(Bearer|ghp_|github_pat_)\\S+`, "g"),
];

hooks: {
  onPostToolUse: async (input) => {
    if (typeof input.toolResult === "string") {
      let redacted = input.toolResult;
      for (const pattern of SENSITIVE_PATTERNS) {
        redacted = redacted.replace(pattern, "[REDACTED]");
      }
      if (redacted !== input.toolResult) return { modifiedResult: redacted };
    }
    return null; // Sin cambios
  },
}

const session = await client.createSession({
  model: "gpt-4.1",
  mcpServers: {
    // GitHub MCP oficial (HTTP remoto)
    github: {
      type:    "http",
      url:     "https://api.githubcopilot.com/mcp/",
      headers: { Authorization: `Bearer ${process.env.GITHUB_TOKEN}` },
      tools:   ["*"],
    },
    // PostgreSQL MCP (local via npx)
    postgres: {
      type:    "local",
      command: "npx",
      args:    ["-y", "@modelcontextprotocol/server-postgres",
                process.env.DATABASE_URL ?? ""],
      tools:   ["*"],
      timeout: 30000,
    },
    // Filesystem MCP (solo lectura en /tmp/reports)
    filesystem: {
      type:    "local",
      command: "npx",
      args:    ["-y", "@modelcontextprotocol/server-filesystem", "/tmp/reports"],
      tools:   ["read_file", "list_directory"],
    },
  },
});

// OpenAI
provider: { type: "openai", baseUrl: "https://api.openai.com/v1", apiKey: process.env.OPENAI_API_KEY }

// Anthropic (Claude)
provider: { type: "anthropic", baseUrl: "https://api.anthropic.com", apiKey: process.env.ANTHROPIC_API_KEY }

// Azure OpenAI (nativo)
provider: {
  type:    "azure",
  baseUrl: "https://mi-recurso.openai.azure.com",
  apiKey:  process.env.AZURE_OPENAI_KEY,
  azure:   { apiVersion: "2024-10-21" },
}

// Azure AI Foundry (GPT-5 → wireApi: "responses")
provider: {
  type:    "openai",
  baseUrl: "https://mi-recurso.openai.azure.com/openai/v1/",
  apiKey:  process.env.FOUNDRY_API_KEY,
  wireApi: "responses",
}

// Ollama (local, sin autenticación)
provider: { type: "openai", baseUrl: "http://localhost:11434/v1" }

// Crear con ID explícito por PR
const session = await client.createSession({
  sessionId: "tenant-cultivaia-pr-42",
  model:     "gpt-4.1",
});

// Más tarde (incluso desde otra instancia del cliente)
const resumed = await client.resumeSession("tenant-cultivaia-pr-42");
await resumed.sendAndWait({ prompt: "¿Qué findings encontramos en el PR?" });

// Gestión
const sessions = await client.listSessions();
const lastId   = await client.getLastSessionId();
await client.deleteSession("tenant-cultivaia-pr-42");
await session.destroy();

services:
  copilot-cli:
    image: ghcr.io/github/copilot-cli:latest
    command: ["--headless", "--port", "4321"]
    environment:
      - COPILOT_GITHUB_TOKEN=${COPILOT_GITHUB_TOKEN}
    volumes:
      - session-data:/root/.copilot/session-state
    healthcheck:
      test: ["CMD", "nc", "-z", "localhost", "4321"]
      interval: 30s
      timeout: 5s
      retries: 3

  pr-review-api:
    build: .
    environment:
      - CLI_URL=copilot-cli:4321
      - GITHUB_TOKEN=${GITHUB_TOKEN}
      - DATABASE_URL=${DATABASE_URL}
    depends_on:
      copilot-cli: { condition: service_healthy }
    deploy:
      replicas: 3   # Múltiples workers, una CLI compartida

  redis:
    image: redis:7-alpine  # Session locking para sesiones compartidas
    volumes:
      - redis-data:/data

volumes:
  session-data:
  redis-data: