@mate_tsaava/pr-review 1.0.0

package/dist/llm/claude.js

@@ -0,0 +1,187 @@
+import Anthropic from "@anthropic-ai/sdk";
+const SYSTEM_PROMPT = `You are a Senior Principal Engineer conducting a code review. You are direct, blunt, and pragmatic.
+
+Your task is to review the PR diff and identify issues in the NEW CODE ONLY. For each issue, provide:
+- file: The EXACT file path from the diff header (e.g., "/CredoWebAPI/Controllers/ScoringController.cs")
+- line: The EXACT line number where the problem IS, not where the function starts. Point to the specific problematic line.
+- endLine: (optional) If the issue spans multiple lines, include the ending line number.
+- severity: BLOCK (must fix before merge), HIGH (should fix), or MEDIUM (nice to fix)
+- category: Type of issue (Security, Architecture, Naming, Performance, Clean Code, etc.)
+- codeSnippet: Quote the EXACT problematic code (1-3 lines max) so there's no ambiguity
+- message: A witty, memorable comment about the issue
+- fix: The specific action to fix the issue, referencing the exact lines
+
+CRITICAL RULES:
+1. ONLY review lines starting with "+" (added or modified code). These are the NEW lines being introduced.
+2. NEVER comment on lines starting with "-" (deleted/old code). These are being REMOVED from the codebase.
+3. When a line is CHANGED, it appears as "-old" then "+new" - only review the "+new" version.
+4. The "file" field MUST be the exact path from the diff (starts with /)
+5. The "line" field MUST be a positive integer from the NEW code's line numbers (the + lines)
+6. If old problematic code is being deleted and replaced with better code, that is GOOD - do not flag the old code as an issue.
+
+Return your response as valid JSON in this exact format:
+{
+  "issues": [
+    {
+      "file": "/path/to/file.cs",
+      "line": 42,
+      "endLine": 43,
+      "severity": "HIGH",
+      "category": "Naming",
+      "codeSnippet": "var isLimit = await productTask;",
+      "message": "Your creative roast here",
+      "fix": "The actual fix they need, e.g., 'On lines 42-43, change X to Y'"
+    }
+  ],
+  "summary": "Review complete. BLOCK: X | HIGH: X | MEDIUM: X"
+}
+
+If there are no issues, return:
+{
+  "issues": [],
+  "summary": "Ship it! Clean code detected."
+}`;
+export class ClaudeAdapter {
+    client;
+    model;
+    verbose;
+    constructor(config) {
+        this.client = new Anthropic({ apiKey: config.apiKey });
+        this.model = config.model;
+        this.verbose = config.verbose || false;
+    }
+    async review(prompt) {
+        const userPrompt = this.buildUserPrompt(prompt);
+        const systemPrompt = SYSTEM_PROMPT + "\n\n" + prompt.rules;
+        const maxRetries = 3;
+        let lastError = null;
+        if (this.verbose) {
+            console.log("\n" + "=".repeat(80));
+            console.log("📤 API CALL: Claude messages.create");
+            console.log("=".repeat(80));
+            console.log(`Model: ${this.model}`);
+            console.log(`Max tokens: 4096`);
+            console.log(`System prompt length: ${systemPrompt.length} chars`);
+            console.log(`User prompt length: ${userPrompt.length} chars`);
+            console.log("\n--- SYSTEM PROMPT ---");
+            console.log(systemPrompt.slice(0, 2000) + (systemPrompt.length > 2000 ? "\n... (truncated)" : ""));
+            console.log("\n--- USER PROMPT (first 3000 chars) ---");
+            console.log(userPrompt.slice(0, 3000) + (userPrompt.length > 3000 ? "\n... (truncated)" : ""));
+            console.log("=".repeat(80) + "\n");
+        }
+        for (let attempt = 1; attempt <= maxRetries; attempt++) {
+            try {
+                const response = await this.client.messages.create({
+                    model: this.model,
+                    max_tokens: 4096,
+                    system: systemPrompt,
+                    messages: [
+                        {
+                            role: "user",
+                            content: userPrompt,
+                        },
+                    ],
+                });
+                if (this.verbose) {
+                    console.log("\n" + "=".repeat(80));
+                    console.log("📥 API RESPONSE");
+                    console.log("=".repeat(80));
+                    console.log(`Input tokens: ${response.usage?.input_tokens}`);
+                    console.log(`Output tokens: ${response.usage?.output_tokens}`);
+                    console.log(`Stop reason: ${response.stop_reason}`);
+                }
+                const content = response.content[0];
+                if (content.type !== "text") {
+                    throw new Error("Unexpected response type from Claude");
+                }
+                if (this.verbose) {
+                    console.log("\n--- RAW RESPONSE ---");
+                    console.log(content.text);
+                    console.log("=".repeat(80) + "\n");
+                }
+                return this.parseResponse(content.text);
+            }
+            catch (error) {
+                lastError = error instanceof Error ? error : new Error(String(error));
+                const isRateLimit = lastError.message.includes("429") || lastError.message.includes("rate_limit");
+                if (this.verbose) {
+                    console.log(`\n❌ API Error (attempt ${attempt}/${maxRetries}): ${lastError.message}`);
+                }
+                if (isRateLimit && attempt < maxRetries) {
+                    const waitTime = Math.pow(2, attempt) * 30; // 60s, 120s, 240s
+                    console.log(`⏳ Rate limited. Waiting ${waitTime}s before retry ${attempt + 1}/${maxRetries}...`);
+                    await new Promise((resolve) => setTimeout(resolve, waitTime * 1000));
+                }
+                else {
+                    throw lastError;
+                }
+            }
+        }
+        throw lastError;
+    }
+    buildUserPrompt(prompt) {
+        let userPrompt = `## PR Metadata
+- ID: ${prompt.prMetadata.id}
+- Title: ${prompt.prMetadata.title}
+- Author: ${prompt.prMetadata.author}
+- Source Branch: ${prompt.prMetadata.sourceBranch}
+- Target Branch: ${prompt.prMetadata.targetBranch}
+- Description: ${prompt.prMetadata.description || "No description"}
+
+## File Diffs
+`;
+        for (const diff of prompt.diffs) {
+            userPrompt += `\n### ${diff.path}\n\`\`\`diff\n${diff.diff}\n\`\`\`\n`;
+        }
+        if (prompt.cleanCodeGuide) {
+            userPrompt += `\n## Clean Code Guidelines Reference\n${prompt.cleanCodeGuide.slice(0, 10000)}\n`;
+        }
+        return userPrompt;
+    }
+    parseResponse(text) {
+        // Extract JSON - find the first { and match to its closing }
+        const startIdx = text.indexOf("{");
+        if (startIdx === -1) {
+            throw new Error("Could not find JSON in Claude response");
+        }
+        // Find matching closing brace
+        let depth = 0;
+        let endIdx = -1;
+        for (let i = startIdx; i < text.length; i++) {
+            if (text[i] === "{")
+                depth++;
+            if (text[i] === "}")
+                depth--;
+            if (depth === 0) {
+                endIdx = i;
+                break;
+            }
+        }
+        if (endIdx === -1) {
+            throw new Error("Could not find closing brace in Claude response");
+        }
+        const jsonStr = text.slice(startIdx, endIdx + 1);
+        try {
+            const parsed = JSON.parse(jsonStr);
+            const issues = (parsed.issues || []).filter((issue) => {
+                // Validate issue has valid file path and line number
+                if (!issue.file || !issue.file.startsWith("/")) {
+                    console.warn(`⚠ Skipping issue with invalid file path: ${issue.file}`);
+                    return false;
+                }
+                if (!issue.line || issue.line <= 0) {
+                    console.warn(`⚠ Skipping issue with invalid line number: ${issue.line}`);
+                    return false;
+                }
+                return true;
+            });
+            return {
+                issues,
+                summary: parsed.summary || "Review complete.",
+            };
+        }
+        catch (error) {
+            throw new Error(`Failed to parse Claude response: ${error}`);
+        }
+    }
+}

