Claude API で作る GitHub PR レビューボット — Webhook統合からセキュリティスキャン・品質スコアリングまで実装

// src/github/prDiff.ts
import { Octokit } from '@octokit/rest';
 
export interface PRFile {
  filename: string;
  status: string; // 'added' | 'modified' | 'deleted' | 'renamed'
  additions: number;
  deletions: number;
  patch: string;
}
 
export interface PRDiff {
  files: PRFile[];
  totalAdditions: number;
  totalDeletions: number;
  skippedFiles: string[]; // 除外されたファイル名のリスト
}
 
export async function getPRDiff(
  owner: string,
  repo: string,
  pullNumber: number
): Promise<PRDiff> {
  const octokit = new Octokit({
    auth: process.env.GITHUB_TOKEN,
  });
 
  const { data: files } = await octokit.pulls.listFiles({
    owner,
    repo,
    pull_number: pullNumber,
    per_page: 100,
  });
 
  const skippedFiles: string[] = [];
  const reviewableFiles: PRFile[] = [];
 
  for (const file of files) {
    // バイナリファイル（patch なし）は除外
    if (!file.patch) {
      skippedFiles.push(`${file.filename} (binary/too large)`);
      continue;
    }
    // 500行超の変更は大きすぎる（コスト・品質の両面）
    if (file.changes > 500) {
      skippedFiles.push(`${file.filename} (${file.changes} lines — too large)`);
      continue;
    }
    // テストファイルは別途処理（本番コードに集中）
    if (isTestFile(file.filename)) {
      skippedFiles.push(`${file.filename} (test file)`);
      continue;
    }
 
    reviewableFiles.push({
      filename: file.filename,
      status: file.status,
      additions: file.additions,
      deletions: file.deletions,
      patch: file.patch,
    });
  }
 
  return {
    files: reviewableFiles,
    totalAdditions: files.reduce((sum, f) => sum + f.additions, 0),
    totalDeletions: files.reduce((sum, f) => sum + f.deletions, 0),
    skippedFiles,
  };
}
 
function isTestFile(filename: string): boolean {
  return (
    filename.includes('__tests__') ||
    filename.includes('.test.') ||
    filename.includes('.spec.') ||
    filename.endsWith('_test.ts') ||
    filename.endsWith('_test.py') ||
    filename.endsWith('Test.java')
  );
}

// src/claude/reviewer.ts
import Anthropic from '@anthropic-ai/sdk';
 
const anthropic = new Anthropic({
  apiKey: process.env.ANTHROPIC_API_KEY,
});
 
// レビュー結果の型定義
export interface ReviewResult {
  overall_score: number; // 0〜100
  security_issues: SecurityIssue[];
  quality_issues: QualityIssue[];
  improvements: Improvement[];
  summary: string;
}
 
interface SecurityIssue {
  severity: 'critical' | 'high' | 'medium' | 'low';
  file: string;
  line_hint: string; // 問題箇所のコードスニペット（1〜2行）
  description: string;
  recommendation: string;
}
 
interface QualityIssue {
  category: 'error_handling' | 'performance' | 'readability' | 'testability';
  file: string;
  description: string;
  suggestion: string;
}
 
interface Improvement {
  type: 'refactor' | 'optimization' | 'best_practice';
  description: string;
}
 
