mkdir -p scripts
npm init -y

npm i -E @anthropic-ai/sdk @octokit/rest zod p-limit minimatch dotenv

{
  "name": "pr-reviewer",
  "type": "module",
  "scripts": {
    "review:local": "REVIEW_LOCAL=1 node scripts/review.mjs",
    "lint": "node -e \"console.log('OK')\""
  }
}

echo "ANTHROPIC_API_KEY=sk-ant-xxxxxxxx" > .env.local

name: PR Review (Claude)

on:
  pull_request:
    types: [opened, synchronize, reopened]
    branches:
      - main
      - develop

permissions:
  contents: read
  pull-requests: write

jobs:
  review:
    runs-on: ubuntu-latest
    steps:
      - name: Checkout
        uses: actions/checkout@v4

      - name: Setup Node
        uses: actions/setup-node@v4
        with:
          node-version: '18'

      - name: Cache reviewer state
        uses: actions/cache@v4
        with:
          path: .pr-review-cache.json
          key: pr-review-cache-${{ github.event.pull_request.number }}-v1

      - name: Install deps
        run: npm ci

      - name: Run reviewer
        env:
          GITHUB_TOKEN: ${{ secrets.GITHUB_TOKEN }}
          ANTHROPIC_API_KEY: ${{ secrets.ANTHROPIC_API_KEY }}
          MODEL: ${{ vars.MODEL || 'claude-3-5-sonnet-20240620' }}
          MAX_TOKENS: ${{ vars.MAX_TOKENS || '1000' }}
          ENABLE_DEBUG: ${{ vars.ENABLE_DEBUG || '0' }}
          INCLUDE_GLOBS: "**/*.js,**/*.ts,**/*.tsx,**/*.jsx,**/*.py,**/*.rb,**/*.go"
          EXCLUDE_GLOBS: "**/dist/**,**/build/**,**/*.min.*"
          MAX_PATCH_CHARS: "20000"
          MAX_COMMENTS_PER_FILE: "6"
          PARALLEL_LIMIT: "3"
        run: node scripts/review.mjs

      - name: Upload logs
        if: always()
        uses: actions/upload-artifact@v4
        with:
          name: pr-review-logs-${{ github.run_id }}
          path: .review-logs

// scripts/review.mjs
import 'dotenv/config';
import fs from 'node:fs';
import path from 'node:path';
import crypto from 'node:crypto';
import { fileURLToPath } from 'node:url';
import { Octokit } from '@octokit/rest';
import Anthropic from '@anthropic-ai/sdk';
import { z } from 'zod';
import pLimit from 'p-limit';
import { minimatch } from 'minimatch';

const __filename = fileURLToPath(import.meta.url);
const __dirname = path.dirname(__filename);

// --- Config & helpers ---
const CONFIG = {
  model: process.env.MODEL || 'claude-3-5-sonnet-20240620',
  maxTokens: Number(process.env.MAX_TOKENS || 1000),
  temperature: 0.2,
  includeGlobs: (process.env.INCLUDE_GLOBS || '**/*').split(','),
  excludeGlobs: (process.env.EXCLUDE_GLOBS || '').split(',').filter(Boolean),
  maxPatchChars: Number(process.env.MAX_PATCH_CHARS || 20000),
  maxCommentsPerFile: Number(process.env.MAX_COMMENTS_PER_FILE || 6),
  parallelLimit: Number(process.env.PARALLEL_LIMIT || 3),
  enableDebug: process.env.ENABLE_DEBUG === '1',
  localMode: process.env.REVIEW_LOCAL === '1',
  logsDir: path.resolve(process.cwd(), '.review-logs')
};

if (!fs.existsSync(CONFIG.logsDir)) {
  fs.mkdirSync(CONFIG.logsDir, { recursive: true });
}

const octokit = new Octokit({ auth: process.env.GITHUB_TOKEN });
const anthropic = new Anthropic({ apiKey: process.env.ANTHROPIC_API_KEY });