package/dist/llm/index.d.ts

@@ -0,0 +1,5 @@
+import type { LLMAdapter, LLMAdapterConfig } from "./adapter.js";
+export type LLMProvider = "claude" | "openai" | "azure-openai";
+export declare function createLLMAdapter(provider: LLMProvider, config: LLMAdapterConfig): LLMAdapter;
+export type { LLMAdapter, LLMAdapterConfig } from "./adapter.js";
+export type { ReviewPrompt, ReviewResult, ReviewIssue, Severity } from "./types.js";

package/dist/llm/index.js

@@ -0,0 +1,15 @@
+import { ClaudeAdapter } from "./claude.js";
+import { OpenAIAdapter } from "./openai.js";
+import { AzureOpenAIAdapter } from "./azure-openai.js";
+export function createLLMAdapter(provider, config) {
+    switch (provider) {
+        case "claude":
+            return new ClaudeAdapter(config);
+        case "openai":
+            return new OpenAIAdapter(config);
+        case "azure-openai":
+            return new AzureOpenAIAdapter(config);
+        default:
+            throw new Error(`Unknown LLM provider: ${provider}`);
+    }
+}

package/dist/llm/openai.d.ts

@@ -0,0 +1,10 @@
+import type { LLMAdapter, LLMAdapterConfig } from "./adapter.js";
+import type { ReviewPrompt, ReviewResult } from "./types.js";
+export declare class OpenAIAdapter implements LLMAdapter {
+    private client;
+    private model;
+    constructor(config: LLMAdapterConfig);
+    review(prompt: ReviewPrompt): Promise<ReviewResult>;
+    private buildUserPrompt;
+    private parseResponse;
+}

