diff-hound 1.0.2 → 1.2.0

package/dist/models/base.test.js

@@ -0,0 +1,241 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const vitest_1 = require("vitest");
+const base_1 = require("./base");
+/**
+ * Concrete test implementation of BaseReviewModel.
+ * Returns whatever content is set via setResponse().
+ */
+class TestModel extends base_1.BaseReviewModel {
+    constructor() {
+        super(...arguments);
+        this.responseContent = "";
+        this.lastMessages = [];
+    }
+    setResponse(content) {
+        this.responseContent = content;
+    }
+    getModelName() {
+        return "TestModel";
+    }
+    supportsStructuredOutput() {
+        return true;
+    }
+    async callLLM(messages, _config) {
+        this.lastMessages = messages;
+        return this.responseContent;
+    }
+}
+function makeConfig(overrides = {}) {
+    return {
+        provider: "openai",
+        model: "test-model",
+        gitPlatform: "local",
+        ...overrides,
+    };
+}
+function makeFile(overrides = {}) {
+    return {
+        filename: "src/app.ts",
+        status: "modified",
+        additions: 1,
+        deletions: 0,
+        patch: "+const x = 1;",
+        ...overrides,
+    };
+}
+(0, vitest_1.describe)("BaseReviewModel", () => {
+    (0, vitest_1.describe)("file filtering", () => {
+        (0, vitest_1.it)("should filter files matching glob ignore patterns", async () => {
+            const model = new TestModel();
+            model.setResponse(JSON.stringify({ summary: "", comments: [] }));
+            const result = await model.review([makeFile({ filename: "README.md" })], makeConfig({ ignoreFiles: ["*.md"] }));
+            (0, vitest_1.expect)(result).toHaveLength(1);
+            (0, vitest_1.expect)(result[0].content).toContain("No files to review");
+        });
+        (0, vitest_1.it)("should filter files matching exact ignore patterns", async () => {
+            const model = new TestModel();
+            model.setResponse(JSON.stringify({ summary: "", comments: [] }));
+            const result = await model.review([makeFile({ filename: "package-lock.json" })], makeConfig({ ignoreFiles: ["package-lock.json"] }));
+            (0, vitest_1.expect)(result).toHaveLength(1);
+            (0, vitest_1.expect)(result[0].content).toContain("No files to review");
+        });
+        (0, vitest_1.it)("should keep files that do not match ignore patterns", async () => {
+            const model = new TestModel();
+            model.setResponse(JSON.stringify({ summary: "", comments: [] }));
+            await model.review([makeFile({ filename: "src/index.ts" })], makeConfig({ ignoreFiles: ["*.md"] }));
+            // callLLM was invoked (file was not filtered out)
+            (0, vitest_1.expect)(model.lastMessages).toHaveLength(2);
+        });
+        (0, vitest_1.it)("should pass all files through when no ignore patterns are set", async () => {
+            const model = new TestModel();
+            model.setResponse(JSON.stringify({ summary: "", comments: [] }));
+            await model.review([makeFile(), makeFile({ filename: "src/other.ts" })], makeConfig());
+            (0, vitest_1.expect)(model.lastMessages).toHaveLength(2);
+        });
+    });
+    (0, vitest_1.describe)("prompt generation", () => {
+        (0, vitest_1.it)("should include file names and diff content in prompt", async () => {
+            const model = new TestModel();
+            model.setResponse(JSON.stringify({ summary: "", comments: [] }));
+            await model.review([makeFile({ filename: "src/foo.ts", patch: "+const y = 2;" })], makeConfig());
+            const userMessage = model.lastMessages[1].content;
+            (0, vitest_1.expect)(userMessage).toContain("src/foo.ts");
+            (0, vitest_1.expect)(userMessage).toContain("+const y = 2;");
+        });
+        (0, vitest_1.it)("should include custom rules in prompt", async () => {
+            const model = new TestModel();
+            model.setResponse(JSON.stringify({ summary: "", comments: [] }));
+            await model.review([makeFile()], makeConfig({ rules: ["Use const over let", "No magic numbers"] }));
+            const userMessage = model.lastMessages[1].content;
+            (0, vitest_1.expect)(userMessage).toContain("- Use const over let");
+            (0, vitest_1.expect)(userMessage).toContain("- No magic numbers");
+        });
+        (0, vitest_1.it)("should include custom prompt in user message", async () => {
+            const model = new TestModel();
+            model.setResponse(JSON.stringify({ summary: "", comments: [] }));
+            await model.review([makeFile()], makeConfig({ customPrompt: "Focus on security issues" }));
+            const userMessage = model.lastMessages[1].content;
+            (0, vitest_1.expect)(userMessage).toContain("Focus on security issues");
+        });
+        (0, vitest_1.it)("should set system message as first message", async () => {
+            const model = new TestModel();
+            model.setResponse(JSON.stringify({ summary: "", comments: [] }));
+            await model.review([makeFile()], makeConfig());
+            (0, vitest_1.expect)(model.lastMessages[0].role).toBe("system");
+            (0, vitest_1.expect)(model.lastMessages[0].content).toContain("senior software engineer");
+        });
+    });
+    (0, vitest_1.describe)("structured response parsing", () => {
+        (0, vitest_1.it)("should parse valid structured JSON response", async () => {
+            const model = new TestModel();
+            model.setResponse(JSON.stringify({
+                summary: "Good code",
+                comments: [
+                    {
+                        file: "src/app.ts",
+                        line: 5,
+                        severity: "warning",
+                        category: "bug",
+                        confidence: 0.9,
+                        title: "Null check missing",
+                        explanation: "Variable could be null",
+                        suggestion: "Add null check",
+                    },
+                ],
+            }));
+            const result = await model.review([makeFile()], makeConfig());
+            (0, vitest_1.expect)(result).toHaveLength(2);
+            (0, vitest_1.expect)(result[0].type).toBe("summary");
+            (0, vitest_1.expect)(result[0].content).toBe("Good code");
+            (0, vitest_1.expect)(result[1].type).toBe("inline");
+            (0, vitest_1.expect)(result[1].path).toBe("src/app.ts");
+            (0, vitest_1.expect)(result[1].line).toBe(5);
+        });
+        (0, vitest_1.it)("should filter comments below minimum confidence", async () => {
+            const model = new TestModel();
+            model.setResponse(JSON.stringify({
+                summary: "",
+                comments: [
+                    {
+                        file: "src/app.ts",
+                        line: 1,
+                        severity: "suggestion",
+                        category: "style",
+                        confidence: 0.3,
+                        title: "Low confidence",
+                        explanation: "Should be filtered",
+                        suggestion: "",
+                    },
+                    {
+                        file: "src/app.ts",
+                        line: 2,
+                        severity: "warning",
+                        category: "bug",
+                        confidence: 0.9,
+                        title: "High confidence",
+                        explanation: "Should pass",
+                        suggestion: "",
+                    },
+                ],
+            }));
+            const result = await model.review([makeFile()], makeConfig());
+            const inlineComments = result.filter((c) => c.type === "inline");
+            (0, vitest_1.expect)(inlineComments).toHaveLength(1);
+            (0, vitest_1.expect)(inlineComments[0].line).toBe(2);
+        });
+        (0, vitest_1.it)("should filter comments below minimum severity", async () => {
+            const model = new TestModel();
+            model.setResponse(JSON.stringify({
+                summary: "",
+                comments: [
+                    {
+                        file: "src/app.ts",
+                        line: 1,
+                        severity: "nitpick",
+                        category: "style",
+                        confidence: 0.9,
+                        title: "Nitpick",
+                        explanation: "Should be filtered when min is suggestion",
+                        suggestion: "",
+                    },
+                    {
+                        file: "src/app.ts",
+                        line: 2,
+                        severity: "warning",
+                        category: "bug",
+                        confidence: 0.9,
+                        title: "Warning",
+                        explanation: "Should pass",
+                        suggestion: "",
+                    },
+                ],
+            }));
+            const result = await model.review([makeFile()], makeConfig({ severity: "suggestion" }));
+            const inlineComments = result.filter((c) => c.type === "inline");
+            (0, vitest_1.expect)(inlineComments).toHaveLength(1);
+            (0, vitest_1.expect)(inlineComments[0].line).toBe(2);
+        });
+    });
+    (0, vitest_1.describe)("legacy response parsing", () => {
+        (0, vitest_1.it)("should parse inline comments from free-text response", async () => {
+            const model = new TestModel();
+            model.setResponse("src/app.ts:5 — Missing null check");
+            const result = await model.review([makeFile()], makeConfig());
+            (0, vitest_1.expect)(result).toHaveLength(1);
+            (0, vitest_1.expect)(result[0].type).toBe("inline");
+            (0, vitest_1.expect)(result[0].path).toBe("src/app.ts");
+            (0, vitest_1.expect)(result[0].line).toBe(5);
+            (0, vitest_1.expect)(result[0].content).toBe("Missing null check");
+        });
+        (0, vitest_1.it)("should fall back to summary when no inline comments found", async () => {
+            const model = new TestModel();
+            model.setResponse("This code looks fine overall.");
+            const result = await model.review([makeFile()], makeConfig());
+            (0, vitest_1.expect)(result).toHaveLength(1);
+            (0, vitest_1.expect)(result[0].type).toBe("summary");
+            (0, vitest_1.expect)(result[0].content).toBe("This code looks fine overall.");
+        });
+        (0, vitest_1.it)("should return summary when commentStyle is summary", async () => {
+            const model = new TestModel();
+            model.setResponse("src/app.ts:5 — This would normally be inline");
+            const result = await model.review([makeFile()], makeConfig({ commentStyle: "summary" }));
+            (0, vitest_1.expect)(result).toHaveLength(1);
+            (0, vitest_1.expect)(result[0].type).toBe("summary");
+        });
+    });
+    (0, vitest_1.describe)("malformed structured response", () => {
+        (0, vitest_1.it)("should fall back to legacy parsing for invalid JSON schema", async () => {
+            const warnSpy = vitest_1.vi.spyOn(console, "warn").mockImplementation(() => { });
+            const model = new TestModel();
+            // Valid JSON but wrong schema (missing required fields)
+            model.setResponse(JSON.stringify({ comments: [{ wrong: "fields" }] }));
+            const result = await model.review([makeFile()], makeConfig());
+            // Falls through to legacy parsing → summary comment
+            (0, vitest_1.expect)(result).toHaveLength(1);
+            (0, vitest_1.expect)(result[0].type).toBe("summary");
+            (0, vitest_1.expect)(warnSpy).toHaveBeenCalled();
+            warnSpy.mockRestore();
+        });
+    });
+});

