@mate_tsaava/pr-review 1.0.0

package/LICENSE.md

@@ -0,0 +1,21 @@
+    MIT License
+
+    Copyright (c) Microsoft Corporation.
+
+    Permission is hereby granted, free of charge, to any person obtaining a copy
+    of this software and associated documentation files (the "Software"), to deal
+    in the Software without restriction, including without limitation the rights
+    to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+    copies of the Software, and to permit persons to whom the Software is
+    furnished to do so, subject to the following conditions:
+
+    The above copyright notice and this permission notice shall be included in all
+    copies or substantial portions of the Software.
+
+    THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+    IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+    FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+    AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+    LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+    OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+    SOFTWARE

package/README.md

@@ -0,0 +1,109 @@
+# @mate_tsaava/pr-review
+
+AI-powered PR review CLI for Azure DevOps.
+
+## Installation
+
+```bash
+npm install -g @mate_tsaava/pr-review
+# or
+npx @mate_tsaava/pr-review --help
+```
+
+## Setup
+
+1. Set environment variables:
+
+```bash
+export AZURE_DEVOPS_PAT="your-personal-access-token"
+export ANTHROPIC_API_KEY="sk-ant-..."  # or OPENAI_API_KEY
+```
+
+2. (Optional) Create config file:
+
+```bash
+pr-review init
+```
+
+## Usage
+
+```bash
+# Basic usage
+pr-review --org myorg --project MyProject --pr 123
+
+# With specific LLM provider
+pr-review --org myorg --project MyProject --pr 123 --provider openai --model gpt-4o
+
+# Dry run (show review without posting)
+pr-review --org myorg --project MyProject --pr 123 --dry-run
+
+# Specify repository (if different from project name)
+pr-review --org myorg --project MyProject --repo MyRepo --pr 123
+
+# Verbose mode (show prompts, responses, API calls)
+pr-review --org myorg --project MyProject --pr 123 --verbose
+
+# Large PRs - adjust batching
+pr-review --org myorg --project MyProject --pr 123 --max-tokens 100000 --max-files 5
+```
+
+## Configuration
+
+Config file locations (checked in order):
+
+1. Path specified via `--config` option
+2. `.pr-review.json` (current directory)
+3. `~/.pr-review/config.json` (home directory)
+
+Example config:
+
+```json
+{
+  "azureDevOps": {
+    "defaultOrg": "myorg",
+    "defaultProject": "MyProject"
+  },
+  "llm": {
+    "provider": "claude",
+    "model": "claude-sonnet-4-20250514"
+  },
+  "rules": {
+    "path": "./rules/pr-review.md",
+    "cleanCodeGuide": "./rules/clean-code-dotnet.md"
+  }
+}
+```
+
+## LLM Providers
+
+| Provider | API Key Env Var | Default Model |
+|----------|-----------------|---------------|
+| claude | `ANTHROPIC_API_KEY` | claude-sonnet-4-20250514 |
+| openai | `OPENAI_API_KEY` | gpt-4o |
+| azure-openai | `AZURE_OPENAI_API_KEY` + `AZURE_OPENAI_ENDPOINT` | gpt-4o |
+
+## Exit Codes
+
+| Code | Meaning |
+|------|---------|
+| 0 | Review complete, no blocking issues |
+| 1 | Review complete, blocking issues found |
+| 2 | Error occurred |
+
+## Custom Review Rules
+
+You can provide custom review rules by creating a markdown file and referencing it in the config:
+
+```json
+{
+  "rules": {
+    "path": "./my-team-rules.md"
+  }
+}
+```
+
+The rules file should contain guidelines for the AI reviewer to follow when analyzing code.
+
+## License
+
+MIT

package/dist/cli.d.ts

@@ -0,0 +1,2 @@
+#!/usr/bin/env node
+export {};

package/dist/cli.js