package/dist/llm/openai.js

@@ -0,0 +1,73 @@
+import OpenAI from "openai";
+const SYSTEM_PROMPT = `You are a Senior Principal Engineer conducting a code review. You are direct, blunt, and pragmatic.
+
+Your task is to review the PR diff and identify issues. For each issue, provide:
+- file: The file path
+- line: The line number where the issue occurs
+- severity: BLOCK (must fix before merge), HIGH (should fix), or MEDIUM (nice to fix)
+- category: Type of issue (Security, Architecture, Naming, Performance, Clean Code, etc.)
+- message: A witty, memorable comment about the issue
+- fix: The specific action to fix the issue
+
+IMPORTANT: Return your response as valid JSON in this exact format:
+{
+  "issues": [...],
+  "summary": "Review complete. BLOCK: X | HIGH: X | MEDIUM: X"
+}`;
+export class OpenAIAdapter {
+    client;
+    model;
+    constructor(config) {
+        this.client = new OpenAI({ apiKey: config.apiKey });
+        this.model = config.model;
+    }
+    async review(prompt) {
+        const userPrompt = this.buildUserPrompt(prompt);
+        const response = await this.client.chat.completions.create({
+            model: this.model,
+            messages: [
+                {
+                    role: "system",
+                    content: SYSTEM_PROMPT + "\n\n" + prompt.rules,
+                },
+                {
+                    role: "user",
+                    content: userPrompt,
+                },
+            ],
+            response_format: { type: "json_object" },
+        });
+        const content = response.choices[0]?.message?.content;
+        if (!content) {
+            throw new Error("Empty response from OpenAI");
+        }
+        return this.parseResponse(content);
+    }
+    buildUserPrompt(prompt) {
+        let userPrompt = `## PR Metadata
+- ID: ${prompt.prMetadata.id}
+- Title: ${prompt.prMetadata.title}
+- Author: ${prompt.prMetadata.author}
+- Source Branch: ${prompt.prMetadata.sourceBranch}
+- Target Branch: ${prompt.prMetadata.targetBranch}
+
+## File Diffs
+`;
+        for (const diff of prompt.diffs) {
+            userPrompt += `\n### ${diff.path}\n\`\`\`diff\n${diff.diff}\n\`\`\`\n`;
+        }
+        return userPrompt;
+    }
+    parseResponse(text) {
+        try {
+            const parsed = JSON.parse(text);
+            return {
+                issues: parsed.issues || [],
+                summary: parsed.summary || "Review complete.",
+            };
+        }
+        catch (error) {
+            throw new Error(`Failed to parse OpenAI response: ${error}`);
+        }
+    }
+}

package/dist/llm/types.d.ts