const reviewTool: Anthropic.Tool = {
  name: 'submit_code_review',
  description:
    'コードレビューの結果を構造化して提出する。分析完了後に必ず1回呼び出すこと。',
  input_schema: {
    type: 'object' as const,
    properties: {
      overall_score: {
        type: 'number',
        description:
          '全体的なコード品質スコア (0-100)。セキュリティ問題があれば大幅減点。100 が最高品質。',
        minimum: 0,
        maximum: 100,
      },
      security_issues: {
        type: 'array',
        description: 'セキュリティ上の問題点のリスト。問題なければ空配列。',
        items: {
          type: 'object',
          properties: {
            severity: {
              type: 'string',
              enum: ['critical', 'high', 'medium', 'low'],
              description:
                'critical: 即時修正必須 / high: マージ前に修正 / medium: 次回対応可 / low: 参考情報',
            },
            file: { type: 'string', description: 'ファイルパス' },
            line_hint: {
              type: 'string',
              description: '問題のあるコード行（1〜2行のスニペット）',
            },
            description: { type: 'string' },
            recommendation: { type: 'string' },
          },
          required: [
            'severity',
            'file',
            'line_hint',
            'description',
            'recommendation',
          ],
        },
      },
      quality_issues: {
        type: 'array',
        description: 'コード品質の問題点。問題なければ空配列。',
        items: {
          type: 'object',
          properties: {
            category: {
              type: 'string',
              enum: [
                'error_handling',
                'performance',
                'readability',
                'testability',
              ],
            },
            file: { type: 'string' },
            description: { type: 'string' },
            suggestion: { type: 'string' },
          },
          required: ['category', 'file', 'description', 'suggestion'],
        },
      },
      improvements: {
        type: 'array',
        description: '改善提案（必須ではないが推奨する変更）。最大3件まで。',
        items: {
          type: 'object',
          properties: {
            type: {
              type: 'string',
              enum: ['refactor', 'optimization', 'best_practice'],
            },
            description: { type: 'string' },
          },
          required: ['type', 'description'],
        },
      },
      summary: {
        type: 'string',
        description:
          'PR全体の評価を3〜5文で。スコアの根拠・主要な問題・良い点を含める。',
      },
    },
    required: [
      'overall_score',
      'security_issues',
      'quality_issues',
      'improvements',
      'summary',
    ],
  },
};
 
const SYSTEM_PROMPT = `あなたはシニアソフトウェアエンジニアです。GitHub の PR diff を受け取り、セキュリティ・コード品質・改善点を分析します。
 
分析の優先順位:
1. セキュリティ: SQLインジェクション・XSS・SSRF・認証バイパス・シークレット露出・不適切な権限チェック
2. エラーハンドリング: 例外の握りつぶし・不適切な try/catch・エラー伝播の欠如・タイムアウト未設定
3. パフォーマンス: N+1 クエリ・不要なループ・リソースリーク・非同期処理の誤用
4. 可読性: 複雑すぎる関数（20行超）・意味のない変数名・デッドコード
 
必ず submit_code_review ツールを1回呼び出して結果を提出してください。`;
 
export async function reviewPRDiff(
  diffContent: string,
  prTitle: string,
  prDescription: string,
  skippedFiles: string[]
): Promise<ReviewResult> {
  const skippedNote =
    skippedFiles.length > 0
      ? `\n\n⚠️ 以下のファイルはレビュー対象外です:\n${skippedFiles.map(f => `- ${f}`).join('\n')}`
      : '';
 
  const userMessage = `## PR タイトル
${prTitle}
 
## PR 説明
${prDescription || '（説明なし）'}
${skippedNote}
 
## コード差分
\`\`\`diff
${diffContent}
\`\`\`
 
上記の PR diff をレビューし、submit_code_review ツールで結果を提出してください。`;
 
  let retryCount = 0;
  const maxRetries = 3;
 
  while (retryCount < maxRetries) {
    try {
      const response = await anthropic.messages.create({
        model: 'claude-sonnet-4-6',
        max_tokens: 4096,
        system: SYSTEM_PROMPT,
        tools: [reviewTool],
        tool_choice: { type: 'any' }, // ツール呼び出しを強制
        messages: [{ role: 'user', content: userMessage }],
      });
 
      // Tool Use ブロックを取り出す
      const toolUseBlock = response.content.find(
        (block): block is Anthropic.ToolUseBlock =>
          block.type === 'tool_use' && block.name === 'submit_code_review'
      );
 
      if (!toolUseBlock) {
        throw new Error(
          `submit_code_review が呼ばれませんでした。stop_reason: ${response.stop_reason}`
        );
      }
 
      // トークン使用量をログ（コスト管理用）
      console.log(
        JSON.stringify({
          event: 'claude_review_complete',
          input_tokens: response.usage.input_tokens,
          output_tokens: response.usage.output_tokens,
          model: response.model,
        })
      );
 
      return toolUseBlock.input as ReviewResult;
    } catch (error) {
      retryCount++;
      console.error(`[Claude API] エラー (試行 ${retryCount}/${maxRetries}):`, error);
 
      if (retryCount >= maxRetries) {
        throw error;
      }
 
      // レート制限（429）は指数バックオフでリトライ
      if (isRateLimitError(error)) {
        const waitMs = Math.pow(2, retryCount) * 1000; // 2s, 4s, 8s
        console.log(`[Claude API] レート制限 — ${waitMs}ms 待機してリトライ`);
        await sleep(waitMs);
      } else {
        // その他のエラーは即時中断（リトライ不要）
        throw error;
      }
    }
  }
 
  throw new Error('最大リトライ回数を超えました');
}
 
