diff-hound 1.0.2 → 1.2.0

package/dist/core/parseUnifiedDiff.test.js

@@ -0,0 +1,310 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const vitest_1 = require("vitest");
+const parseUnifiedDiff_1 = require("./parseUnifiedDiff");
+(0, vitest_1.describe)("parseUnifiedDiff", () => {
+    (0, vitest_1.describe)("basic functionality", () => {
+        (0, vitest_1.it)("should return empty array for empty input", () => {
+            const result = (0, parseUnifiedDiff_1.parseUnifiedDiff)([]);
+            (0, vitest_1.expect)(result).toEqual([]);
+        });
+        (0, vitest_1.it)("should handle file with no patch", () => {
+            const files = [
+                {
+                    filename: "src/unchanged.ts",
+                    status: "modified",
+                    additions: 0,
+                    deletions: 0,
+                },
+            ];
+            const result = (0, parseUnifiedDiff_1.parseUnifiedDiff)(files);
+            (0, vitest_1.expect)(result[0].patch).toBeUndefined();
+        });
+        (0, vitest_1.it)("should skip deleted files", () => {
+            const files = [
+                {
+                    filename: "src/deleted.ts",
+                    status: "deleted",
+                    additions: 0,
+                    deletions: 20,
+                    patch: "diff content here",
+                },
+            ];
+            const result = (0, parseUnifiedDiff_1.parseUnifiedDiff)(files);
+            (0, vitest_1.expect)(result[0].patch).toBe("diff content here");
+        });
+    });
+    (0, vitest_1.describe)("line number annotation", () => {
+        (0, vitest_1.it)("should annotate added lines with line numbers", () => {
+            const files = [
+                {
+                    filename: "src/utils.ts",
+                    status: "added",
+                    additions: 3,
+                    deletions: 0,
+                    patch: `@@ -0,0 +1,3 @@
++line one
++line two
++line three`,
+                },
+            ];
+            const result = (0, parseUnifiedDiff_1.parseUnifiedDiff)(files);
+            const lines = result[0].patch?.split("\n") ?? [];
+            (0, vitest_1.expect)(lines[0]).toBe("@@ -0,0 +1,3 @@");
+            (0, vitest_1.expect)(lines[1]).toBe("+line one // LINE_NUMBER: 1");
+            (0, vitest_1.expect)(lines[2]).toBe("+line two // LINE_NUMBER: 2");
+            (0, vitest_1.expect)(lines[3]).toBe("+line three // LINE_NUMBER: 3");
+        });
+        (0, vitest_1.it)("should handle multiple hunks correctly", () => {
+            const files = [
+                {
+                    filename: "src/app.ts",
+                    status: "modified",
+                    additions: 6,
+                    deletions: 2,
+                    patch: `@@ -1,5 +1,5 @@
+ context line
+-old line
++new line 1
++new line 2
+ context line
+ context line
+@@ -20,3 +20,5 @@
+ context line
+-old line 2
++new line 3
++new line 4
++new line 5`,
+                },
+            ];
+            const result = (0, parseUnifiedDiff_1.parseUnifiedDiff)(files);
+            const lines = result[0].patch?.split("\n") ?? [];
+            // First hunk starts at line 1
+            (0, vitest_1.expect)(lines).toContain("+new line 1 // LINE_NUMBER: 2");
+            (0, vitest_1.expect)(lines).toContain("+new line 2 // LINE_NUMBER: 3");
+            // Second hunk starts at line 20
+            (0, vitest_1.expect)(lines).toContain("+new line 3 // LINE_NUMBER: 21");
+            (0, vitest_1.expect)(lines).toContain("+new line 4 // LINE_NUMBER: 22");
+            (0, vitest_1.expect)(lines).toContain("+new line 5 // LINE_NUMBER: 23");
+        });
+        (0, vitest_1.it)("should handle context lines without annotation", () => {
+            const files = [
+                {
+                    filename: "src/file.ts",
+                    status: "modified",
+                    additions: 1,
+                    deletions: 0,
+                    patch: `@@ -5,5 +5,6 @@
+ context line 1
+ context line 2
++added line
+ context line 3
+ context line 4`,
+                },
+            ];
+            const result = (0, parseUnifiedDiff_1.parseUnifiedDiff)(files);
+            const lines = result[0].patch?.split("\n") ?? [];
+            (0, vitest_1.expect)(lines[1]).toBe(" context line 1");
+            (0, vitest_1.expect)(lines[2]).toBe(" context line 2");
+            (0, vitest_1.expect)(lines[3]).toBe("+added line // LINE_NUMBER: 7");
+            (0, vitest_1.expect)(lines[4]).toBe(" context line 3");
+        });
+        (0, vitest_1.it)("should handle deleted lines without line numbers", () => {
+            const files = [
+                {
+                    filename: "src/file.ts",
+                    status: "modified",
+                    additions: 0,
+                    deletions: 2,
+                    patch: `@@ -10,5 +8,3 @@
+ context line
+-deleted line 1
+-deleted line 2
+ context line`,
+                },
+            ];
+            const result = (0, parseUnifiedDiff_1.parseUnifiedDiff)(files);
+            const lines = result[0].patch?.split("\n") ?? [];
+            (0, vitest_1.expect)(lines).toContain("-deleted line 1");
+            (0, vitest_1.expect)(lines).toContain("-deleted line 2");
+            (0, vitest_1.expect)(lines[2]).not.toContain("LINE_NUMBER");
+            (0, vitest_1.expect)(lines[3]).not.toContain("LINE_NUMBER");
+        });
+    });
+    (0, vitest_1.describe)("hunk header parsing", () => {
+        (0, vitest_1.it)("should parse hunk header with single line addition", () => {
+            const files = [
+                {
+                    filename: "src/single.ts",
+                    status: "modified",
+                    additions: 1,
+                    deletions: 0,
+                    patch: `@@ -10 +10,2 @@
+ context
++added`,
+                },
+            ];
+            const result = (0, parseUnifiedDiff_1.parseUnifiedDiff)(files);
+            const lines = result[0].patch?.split("\n") ?? [];
+            (0, vitest_1.expect)(lines[0]).toBe("@@ -10 +10,2 @@");
+            // Line 10 is context, added line is at line 11
+            (0, vitest_1.expect)(lines[2]).toBe("+added // LINE_NUMBER: 11");
+        });
+        (0, vitest_1.it)("should parse hunk header starting at line 1", () => {
+            const files = [
+                {
+                    filename: "src/start.ts",
+                    status: "modified",
+                    additions: 2,
+                    deletions: 0,
+                    patch: `@@ -0,0 +1,2 @@
++first
++second`,
+                },
+            ];
+            const result = (0, parseUnifiedDiff_1.parseUnifiedDiff)(files);
+            const lines = result[0].patch?.split("\n") ?? [];
+            (0, vitest_1.expect)(lines[1]).toBe("+first // LINE_NUMBER: 1");
+            (0, vitest_1.expect)(lines[2]).toBe("+second // LINE_NUMBER: 2");
+        });
+        (0, vitest_1.it)("should reset line offset for each hunk", () => {
+            const files = [
+                {
+                    filename: "src/multi.ts",
+                    status: "modified",
+                    additions: 4,
+                    deletions: 0,
+                    patch: `@@ -1,3 +1,5 @@
+ line1
++added1
++added2
+ line2
+ line3
+@@ -50,3 +52,5 @@
+ line50
++added3
++added4
+ line51
+ line52`,
+                },
+            ];
+            const result = (0, parseUnifiedDiff_1.parseUnifiedDiff)(files);
+            const lines = result[0].patch?.split("\n") ?? [];
+            // First hunk
+            (0, vitest_1.expect)(lines).toContain("+added1 // LINE_NUMBER: 2");
+            (0, vitest_1.expect)(lines).toContain("+added2 // LINE_NUMBER: 3");
+            // Second hunk should start at 53
+            (0, vitest_1.expect)(lines).toContain("+added3 // LINE_NUMBER: 53");
+            (0, vitest_1.expect)(lines).toContain("+added4 // LINE_NUMBER: 54");
+        });
+    });
+    (0, vitest_1.describe)("edge cases", () => {
+        (0, vitest_1.it)("should handle file paths with special characters", () => {
+            const files = [
+                {
+                    filename: "src/components/my-component.ts",
+                    status: "modified",
+                    additions: 1,
+                    deletions: 0,
+                    patch: `@@ -1,2 +1,3 @@
+ import React from 'react';
++import { useEffect } from 'react';
+ export function Component() {},
+`,
+                },
+            ];
+            const result = (0, parseUnifiedDiff_1.parseUnifiedDiff)(files);
+            (0, vitest_1.expect)(result[0].filename).toBe("src/components/my-component.ts");
+            (0, vitest_1.expect)(result[0].patch).toContain("LINE_NUMBER: 2");
+        });
+        (0, vitest_1.it)("should handle empty lines in patches", () => {
+            const files = [
+                {
+                    filename: "src/spacing.ts",
+                    status: "modified",
+                    additions: 2,
+                    deletions: 0,
+                    patch: `@@ -1,3 +1,5 @@
+ line1
++
++line between
+ line2`,
+                },
+            ];
+            const result = (0, parseUnifiedDiff_1.parseUnifiedDiff)(files);
+            const lines = result[0].patch?.split("\n") ?? [];
+            (0, vitest_1.expect)(lines[2]).toBe("+ // LINE_NUMBER: 2");
+            (0, vitest_1.expect)(lines[3]).toBe("+line between // LINE_NUMBER: 3");
+        });
+        (0, vitest_1.it)("should preserve original file metadata", () => {
+            const files = [
+                {
+                    filename: "src/test.ts",
+                    status: "renamed",
+                    additions: 1,
+                    deletions: 1,
+                    previousFilename: "src/old-test.ts",
+                    patch: `@@ -1,1 +1,1 @@
+-old
++new`,
+                },
+            ];
+            const result = (0, parseUnifiedDiff_1.parseUnifiedDiff)(files);
+            (0, vitest_1.expect)(result[0].filename).toBe("src/test.ts");
+            (0, vitest_1.expect)(result[0].status).toBe("renamed");
+            (0, vitest_1.expect)(result[0].previousFilename).toBe("src/old-test.ts");
+            (0, vitest_1.expect)(result[0].additions).toBe(1);
+            (0, vitest_1.expect)(result[0].deletions).toBe(1);
+        });
+        (0, vitest_1.it)("should handle multiple files in a single call", () => {
+            const files = [
+                {
+                    filename: "src/file1.ts",
+                    status: "modified",
+                    additions: 1,
+                    deletions: 0,
+                    patch: `@@ -1,1 +1,2 @@
+ line1
++added`,
+                },
+                {
+                    filename: "src/file2.ts",
+                    status: "modified",
+                    additions: 1,
+                    deletions: 0,
+                    patch: `@@ -5,1 +5,2 @@
+ line5
++added here`,
+                },
+            ];
+            const result = (0, parseUnifiedDiff_1.parseUnifiedDiff)(files);
+            (0, vitest_1.expect)(result).toHaveLength(2);
+            (0, vitest_1.expect)(result[0].patch).toContain("LINE_NUMBER: 2");
+            // Line 5 is context, added line is at line 6
+            (0, vitest_1.expect)(result[1].patch).toContain("LINE_NUMBER: 6");
+        });
+        (0, vitest_1.it)("should handle lines starting with +++ or --- (diff metadata)", () => {
+            const files = [
+                {
+                    filename: "src/file.ts",
+                    status: "modified",
+                    additions: 0,
+                    deletions: 0,
+                    patch: `--- a/src/file.ts
++++ b/src/file.ts
+@@ -1,3 +1,3 @@
+ context
+-old
++new`,
+                },
+            ];
+            const result = (0, parseUnifiedDiff_1.parseUnifiedDiff)(files);
+            const lines = result[0].patch?.split("\n") ?? [];
+            // These should not be annotated as added lines
+            (0, vitest_1.expect)(lines[0]).toBe("--- a/src/file.ts");
+            (0, vitest_1.expect)(lines[1]).toBe("+++ b/src/file.ts");
+            (0, vitest_1.expect)(lines[0]).not.toContain("LINE_NUMBER");
+            (0, vitest_1.expect)(lines[1]).not.toContain("LINE_NUMBER");
+        });
+    });
+});