@@ -0,0 +1,31 @@
+export type Severity = "BLOCK" | "HIGH" | "MEDIUM";
+export interface ReviewIssue {
+    file: string;
+    line: number;
+    endLine?: number;
+    severity: Severity;
+    category: string;
+    codeSnippet?: string;
+    message: string;
+    fix: string;
+}
+export interface ReviewResult {
+    issues: ReviewIssue[];
+    summary: string;
+}
+export interface ReviewPrompt {
+    prMetadata: {
+        id: number;
+        title: string;
+        description: string;
+        sourceBranch: string;
+        targetBranch: string;
+        author: string;
+    };
+    diffs: Array<{
+        path: string;
+        diff: string;
+    }>;
+    rules: string;
+    cleanCodeGuide?: string;
+}

package/dist/llm/types.js

@@ -0,0 +1 @@
+export {};

package/dist/reviewer.d.ts

@@ -0,0 +1,29 @@
+import type { ReviewResult } from "./llm/types.js";
+import type { Config } from "./config.js";
+export interface ReviewOptions {
+    organization: string;
+    project: string;
+    repositoryId: string;
+    pullRequestId: number;
+    dryRun: boolean;
+    maxTokensPerBatch?: number;
+    maxFilesPerBatch?: number;
+    verbose?: boolean;
+}
+export interface ReviewOutput {
+    result: ReviewResult;
+    postedComments: number;
+    summaryPosted: boolean;
+}
+export declare class PRReviewer {
+    private config;
+    private client;
+    private fetcher;
+    private poster;
+    constructor(config: Config, organization: string, project: string);
+    review(options: ReviewOptions): Promise<ReviewOutput>;
+    private loadRules;
+    private loadCleanCodeGuide;
+    private formatComment;
+    private generateSummary;
+}

package/dist/reviewer.js