function isRateLimitError(error: unknown): boolean {
  return (
    error instanceof Anthropic.RateLimitError ||
    (error instanceof Error && error.message.includes('429'))
  );
}
 
function sleep(ms: number): Promise<void> {
  return new Promise(resolve => setTimeout(resolve, ms));
}

// src/github/postReview.ts
import { Octokit } from '@octokit/rest';
import type { ReviewResult } from '../claude/reviewer';
 
export async function postReviewComment(
  owner: string,
  repo: string,
  pullNumber: number,
  review: ReviewResult
): Promise<void> {
  const octokit = new Octokit({
    auth: process.env.GITHUB_TOKEN,
  });
 
  // critical/high のセキュリティ問題があれば REQUEST_CHANGES
  const requiresChanges = review.security_issues.some(
    issue => issue.severity === 'critical' || issue.severity === 'high'
  );
 
  const event = requiresChanges ? 'REQUEST_CHANGES' : 'COMMENT';
  const body = formatReviewBody(review);
 
  await octokit.pulls.createReview({
    owner,
    repo,
    pull_number: pullNumber,
    event,
    body,
  });
 
  console.log(
    `[GitHub] PR #${pullNumber} にレビューコメントを投稿しました (${event})`
  );
}
 
function formatReviewBody(review: ReviewResult): string {
  const scoreEmoji =
    review.overall_score >= 80 ? '🟢' :
    review.overall_score >= 60 ? '🟡' : '🔴';
 
  let body = `## 🤖 Claude Code Review\n\n`;
  body += `${scoreEmoji} **品質スコア: ${review.overall_score}/100**\n\n`;
  body += `${review.summary}\n\n`;
 
  if (review.security_issues.length > 0) {
    body += `### 🔒 セキュリティ指摘\n\n`;
    for (const issue of review.security_issues) {
      const badge =
        issue.severity === 'critical' ? '🚨 CRITICAL' :
        issue.severity === 'high' ? '⚠️ HIGH' :
        issue.severity === 'medium' ? '⚡ MEDIUM' : 'ℹ️ LOW';
 
      body += `**${badge}** \`${issue.file}\`\n\n`;
      body += `\`\`\`\n${issue.line_hint}\n\`\`\`\n\n`;
      body += `${issue.description}\n\n`;
      body += `> 💡 **推奨対応**: ${issue.recommendation}\n\n`;
      body += `---\n\n`;
    }
  }
 
  if (review.quality_issues.length > 0) {
    body += `### 🔍 品質指摘\n\n`;
    const categoryLabel: Record<string, string> = {
      error_handling: 'エラーハンドリング',
      performance: 'パフォーマンス',
      readability: '可読性',
      testability: 'テスト容易性',
    };
 
    for (const issue of review.quality_issues) {
      body += `**[${categoryLabel[issue.category]}]** \`${issue.file}\`\n\n`;
      body += `${issue.description}\n\n`;
      body += `> 💡 ${issue.suggestion}\n\n`;
    }
  }
 
  if (review.improvements.length > 0) {
    body += `### 💡 改善提案（任意対応）\n\n`;
    const typeLabel: Record<string, string> = {
      refactor: 'リファクタリング',
      optimization: '最適化',
      best_practice: 'ベストプラクティス',
    };
 
    for (const improvement of review.improvements) {
      body += `- **[${typeLabel[improvement.type]}]** ${improvement.description}\n`;
    }
    body += '\n';
  }
 
  body += `---\n*このレビューは Claude Sonnet 4.6 によって自動生成されました。内容は参考情報です。*`;
 
  return body;
}