function debugLog(name, data) {
  if (!CONFIG.enableDebug) return;
  const file = path.join(CONFIG.logsDir, `${Date.now()}-${name}.json`);
  fs.writeFileSync(file, JSON.stringify(data, null, 2), 'utf8');
}

function hash(text) {
  return crypto.createHash('sha256').update(text).digest('hex').slice(0, 16);
}

// Simple local cache persisted in workspace
const CACHE_FILE = path.resolve(process.cwd(), '.pr-review-cache.json');
function readCache() {
  try {
    return JSON.parse(fs.readFileSync(CACHE_FILE, 'utf8'));
  } catch {
    return {};
  }
}
function writeCache(cache) {
  fs.writeFileSync(CACHE_FILE, JSON.stringify(cache, null, 2), 'utf8');
}

// --- Unified diff utilities ---
function truncatePatch(patch, limit = CONFIG.maxPatchChars) {
  if (!patch) return '';
  if (patch.length <= limit) return patch;
  // Keep head/tail and all hunk headers to help the model keep context
  const hunks = patch.split('\n').filter(l => l.startsWith('@@ '));
  const head = patch.slice(0, Math.floor(limit * 0.6));
  const tail = patch.slice(-Math.floor(limit * 0.35));
  const header = `\n\n--- PATCH TRUNCATED (${patch.length} chars > ${limit}) ---\n`;
  return head + header + hunks.join('\n') + '\n' + tail;
}

// Build a set of valid "new file" line numbers present in the diff hunks
function buildNewLineMap(patch) {
  const map = new Set();
  if (!patch) return map;
  const lines = patch.split('\n');
  let newLine = 0;
  for (const line of lines) {
    if (line.startsWith('@@')) {
      // Example: @@ -12,7 +12,9 @@
      const m = line.match(/\+(\d+)(?:,(\d+))?/);
      if (m) newLine = Number(m[1]);
      continue;
    }
    if (line.startsWith('+')) {
      map.add(newLine);
      newLine += 1;
    } else if (line.startsWith('-')) {
      // removal does not advance new line counter
      continue;
    } else {
      // context line
      map.add(newLine);
      newLine += 1;
    }
  }
  return map;
}

function matchesGlobs(file, includes, excludes) {
  const inc = includes.length === 0 || includes.some(g => minimatch(file, g));
  const exc = excludes.some(g => minimatch(file, g));
  return inc && !exc;
}

// --- Zod schema for model output ---
const CommentSchema = z.object({
  line: z.number().int().positive(),
  severity: z.enum(['nit', 'info', 'warn', 'error']),
  message: z.string().min(1),
  suggestion: z.string().optional()
});
const FileReviewSchema = z.object({
  file: z.string(),
  comments: z.array(CommentSchema).max(CONFIG.maxCommentsPerFile)
});
const ResponseSchema = FileReviewSchema;

// --- Prompt builders ---
function systemPrompt() {
  return [
    'Tu es un reviewer de code senior.',
    'Objectif: produire des retours concis, actionnables et priorisés.',
    'Priorités: 1) Bugs et sécurité, 2) Perf et complexité, 3) Lisibilité et DX.',
    'Quand c’est pertinent, propose un diff minimaliste sous forme de suggestion.',
    `Réponds STRICTEMENT en JSON valide selon le schéma:`,
    `{"file": "path", "comments": [{"line": 0, "severity": "nit|info|warn|error", "message":"...", "suggestion":"..."}]}`,
    `Ne dépasse pas ${CONFIG.maxCommentsPerFile} commentaires par fichier et évite les doublons.`,
    'N’invente pas: si tu n’es pas certain, classe en "info" et explique tes hypothèses.'
  ].join('\n');
}