@@ -0,0 +1,142 @@
+import { readFileSync, existsSync } from "fs";
+import { join, dirname } from "path";
+import { fileURLToPath } from "url";
+import { AzureDevOpsClient, PullRequestFetcher, CommentPoster, createPatAuthenticator } from "@mate_tsaava/azure-devops-core";
+import { createLLMAdapter } from "./llm/index.js";
+import { createBatches } from "./utils/batcher.js";
+import { estimateDiffTokens } from "./utils/tokens.js";
+const __dirname = dirname(fileURLToPath(import.meta.url));
+export class PRReviewer {
+    config;
+    client;
+    fetcher;
+    poster;
+    constructor(config, organization, project) {
+        this.config = config;
+        this.client = new AzureDevOpsClient({
+            organization,
+            getToken: createPatAuthenticator(),
+        });
+        this.fetcher = new PullRequestFetcher(this.client, project);
+        this.poster = new CommentPoster(this.client, project);
+    }
+    async review(options) {
+        // 1. Fetch PR diff
+        console.log(`Fetching PR #${options.pullRequestId}...`);
+        const prDiff = await this.fetcher.fetchFullDiff(options.repositoryId, options.pullRequestId);
+        console.log(`Found ${prDiff.files.length} changed files`);
+        // 2. Load review rules
+        const rules = this.loadRules();
+        // 3. Create batches
+        const maxTokens = options.maxTokensPerBatch || 150000;
+        const maxFiles = options.maxFilesPerBatch || 10;
+        const diffs = prDiff.diffs.map((d) => ({ path: d.path, diff: d.diff }));
+        const totalTokens = estimateDiffTokens(diffs);
+        const batches = createBatches(diffs, maxTokens, maxFiles);
+        console.log(`Estimated ${totalTokens} tokens across ${diffs.length} files`);
+        console.log(`📦 Processing ${batches.length} batch(es)...`);
+        // 4. Send to LLM
+        console.log(`Analyzing with ${this.config.llm.provider}...`);
+        const llm = createLLMAdapter(this.config.llm.provider, {
+            apiKey: this.config.llm.apiKey,
+            model: this.config.llm.model || "claude-sonnet-4-20250514",
+            endpoint: this.config.llm.endpoint,
+            verbose: options.verbose,
+        });
+        const allIssues = [];
+        try {
+            for (let i = 0; i < batches.length; i++) {
+                const batch = batches[i];
+                console.log(`🔍 Reviewing batch ${i + 1}/${batches.length} (${batch.files.length} files, ~${batch.totalTokens} tokens)...`);
+                const batchResult = await llm.review({
+                    prMetadata: {
+                        id: prDiff.pr.id,
+                        title: prDiff.pr.title,
+                        description: prDiff.pr.description,
+                        sourceBranch: prDiff.pr.sourceBranch,
+                        targetBranch: prDiff.pr.targetBranch,
+                        author: prDiff.pr.author.displayName,
+                    },
+                    diffs: batch.files.map((f) => ({ path: f.path, diff: f.diff })),
+                    rules,
+                    cleanCodeGuide: this.loadCleanCodeGuide(),
+                });
+                allIssues.push(...batchResult.issues);
+            }
+        }
+        catch (error) {
+            throw new Error(`Failed to analyze PR with ${this.config.llm.provider}: ${error instanceof Error ? error.message : String(error)}`);
+        }
+        // 5. Generate combined result
+        const result = {
+            issues: allIssues,
+            summary: this.generateSummary(allIssues),
+        };
+        // 4. Post comments (unless dry run)
+        let postedComments = 0;
+        let summaryPosted = false;
+        if (!options.dryRun) {
+            console.log("\nPosting comments...");
+            for (const issue of result.issues) {
+                try {
+                    await this.poster.postInlineComment(options.repositoryId, options.pullRequestId, {
+                        filePath: issue.file,
+                        line: issue.line,
+                        content: this.formatComment(issue),
+                    });
+                    postedComments++;
+                    console.log(`  • ${issue.severity}: ${issue.category} (${issue.file}:${issue.line})`);
+                }
+                catch (error) {
+                    console.error(`  ✗ Failed to post comment at ${issue.file}:${issue.line}: ${error instanceof Error ? error.message : String(error)}`);
+                }
+            }
+            try {
+                await this.poster.postSummaryComment(options.repositoryId, options.pullRequestId, { content: result.summary });
+                summaryPosted = true;
+                console.log("📝 Summary posted.");
+            }
+            catch (error) {
+                console.error(`✗ Failed to post summary comment: ${error instanceof Error ? error.message : String(error)}`);
+            }
+        }
+        else {
+            console.log("\nDry run - would post these comments:");
+            for (const issue of result.issues) {
+                console.log(`  [${issue.severity}] ${issue.category} (${issue.file}:${issue.line})`);
+                console.log(`    ${issue.message}`);
+                console.log(`    Fix: ${issue.fix}\n`);
+            }
+            console.log(`Summary: ${result.summary}`);
+        }
+        return { result, postedComments, summaryPosted };
+    }
+    loadRules() {
+        const rulesPath = this.config.rules?.path || join(__dirname, "rules", "pr-review.md");
+        if (existsSync(rulesPath)) {
+            return readFileSync(rulesPath, "utf-8");
+        }
+        console.warn(`⚠ Rules file not found at ${rulesPath}, using default rules`);
+        return "Review for code quality, security issues, and best practices.";
+    }
+    loadCleanCodeGuide() {
+        // Skip for large PRs to stay within token limits
+        // TODO: Add --no-guide flag to control this
+        return undefined;
+    }
+    formatComment(issue) {
+        const lineRef = issue.endLine ? `Lines ${issue.line}-${issue.endLine}` : `Line ${issue.line}`;
+        const snippet = issue.codeSnippet ? `\n\n\`\`\`\n${issue.codeSnippet}\n\`\`\`` : "";
+        return `**[${issue.severity}] ${issue.category}** (${lineRef})${snippet}
+
+> ${issue.message}
+
+**Fix:** ${issue.fix}`;
+    }
+    generateSummary(issues) {
+        const block = issues.filter((i) => i.severity === "BLOCK").length;
+        const high = issues.filter((i) => i.severity === "HIGH").length;
+        const medium = issues.filter((i) => i.severity === "MEDIUM").length;
+        return `Review complete. BLOCK: ${block} | HIGH: ${high} | MEDIUM: ${medium}`;
+    }
+}