// src/handlers/pullRequest.ts
import { getPRDiff } from '../github/prDiff';
import { reviewPRDiff } from '../claude/reviewer';
import { postReviewComment } from '../github/postReview';
 
interface PullRequestPayload {
  action: string;
  pull_request: {
    number: number;
    title: string;
    body: string | null;
    draft: boolean;
  };
  repository: {
    owner: { login: string };
    name: string;
  };
}
 
// デバウンス用（短時間に複数コミットが来た場合に最後の1回だけ処理）
const pendingReviews = new Map<string, ReturnType<typeof setTimeout>>();
 
export async function handlePullRequestEvent(
  payload: PullRequestPayload
): Promise<void> {
  const { pull_request, repository } = payload;
  const owner = repository.owner.login;
  const repo = repository.name;
  const pullNumber = pull_request.number;
  const prKey = `${owner}/${repo}#${pullNumber}`;
 
  // Draft PR はレビューしない
  if (pull_request.draft) {
    console.log(`[PR #${pullNumber}] Draft PR のためスキップ`);
    return;
  }
 
  // デバウンス: 30秒以内に次のイベントが来たら前のタイマーをキャンセル
  if (pendingReviews.has(prKey)) {
    clearTimeout(pendingReviews.get(prKey)!);
    console.log(`[PR #${pullNumber}] デバウンス: タイマーをリセット`);
  }
 
  const timer = setTimeout(async () => {
    pendingReviews.delete(prKey);
    await executeReview(owner, repo, pullNumber, pull_request.title, pull_request.body || '');
  }, 30_000); // 30秒後に実行
 
  pendingReviews.set(prKey, timer);
  console.log(`[PR #${pullNumber}] レビュー予約 (30秒後): ${pull_request.title}`);
}
 
async function executeReview(
  owner: string,
  repo: string,
  pullNumber: number,
  prTitle: string,
  prDescription: string
): Promise<void> {
  console.log(`[PR #${pullNumber}] レビュー開始`);
 
  // Step 1: diff 取得
  const prDiff = await getPRDiff(owner, repo, pullNumber);
 
  if (prDiff.files.length === 0) {
    console.log(`[PR #${pullNumber}] レビュー対象ファイルなし（スキップ）`);
    return;
  }
 
  if (prDiff.skippedFiles.length > 0) {
    console.log(
      `[PR #${pullNumber}] スキップされたファイル:`,
      prDiff.skippedFiles
    );
  }
 
  // diff をテキスト形式に整形
  const diffContent = prDiff.files
    .map(f => `### ${f.filename} (${f.status}, +${f.additions}/-${f.deletions})\n${f.patch}`)
    .join('\n\n');
 
  // コスト見積もりをログ（概算: 文字数 / 4 ≒ トークン数）
  const estimatedInputTokens = Math.ceil(
    (SYSTEM_PROMPT_CHARS + diffContent.length) / 4
  );
  console.log(
    `[PR #${pullNumber}] ファイル数: ${prDiff.files.length}, 推定入力トークン: ~${estimatedInputTokens}`
  );
 
  // Step 2: Claude API でレビュー
  const review = await reviewPRDiff(
    diffContent,
    prTitle,
    prDescription,
    prDiff.skippedFiles
  );
 
  console.log(
    `[PR #${pullNumber}] レビュー完了: スコア ${review.overall_score}/100, ` +
    `セキュリティ ${review.security_issues.length}件, 品質 ${review.quality_issues.length}件`
  );
 
  // Step 3: GitHub にコメント投稿
  await postReviewComment(owner, repo, pullNumber, review);
 
  console.log(`[PR #${pullNumber}] 完了`);
}
 