@@ -0,0 +1,133 @@
+#!/usr/bin/env node
+import yargs from "yargs";
+import { hideBin } from "yargs/helpers";
+import { config as loadEnv } from "dotenv";
+import chalk from "chalk";
+// Load environment variables
+loadEnv();
+yargs(hideBin(process.argv))
+    .scriptName("pr-review")
+    .usage("Usage: $0 <command> [options]")
+    .command("init", "Initialize configuration file", (yargs) => {
+    return yargs.option("local", {
+        describe: "Create config in current directory instead of home",
+        type: "boolean",
+        default: false,
+    });
+}, async (argv) => {
+    const { initConfig } = await import("./commands/init.js");
+    initConfig(argv.local ? "local" : "global");
+})
+    .command("$0", "Review a pull request", (yargs) => {
+    return yargs
+        .option("org", {
+        alias: "o",
+        describe: "Azure DevOps organization name",
+        type: "string",
+        demandOption: true,
+    })
+        .option("project", {
+        alias: "p",
+        describe: "Azure DevOps project name",
+        type: "string",
+        demandOption: true,
+    })
+        .option("pr", {
+        describe: "Pull request ID",
+        type: "number",
+        demandOption: true,
+    })
+        .option("repo", {
+        alias: "r",
+        describe: "Repository name or ID (defaults to project name)",
+        type: "string",
+    })
+        .option("provider", {
+        describe: "LLM provider to use",
+        choices: ["claude", "azure-openai", "openai"],
+        default: "claude",
+    })
+        .option("model", {
+        alias: "m",
+        describe: "Model to use (provider-specific)",
+        type: "string",
+    })
+        .option("dry-run", {
+        describe: "Show review without posting comments",
+        type: "boolean",
+        default: false,
+    })
+        .option("max-tokens", {
+        describe: "Max tokens per batch (default: 150000)",
+        type: "number",
+        default: 150000,
+    })
+        .option("max-files", {
+        describe: "Max files per batch (default: 10)",
+        type: "number",
+        default: 10,
+    })
+        .option("config", {
+        alias: "c",
+        describe: "Path to config file",
+        type: "string",
+    })
+        .option("verbose", {
+        alias: "v",
+        describe: "Show detailed logs (prompts, responses, API calls)",
+        type: "boolean",
+        default: false,
+    });
+}, async (argv) => {
+    const { loadConfig } = await import("./config.js");
+    const { PRReviewer } = await import("./reviewer.js");
+    console.log(chalk.bold("PR Review CLI"));
+    console.log(chalk.dim("=============\n"));
+    try {
+        // Load configuration
+        const config = loadConfig({
+            provider: argv.provider,
+            model: argv.model,
+            config: argv.config,
+        });
+        // Create reviewer
+        const reviewer = new PRReviewer(config, argv.org, argv.project);
+        // Run review
+        const { result, postedComments, summaryPosted } = await reviewer.review({
+            organization: argv.org,
+            project: argv.project,
+            repositoryId: argv.repo || argv.project,
+            pullRequestId: argv.pr,
+            dryRun: argv.dryRun,
+            maxTokensPerBatch: argv.maxTokens,
+            maxFilesPerBatch: argv.maxFiles,
+            verbose: argv.verbose,
+        });
+        // Print summary
+        console.log("\n" + chalk.bold("Result:"));
+        const issues = result.issues || [];
+        const blockCount = issues.filter((i) => i.severity === "BLOCK").length;
+        const highCount = issues.filter((i) => i.severity === "HIGH").length;
+        const mediumCount = issues.filter((i) => i.severity === "MEDIUM").length;
+        const blockText = blockCount > 0 ? chalk.red(`${blockCount} BLOCK`) : chalk.green("0 BLOCK");
+        const highText = highCount > 0 ? chalk.yellow(`${highCount} HIGH`) : chalk.green("0 HIGH");
+        const mediumText = `${mediumCount} MEDIUM`;
+        console.log(`${blockText} | ${highText} | ${mediumText}`);
+        if (!argv.dryRun) {
+            console.log(chalk.dim(`\nPosted ${postedComments} inline comments`));
+            if (summaryPosted) {
+                console.log(chalk.dim("Summary comment posted"));
+            }
+        }
+        // Exit code based on blockers
+        process.exit(blockCount > 0 ? 1 : 0);
+    }
+    catch (error) {
+        console.error(chalk.red("\nError:"), error instanceof Error ? error.message : String(error));
+        process.exit(2);
+    }
+})
+    .help()
+    .version()
+    .strict()
+    .parse();

package/dist/commands/init.d.ts

@@ -0,0 +1 @@
+export declare function initConfig(location?: "local" | "global"): void;

package/dist/commands/init.js