function userPromptPerFile({ prTitle, prBody, repoRules, filePath, patch }) {
  const rules = repoRules || 'Suivre ESLint/Prettier si applicable. Respecter conventions des tests et de sécurité du repo.';
  return [
    `PR: ${prTitle}`,
    `Description: ${prBody || '(pas de description)'}`,
    `Règles du repo: ${rules}`,
    `Fichier: ${filePath}`,
    `Patch (unified diff):`,
    '```diff',
    patch || '(pas de patch)',
    '```',
    'Contraintes:',
    `- Utilise les numéros de lignes du nouveau fichier (côté head) dans "line".`,
    `- Retourne strictement un JSON (pas de texte hors JSON).`,
    `- Max commentaires: ${CONFIG.maxCommentsPerFile}.`,
  ].join('\n');
}

// --- Anthropic call w/ retries ---
async function callClaude({ filePath, prTitle, prBody, repoRules, patch }) {
  const SYS = systemPrompt();
  const USR = userPromptPerFile({ prTitle, prBody, repoRules, filePath, patch });
  debugLog(`prompt-${hash(filePath)}`, { system: SYS, user: USR });

  let attempt = 0;
  const maxAttempts = 3;
  const baseDelay = 1000;

  while (attempt < maxAttempts) {
    attempt += 1;
    try {
      const msg = await anthropic.messages.create({
        model: CONFIG.model,
        max_tokens: CONFIG.maxTokens,
        temperature: CONFIG.temperature,
        system: SYS,
        messages: [{ role: 'user', content: USR }]
      });
      const textBlocks = msg.content.filter(b => b.type === 'text').map(b => b.text).join('\n');
      const json = extractJson(textBlocks);
      debugLog(`response-${hash(filePath)}`, { raw: textBlocks, json });
      const parsed = ResponseSchema.safeParse(json);
      if (!parsed.success) {
        throw new Error(`Invalid JSON from model: ${parsed.error.message}`);
      }
      return parsed.data;
    } catch (err) {
      if (attempt >= maxAttempts) throw err;
      const delay = baseDelay * Math.pow(2, attempt - 1);
      await new Promise(res => setTimeout(res, delay));
    }
  }
}

function extractJson(text) {
  // Try direct JSON
  try { return JSON.parse(text); } catch {}
  // Try fenced code blocks
  const fenced = text.match(/```(?:json)?\s*([\s\S]*?)```/);
  if (fenced) {
    try { return JSON.parse(fenced[1]); } catch {}
  }
  // Last resort: naive braces slice
  const start = text.indexOf('{');
  const end = text.lastIndexOf('}');
  if (start !== -1 && end !== -1 && end > start) {
    const slice = text.slice(start, end + 1);
    return JSON.parse(slice);
  }
  throw new Error('Unable to extract JSON from model response');
}

// --- GitHub context ---
function getGhContext() {
  if (CONFIG.localMode) {
    return {
      owner: 'local',
      repo: 'local',
      pull_number: 0,
      isLocal: true
    };
  }
  const repoFull = process.env.GITHUB_REPOSITORY;
  const [owner, repo] = repoFull.split('/');
  const eventPath = process.env.GITHUB_EVENT_PATH;
  const event = JSON.parse(fs.readFileSync(eventPath, 'utf8'));
  const pr = event.pull_request;
  return {
    owner,
    repo,
    pull_number: pr.number,
    pr
  };
}