// システムプロンプトの文字数（概算コスト計算用）
const SYSTEM_PROMPT_CHARS = 800;

ANTHROPIC_API_KEY=sk-ant-...    # Anthropic コンソールで取得
GITHUB_TOKEN=ghp_...            # PR への書き込み権限（repo スコープ）
GITHUB_WEBHOOK_SECRET=xxxxx     # GitHub Webhook 設定で指定した秘密鍵
PORT=3000                       # サーバーポート

{
  "build": {
    "builder": "NIXPACKS"
  },
  "deploy": {
    "startCommand": "npx ts-node src/webhook.ts",
    "healthcheckPath": "/health",
    "healthcheckTimeout": 10
  }
}

// scripts/testWebhook.ts
import crypto from 'crypto';
import fetch from 'node-fetch';
 
const WEBHOOK_SECRET = process.env.GITHUB_WEBHOOK_SECRET!;
const SERVER_URL = process.env.SERVER_URL || 'http://localhost:3000';
 
const mockPayload = {
  action: 'opened',
  pull_request: {
    number: 1,
    title: 'Test PR: ユーザー認証を追加',
    body: 'JWT ベースの認証を追加します。#42 を参照。',
    draft: false,
  },
  repository: {
    owner: { login: 'your-org' },
    name: 'your-repo',
  },
};
 
const payloadStr = JSON.stringify(mockPayload);
const hmac = crypto.createHmac('sha256', WEBHOOK_SECRET);
hmac.update(payloadStr);
const signature = `sha256=${hmac.digest('hex')}`;
 
const response = await fetch(`${SERVER_URL}/webhook`, {
  method: 'POST',
  headers: {
    'Content-Type': 'application/json',
    'X-GitHub-Event': 'pull_request',
    'X-Hub-Signature-256': signature,
  },
  body: payloadStr,
});
 
console.log('Status:', response.status);
console.log('Body:', await response.json());

# ログから概算コストを出す（料金は実際の単価に合わせて調整）
cat app.log | grep claude_review_complete | python3 -c "
import sys, json
total_in, total_out = 0, 0
for line in sys.stdin:
    try:
        d = json.loads(line)
        total_in += d.get('input_tokens', 0)
        total_out += d.get('output_tokens', 0)
    except: pass
# claude-sonnet-4-6: \$3/M input, \$15/M output
cost = (total_in / 1_000_000 * 3) + (total_out / 1_000_000 * 15)
print(f'Input: {total_in:,} tokens, Output: {total_out:,} tokens')
print(f'Estimated cost: \${cost:.4f}')
"

// src/outcome.ts — 202 とは別の場所に「終わり方」を残す
type Outcome = 'accepted' | 'completed' | 'failed' | 'skipped';
 
const ledger = new Map<string, Outcome>();
 
export function record(deliveryId: string, outcome: Outcome) {
  ledger.set(deliveryId, outcome);
  console.log(JSON.stringify({ event: 'pr_review_outcome', deliveryId, outcome }));
}
 
// 受付だけで終わっている配信を数える（監視はこの数を見る）
export function stranded(): number {
  let n = 0;
  for (const o of ledger.values()) if (o === 'accepted') n++;
  return n;
}

const deliveryId = req.headers['x-github-delivery'] as string;
record(deliveryId, 'accepted');
res.status(202).json({ accepted: true });
 
handlePullRequestEvent(payload)
  .then(r => record(deliveryId, r.reviewed ? 'completed' : 'skipped'))
  .catch(err => {
    record(deliveryId, 'failed');
    console.error('[PR handler]', err);
  });