package/dist/models/index.d.ts

@@ -1,8 +1,12 @@
 import { CodeReviewModel } from "../types";
+import { OpenAIModel } from "./openai";
+import { BaseReviewModel, LLMMessage } from "./base";
+export { BaseReviewModel, LLMMessage };
+export { OpenAIModel };
 /**
  * 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 provider The provider of the AI model (e.g., openai, ollama, anthropic)
+ * @param model The specific model to use (e.g., gpt-4o, llama3)
  * @param endpoint Optional custom endpoint URL
  * @returns Model adapter instance
  */

package/dist/models/index.js

@@ -1,11 +1,16 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
+exports.OpenAIModel = exports.BaseReviewModel = void 0;
 exports.getModel = getModel;
 const openai_1 = require("./openai");
+Object.defineProperty(exports, "OpenAIModel", { enumerable: true, get: function () { return openai_1.OpenAIModel; } });
+const ollama_1 = require("./ollama");
+const base_1 = require("./base");
+Object.defineProperty(exports, "BaseReviewModel", { enumerable: true, get: function () { return base_1.BaseReviewModel; } });
 /**
  * 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 provider The provider of the AI model (e.g., openai, ollama, anthropic)
+ * @param model The specific model to use (e.g., gpt-4o, llama3)
  * @param endpoint Optional custom endpoint URL
  * @returns Model adapter instance
  */
