GitHub API con Claude Code

Optimizando el uso de la API de GitHub con Claude Code

Aprovechando la API de GitHub, puede automatizar muchos aspectos del flujo de trabajo de desarrollo: gestion de repositorios, creacion de PRs, gestion de issues y releases. Con Claude Code, puede construir rapidamente scripts de automatizacion utilizando el SDK Octokit.

Configuracion del cliente Octokit

> Configura un cliente de la API de GitHub.
> Compatible con autenticacion tanto de GitHub App como de Personal Access Token.

// src/lib/github.ts
import { Octokit } from '@octokit/rest';
import { createAppAuth } from '@octokit/auth-app';

// Autenticacion con Personal Access Token
export function createOctokitWithPAT(token: string) {
  return new Octokit({ auth: token });
}

// Autenticacion con GitHub App
export function createOctokitWithApp(
  appId: string,
  privateKey: string,
  installationId: number
) {
  return new Octokit({
    authStrategy: createAppAuth,
    auth: { appId, privateKey, installationId },
  });
}

const octokit = createOctokitWithPAT(process.env.GITHUB_TOKEN!);
export default octokit;

Herramienta de automatizacion de PRs

> Crea una herramienta que automatice la creacion de PRs, asignacion de revisores y etiquetado.

// src/services/pr-automation.ts
import octokit from '../lib/github';

interface CreatePROptions {
  owner: string;
  repo: string;
  title: string;
  body: string;
  head: string;
  base: string;
  reviewers?: string[];
  labels?: string[];
  draft?: boolean;
}

export async function createPullRequest(options: CreatePROptions) {
  // Crear PR
  const { data: pr } = await octokit.pulls.create({
    owner: options.owner,
    repo: options.repo,
    title: options.title,
    body: options.body,
    head: options.head,
    base: options.base,
    draft: options.draft || false,
  });

  // Asignar revisores
  if (options.reviewers?.length) {
    await octokit.pulls.requestReviewers({
      owner: options.owner,
      repo: options.repo,
      pull_number: pr.number,
      reviewers: options.reviewers,
    });
  }

  // Agregar etiquetas
  if (options.labels?.length) {
    await octokit.issues.addLabels({
      owner: options.owner,
      repo: options.repo,
      issue_number: pr.number,
      labels: options.labels,
    });
  }

  return pr;
}

// Analizar archivos modificados de un PR
export async function analyzePRChanges(
  owner: string,
  repo: string,
  pullNumber: number
) {
  const { data: files } = await octokit.pulls.listFiles({
    owner, repo,
    pull_number: pullNumber,
    per_page: 100,
  });

  const summary = {
    totalFiles: files.length,
    additions: files.reduce((sum, f) => sum + f.additions, 0),
    deletions: files.reduce((sum, f) => sum + f.deletions, 0),
    filesByType: {} as Record<string, number>,
  };

  for (const file of files) {
    const ext = file.filename.split('.').pop() || 'other';
    summary.filesByType[ext] = (summary.filesByType[ext] || 0) + 1;
  }

  return summary;
}

Automatizacion de gestion de issues

> Crea un script para el cierre automatico de issues obsoletos y la asignacion automatica de etiquetas.

// src/services/issue-management.ts
import octokit from '../lib/github';

export async function closeStaleIssues(
  owner: string,
  repo: string,
  daysThreshold = 90
) {
  const cutoffDate = new Date();
  cutoffDate.setDate(cutoffDate.getDate() - daysThreshold);

  const { data: issues } = await octokit.issues.listForRepo({
    owner, repo,
    state: 'open',
    sort: 'updated',
    direction: 'asc',
    per_page: 100,
  });

  const staleIssues = issues.filter(
    (issue) =>
      !issue.pull_request &&
      new Date(issue.updated_at) < cutoffDate
  );

  for (const issue of staleIssues) {
    // Agregar etiqueta stale
    await octokit.issues.addLabels({
      owner, repo,
      issue_number: issue.number,
      labels: ['stale'],
    });

    // Agregar comentario y cerrar
    await octokit.issues.createComment({
      owner, repo,
      issue_number: issue.number,
      body: `Este issue se cierra automaticamente porque no ha sido actualizado en mas de ${daysThreshold} dias. Si necesita atencion nuevamente, por favor reabralo.`,
    });

    await octokit.issues.update({
      owner, repo,
      issue_number: issue.number,
      state: 'closed',
      state_reason: 'not_planned',
    });
  }

  return { closedCount: staleIssues.length };
}

Automatizacion de releases

// src/services/release.ts
import octokit from '../lib/github';

export async function createRelease(
  owner: string,
  repo: string,
  tagName: string,
  options?: { prerelease?: boolean; generateNotes?: boolean }
) {
  const { data: release } = await octokit.repos.createRelease({
    owner, repo,
    tag_name: tagName,
    name: `Release ${tagName}`,
    generate_release_notes: options?.generateNotes ?? true,
    prerelease: options?.prerelease ?? false,
  });

  return release;
}

Servidor de recepcion de Webhooks

// src/api/github-webhook.ts
import { Webhooks } from '@octokit/webhooks';

const webhooks = new Webhooks({
  secret: process.env.GITHUB_WEBHOOK_SECRET!,
});

webhooks.on('pull_request.opened', async ({ payload }) => {
  const { pull_request, repository } = payload;
  console.log(`Nuevo PR: ${pull_request.title} en ${repository.full_name}`);
  // Etiquetado automatico, asignacion de revisores, etc.
});

webhooks.on('issues.opened', async ({ payload }) => {
  const { issue, repository } = payload;
  console.log(`Nuevo Issue: ${issue.title} en ${repository.full_name}`);
});

export default webhooks;

Resumen

Combinando la API de GitHub con Claude Code, puede realizar rapidamente la automatizacion del flujo de trabajo de desarrollo. Consulte tambien la guia de uso de GitHub Actions y el flujo de trabajo Git.

Para detalles de la API de GitHub, consulte la documentacion de la API REST de GitHub.