app.get('/health', (_req, res) => {
  const s = stranded();
  res.status(s > 5 ? 503 : 200).json({ status: s > 5 ? 'degraded' : 'ok', stranded: s });
});

import { createAppAuth } from '@octokit/auth-app';
import { Octokit } from '@octokit/rest';
 
function createOctokitForInstallation(installationId: number): Octokit {
  return new Octokit({
    authStrategy: createAppAuth,
    auth: {
      appId: process.env.GITHUB_APP_ID,
      privateKey: process.env.GITHUB_APP_PRIVATE_KEY,
      installationId,
    },
  });
}

// tests/goldenSet.ts
export interface GoldenCase {
  name: string;
  diff: string;
  expect: Array<{
    kind: 'security' | 'quality';
    // security なら severity、quality なら category を照合する
    match: string;
    // 指摘文に含まれてほしいキーワード（表現の揺れを吸収するため部分一致）
    keyword: RegExp;
  }>;
}
 
export const goldenSet: GoldenCase[] = [
  {
    name: 'hardcoded-secret',
    diff: `--- a/src/client.ts
+++ b/src/client.ts
@@
-const apiKey = process.env.API_KEY;
+const apiKey = 'YOUR_API_KEY_LITERAL_PLACEHOLDER';
`,
    expect: [{ kind: 'security', match: 'critical', keyword: /ハードコード|環境変数|secret/i }],
  },
  {
    name: 'swallowed-error',
    diff: `--- a/src/job.ts
+++ b/src/job.ts
@@
-  await runJob();
+  try {
+    await runJob();
+  } catch (e) {}
`,
    expect: [{ kind: 'quality', match: 'error_handling', keyword: /握りつぶ|catch|ログ/i }],
  },
  {
    name: 'n-plus-one',
    diff: `--- a/src/report.ts
+++ b/src/report.ts
@@
-const rows = await db.users.findManyWithPosts();
+const users = await db.users.findMany();
+for (const u of users) {
+  u.posts = await db.posts.findByUser(u.id);
+}
`,
    expect: [{ kind: 'quality', match: 'performance', keyword: /N\+1|ループ|クエリ/i }],
  },
];

// scripts/runGoldenSet.ts
import fs from 'fs';
import { reviewPRDiff } from '../src/review';
import { goldenSet } from '../tests/goldenSet';
 
const BASELINE = 'tests/.golden-baseline.json';
 
async function main() {
  const result: Record<string, boolean> = {};
 
  for (const c of goldenSet) {
    const review = await reviewPRDiff(c.diff, `golden: ${c.name}`, '', []);
 
    const hit = c.expect.every(e => {
      const pool =
        e.kind === 'security'
          ? review.security_issues
              .filter(i => i.severity === e.match)
              .map(i => `${i.description} ${i.recommendation}`)
          : review.quality_issues
              .filter(i => i.category === e.match)
              .map(i => `${i.description} ${i.suggestion}`);
      return pool.some(text => e.keyword.test(text));
    });
 
    result[c.name] = hit;
    console.log(`${hit ? 'PASS' : 'FAIL'}  ${c.name}  (score=${review.overall_score})`);
  }
 
  const detected = Object.values(result).filter(Boolean).length;
  console.log(`\n検出 ${detected}/${goldenSet.length}`);
 
  if (!fs.existsSync(BASELINE)) {
    fs.writeFileSync(BASELINE, JSON.stringify(result, null, 2));
    console.log('ベースラインを作成しました。次回からこの結果と比較します。');
    return;
  }
 
  const base: Record<string, boolean> = JSON.parse(fs.readFileSync(BASELINE, 'utf-8'));
  const regressed = Object.keys(base).filter(k => base[k] && !result[k]);
 
  if (regressed.length > 0) {
    console.error(`回帰: ${regressed.join(', ')}`);
    process.exit(1);
  }
  console.log('回帰なし。ベースラインを更新します。');
  fs.writeFileSync(BASELINE, JSON.stringify(result, null, 2));
}
 
main();