diff-hound 1.0.2 → 1.2.0

package/dist/models/openai.d.ts

@@ -1,30 +1,27 @@
-import { CodeReviewModel, FileChange, AIComment, ReviewConfig } from "../types";
+import { ReviewConfig } from "../types";
+import { BaseReviewModel, LLMMessage } from "./base";
 /**
  * OpenAI model adapter for code review
+ * Uses structured JSON output via response_format for reliable parsing
  */
-export declare class OpenAIModel implements CodeReviewModel {
+export declare class OpenAIModel extends BaseReviewModel {
     private client;
     private model;
+    private endpoint?;
     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
+     * Get the model name for this adapter
      */
-    private generatePrompt;
+    protected getModelName(): string;
     /**
-     * Parse the AI response into comments
-     * @param response AI generated response
-     * @param config Review configuration
-     * @returns List of comments
+     * OpenAI supports structured JSON output via response_format
      */
-    private parseResponse;
+    protected supportsStructuredOutput(): boolean;
     /**
-     * Review code changes and generate comments
-     * @param diff File changes to review
-     * @param config Review configuration
-     * @returns List of AI comments
+     * Make an LLM API call to OpenAI
+     * @param messages Array of messages to send to the LLM
+     * @param _config Review configuration (unused but kept for interface consistency)
+     * @returns Raw response string from the LLM
      */
-    review(diff: FileChange[], config: ReviewConfig): Promise<AIComment[]>;
+    protected callLLM(messages: LLMMessage[], _config: ReviewConfig): Promise<string>;
 }

package/dist/models/openai.js

@@ -5,11 +5,16 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.OpenAIModel = void 0;
 const openai_1 = __importDefault(require("openai"));
+const base_1 = require("./base");
+// Import the JSON schema for OpenAI
+const review_response_json_1 = __importDefault(require("../schemas/review-response.json"));
 /**
  * OpenAI model adapter for code review
+ * Uses structured JSON output via response_format for reliable parsing
  */
-class OpenAIModel {
+class OpenAIModel extends base_1.BaseReviewModel {
     constructor(model, endpoint) {
+        super();
         const apiKey = process.env.OPENAI_API_KEY;
         if (!apiKey) {
             throw new Error("OPENAI_API_KEY environment variable is required");
@@ -18,145 +23,56 @@ class OpenAIModel {
             throw new Error("Model is required");
         }
         this.model = model;
+        this.endpoint = endpoint;
         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
+     * Get the model name for this adapter
      */
-    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 || ""}`;
+    getModelName() {
+        return `OpenAI (${this.model})`;
     }
     /**
-     * Parse the AI response into comments
-     * @param response AI generated response
-     * @param config Review configuration
-     * @returns List of comments
+     * OpenAI supports structured JSON output via response_format
      */
-    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;
+    supportsStructuredOutput() {
+        return true;
     }
     /**
-     * Review code changes and generate comments
-     * @param diff File changes to review
-     * @param config Review configuration
-     * @returns List of AI comments
+     * Make an LLM API call to OpenAI
+     * @param messages Array of messages to send to the LLM
+     * @param _config Review configuration (unused but kept for interface consistency)
+     * @returns Raw response string from the LLM
      */
-    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",
+    async callLLM(messages, _config) {
+        // Use structured output with JSON schema
+        const response = await this.client.chat.completions.create({
+            model: this.model,
+            messages: messages.map((m) => ({
+                role: m.role,
+                content: m.content,
+            })),
+            temperature: 0.1,
+            max_tokens: 4000,
+            store: true,
+            response_format: {
+                type: "json_schema",
+                json_schema: {
+                    name: "review_response",
+                    description: "Structured code review response",
+                    schema: review_response_json_1.default,
+                    strict: true,
                 },
-            ];
-        }
-        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;
+            },
+        });
+        const content = response.choices[0]?.message.content;
+        if (!content) {
+            throw new Error("No response from OpenAI");
         }
+        return content;
     }
 }
 exports.OpenAIModel = OpenAIModel;

package/dist/models/openai.test.d.ts

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

package/dist/models/openai.test.js

@@ -0,0 +1,209 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const vitest_1 = require("vitest");
+// Test the response parsing function directly
+// We need to extract the parseResponse function for testing
+// Re-implement the parsing logic for testing (same as in openai.ts)
+function parseResponse(response, commentStyle, severity) {
+    const comments = [];
+    if (commentStyle === "summary") {
+        comments.push({
+            type: "summary",
+            content: response.trim(),
+            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,
+        });
+    }
+    // If no inline comments were parsed, create a summary comment
+    if (comments.length === 0) {
+        comments.push({
+            type: "summary",
+            content: response.trim(),
+            severity,
+        });
+    }
+    return comments;
+}
+(0, vitest_1.describe)("OpenAI Response Parsing", () => {
+    const severity = "suggestion";
+    (0, vitest_1.describe)("summary style", () => {
+        (0, vitest_1.it)("should return summary comment when commentStyle is summary", () => {
+            const summaryContent = "This is a summary of the changes.";
+            const result = parseResponse(summaryContent, "summary", severity);
+            (0, vitest_1.expect)(result).toHaveLength(1);
+            (0, vitest_1.expect)(result[0]).toEqual({
+                type: "summary",
+                content: summaryContent,
+                severity: "suggestion",
+            });
+        });
+    });
+    (0, vitest_1.describe)("inline style", () => {
+        (0, vitest_1.it)("should parse inline comments correctly", () => {
+            const response = `src/utils.ts:3 — Missing null check on the user object
+src/utils.ts:8 — Unused import 'fs'
+src/utils.ts:15 — Consider using const instead of let`;
+            const result = parseResponse(response, "inline", severity);
+            (0, vitest_1.expect)(result).toHaveLength(3);
+            (0, vitest_1.expect)(result[0]).toEqual({
+                type: "inline",
+                path: "src/utils.ts",
+                line: 3,
+                content: "Missing null check on the user object",
+                severity: "suggestion",
+            });
+            (0, vitest_1.expect)(result[1]).toEqual({
+                type: "inline",
+                path: "src/utils.ts",
+                line: 8,
+                content: "Unused import 'fs'",
+                severity: "suggestion",
+            });
+            (0, vitest_1.expect)(result[2]).toEqual({
+                type: "inline",
+                path: "src/utils.ts",
+                line: 15,
+                content: "Consider using const instead of let",
+                severity: "suggestion",
+            });
+        });
+        (0, vitest_1.it)("should handle em-dash separator in inline comments", () => {
+            const response = `src/file.ts:10 — Comment with em-dash`;
+            const result = parseResponse(response, "inline", severity);
+            (0, vitest_1.expect)(result).toHaveLength(1);
+            (0, vitest_1.expect)(result[0].line).toBe(10);
+            (0, vitest_1.expect)(result[0].content).toBe("Comment with em-dash");
+        });
+        (0, vitest_1.it)("should handle en-dash separator in inline comments", () => {
+            const response = `src/file.ts:5 – Comment with en-dash`;
+            const result = parseResponse(response, "inline", severity);
+            (0, vitest_1.expect)(result).toHaveLength(1);
+            (0, vitest_1.expect)(result[0].line).toBe(5);
+        });
+        (0, vitest_1.it)("should handle hyphen separator in inline comments", () => {
+            const response = `src/file.ts:5 - Comment with hyphen`;
+            const result = parseResponse(response, "inline", severity);
+            (0, vitest_1.expect)(result).toHaveLength(1);
+            (0, vitest_1.expect)(result[0].line).toBe(5);
+        });
+        (0, vitest_1.it)("should fall back to summary if no inline comments are parsed", () => {
+            const response = "This is just a general review comment without specific line numbers.";
+            const result = parseResponse(response, "inline", severity);
+            (0, vitest_1.expect)(result).toHaveLength(1);
+            (0, vitest_1.expect)(result[0].type).toBe("summary");
+            (0, vitest_1.expect)(result[0].content).toBe(response);
+        });
+        (0, vitest_1.it)("should handle comments with colons in content", () => {
+            const response = `src/file.ts:10 — Warning: this is a warning with: multiple colons`;
+            const result = parseResponse(response, "inline", severity);
+            (0, vitest_1.expect)(result).toHaveLength(1);
+            (0, vitest_1.expect)(result[0].line).toBe(10);
+            (0, vitest_1.expect)(result[0].content).toContain("Warning:");
+            (0, vitest_1.expect)(result[0].content).toContain("multiple colons");
+        });
+        (0, vitest_1.it)("should handle file paths with dots and dashes", () => {
+            const response = `src/my-component.test.ts:42 — Test comment`;
+            const result = parseResponse(response, "inline", severity);
+            (0, vitest_1.expect)(result).toHaveLength(1);
+            (0, vitest_1.expect)(result[0].path).toBe("src/my-component.test.ts");
+            (0, vitest_1.expect)(result[0].line).toBe(42);
+        });
+        (0, vitest_1.it)("should handle file paths with nested directories", () => {
+            const response = `src/components/user/profile/settings.ts:100 — Deeply nested file`;
+            const result = parseResponse(response, "inline", severity);
+            (0, vitest_1.expect)(result).toHaveLength(1);
+            (0, vitest_1.expect)(result[0].path).toBe("src/components/user/profile/settings.ts");
+            (0, vitest_1.expect)(result[0].line).toBe(100);
+        });
+        (0, vitest_1.it)("should handle comments at line 1", () => {
+            const response = `src/file.ts:1 — Comment on first line`;
+            const result = parseResponse(response, "inline", severity);
+            (0, vitest_1.expect)(result).toHaveLength(1);
+            (0, vitest_1.expect)(result[0].line).toBe(1);
+        });
+        (0, vitest_1.it)("should handle comments at high line numbers", () => {
+            const response = `src/file.ts:9999 — Comment on high line number`;
+            const result = parseResponse(response, "inline", severity);
+            (0, vitest_1.expect)(result).toHaveLength(1);
+            (0, vitest_1.expect)(result[0].line).toBe(9999);
+        });
+        (0, vitest_1.it)("should handle empty content", () => {
+            const response = "";
+            const result = parseResponse(response, "inline", severity);
+            (0, vitest_1.expect)(result).toHaveLength(1);
+            (0, vitest_1.expect)(result[0].type).toBe("summary");
+            (0, vitest_1.expect)(result[0].content).toBe("");
+        });
+        (0, vitest_1.it)("should handle whitespace-only content", () => {
+            const response = "   \n\n   ";
+            const result = parseResponse(response, "inline", severity);
+            (0, vitest_1.expect)(result).toHaveLength(1);
+            (0, vitest_1.expect)(result[0].type).toBe("summary");
+        });
+        (0, vitest_1.it)("should handle multiple files in same response", () => {
+            const response = `src/utils.ts:5 — First file comment
+src/helpers.ts:10 — Second file comment
+src/constants.ts:1 — Third file comment`;
+            const result = parseResponse(response, "inline", severity);
+            (0, vitest_1.expect)(result).toHaveLength(3);
+            (0, vitest_1.expect)(result[0].path).toBe("src/utils.ts");
+            (0, vitest_1.expect)(result[1].path).toBe("src/helpers.ts");
+            (0, vitest_1.expect)(result[2].path).toBe("src/constants.ts");
+        });
+        (0, vitest_1.it)("should trim whitespace from comment content", () => {
+            const response = `src/file.ts:10 —    Comment with extra spaces   `;
+            const result = parseResponse(response, "inline", severity);
+            (0, vitest_1.expect)(result).toHaveLength(1);
+            (0, vitest_1.expect)(result[0].content).toBe("Comment with extra spaces");
+        });
+        (0, vitest_1.it)("should handle comments with quotes and special characters", () => {
+            const response = `src/file.ts:10 — This has "quotes" and 'apostrophes' and \`backticks\``;
+            const result = parseResponse(response, "inline", severity);
+            (0, vitest_1.expect)(result).toHaveLength(1);
+            (0, vitest_1.expect)(result[0].content).toContain('"quotes"');
+            (0, vitest_1.expect)(result[0].content).toContain("'apostrophes'");
+            (0, vitest_1.expect)(result[0].content).toContain("`backticks`");
+        });
+        (0, vitest_1.it)("should handle comments with parentheses and brackets", () => {
+            const response = `src/file.ts:10 — Check the array[index] and call function(arg1, arg2)`;
+            const result = parseResponse(response, "inline", severity);
+            (0, vitest_1.expect)(result).toHaveLength(1);
+            (0, vitest_1.expect)(result[0].content).toContain("array[index]");
+            (0, vitest_1.expect)(result[0].content).toContain("function(arg1, arg2)");
+        });
+        (0, vitest_1.it)("should handle comments with URL-like paths", () => {
+            const response = `src/file.ts:10 — See https://example.com/docs for more info`;
+            const result = parseResponse(response, "inline", severity);
+            (0, vitest_1.expect)(result).toHaveLength(1);
+            (0, vitest_1.expect)(result[0].content).toContain("https://example.com/docs");
+        });
+    });
+});
+(0, vitest_1.describe)("OpenAIModel constructor validation", () => {
+    // We need to dynamically import the OpenAIModel to avoid module-level side effects
+    (0, vitest_1.it)("should throw error if OPENAI_API_KEY is not set", async () => {
+        delete process.env.OPENAI_API_KEY;
+        const { OpenAIModel } = await import("./openai.js");
+        (0, vitest_1.expect)(() => new OpenAIModel("gpt-4o")).toThrow("OPENAI_API_KEY environment variable is required");
+    });
+    (0, vitest_1.it)("should throw error if model is not provided", async () => {
+        process.env.OPENAI_API_KEY = "test-key";
+        const { OpenAIModel } = await import("./openai.js");
+        (0, vitest_1.expect)(() => new OpenAIModel("")).toThrow("Model is required");
+        delete process.env.OPENAI_API_KEY;
+    });
+});

