diff-hound 1.0.0

package/README.md

@@ -0,0 +1,221 @@
+# Diff Hound
+
+Diff Hound is an automated AI-powered code review tool that posts intelligent, contextual comments directly on pull requests across supported platforms.
+
+Supports GitHub today. GitLab and Bitbucket support are planned.
+
+---
+
+## ✨ Features
+
+- 🧠 Automated code review using OpenAI (Upcoming: Claude, DeepSeek, CodeLlama)
+- 💬 Posts inline or summary comments on pull requests
+- 🔌 Plug-and-play architecture for models and platforms
+- ⚙️ Configurable with JSON/YAML config files and CLI overrides
+- 🛠️ Designed for CI/CD pipelines and local runs
+- 🧐 Tracks last reviewed commit to avoid duplicate reviews
+
+---
+
+## 🛠️ Installation
+
+### Option 1: Install via npm
+
+```bash
+npm install -g diff-hound
+```
+
+### Option 2: Install from source
+
+```bash
+git clone https://github.com/runtimebug/diff-hound.git
+cd diff-hound
+npm install
+npm run build
+npm link
+```
+
+---
+
+## 🚀 How to Use
+
+### Step 1: Setup Environment Variables
+
+Copy the provided `.env.example` to `.env` and fill in your credentials:
+
+```bash
+cp .env.example .env
+```
+
+Then modify with your keys / tokens:
+
+```env
+# Platform tokens
+GITHUB_TOKEN=your_github_token # Requires 'repo' scope
+
+# AI Model API keys
+OPENAI_API_KEY=your_openai_key
+```
+
+> 🔐 `GITHUB_TOKEN` is used to fetch PRs and post comments – [get it here](https://github.com/settings/personal-access-tokens)  
+> 🔐 `OPENAI_API_KEY` is used to generate code reviews via GPT – [get it here](https://platform.openai.com/api-keys)
+
+---
+
+### Step 2: Create a Config File
+
+You can define your config in `.aicodeconfig.json` or `.aicode.yml`:
+
+#### JSON Example (`.aicodeconfig.json`)
+
+```json
+{
+  "provider": "openai",
+  "model": "gpt-4o", // Or any other openai model
+  "endpoint": "", // Optional: custom endpoint
+  "gitProvider": "github",
+  "repo": "your-username/your-repo",
+  "dryRun": false,
+  "verbose": false,
+  "rules": [
+    "Prefer const over let when variables are not reassigned",
+    "Avoid reassigning const variables",
+    "Add descriptive comments for complex logic",
+    "Remove unnecessary comments",
+    "Follow the DRY (Don't Repeat Yourself) principle",
+    "Use descriptive variable and function names",
+    "Handle errors appropriately",
+    "Add type annotations where necessary"
+  ],
+  "ignoreFiles": ["*.md", "package-lock.json", "yarn.lock", "LICENSE", "*.log"],
+  "commentStyle": "inline",
+  "severity": "suggestion"
+}
+```
+
+#### YAML Example (`.aicode.yml`)
+
+```yaml
+provider: openai
+model: gpt-4o # Or any other openai model
+endpoint: "" # Optional: custom endpoint
+gitProvider: github
+repo: your-username/your-repo
+dryRun: false
+verbose: false
+commentStyle: inline
+severity: suggestion
+ignoreFiles:
+  - "*.md"
+  - package-lock.json
+  - yarn.lock
+  - LICENSE
+  - "*.log"
+rules:
+  - Prefer const over let when variables are not reassigned
+  - Avoid reassigning const variables
+  - Add descriptive comments for complex logic
+  - Remove unnecessary comments
+  - Follow the DRY (Don't Repeat Yourself) principle
+  - Use descriptive variable and function names
+  - Handle errors appropriately
+  - Add type annotations where necessary
+```
+
+---
+
+### Step 3: Run It
+
+```bash
+diff-hound
+```
+
+Or override config values via CLI:
+
+```bash
+diff-hound --repo=owner/repo --provider=openai --model=gpt-4o --dry-run
+```
+
+> Add `--dry-run` to **print comments to console** instead of posting them.
+
+---
+
+### Output Example (Dry Run)
+
+```bash
+== Comments for PR #42: Fix input validation ==
+
+src/index.ts:17 —
+Prefer `const` over `let` since `userId` is not reassigned.
+
+src/utils/parse.ts:45 —
+Consider refactoring to reduce nesting.
+```
+
+---
+
+### Optional CLI Flags
+
+| Flag               | Short | Description                             |
+| ------------------ | ----- | --------------------------------------- |
+| `--provider`       | `-p`  | AI model provider (e.g. `openai`)       |
+| `--model`          | `-m`  | AI model (e.g. `gpt-4o`, `gpt-4`, etc.) |
+| `--model-endpoint` | `-e`  | Custom API endpoint for the model       |
+| `--git-provider`   | `-g`  | Repo platform (default: `github`)       |
+| `--repo`           | `-r`  | GitHub repo in format `owner/repo`      |
+| `--comment-style`  | `-s`  | `inline` or `summary`                   |
+| `--dry-run`        | `-d`  | Don’t post comments, only print         |
+| `--verbose`        | `-v`  | Enable debug logs                       |
+| `--config-path`    | `-c`  | Custom config file path                 |
+
+---
+
+## 🛠️ Development
+
+### Project Structure
+
+```
+diff-hound/
+├── bin/                  # CLI entrypoint
+├── src/
+│   ├── cli/              # CLI argument parsing
+│   ├── config/           # JSON/YAML config handling
+│   ├── core/             # Diff parsing, formatting
+│   ├── models/           # AI model adapters
+│   ├── platforms/        # GitHub, GitLab, etc.
+│   └── types/            # TypeScript types
+├── .env
+├── README.md
+```
+
+---
+
+### Add Support for New AI Models
+
+Create a new class in `src/models/` that implements the `CodeReviewModel` interface.
+
+---
+
+### Add Support for New Platforms
+
+Create a new class in `src/platforms/` that implements the `CodeReviewPlatform` interface.
+
+---
+
+## ✅ Next Steps
+
+🔧 Add Winston for production-grade logging  
+🌐 Implement GitLab and Bitbucket platform adapters  
+🌍 Add support for other AI model providers (e.g. Anthropic, DeepSeek...)  
+💻 Add support for running local models (e.g. Ollama, Llama.cpp, Hugging Face transformers)  
+📤 Add support for webhook triggers (e.g., GitHub Actions, GitLab CI)  
+🧪 Add unit and integration test suites (Jest or Vitest)  
+📦 Publish Docker image for CI/CD use  
+🧩 Enable plugin hooks for custom rule logic  
+🗂 Add support for reviewing diffs from local branches or patch files
+
+---
+
+## 📜 License
+
+MIT – Use freely, contribute openly.

package/bin/diff-hound.js

@@ -0,0 +1,4 @@
+#!/usr/bin/env node
+
+// This is a simple wrapper to run the compiled TypeScript code
+require("../dist/index.js");

package/dist/cli/index.d.ts

@@ -0,0 +1,9 @@
+import { ReviewConfig } from "../types";
+/**
+ * Parse and validate CLI arguments
+ */
+export declare function parseCli(): Partial<ReviewConfig>;
+/**
+ * Log message if verbose mode is enabled
+ */
+export declare function verboseLog(options: Partial<ReviewConfig>, message: string): void;

package/dist/cli/index.js

@@ -0,0 +1,56 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.parseCli = parseCli;
+exports.verboseLog = verboseLog;
+const commander_1 = require("commander");
+const dotenv_1 = __importDefault(require("dotenv"));
+const package_json_1 = require("../../package.json");
+const config_1 = require("../config");
+// Load environment variables
+dotenv_1.default.config();
+/**
+ * Parse and validate CLI arguments
+ */
+function parseCli() {
+    const program = new commander_1.Command();
+    program
+        .name("diff-hound")
+        .description("AI-powered code review for GitHub, GitLab, and Bitbucket")
+        .version(package_json_1.version)
+        .option("-p, --provider <provider>", "The provider of the AI model (openai, anthropic, deepseek, groq, gemini)", config_1.DEFAULT_CONFIG.provider)
+        .option("-m, --model <model>", "The AI model (gpt-4o, claude-3-5-sonnet, deepseek, llama3, gemini-2.0-flash)", config_1.DEFAULT_CONFIG.model)
+        .option("-e, --model-endpoint <endpoint>", "The endpoint for the AI model")
+        .option("-g, --git-platform <platform>", "Platform to use (github, gitlab, bitbucket)", config_1.DEFAULT_CONFIG.gitPlatform)
+        .option("-r, --repo <owner/repo>", "Repository to review")
+        .option("-s, --comment-style <commentStyle>", "Comment style (inline, summary)", config_1.DEFAULT_CONFIG.commentStyle)
+        .option("-d, --dry-run", "Do not post comments, just print them", config_1.DEFAULT_CONFIG.dryRun)
+        .option("-v, --verbose", "Enable verbose logging", config_1.DEFAULT_CONFIG.verbose)
+        .option("-c, --config-path <path>", "Path to config file (default: .aicodeconfig.json or .aicode.yml)")
+        .parse(process.argv);
+    const options = program.opts();
+    return sanitizeCliOptions({
+        provider: options.provider,
+        model: options.model,
+        gitPlatform: options.gitPlatform,
+        repo: options.repo,
+        commentStyle: options.commentStyle,
+        dryRun: options.dryRun,
+        verbose: options.verbose,
+        endpoint: options.modelEndpoint,
+        configPath: options.configPath,
+    });
+}
+/**
+ * Log message if verbose mode is enabled
+ */
+function verboseLog(options, message) {
+    if (options.verbose) {
+        console.log(`[DEBUG] ${message}`);
+    }
+}
+function sanitizeCliOptions(cli) {
+    return Object.fromEntries(Object.entries(cli).filter(([_, v]) => v !== undefined));
+}

package/dist/config/index.d.ts

@@ -0,0 +1,18 @@
+import { ReviewConfig } from "../types";
+/**
+ * Default configuration
+ */
+export declare const DEFAULT_CONFIG: ReviewConfig;
+/**
+ * Load configuration from file
+ * @param configPath Optional path to config file
+ * @returns Review configuration
+ */
+export declare function loadConfig(configPath?: string): Promise<ReviewConfig>;
+/**
+ * Validates the configuration : CLI options && config file
+ * @param cliOptions CLI options from command line
+ * @param config Configuration from file
+ * @returns Updated configuration
+ */
+export declare function validateConfig(cliOptions: Partial<ReviewConfig>, config: ReviewConfig): ReviewConfig;

package/dist/config/index.js

@@ -0,0 +1,102 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.DEFAULT_CONFIG = void 0;
+exports.loadConfig = loadConfig;
+exports.validateConfig = validateConfig;
+const fs_1 = __importDefault(require("fs"));
+const path_1 = __importDefault(require("path"));
+const js_yaml_1 = __importDefault(require("js-yaml"));
+/**
+ * Default configuration
+ */
+exports.DEFAULT_CONFIG = {
+    provider: "openai",
+    model: "gpt-4o",
+    gitPlatform: "github",
+    commentStyle: "inline",
+    dryRun: false,
+    verbose: false,
+    severity: "suggestion",
+    ignoreFiles: [],
+};
+/**
+ * Load configuration from file
+ * @param configPath Optional path to config file
+ * @returns Review configuration
+ */
+async function loadConfig(configPath) {
+    // If config path is specified, use it
+    if (configPath && fs_1.default.existsSync(configPath)) {
+        return loadConfigFromFile(configPath);
+    }
+    // Otherwise, look for default config files
+    const jsonConfigPath = path_1.default.resolve(process.cwd(), ".aicodeconfig.json");
+    const yamlConfigPath = path_1.default.resolve(process.cwd(), ".aicode.yml");
+    if (fs_1.default.existsSync(jsonConfigPath)) {
+        return loadConfigFromFile(jsonConfigPath);
+    }
+    if (fs_1.default.existsSync(yamlConfigPath)) {
+        return loadConfigFromFile(yamlConfigPath);
+    }
+    // Return default config if no config file is found
+    return { ...exports.DEFAULT_CONFIG };
+}
+/**
+ * Load configuration from a specific file
+ * @param filePath Path to config file
+ * @returns Review configuration
+ */
+function loadConfigFromFile(filePath) {
+    try {
+        const fileContent = fs_1.default.readFileSync(filePath, "utf8");
+        let config;
+        if (filePath.endsWith(".json")) {
+            config = JSON.parse(fileContent);
+        }
+        else if (filePath.endsWith(".yml") || filePath.endsWith(".yaml")) {
+            config = js_yaml_1.default.load(fileContent);
+        }
+        else {
+            throw new Error(`Unsupported config file format: ${filePath}`);
+        }
+        // Merge with default config
+        return { ...exports.DEFAULT_CONFIG, ...config };
+    }
+    catch (error) {
+        console.error(`Error loading config from ${filePath}: ${error}`);
+        return { ...exports.DEFAULT_CONFIG };
+    }
+}
+/**
+ * Validates the configuration : CLI options && config file
+ * @param cliOptions CLI options from command line
+ * @param config Configuration from file
+ * @returns Updated configuration
+ */
+function validateConfig(cliOptions, config) {
+    let finalConfig = { ...config, ...cliOptions };
+    // Validate provider
+    // Todo: Add more providers as needed ("anthropic", "deepseek", "groq", "gemini")
+    const validProviders = ["openai"];
+    if (!validProviders.includes(finalConfig.provider)) {
+        console.error(`Error: Invalid provider '${finalConfig.provider}'. Using default: ${exports.DEFAULT_CONFIG.provider}`);
+        finalConfig.provider = exports.DEFAULT_CONFIG.provider;
+    }
+    // Validate platform
+    // Todo: Add more platforms as needed ("gitlab", "bitbucket")
+    const validPlatforms = ["github"];
+    if (!validPlatforms.includes(finalConfig.gitPlatform)) {
+        console.error(`Error: Invalid platform '${finalConfig.gitPlatform}'. Using default: ${exports.DEFAULT_CONFIG.gitPlatform}`);
+        finalConfig.gitPlatform = exports.DEFAULT_CONFIG.gitPlatform;
+    }
+    // Validate severity
+    if (finalConfig.severity &&
+        !["suggestion", "warning", "error"].includes(finalConfig.severity)) {
+        console.warn(`Warning: Invalid severity '${finalConfig.severity}' in config file. Using default: ${exports.DEFAULT_CONFIG.severity}`);
+        finalConfig.severity = exports.DEFAULT_CONFIG.severity;
+    }
+    return finalConfig;
+}

package/dist/core/parseUnifiedDiff.d.ts

@@ -0,0 +1,2 @@
+import { FileChange } from "../types";
+export declare function parseUnifiedDiff(files: FileChange[]): FileChange[];

package/dist/core/parseUnifiedDiff.js

@@ -0,0 +1,38 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.parseUnifiedDiff = parseUnifiedDiff;
+function parseUnifiedDiff(files) {
+    return files.map((file) => {
+        if (!file.patch || file.status === "deleted")
+            return file;
+        const lines = file.patch.split("\n");
+        const updatedLines = [];
+        let newLineNum = 0;
+        let lineOffset = 0;
+        for (const line of lines) {
+            const hunkMatch = line.match(/^@@ -\d+(?:,\d+)? \+(\d+)(?:,\d+)? @@/);
+            if (hunkMatch) {
+                newLineNum = parseInt(hunkMatch[1], 10);
+                lineOffset = 0;
+                updatedLines.push(line); // keep hunk line
+                continue;
+            }
+            if (line.startsWith("+") && !line.startsWith("+++")) {
+                const actualLineNumber = newLineNum + lineOffset;
+                updatedLines.push(`${line} // LINE_NUMBER: ${actualLineNumber}`);
+                lineOffset++;
+            }
+            else if (line.startsWith("-") && !line.startsWith("---")) {
+                updatedLines.push(line); // deleted line
+            }
+            else {
+                updatedLines.push(line); // context line
+                lineOffset++;
+            }
+        }
+        return {
+            ...file,
+            patch: updatedLines.join("\n"),
+        };
+    });
+}

package/dist/index.d.ts

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

package/dist/index.js

@@ -0,0 +1,110 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const cli_1 = require("./cli");
+const config_1 = require("./config");
+const platforms_1 = require("./platforms");
+const models_1 = require("./models");
+const parseUnifiedDiff_1 = require("./core/parseUnifiedDiff");
+async function main() {
+    try {
+        // Parse CLI options
+        const cliOptions = (0, cli_1.parseCli)();
+        (0, cli_1.verboseLog)(cliOptions, "CLI options parsed");
+        // Load configuration
+        const fileConfig = await (0, config_1.loadConfig)(cliOptions.configPath);
+        (0, cli_1.verboseLog)(cliOptions, `Configuration loaded from ${cliOptions.configPath || "default"}`);
+        // Merge CLI options with config
+        const config = (0, config_1.validateConfig)(cliOptions, fileConfig);
+        (0, cli_1.verboseLog)(config, `Bot configuration: ${JSON.stringify(config, null, 2)}`);
+        // Get platform adapter
+        const platform = await (0, platforms_1.getPlatform)(config.gitPlatform);
+        (0, cli_1.verboseLog)(config, `Using platform: ${config.gitPlatform}`);
+        // Get model adapter
+        const model = (0, models_1.getModel)(config.provider, config.model, config.endpoint);
+        (0, cli_1.verboseLog)(config, `Using model: ${config.model}`);
+        // Ensure repository is specified
+        if (!config.repo) {
+            console.error("Error: Repository is not specified. Please add it to the config file or use the --repo CLI option.");
+            process.exit(1);
+        }
+        // Get pull requests that need review
+        const pullRequests = await platform.getPullRequests(config.repo);
+        (0, cli_1.verboseLog)(config, `Found ${pullRequests.length} PRs`);
+        if (pullRequests.length === 0) {
+            console.log("No pull requests found that need review");
+            return;
+        }
+        // Process each pull request
+        const results = [];
+        for (const pr of pullRequests) {
+            (0, cli_1.verboseLog)(config, `Processing PR #${pr.number}: ${pr.title}`);
+            // Check if AI has already commented since the last update
+            const hasCommented = await platform.hasAICommented(config.repo, pr.id);
+            if (hasCommented) {
+                (0, cli_1.verboseLog)(config, `Skipping PR #${pr.number} - already reviewed since last update`);
+                results.push({
+                    prId: pr.id,
+                    commentsPosted: 0,
+                    status: "skipped",
+                });
+                continue;
+            }
+            try {
+                // Get PR diff
+                const diff = await platform.getPullRequestDiff(config.repo, pr.id);
+                (0, cli_1.verboseLog)(config, `Got diff for PR #${pr.number} with ${diff.length} changed files`);
+                const parsedDiff = (0, parseUnifiedDiff_1.parseUnifiedDiff)(diff);
+                (0, cli_1.verboseLog)(config, `Parsed diff for PR #${pr.number} with ${diff.length} changed files`);
+                // Get AI review
+                const comments = await model.review(parsedDiff, config);
+                (0, cli_1.verboseLog)(config, `Generated ${comments.length} comments for PR #${pr.number}`);
+                if (cliOptions.dryRun) {
+                    // Just print comments in dry run mode
+                    console.log(`\n== Comments for PR #${pr.number}: ${pr.title} ==`);
+                    comments.forEach((comment) => {
+                        console.log(`\n${comment.type === "inline"
+                            ? `${comment.path}:${comment.line}`
+                            : "Summary comment"}:`);
+                        console.log(comment.content);
+                    });
+                }
+                else {
+                    // Post comments to PR
+                    for (const comment of comments) {
+                        await platform.postComment(config.repo, pr.id, comment);
+                    }
+                    console.log(`Posted ${comments.length} comments to PR #${pr.number}`);
+                }
+                results.push({
+                    prId: pr.id,
+                    commentsPosted: comments.length,
+                    status: "success",
+                });
+            }
+            catch (error) {
+                console.error(`Error processing PR #${pr.number}: ${error}`);
+                results.push({
+                    prId: pr.id,
+                    commentsPosted: 0,
+                    status: "failure",
+                    error: error instanceof Error ? error.message : String(error),
+                });
+            }
+        }
+        // Print summary
+        console.log("\n== Review Summary ==");
+        console.log(`Total PRs: ${pullRequests.length}`);
+        console.log(`Reviewed: ${results.filter((r) => r.status === "success").length}`);
+        console.log(`Skipped: ${results.filter((r) => r.status === "skipped").length}`);
+        console.log(`Failed: ${results.filter((r) => r.status === "failure").length}`);
+    }
+    catch (error) {
+        console.error(`Error: ${error}`);
+        process.exit(1);
+    }
+}
+// Run the application
+main().catch((error) => {
+    console.error(`Unhandled error: ${error}`);
+    process.exit(1);
+});

package/dist/models/index.d.ts

@@ -0,0 +1,9 @@
+import { CodeReviewModel } from "../types";
+/**
+ * Get model adapter for the specified AI model
+ * @param provider The provider of the AI model (e.g., openai, anthropic, deepseek)
+ * @param model The specific model to use (e.g., gpt-3.5-turbo, gpt-4)
+ * @param endpoint Optional custom endpoint URL
+ * @returns Model adapter instance
+ */
+export declare function getModel(provider: string, model: string, endpoint?: string): CodeReviewModel;

package/dist/models/index.js

@@ -0,0 +1,19 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getModel = getModel;
+const openai_1 = require("./openai");
+/**
+ * Get model adapter for the specified AI model
+ * @param provider The provider of the AI model (e.g., openai, anthropic, deepseek)
+ * @param model The specific model to use (e.g., gpt-3.5-turbo, gpt-4)
+ * @param endpoint Optional custom endpoint URL
+ * @returns Model adapter instance
+ */
+function getModel(provider, model, endpoint) {
+    switch (provider) {
+        case "openai":
+            return new openai_1.OpenAIModel(model, endpoint);
+        default:
+            throw new Error(`Unsupported provider: ${provider}`);
+    }
+}

package/dist/models/openai.d.ts

@@ -0,0 +1,30 @@
+import { CodeReviewModel, FileChange, AIComment, ReviewConfig } from "../types";
+/**
+ * OpenAI model adapter for code review
+ */
+export declare class OpenAIModel implements CodeReviewModel {
+    private client;
+    private model;
+    constructor(model: string, endpoint?: string);
+    /**
+     * Generate a code review prompt for the given diff
+     * @param diff File changes to review
+     * @param config Review configuration
+     * @returns Prompt for the AI
+     */
+    private generatePrompt;
+    /**
+     * Parse the AI response into comments
+     * @param response AI generated response
+     * @param config Review configuration
+     * @returns List of comments
+     */
+    private parseResponse;
+    /**
+     * Review code changes and generate comments
+     * @param diff File changes to review
+     * @param config Review configuration
+     * @returns List of AI comments
+     */
+    review(diff: FileChange[], config: ReviewConfig): Promise<AIComment[]>;
+}

package/dist/models/openai.js

@@ -0,0 +1,162 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.OpenAIModel = void 0;
+const openai_1 = __importDefault(require("openai"));
+/**
+ * OpenAI model adapter for code review
+ */
+class OpenAIModel {
+    constructor(model, endpoint) {
+        const apiKey = process.env.OPENAI_API_KEY;
+        if (!apiKey) {
+            throw new Error("OPENAI_API_KEY environment variable is required");
+        }
+        if (!model) {
+            throw new Error("Model is required");
+        }
+        this.model = model;
+        this.client = new openai_1.default({
+            apiKey,
+            baseURL: endpoint,
+        });
+    }
+    /**
+     * Generate a code review prompt for the given diff
+     * @param diff File changes to review
+     * @param config Review configuration
+     * @returns Prompt for the AI
+     */
+    generatePrompt(diff, config) {
+        const rules = config.rules && config.rules.length > 0
+            ? `\nApply these specific rules:\n${config.rules
+                .map((rule) => `- ${rule}`)
+                .join("\n")}`
+            : "";
+        const diffText = diff
+            .map((file) => {
+            return `File: ${file.filename} (${file.status})
+${file.patch || "No changes"}
+`;
+        })
+            .join("\n\n");
+        return `
+Only provide brief, actionable, file-specific feedback related to the actual code diff.
+Do not include general advice, documentation-style summaries, or best practices unless they directly relate to the diff.
+Use a direct tone. No greetings. No summaries. No repeated advice.
+
+Important formatting rules:
+- Do not comment on lines that are unchanged or just context unless it's directly impacted by a change.
+${config.commentStyle === "inline"
+            ? "- Output only inline comments, Use this format: 'filename.py:<line number in the new file> — comment'"
+            : "- Provide a single short summary of your review."}
+
+${rules}
+
+Here are the changes to review:
+
+${diffText}
+
+${config.customPrompt || ""}`;
+    }
+    /**
+     * Parse the AI response into comments
+     * @param response AI generated response
+     * @param config Review configuration
+     * @returns List of comments
+     */
+    parseResponse(response, config) {
+        const comments = [];
+        if (config.commentStyle === "summary") {
+            // Generate a single summary comment
+            comments.push({
+                type: "summary",
+                content: response.trim(),
+                severity: config.severity,
+            });
+            return comments;
+        }
+        // Look for patterns like "filename.ext:123 — comment text"
+        const inlineCommentRegex = /([\w/.-]+):(\d+)\s*[—–-]\s*(.*?)(?=\s+[\w/.-]+:\d+\s*[—–-]|$)/gs;
+        let match;
+        while ((match = inlineCommentRegex.exec(response + "\n\n")) !== null) {
+            const [, path, lineStr, content] = match;
+            const line = parseInt(lineStr, 10);
+            comments.push({
+                type: "inline",
+                path,
+                line,
+                content: content.trim(),
+                severity: config.severity,
+            });
+        }
+        // If no inline comments were parsed, create a summary comment
+        if (comments.length === 0) {
+            comments.push({
+                type: "summary",
+                content: response.trim(),
+                severity: config.severity,
+            });
+        }
+        return comments;
+    }
+    /**
+     * Review code changes and generate comments
+     * @param diff File changes to review
+     * @param config Review configuration
+     * @returns List of AI comments
+     */
+    async review(diff, config) {
+        // Filter out ignored files
+        if (config.ignoreFiles && config.ignoreFiles.length > 0) {
+            diff = diff.filter((file) => {
+                return !config.ignoreFiles?.some((pattern) => {
+                    // Basic glob pattern matching for *.ext
+                    if (pattern.startsWith("*") && pattern.indexOf(".") > 0) {
+                        const ext = pattern.substring(1);
+                        return file.filename.endsWith(ext);
+                    }
+                    return file.filename === pattern;
+                });
+            });
+        }
+        // Skip if no files to review
+        if (diff.length === 0) {
+            return [
+                {
+                    type: "summary",
+                    content: "No files to review after applying ignore patterns.",
+                    severity: "suggestion",
+                },
+            ];
+        }
+        const prompt = this.generatePrompt(diff, config);
+        try {
+            const response = await this.client.chat.completions.create({
+                model: this.model,
+                messages: [
+                    {
+                        role: "system",
+                        content: "You are a senior software engineer doing a peer code review. Your job is to spot all logic, syntax, and semantic issues in a code diff.",
+                    },
+                    { role: "user", content: prompt },
+                ],
+                temperature: 0.1,
+                max_tokens: 4000,
+                store: true,
+            });
+            const content = response.choices[0]?.message.content;
+            if (!content) {
+                throw new Error("No response from OpenAI");
+            }
+            return this.parseResponse(content, config);
+        }
+        catch (error) {
+            console.error("Error generating review with OpenAI:", error);
+            throw error;
+        }
+    }
+}
+exports.OpenAIModel = OpenAIModel;

package/dist/platforms/github.d.ts

@@ -0,0 +1,43 @@
+import { CodeReviewPlatform, PullRequest, FileChange, AIComment } from "../types";
+/**
+ * GitHub platform adapter
+ */
+export declare class GithubPlatform implements CodeReviewPlatform {
+    private client;
+    private commentSignature;
+    private constructor();
+    static init(): Promise<GithubPlatform>;
+    /**
+     * Extract owner and repo from repo string
+     * @param repo Repository in format "owner/repo"
+     * @returns Object with owner and repo properties
+     */
+    private parseRepo;
+    /**
+     * Get all open pull requests for a repository
+     * @param repo Repository in format "owner/repo"
+     * @returns List of pull requests
+     */
+    getPullRequests(repo: string): Promise<PullRequest[]>;
+    /**
+     * Get the diff for a pull request
+     * @param repo Repository in format "owner/repo"
+     * @param prId Pull request ID
+     * @returns List of file changes
+     */
+    getPullRequestDiff(repo: string, prId: string | number): Promise<FileChange[]>;
+    /**
+     * Post a comment on a pull request
+     * @param repo Repository in format "owner/repo"
+     * @param prId Pull request ID
+     * @param comment Comment to post
+     */
+    postComment(repo: string, prId: string | number, comment: AIComment): Promise<void>;
+    /**
+     * Checks if the AI has already commented on the latest commit of a pull request
+     * @param repo Repository in format "owner/repo"
+     * @param prId Pull request ID
+     * @returns True if the AI has commented, false otherwise
+     */
+    hasAICommented(repo: string, prId: string | number): Promise<boolean>;
+}

package/dist/platforms/github.js

@@ -0,0 +1,157 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.GithubPlatform = void 0;
+/**
+ * GitHub platform adapter
+ */
+class GithubPlatform {
+    constructor(client) {
+        this.commentSignature = "<!-- DIFF-HOUND-BOT -->";
+        this.client = client;
+    }
+    static async init() {
+        const { Octokit } = await import("@octokit/rest");
+        const token = process.env.GITHUB_TOKEN;
+        if (!token) {
+            throw new Error("GITHUB_TOKEN environment variable is required");
+        }
+        const client = new Octokit({ auth: token });
+        return new GithubPlatform(client);
+    }
+    /**
+     * Extract owner and repo from repo string
+     * @param repo Repository in format "owner/repo"
+     * @returns Object with owner and repo properties
+     */
+    parseRepo(repo) {
+        const [owner, repoName] = repo.split("/");
+        if (!owner || !repoName) {
+            throw new Error(`Invalid repository format: ${repo}. Expected format: owner/repo`);
+        }
+        return { owner, repo: repoName };
+    }
+    /**
+     * Get all open pull requests for a repository
+     * @param repo Repository in format "owner/repo"
+     * @returns List of pull requests
+     */
+    async getPullRequests(repo) {
+        const { owner, repo: repoName } = this.parseRepo(repo);
+        const { data: pulls } = await this.client.pulls.list({
+            owner,
+            repo: repoName,
+            state: "open",
+            sort: "updated",
+            direction: "desc",
+        });
+        return pulls.map((pull) => ({
+            id: pull.number,
+            number: pull.number,
+            title: pull.title,
+            description: pull.body || undefined,
+            author: pull.user?.login || "unknown",
+            branch: pull.head.ref,
+            baseBranch: pull.base.ref,
+            updatedAt: new Date(pull.updated_at),
+            url: pull.html_url,
+        }));
+    }
+    /**
+     * Get the diff for a pull request
+     * @param repo Repository in format "owner/repo"
+     * @param prId Pull request ID
+     * @returns List of file changes
+     */
+    async getPullRequestDiff(repo, prId) {
+        const { owner, repo: repoName } = this.parseRepo(repo);
+        const { data: files } = await this.client.pulls.listFiles({
+            owner,
+            repo: repoName,
+            pull_number: Number(prId),
+        });
+        return files.map((file) => ({
+            filename: file.filename,
+            status: file.status,
+            additions: file.additions,
+            deletions: file.deletions,
+            patch: file.patch || undefined,
+            previousFilename: file.previous_filename,
+        }));
+    }
+    /**
+     * Post a comment on a pull request
+     * @param repo Repository in format "owner/repo"
+     * @param prId Pull request ID
+     * @param comment Comment to post
+     */
+    async postComment(repo, prId, comment) {
+        const { owner, repo: repoName } = this.parseRepo(repo);
+        const pullNumber = Number(prId);
+        const { data: pull } = await this.client.pulls.get({
+            owner,
+            repo: repoName,
+            pull_number: pullNumber,
+        });
+        if (comment.type === "inline" && comment.path && comment.line) {
+            // Post inline comment
+            await this.client.pulls.createReviewComment({
+                owner,
+                repo: repoName,
+                pull_number: pullNumber,
+                body: `${comment.content}\n\n${this.commentSignature}\n<!-- SHA: ${pull.head.sha} -->`,
+                commit_id: pull.head.sha,
+                path: comment.path,
+                line: comment.line,
+            });
+        }
+        else {
+            // Post PR comment
+            await this.client.issues.createComment({
+                owner,
+                repo: repoName,
+                issue_number: pullNumber,
+                body: `${comment.content}\n\n${this.commentSignature}\n<!-- SHA: ${pull.head.sha} -->`,
+            });
+        }
+    }
+    /**
+     * Checks if the AI has already commented on the latest commit of a pull request
+     * @param repo Repository in format "owner/repo"
+     * @param prId Pull request ID
+     * @returns True if the AI has commented, false otherwise
+     */
+    async hasAICommented(repo, prId) {
+        const { owner, repo: repoName } = this.parseRepo(repo);
+        const pullNumber = Number(prId);
+        const { data: pull } = await this.client.pulls.get({
+            owner,
+            repo: repoName,
+            pull_number: pullNumber,
+        });
+        const latestCommitSha = pull.head.sha;
+        // --- Get issue (summary) comments
+        const issueComments = (await this.client.paginate(this.client.issues.listComments.endpoint.merge({
+            owner,
+            repo: repoName,
+            issue_number: pullNumber,
+            per_page: 100,
+        })));
+        // --- Get review (inline) comments
+        const reviewComments = (await this.client.paginate(this.client.pulls.listReviewComments.endpoint.merge({
+            owner,
+            repo: repoName,
+            pull_number: pullNumber,
+            per_page: 100,
+        })));
+        const allComments = [...issueComments, ...reviewComments];
+        const reviewedShas = allComments
+            .filter((c) => c.body?.includes(this.commentSignature))
+            .map((c) => {
+            const match = c.body?.match(/<!-- SHA: (.+?) -->/);
+            return match?.[1];
+        })
+            .filter(Boolean);
+        return reviewedShas.includes(latestCommitSha);
+    }
+}
+exports.GithubPlatform = GithubPlatform;

package/dist/platforms/index.d.ts

@@ -0,0 +1,7 @@
+import { Platform, CodeReviewPlatform } from "../types";
+/**
+ * Get platform adapter for the specified platform
+ * @param platform Platform to use
+ * @returns Platform adapter instance
+ */
+export declare function getPlatform(platform: Platform): Promise<CodeReviewPlatform>;

package/dist/platforms/index.js

@@ -0,0 +1,17 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getPlatform = getPlatform;
+const github_1 = require("./github");
+/**
+ * Get platform adapter for the specified platform
+ * @param platform Platform to use
+ * @returns Platform adapter instance
+ */
+async function getPlatform(platform) {
+    switch (platform) {
+        case "github":
+            return await github_1.GithubPlatform.init();
+        default:
+            throw new Error(`Unsupported platform: ${platform}`);
+    }
+}

package/dist/types/index.d.ts

@@ -0,0 +1,64 @@
+/**
+ * Core types for the AI Code Reviewer
+ */
+export type Platform = "github";
+export type Provider = "openai";
+export interface ReviewConfig {
+    provider: Provider;
+    model: string;
+    gitPlatform: Platform;
+    repo?: string;
+    commentStyle?: "inline" | "summary";
+    dryRun?: boolean;
+    verbose?: boolean;
+    endpoint?: string;
+    configPath?: string;
+    severity?: "suggestion" | "warning" | "error";
+    ignoreFiles?: string[];
+    rules?: string[];
+    customPrompt?: string;
+}
+export interface PullRequest {
+    id: string | number;
+    number?: number;
+    title: string;
+    description?: string;
+    author: string;
+    branch: string;
+    baseBranch: string;
+    commits?: string[];
+    updatedAt: Date;
+    url?: string;
+}
+export interface FileChange {
+    filename: string;
+    status: "added" | "modified" | "deleted" | "renamed";
+    additions: number;
+    deletions: number;
+    patch?: string;
+    previousFilename?: string;
+}
+export interface AIComment {
+    type: "inline" | "summary";
+    path?: string;
+    line?: number;
+    content: string;
+    suggestions?: string[];
+    severity?: "suggestion" | "warning" | "error";
+    created_at?: string;
+}
+export interface CodeReviewPlatform {
+    getPullRequests(repo: string): Promise<PullRequest[]>;
+    getPullRequestDiff(repo: string, prId: string | number): Promise<FileChange[]>;
+    postComment(repo: string, prId: string | number, comment: AIComment): Promise<void>;
+    hasAICommented(repo: string, prId: string | number): Promise<boolean>;
+}
+export interface CodeReviewModel {
+    review(diff: FileChange[], config: ReviewConfig): Promise<AIComment[]>;
+}
+export interface ReviewResult {
+    prId: string | number;
+    commentsPosted: number;
+    status: "success" | "failure" | "skipped";
+    error?: string;
+}

package/dist/types/index.js

@@ -0,0 +1,5 @@
+"use strict";
+/**
+ * Core types for the AI Code Reviewer
+ */
+Object.defineProperty(exports, "__esModule", { value: true });

package/package.json

@@ -0,0 +1,56 @@
+{
+  "name": "diff-hound",
+  "version": "1.0.0",
+  "description": "AI-powered code review bot for GitHub, GitLab, and Bitbucket",
+  "main": "./bin/index.js",
+  "bin": {
+    "diff-hound": "bin/diff-hound.js"
+  },
+  "files": [
+    "bin",
+    "dist",
+    "README.md",
+    "LICENSE"
+  ],
+  "scripts": {
+    "build": "tsc",
+    "start": "node dist/index.js",
+    "dev": "ts-node src/index.ts",
+    "lint": "eslint src/**/*.ts"
+  },
+  "keywords": [
+    "code-review",
+    "ai",
+    "github",
+    "gitlab",
+    "bitbucket",
+    "openai",
+    "claude",
+    "llm"
+  ],
+  "author": "runtimebug",
+  "license": "MIT",
+  "engines": {
+    "node": ">=18.0.0"
+  },
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/runtimebug/diff-hound.git"
+  },
+  "dependencies": {
+    "@octokit/rest": "^21.1.1",
+    "commander": "^11.0.0",
+    "dotenv": "^16.3.1",
+    "js-yaml": "^4.1.0",
+    "openai": "^4.10.0"
+  },
+  "devDependencies": {
+    "@types/js-yaml": "^4.0.5",
+    "@types/node": "^20.6.0",
+    "@typescript-eslint/eslint-plugin": "^6.7.0",
+    "@typescript-eslint/parser": "^6.7.0",
+    "eslint": "^8.49.0",
+    "ts-node": "^10.9.1",
+    "typescript": "^5.2.2"
+  }
+}