package/dist/index.js

@@ -17,18 +17,23 @@ async function main() {
         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);
+        const platform = await (0, platforms_1.getPlatform)(config.gitPlatform, config);
         (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) {
+        // Ensure repository is specified (not needed for local mode)
+        if (!config.local && !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);
         }
+        // In local mode, use a placeholder repo identifier
+        const repo = config.local ? "local" : config.repo;
+        if (config.local) {
+            console.log("Running in local mode (dry-run)");
+        }
         // Get pull requests that need review
-        const pullRequests = await platform.getPullRequests(config.repo);
+        const pullRequests = await platform.getPullRequests(repo);
         (0, cli_1.verboseLog)(config, `Found ${pullRequests.length} PRs`);
         if (pullRequests.length === 0) {
             console.log("No pull requests found that need review");
@@ -39,7 +44,7 @@ async function main() {
         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);
+            const hasCommented = await platform.hasAICommented(repo, pr.id);
             if (hasCommented) {
                 (0, cli_1.verboseLog)(config, `Skipping PR #${pr.number} - already reviewed since last update`);
                 results.push({
@@ -51,16 +56,19 @@ async function main() {
             }
             try {
                 // Get PR diff
-                const diff = await platform.getPullRequestDiff(config.repo, pr.id);
+                const diff = await platform.getPullRequestDiff(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) {
+                if (config.dryRun) {
                     // Just print comments in dry run mode
-                    console.log(`\n== Comments for PR #${pr.number}: ${pr.title} ==`);
+                    const header = config.local
+                        ? `\n== Review: ${pr.title} ==`
+                        : `\n== Comments for PR #${pr.number}: ${pr.title} ==`;
+                    console.log(header);
                     comments.forEach((comment) => {
                         console.log(`\n${comment.type === "inline"
                             ? `${comment.path}:${comment.line}`
@@ -71,7 +79,7 @@ async function main() {
                 else {
                     // Post comments to PR
                     for (const comment of comments) {
-                        await platform.postComment(config.repo, pr.id, comment);
+                        await platform.postComment(repo, pr.id, comment);
                     }
                     console.log(`Posted ${comments.length} comments to PR #${pr.number}`);
                 }

package/dist/models/base.d.ts

@@ -0,0 +1,74 @@
+import { CodeReviewModel, FileChange, AIComment, ReviewConfig } from "../types";
+/**
+ * Message format for LLM conversations
+ */
+export interface LLMMessage {
+    role: "system" | "user" | "assistant";
+    content: string;
+}
+/**
+ * Abstract base class for model adapters.
+ * Providers share ~70% of logic (prompt gen, parsing, filtering).
+ * Provider-specific implementations only need to implement:
+ * - callLLM(): Make the actual API call to the LLM
+ * - supportsStructuredOutput(): Whether the provider supports JSON schema output
+ */
+export declare abstract class BaseReviewModel implements CodeReviewModel {
+    /**
+     * Make an LLM API call with the given messages.
+     * Provider-specific implementations handle authentication, request formatting,
+     * and response extraction.
+     * @param messages Array of messages to send to the LLM
+     * @param config Review configuration
+     * @returns Raw response string from the LLM
+     */
+    protected abstract callLLM(messages: LLMMessage[], config: ReviewConfig): Promise<string>;
+    /**
+     * Check if this provider supports structured JSON output.
+     * If true, the model will request JSON schema output and parse it accordingly.
+     * If false, the model will request free-text output and use legacy parsing.
+     */
+    protected abstract supportsStructuredOutput(): boolean;
+    /**
+     * Get the model name/identifier for this adapter
+     */
+    protected abstract getModelName(): string;
+    /**
+     * Review code changes and generate comments.
+     * This is the main entry point that orchestrates the review process.
+     * @param diff File changes to review
+     * @param config Review configuration
+     * @returns List of AI comments
+     */
+    review(diff: FileChange[], config: ReviewConfig): Promise<AIComment[]>;
+    /**
+     * Filter out files that match ignore patterns
+     */
+    protected filterIgnoredFiles(diff: FileChange[], config: ReviewConfig): FileChange[];
+    /**
+     * Generate the system prompt for the LLM
+     */
+    protected getSystemPrompt(_config: ReviewConfig): 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
+     */
+    protected generatePrompt(diff: FileChange[], config: ReviewConfig): string;
+    /**
+     * Parse a structured JSON response from the LLM
+     * @param response Raw LLM response
+     * @param config Review configuration
+     * @returns List of AI comments
+     */
+    protected parseStructuredResponse(response: string, config: ReviewConfig): AIComment[];
+    /**
+     * Parse a free-text response from the LLM (legacy mode)
+     * Used when structured output is not supported or parsing fails.
+     * @param response Raw LLM response
+     * @param config Review configuration
+     * @returns List of AI comments
+     */
+    protected parseFreeTextResponse(response: string, config: ReviewConfig): AIComment[];
+}

package/dist/models/base.js

@@ -0,0 +1,236 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.BaseReviewModel = void 0;
+const review_response_1 = require("../schemas/review-response");
+const validate_1 = require("../schemas/validate");
+/**
+ * Abstract base class for model adapters.
+ * Providers share ~70% of logic (prompt gen, parsing, filtering).
+ * Provider-specific implementations only need to implement:
+ * - callLLM(): Make the actual API call to the LLM
+ * - supportsStructuredOutput(): Whether the provider supports JSON schema output
+ */
+class BaseReviewModel {
+    /**
+     * Review code changes and generate comments.
+     * This is the main entry point that orchestrates the review process.
+     * @param diff File changes to review
+     * @param config Review configuration
+     * @returns List of AI comments
+     */
+    async review(diff, config) {
+        // Filter out ignored files
+        const filteredDiff = this.filterIgnoredFiles(diff, config);
+        // Skip if no files to review
+        if (filteredDiff.length === 0) {
+            return [
+                {
+                    type: "summary",
+                    content: "No files to review after applying ignore patterns.",
+                    severity: "suggestion",
+                },
+            ];
+        }
+        const prompt = this.generatePrompt(filteredDiff, config);
+        const systemPrompt = this.getSystemPrompt(config);
+        try {
+            const raw = await this.callLLM([
+                { role: "system", content: systemPrompt },
+                { role: "user", content: prompt },
+            ], config);
+            return this.supportsStructuredOutput()
+                ? this.parseStructuredResponse(raw, config)
+                : this.parseFreeTextResponse(raw, config);
+        }
+        catch (error) {
+            console.error(`Error generating review with ${this.getModelName()}:`, error);
+            throw error;
+        }
+    }
+    /**
+     * Filter out files that match ignore patterns
+     */
+    filterIgnoredFiles(diff, config) {
+        if (!config.ignoreFiles || config.ignoreFiles.length === 0) {
+            return diff;
+        }
+        return 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;
+            });
+        });
+    }
+    /**
+     * Generate the system prompt for the LLM
+     */
+    getSystemPrompt(_config) {
+        return "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. Always respond with valid JSON matching the requested schema.";
+    }
+    /**
+     * 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 `
+Review the following code changes and provide specific, actionable feedback.
+
+Output your response as a JSON object matching this structure:
+{
+  "summary": "Brief overall assessment (optional)",
+  "comments": [
+    {
+      "file": "path/to/file.ts",
+      "line": 42,
+      "severity": "critical|warning|suggestion|nitpick",
+      "category": "bug|security|performance|style|architecture|testing",
+      "confidence": 0.95,
+      "title": "One-line summary of the issue (max 80 chars)",
+      "explanation": "Detailed explanation of why this is an issue",
+      "suggestion": "Suggested fix or improvement (use empty string if none)"
+    }
+  ]
+}
+
+Severity levels:
+- critical: Bugs, security vulnerabilities, or data loss risks
+- warning: Potential issues or code smells
+- suggestion: Improvements that would be nice to have
+- nitpick: Minor style preferences
+
+Categories:
+- bug: Logic errors, incorrect behavior
+- security: Security vulnerabilities, unsafe practices
+- performance: Performance bottlenecks, inefficiencies
+- style: Code style, formatting, naming
+- architecture: Design patterns, code organization
+- testing: Test coverage, test quality
+
+Important rules:
+- Only comment on lines that are part of the diff (added or modified)
+- Do not comment on unchanged context lines unless directly impacted
+- Be specific and actionable in your feedback
+- Use direct, professional tone
+- Include a suggestion when you can provide a concrete improvement
+${rules}
+
+Here are the changes to review:
+
+${diffText}
+
+${config.customPrompt || ""}`;
+    }
+    /**
+     * Parse a structured JSON response from the LLM
+     * @param response Raw LLM response
+     * @param config Review configuration
+     * @returns List of AI comments
+     */
+    parseStructuredResponse(response, config) {
+        const comments = [];
+        // Check if the response looks like structured JSON
+        if (!(0, validate_1.looksLikeStructuredResponse)(response)) {
+            // Fall back to legacy parsing if it doesn't look like JSON
+            return this.parseFreeTextResponse(response, config);
+        }
+        const result = (0, validate_1.parseStructuredResponse)(response);
+        if (!result.success || !result.data) {
+            console.warn("Structured response parsing failed, falling back to legacy parsing:", result.error);
+            return this.parseFreeTextResponse(response, config);
+        }
+        const structuredResponse = result.data;
+        // Add summary comment if present
+        if (structuredResponse.summary) {
+            comments.push({
+                type: "summary",
+                content: structuredResponse.summary,
+                severity: config.severity,
+            });
+        }
+        // Convert structured comments to AIComment format
+        for (const structuredComment of structuredResponse.comments) {
+            // Apply severity filtering
+            const severityOrder = [
+                "critical",
+                "warning",
+                "suggestion",
+                "nitpick",
+            ];
+            const minSeverity = config.severity || "suggestion";
+            const commentSeverityIndex = severityOrder.indexOf(structuredComment.severity);
+            const minSeverityIndex = severityOrder.indexOf(minSeverity);
+            // Skip comments below the minimum severity threshold
+            if (commentSeverityIndex > minSeverityIndex) {
+                continue;
+            }
+            // Apply confidence filtering (default min: 0.6)
+            const minConfidence = 0.6;
+            if (structuredComment.confidence < minConfidence) {
+                continue;
+            }
+            const aiComment = (0, review_response_1.toAIComment)(structuredComment);
+            comments.push(aiComment);
+        }
+        return comments;
+    }
+    /**
+     * Parse a free-text response from the LLM (legacy mode)
+     * Used when structured output is not supported or parsing fails.
+     * @param response Raw LLM response
+     * @param config Review configuration
+     * @returns List of AI comments
+     */
+    parseFreeTextResponse(response, config) {
+        const comments = [];
+        if (config.commentStyle === "summary") {
+            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;
+    }
+}
+exports.BaseReviewModel = BaseReviewModel;

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

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