// --- Main ---
async function main() {
  const cache = readCache();
  const ctx = getGhContext();

  // Collect PR info and files
  let prData;
  if (!ctx.isLocal) {
    prData = await octokit.pulls.get({
      owner: ctx.owner, repo: ctx.repo, pull_number: ctx.pull_number
    });
  } else {
    prData = {
      data: {
        number: 0,
        title: 'Local review',
        body: 'Test local du reviewer',
        head: { sha: (await exec('git rev-parse HEAD')).trim() },
        base: { ref: 'local' }
      }
    };
  }

  let files;
  if (!ctx.isLocal) {
    const all = await octokit.paginate(octokit.pulls.listFiles, {
      owner: ctx.owner, repo: ctx.repo, pull_number: ctx.pull_number, per_page: 100
    });
    files = all;
  } else {
    const diff = await exec('git diff --unified=3 --patch HEAD~1');
    files = parseLocalDiffToFiles(diff);
  }

  // Filter files
  const filtered = files.filter(f => {
    const patch = f.patch || '';
    const tooBig = (f.changes || 0) > 2000 || patch.length > CONFIG.maxPatchChars * 4;
    const hasPatch = !!f.patch;
    const pathOk = matchesGlobs(f.filename, CONFIG.includeGlobs, CONFIG.excludeGlobs);
    const notBinary = hasPatch; // heuristic: binary often lacks patch
    return pathOk && notBinary && !tooBig;
  });

  // Prepare requests
  const limit = pLimit(CONFIG.parallelLimit);
  const prTitle = prData.data.title || '';
  const prBody = prData.data.body || '';
  const headSha = prData.data.head.sha;
  const repoRules = 'Code style du repo, sécurité de base, tests si modifs logiques, éviter régressions de performances.';

  const results = await Promise.all(filtered.map(f => limit(async () => {
    const filePath = f.filename;
    const patchTrunc = truncatePatch(f.patch || '');
    const id = `${ctx.pull_number}:${filePath}:${hash(patchTrunc)}`;
    const cached = cache[id];
    if (cached) return { filePath, review: cached, map: buildNewLineMap(f.patch || '') };

    const review = await callClaude({
      filePath, prTitle, prBody, repoRules, patch: patchTrunc
    });

    // Enforce file path in response
    review.file = filePath;

    // Deduplicate and cap comments
    const seen = new Set();
    review.comments = review.comments
      .slice(0, CONFIG.maxCommentsPerFile)
      .filter(c => {
        const h = hash(`${review.file}:${c.line}:${c.severity}:${c.message}`);
        if (seen.has(h)) return false;
        seen.add(h);
        return true;
      });

    cache[id] = review;
    return { filePath, review, map: buildNewLineMap(f.patch || '') };
  })));

  writeCache(cache);

  // Publish results
  if (CONFIG.localMode) {
    console.log('Local run - results:');
    console.log(JSON.stringify(results.map(r => r.review), null, 2));
    return;
  }

  await publishToGitHub({
    owner: ctx.owner,
    repo: ctx.repo,
    pull_number: ctx.pull_number,
    headSha,
    results
  });
}

async function publishToGitHub({ owner, repo, pull_number, headSha, results }) {
  const allComments = [];
  for (const r of results) {
    for (const c of r.review.comments) {
      allComments.push({ file: r.review.file, map: r.map, ...c });
    }
  }

  // Top-level summary
  const critical = allComments.filter(c => c.severity === 'error' || c.severity === 'warn');
  if (critical.length > 0) {
    const bodyLines = [
      'Résumé du reviewer (points prioritaires):',
      '',
      ...critical.slice(0, 10).map(c => `- [${c.severity.toUpperCase()}] ${c.file}:${c.line} — ${c.message}`)
    ];
    await octokit.issues.createComment({
      owner, repo, issue_number: pull_number, body: bodyLines.join('\n')
    });
  }

  // Inline comments
  for (const c of allComments) {
    const nearestLine = nearestAvailableLine(c.line, c.map);
    if (!nearestLine) {
      // Fallback: attach to PR top-level if we can’t place inline
      await octokit.issues.createComment({
        owner, repo, issue_number: pull_number,
        body: `Commentaire sur ${c.file} (impossible de placer en ligne):\n\n[${c.severity.toUpperCase()}] ${c.message}`
      });
      continue;
    }

    const pieces = [];
    pieces.push(`[${
      c.severity.toUpperCase()
    }] ${c.message}`);
    if (c.suggestion) {
      pieces.push('');
      pieces.push('```suggestion');
      pieces.push(c.suggestion);
      pieces.push('```');
    }
    const body = pieces.join('\n');

    await octokit.pulls.createReviewComment({
      owner, repo, pull_number,
      commit_id: headSha,
      path: c.file,
      side: 'RIGHT',
      line: nearestLine,
      body
    });
  }
}