@@ -0,0 +1,44 @@
+import { writeFileSync, mkdirSync, existsSync } from "fs";
+import { join } from "path";
+import { homedir } from "os";
+import chalk from "chalk";
+const DEFAULT_CONFIG = {
+    azureDevOps: {
+        pat: "${AZURE_DEVOPS_PAT}",
+        defaultOrg: "",
+        defaultProject: "",
+    },
+    llm: {
+        provider: "claude",
+        model: "claude-sonnet-4-20250514",
+    },
+    rules: {
+        path: "./rules/pr-review.md",
+        cleanCodeGuide: "./rules/clean-code-dotnet.md",
+    },
+};
+export function initConfig(location = "global") {
+    let configPath;
+    let configDir;
+    if (location === "local") {
+        configDir = process.cwd();
+        configPath = join(configDir, ".pr-review.json");
+    }
+    else {
+        configDir = join(homedir(), ".pr-review");
+        configPath = join(configDir, "config.json");
+    }
+    if (existsSync(configPath)) {
+        console.log(chalk.yellow(`Config already exists at ${configPath}`));
+        return;
+    }
+    if (!existsSync(configDir)) {
+        mkdirSync(configDir, { recursive: true });
+    }
+    writeFileSync(configPath, JSON.stringify(DEFAULT_CONFIG, null, 2));
+    console.log(chalk.green(`Created config at ${configPath}`));
+    console.log(chalk.dim("\nNext steps:"));
+    console.log("1. Set AZURE_DEVOPS_PAT environment variable");
+    console.log("2. Set your LLM API key (ANTHROPIC_API_KEY, OPENAI_API_KEY, etc.)");
+    console.log("3. Update defaultOrg and defaultProject in config");
+}

package/dist/config.d.ts

@@ -0,0 +1,84 @@
+import { z } from "zod";
+declare const LLMProviderSchema: z.ZodEnum<["claude", "azure-openai", "openai"]>;
+type LLMProvider = z.infer<typeof LLMProviderSchema>;
+declare const ConfigSchema: z.ZodObject<{
+    azureDevOps: z.ZodObject<{
+        pat: z.ZodString;
+        defaultOrg: z.ZodOptional<z.ZodString>;
+        defaultProject: z.ZodOptional<z.ZodString>;
+    }, "strip", z.ZodTypeAny, {
+        pat: string;
+        defaultOrg?: string | undefined;
+        defaultProject?: string | undefined;
+    }, {
+        pat: string;
+        defaultOrg?: string | undefined;
+        defaultProject?: string | undefined;
+    }>;
+    llm: z.ZodObject<{
+        provider: z.ZodEnum<["claude", "azure-openai", "openai"]>;
+        apiKey: z.ZodString;
+        model: z.ZodOptional<z.ZodString>;
+        endpoint: z.ZodOptional<z.ZodString>;
+    }, "strip", z.ZodTypeAny, {
+        provider: "claude" | "azure-openai" | "openai";
+        apiKey: string;
+        model?: string | undefined;
+        endpoint?: string | undefined;
+    }, {
+        provider: "claude" | "azure-openai" | "openai";
+        apiKey: string;
+        model?: string | undefined;
+        endpoint?: string | undefined;
+    }>;
+    rules: z.ZodOptional<z.ZodObject<{
+        path: z.ZodOptional<z.ZodString>;
+        cleanCodeGuide: z.ZodOptional<z.ZodString>;
+    }, "strip", z.ZodTypeAny, {
+        path?: string | undefined;
+        cleanCodeGuide?: string | undefined;
+    }, {
+        path?: string | undefined;
+        cleanCodeGuide?: string | undefined;
+    }>>;
+}, "strip", z.ZodTypeAny, {
+    azureDevOps: {
+        pat: string;
+        defaultOrg?: string | undefined;
+        defaultProject?: string | undefined;
+    };
+    llm: {
+        provider: "claude" | "azure-openai" | "openai";
+        apiKey: string;
+        model?: string | undefined;
+        endpoint?: string | undefined;
+    };
+    rules?: {
+        path?: string | undefined;
+        cleanCodeGuide?: string | undefined;
+    } | undefined;
+}, {
+    azureDevOps: {
+        pat: string;
+        defaultOrg?: string | undefined;
+        defaultProject?: string | undefined;
+    };
+    llm: {
+        provider: "claude" | "azure-openai" | "openai";
+        apiKey: string;
+        model?: string | undefined;
+        endpoint?: string | undefined;
+    };
+    rules?: {
+        path?: string | undefined;
+        cleanCodeGuide?: string | undefined;
+    } | undefined;
+}>;
+export type Config = z.infer<typeof ConfigSchema>;
+interface CLIOverrides {
+    provider?: LLMProvider;
+    model?: string;
+    config?: string;
+}
+export declare function loadConfig(overrides: CLIOverrides): Config;
+export {};

package/dist/config.js