@@ -13,6 +18,8 @@ function getModel(provider, model, endpoint) {
     switch (provider) {
         case "openai":
             return new openai_1.OpenAIModel(model, endpoint);
+        case "ollama":
+            return new ollama_1.OllamaModel(model, endpoint);
         default:
             throw new Error(`Unsupported provider: ${provider}`);
     }

package/dist/models/ollama.d.ts

@@ -0,0 +1,28 @@
+import { ReviewConfig } from "../types";
+import { BaseReviewModel, LLMMessage } from "./base";
+/**
+ * Ollama model adapter for code review.
+ * Uses the local Ollama HTTP API with JSON format for structured output.
+ */
+export declare class OllamaModel extends BaseReviewModel {
+    private model;
+    private endpoint;
+    constructor(model: string, endpoint?: string);
+    /**
+     * Get the model name for this adapter
+     */
+    protected getModelName(): string;
+    /**
+     * Ollama uses format: "json" which guarantees valid JSON syntax
+     * but does NOT enforce schema. The base class parseStructuredResponse()
+     * handles validation and falls back to legacy parsing if needed.
+     */
+    protected supportsStructuredOutput(): boolean;
+    /**
+     * Make an LLM API call to the local Ollama instance
+     * @param messages Array of messages to send to the LLM
+     * @param config Review configuration
+     * @returns Raw response string from the LLM
+     */
+    protected callLLM(messages: LLMMessage[], config: ReviewConfig): Promise<string>;
+}

package/dist/models/ollama.js

@@ -0,0 +1,88 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.OllamaModel = void 0;
+const base_1 = require("./base");
+/**
+ * Ollama model adapter for code review.
+ * Uses the local Ollama HTTP API with JSON format for structured output.
+ */
+class OllamaModel extends base_1.BaseReviewModel {
+    constructor(model, endpoint) {
+        super();
+        if (!model) {
+            throw new Error("Model is required");
+        }
+        this.model = model;
+        this.endpoint = endpoint || "http://localhost:11434";
+    }
+    /**
+     * Get the model name for this adapter
+     */
+    getModelName() {
+        return `Ollama (${this.model})`;
+    }
+    /**
+     * Ollama uses format: "json" which guarantees valid JSON syntax
+     * but does NOT enforce schema. The base class parseStructuredResponse()
+     * handles validation and falls back to legacy parsing if needed.
+     */
+    supportsStructuredOutput() {
+        return true;
+    }
+    /**
+     * Make an LLM API call to the local Ollama instance
+     * @param messages Array of messages to send to the LLM
+     * @param config Review configuration
+     * @returns Raw response string from the LLM
+     */
+    async callLLM(messages, config) {
+        const timeoutMs = config.requestTimeout ?? 120000;
+        const controller = new AbortController();
+        const timeout = setTimeout(() => controller.abort(), timeoutMs);
+        try {
+            const response = await fetch(`${this.endpoint}/api/chat`, {
+                method: "POST",
+                headers: { "Content-Type": "application/json" },
+                signal: controller.signal,
+                body: JSON.stringify({
+                    model: this.model,
+                    messages,
+                    format: "json",
+                    stream: false,
+                    options: {
+                        temperature: 0.1,
+                        num_predict: 4000,
+                    },
+                }),
+            });
+            if (!response.ok) {
+                const errorText = await response.text();
+                throw new Error(`Ollama API error (${response.status}): ${errorText}`);
+            }
+            const data = (await response.json());
+            const content = data.message?.content;
+            if (!content) {
+                throw new Error("No response content from Ollama");
+            }
+            return content;
+        }
+        catch (error) {
+            if (error instanceof DOMException && error.name === "AbortError") {
+                throw new Error(`Ollama request timed out after ${timeoutMs / 1000}s. ` +
+                    `The model may be too slow for this diff size. ` +
+                    `Try a smaller model or reduce the diff.`);
+            }
+            if (error instanceof TypeError &&
+                (error.message.includes("fetch") ||
+                    error.message.includes("ECONNREFUSED"))) {
+                throw new Error(`Cannot connect to Ollama at ${this.endpoint}. ` +
+                    `Is Ollama running? Start it with: ollama serve`);
+            }
+            throw error;
+        }
+        finally {
+            clearTimeout(timeout);
+        }
+    }
+}
+exports.OllamaModel = OllamaModel;

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

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

package/dist/models/ollama.test.js

@@ -0,0 +1,235 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const vitest_1 = require("vitest");
+(0, vitest_1.describe)("OllamaModel constructor validation", () => {
+    (0, vitest_1.it)("should throw error if model is not provided", async () => {
+        const { OllamaModel } = await import("./ollama.js");
+        (0, vitest_1.expect)(() => new OllamaModel("")).toThrow("Model is required");
+    });
+    (0, vitest_1.it)("should not require any environment variables", async () => {
+        const { OllamaModel } = await import("./ollama.js");
+        (0, vitest_1.expect)(() => new OllamaModel("llama3")).not.toThrow();
+    });
+    (0, vitest_1.it)("should accept a custom endpoint", async () => {
+        const { OllamaModel } = await import("./ollama.js");
+        const model = new OllamaModel("llama3", "http://custom:11434");
+        (0, vitest_1.expect)(model).toBeDefined();
+    });
+});
+(0, vitest_1.describe)("OllamaModel.review()", () => {
+    let originalFetch;
+    (0, vitest_1.beforeEach)(() => {
+        originalFetch = globalThis.fetch;
+    });
+    (0, vitest_1.afterEach)(() => {
+        globalThis.fetch = originalFetch;
+        vitest_1.vi.restoreAllMocks();
+    });
+    (0, vitest_1.it)("should return skip comment when all files are ignored", async () => {
+        const { OllamaModel } = await import("./ollama.js");
+        const model = new OllamaModel("llama3");
+        const result = await model.review([{ filename: "test.md", status: "modified", additions: 1, deletions: 0, patch: "+hello" }], {
+            provider: "ollama",
+            model: "llama3",
+            gitPlatform: "local",
+            ignoreFiles: ["*.md"],
+        });
+        (0, vitest_1.expect)(result).toHaveLength(1);
+        (0, vitest_1.expect)(result[0].type).toBe("summary");
+        (0, vitest_1.expect)(result[0].content).toContain("No files to review");
+    });
+    (0, vitest_1.it)("should call Ollama /api/chat with correct request shape", async () => {
+        const { OllamaModel } = await import("./ollama.js");
+        const model = new OllamaModel("llama3");
+        const mockResponse = {
+            model: "llama3",
+            created_at: "2024-01-01T00:00:00Z",
+            message: {
+                role: "assistant",
+                content: JSON.stringify({
+                    summary: "Looks good",
+                    comments: [],
+                }),
+            },
+            done: true,
+        };
+        globalThis.fetch = vitest_1.vi.fn().mockResolvedValue({
+            ok: true,
+            json: () => Promise.resolve(mockResponse),
+        });
+        await model.review([{ filename: "src/app.ts", status: "modified", additions: 1, deletions: 0, patch: "+const x = 1;" }], {
+            provider: "ollama",
+            model: "llama3",
+            gitPlatform: "local",
+        });
+        (0, vitest_1.expect)(globalThis.fetch).toHaveBeenCalledTimes(1);
+        const [url, options] = globalThis.fetch.mock.calls[0];
+        (0, vitest_1.expect)(url).toBe("http://localhost:11434/api/chat");
+        (0, vitest_1.expect)(options.method).toBe("POST");
+        const body = JSON.parse(options.body);
+        (0, vitest_1.expect)(body.model).toBe("llama3");
+        (0, vitest_1.expect)(body.format).toBe("json");
+        (0, vitest_1.expect)(body.stream).toBe(false);
+        (0, vitest_1.expect)(body.messages).toHaveLength(2);
+        (0, vitest_1.expect)(body.messages[0].role).toBe("system");
+        (0, vitest_1.expect)(body.messages[1].role).toBe("user");
+        (0, vitest_1.expect)(body.options.temperature).toBe(0.1);
+    });
+    (0, vitest_1.it)("should use custom endpoint when provided", async () => {
+        const { OllamaModel } = await import("./ollama.js");
+        const model = new OllamaModel("llama3", "http://remote:9999");
+        const mockResponse = {
+            model: "llama3",
+            created_at: "2024-01-01T00:00:00Z",
+            message: {
+                role: "assistant",
+                content: JSON.stringify({ summary: "", comments: [] }),
+            },
+            done: true,
+        };
+        globalThis.fetch = vitest_1.vi.fn().mockResolvedValue({
+            ok: true,
+            json: () => Promise.resolve(mockResponse),
+        });
+        await model.review([{ filename: "src/app.ts", status: "modified", additions: 1, deletions: 0, patch: "+x" }], { provider: "ollama", model: "llama3", gitPlatform: "local" });
+        const [url] = globalThis.fetch.mock.calls[0];
+        (0, vitest_1.expect)(url).toBe("http://remote:9999/api/chat");
+    });
+    (0, vitest_1.it)("should parse structured JSON response from Ollama", async () => {
+        const { OllamaModel } = await import("./ollama.js");
+        const model = new OllamaModel("llama3");
+        const structuredResponse = {
+            summary: "Found an issue",
+            comments: [
+                {
+                    file: "src/app.ts",
+                    line: 5,
+                    severity: "warning",
+                    category: "bug",
+                    confidence: 0.85,
+                    title: "Potential null reference",
+                    explanation: "Variable could be null here",
+                    suggestion: "Add null check",
+                },
+            ],
+        };
+        globalThis.fetch = vitest_1.vi.fn().mockResolvedValue({
+            ok: true,
+            json: () => Promise.resolve({
+                model: "llama3",
+                created_at: "2024-01-01T00:00:00Z",
+                message: {
+                    role: "assistant",
+                    content: JSON.stringify(structuredResponse),
+                },
+                done: true,
+            }),
+        });
+        const result = await model.review([{ filename: "src/app.ts", status: "modified", additions: 1, deletions: 0, patch: "+const x = null;" }], { provider: "ollama", model: "llama3", gitPlatform: "local" });
+        // Summary + 1 inline comment
+        (0, vitest_1.expect)(result).toHaveLength(2);
+        (0, vitest_1.expect)(result[0].type).toBe("summary");
+        (0, vitest_1.expect)(result[0].content).toBe("Found an issue");
+        (0, vitest_1.expect)(result[1].type).toBe("inline");
+        (0, vitest_1.expect)(result[1].path).toBe("src/app.ts");
+        (0, vitest_1.expect)(result[1].line).toBe(5);
+    });
+    (0, vitest_1.it)("should fall back to legacy parsing for non-JSON responses", async () => {
+        const { OllamaModel } = await import("./ollama.js");
+        const model = new OllamaModel("llama3");
+        globalThis.fetch = vitest_1.vi.fn().mockResolvedValue({
+            ok: true,
+            json: () => Promise.resolve({
+                model: "llama3",
+                created_at: "2024-01-01T00:00:00Z",
+                message: {
+                    role: "assistant",
+                    content: "src/app.ts:5 — Missing null check",
+                },
+                done: true,
+            }),
+        });
+        const result = await model.review([{ filename: "src/app.ts", status: "modified", additions: 1, deletions: 0, patch: "+x" }], { provider: "ollama", model: "llama3", gitPlatform: "local" });
+        (0, vitest_1.expect)(result).toHaveLength(1);
+        (0, vitest_1.expect)(result[0].type).toBe("inline");
+        (0, vitest_1.expect)(result[0].path).toBe("src/app.ts");
+        (0, vitest_1.expect)(result[0].line).toBe(5);
+        (0, vitest_1.expect)(result[0].content).toBe("Missing null check");
+    });
+    (0, vitest_1.it)("should throw on HTTP error from Ollama API", async () => {
+        const { OllamaModel } = await import("./ollama.js");
+        const model = new OllamaModel("llama3");
+        globalThis.fetch = vitest_1.vi.fn().mockResolvedValue({
+            ok: false,
+            status: 404,
+            text: () => Promise.resolve("model 'llama3' not found"),
+        });
+        await (0, vitest_1.expect)(model.review([{ filename: "src/app.ts", status: "modified", additions: 1, deletions: 0, patch: "+x" }], { provider: "ollama", model: "llama3", gitPlatform: "local" })).rejects.toThrow("Ollama API error (404)");
+    });
+    (0, vitest_1.it)("should throw actionable error when Ollama is not running", async () => {
+        const { OllamaModel } = await import("./ollama.js");
+        const model = new OllamaModel("llama3");
+        globalThis.fetch = vitest_1.vi.fn().mockRejectedValue(new TypeError("fetch failed"));
+        await (0, vitest_1.expect)(model.review([{ filename: "src/app.ts", status: "modified", additions: 1, deletions: 0, patch: "+x" }], { provider: "ollama", model: "llama3", gitPlatform: "local" })).rejects.toThrow("Cannot connect to Ollama");
+    });
+    (0, vitest_1.it)("should throw on empty response content", async () => {
+        const { OllamaModel } = await import("./ollama.js");
+        const model = new OllamaModel("llama3");
+        globalThis.fetch = vitest_1.vi.fn().mockResolvedValue({
+            ok: true,
+            json: () => Promise.resolve({
+                model: "llama3",
+                created_at: "2024-01-01T00:00:00Z",
+                message: { role: "assistant", content: "" },
+                done: true,
+            }),
+        });
+        await (0, vitest_1.expect)(model.review([{ filename: "src/app.ts", status: "modified", additions: 1, deletions: 0, patch: "+x" }], { provider: "ollama", model: "llama3", gitPlatform: "local" })).rejects.toThrow("No response content from Ollama");
+    });
+    (0, vitest_1.it)("should filter comments below minimum confidence", async () => {
+        const { OllamaModel } = await import("./ollama.js");
+        const model = new OllamaModel("llama3");
+        const structuredResponse = {
+            summary: "",
+            comments: [
+                {
+                    file: "src/app.ts",
+                    line: 1,
+                    severity: "suggestion",
+                    category: "style",
+                    confidence: 0.3,
+                    title: "Low confidence comment",
+                    explanation: "This should be filtered out",
+                    suggestion: "",
+                },
+                {
+                    file: "src/app.ts",
+                    line: 2,
+                    severity: "warning",
+                    category: "bug",
+                    confidence: 0.9,
+                    title: "High confidence comment",
+                    explanation: "This should pass through",
+                    suggestion: "",
+                },
+            ],
+        };
+        globalThis.fetch = vitest_1.vi.fn().mockResolvedValue({
+            ok: true,
+            json: () => Promise.resolve({
+                model: "llama3",
+                created_at: "2024-01-01T00:00:00Z",
+                message: {
+                    role: "assistant",
+                    content: JSON.stringify(structuredResponse),
+                },
+                done: true,
+            }),
+        });
+        const result = await model.review([{ filename: "src/app.ts", status: "modified", additions: 1, deletions: 0, patch: "+x" }], { provider: "ollama", model: "llama3", gitPlatform: "local" });
+        // Only the high-confidence comment should pass (low confidence filtered)
+        const inlineComments = result.filter((c) => c.type === "inline");
+        (0, vitest_1.expect)(inlineComments).toHaveLength(1);
+        (0, vitest_1.expect)(inlineComments[0].line).toBe(2);
+    });
+});