function nearestAvailableLine(target, map) {
  if (!map || map.size === 0) return null;
  if (map.has(target)) return target;
  // find nearest line in map
  let best = null;
  let bestDist = Infinity;
  for (const l of map) {
    const d = Math.abs(l - target);
    if (d < bestDist) {
      bestDist = d;
      best = l;
    }
  }
  return best;
}

// --- Utilities ---
function parseLocalDiffToFiles(diff) {
  // Minimal parser splitting by "diff --git a/... b/..."
  const files = [];
  const chunks = diff.split('\ndiff --git ').slice(1);
  for (const ch of chunks) {
    const headerLine = ch.split('\n')[0];
    const match = headerLine.match(/a\/(.+?) b\/(.+)$/);
    const filename = match ? match[2] : 'unknown';
    const patch = ch.includes('@@') ? 'diff --git ' + ch : null;
    files.push({ filename, patch, changes: (patch || '').split('\n').length });
  }
  return files;
}

async function exec(cmd) {
  const { exec } = await import('node:child_process');
  return await new Promise((resolve, reject) => {
    exec(cmd, { maxBuffer: 1024 * 1024 * 10 }, (err, stdout, stderr) => {
      if (err) reject(err);
      else resolve(stdout);
    });
  });
}

main().catch(err => {
  console.error('[reviewer] fatal:', err);
  process.exitCode = 1;
});

{
  "file": "src/auth/login.ts",
  "comments": [
    {
      "line": 42,
      "severity": "warn",
      "message": "Le retry manque un backoff exponentiel, risque de surcharge en cas d'incident.",
      "suggestion": "Utiliser une fonction de retry avec jitter, ex: attendre 200ms, 400ms, 800ms, puis abandonner."
    }
  ]
}

[WARN] Le handler n’est pas idempotent; en cas de retry il peut doubler l’effet.

```suggestion
if (processedIds.has(id)) return;
processedIds.add(id);

Si la ligne proposée par le modèle ne correspond pas exactement à une ligne du côté head, le script choisit la ligne la plus proche disponible dans la hunk. En dernier recours, il publie le commentaire au niveau de la PR avec une mention claire du fichier concerné. Cette stratégie évite d’échouer silencieusement et garantit que le feedback arrive aux développeurs.

## Gérer la taille, les erreurs et l’observabilité

La taille des patches est gérée par une heuristique de tronquage qui conserve le début et la fin du diff ainsi que les en-têtes de hunk @@, ce qui préserve les informations de position et le contexte structurel. Cela limite fortement le coût en tokens sans perdre l’alignement nécessaire aux lignes. Les appels au modèle sont protégés par des retries exponentiels sur les erreurs transitoires, avec journalisation dans un répertoire .review-logs téléversé en artefact de run, accessible uniquement au sein de la CI.

Côté robustesse, le script valide strictement le JSON, évite les doublons, et ne bloque pas une publication complète pour un fichier en erreur: un fichier qui échoue sera simplement ignoré avec un log d’échec. Un petit cache local basé sur un hash du patch évite de rappeler le modèle pour un fichier identique au sein d’un run ou d’un run ultérieur si vous conservez l’artefact/cache. Voici un exemple minimaliste d’écriture des logs et du cache, déjà intégré plus haut:

```js
// écritures de logs debug
debugLog(`prompt-${hash(filePath)}`, { system: SYS, user: USR });
debugLog(`response-${hash(filePath)}`, { raw: textBlocks, json });

// lecture/écriture du cache
const cache = readCache();
cache[id] = review;
writeCache(cache);

# simulateur local (ne publie rien)
ANTHROPIC_API_KEY=sk-ant-xxxxxxxx ENABLE_DEBUG=1 npm run review:local

REVIEW_SUMMARY_ONLY=1 npm run review:local