@@ -0,0 +1,77 @@
+import { z } from "zod";
+import { readFileSync, existsSync } from "fs";
+import { homedir } from "os";
+import { join } from "path";
+const LLMProviderSchema = z.enum(["claude", "azure-openai", "openai"]);
+const ConfigSchema = z.object({
+    azureDevOps: z.object({
+        pat: z.string().min(1, "AZURE_DEVOPS_PAT is required"),
+        defaultOrg: z.string().optional(),
+        defaultProject: z.string().optional(),
+    }),
+    llm: z.object({
+        provider: LLMProviderSchema,
+        apiKey: z.string().min(1, "LLM API key is required"),
+        model: z.string().optional(),
+        endpoint: z.string().optional(),
+    }),
+    rules: z
+        .object({
+        path: z.string().optional(),
+        cleanCodeGuide: z.string().optional(),
+    })
+        .optional(),
+});
+export function loadConfig(overrides) {
+    let fileConfig = {};
+    const configPaths = [overrides.config, ".pr-review.json", join(homedir(), ".pr-review", "config.json")].filter(Boolean);
+    for (const configPath of configPaths) {
+        if (existsSync(configPath)) {
+            try {
+                const content = readFileSync(configPath, "utf-8");
+                fileConfig = JSON.parse(content);
+                break;
+            }
+            catch {
+                // Ignore invalid config files
+            }
+        }
+    }
+    const provider = overrides.provider || fileConfig.llm?.provider || "claude";
+    const apiKey = getApiKey(provider, fileConfig.llm?.apiKey);
+    const config = {
+        azureDevOps: {
+            pat: process.env.AZURE_DEVOPS_PAT || fileConfig.azureDevOps?.pat || "",
+            defaultOrg: fileConfig.azureDevOps?.defaultOrg,
+            defaultProject: fileConfig.azureDevOps?.defaultProject,
+        },
+        llm: {
+            provider,
+            apiKey,
+            model: overrides.model || fileConfig.llm?.model || getDefaultModel(provider),
+            endpoint: process.env.AZURE_OPENAI_ENDPOINT || fileConfig.llm?.endpoint,
+        },
+        rules: fileConfig.rules,
+    };
+    return ConfigSchema.parse(config);
+}
+function getApiKey(provider, fileApiKey) {
+    switch (provider) {
+        case "claude":
+            return process.env.ANTHROPIC_API_KEY || fileApiKey || "";
+        case "openai":
+            return process.env.OPENAI_API_KEY || fileApiKey || "";
+        case "azure-openai":
+            return process.env.AZURE_OPENAI_API_KEY || fileApiKey || "";
+    }
+}
+function getDefaultModel(provider) {
+    switch (provider) {
+        case "claude":
+            return "claude-sonnet-4-20250514";
+        case "openai":
+            return "gpt-4o";
+        case "azure-openai":
+            return "gpt-4o";
+    }
+}

package/dist/index.d.ts

@@ -0,0 +1,2 @@
+export declare const VERSION = "1.0.0";
+export { PRReviewer, type ReviewOptions, type ReviewOutput } from "./reviewer.js";

package/dist/index.js

@@ -0,0 +1,3 @@
+// PR Review CLI
+export const VERSION = "1.0.0";
+export { PRReviewer } from "./reviewer.js";

package/dist/llm/adapter.d.ts

@@ -0,0 +1,13 @@
+import type { ReviewPrompt, ReviewResult } from "./types.js";
+export interface ReviewContext {
+    verbose?: boolean;
+}
+export interface LLMAdapter {
+    review(prompt: ReviewPrompt, context?: ReviewContext): Promise<ReviewResult>;
+}
+export interface LLMAdapterConfig {
+    apiKey: string;
+    model: string;
+    endpoint?: string;
+    verbose?: boolean;
+}

package/dist/llm/adapter.js

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

package/dist/llm/azure-openai.d.ts

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

package/dist/llm/azure-openai.js

@@ -0,0 +1,73 @@
+import { AzureOpenAI } 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 AzureOpenAIAdapter {
+    client;
+    model;
+    constructor(config) {
+        if (!config.endpoint) {
+            throw new Error("Azure OpenAI endpoint is required");
+        }
+        this.client = new AzureOpenAI({
+            apiKey: config.apiKey,
+            endpoint: config.endpoint,
+            apiVersion: "2024-02-15-preview",
+        });
+        this.model = config.model;
+    }
+    async review(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: this.buildUserPrompt(prompt) },
+            ],
+            response_format: { type: "json_object" },
+        });
+        const content = response.choices[0]?.message?.content;
+        if (!content) {
+            throw new Error("Empty response from Azure 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 Azure OpenAI response: ${error}`);
+        }
+    }
+}

package/dist/llm/claude.d.ts

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