package/dist/platforms/index.d.ts

@@ -1,7 +1,8 @@
-import { Platform, CodeReviewPlatform } from "../types";
+import { Platform, CodeReviewPlatform, ReviewConfig } from "../types";
 /**
  * Get platform adapter for the specified platform
  * @param platform Platform to use
+ * @param config Full review config (needed for local platform options)
  * @returns Platform adapter instance
  */
-export declare function getPlatform(platform: Platform): Promise<CodeReviewPlatform>;
+export declare function getPlatform(platform: Platform, config?: ReviewConfig): Promise<CodeReviewPlatform>;

package/dist/platforms/index.js

@@ -2,15 +2,22 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.getPlatform = getPlatform;
 const github_1 = require("./github");
+const local_1 = require("./local");
 /**
  * Get platform adapter for the specified platform
  * @param platform Platform to use
+ * @param config Full review config (needed for local platform options)
  * @returns Platform adapter instance
  */
-async function getPlatform(platform) {
+async function getPlatform(platform, config) {
     switch (platform) {
         case "github":
             return await github_1.GithubPlatform.init();
+        case "local":
+            if (!config) {
+                throw new Error("ReviewConfig is required for local platform");
+            }
+            return await local_1.LocalPlatform.create(config);
         default:
             throw new Error(`Unsupported platform: ${platform}`);
     }

package/dist/platforms/local.d.ts

@@ -0,0 +1,41 @@
+import { CodeReviewPlatform, PullRequest, FileChange, AIComment, ReviewConfig } from "../types";
+/**
+ * Local platform adapter — reviews local git diffs without any remote API calls.
+ * Always operates in dry-run mode (output to stdout).
+ */
+export declare class LocalPlatform implements CodeReviewPlatform {
+    private repoPath;
+    private base;
+    private head;
+    private patchFile?;
+    constructor(config: ReviewConfig);
+    static create(config: ReviewConfig): Promise<LocalPlatform>;
+    /**
+     * Determine a sensible default base ref:
+     * 1. If current branch has an upstream, use the merge base with it
+     * 2. Otherwise, use HEAD~1
+     */
+    private resolveDefaultBase;
+    private validateRef;
+    /**
+     * Returns a single synthetic PullRequest from local git metadata.
+     */
+    getPullRequests(_repo: string): Promise<PullRequest[]>;
+    /**
+     * Get file changes by running `git diff` or reading a patch file.
+     */
+    getPullRequestDiff(_repo: string, _prId: string | number): Promise<FileChange[]>;
+    /**
+     * Parse raw `git diff` output into FileChange objects.
+     * This parses the full unified diff format including file headers.
+     */
+    private parseGitDiff;
+    /**
+     * In local mode, "posting" a comment means printing to stdout.
+     */
+    postComment(_repo: string, _prId: string | number, _comment: AIComment): Promise<void>;
+    /**
+     * Always returns false — no duplicate tracking in local mode.
+     */
+    hasAICommented(_repo: string, _prId: string | number): Promise<boolean>;
+}