diff-hound 1.0.2 → 1.2.0

package/dist/schemas/validate.test.js

@@ -0,0 +1,484 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const vitest_1 = require("vitest");
+const validate_1 = require("./validate");
+const review_response_1 = require("./review-response");
+(0, vitest_1.describe)("Schema Validation", () => {
+    (0, vitest_1.describe)("validateStructuredResponse", () => {
+        (0, vitest_1.it)("should validate a valid structured response", () => {
+            const response = {
+                summary: "Overall review",
+                comments: [
+                    {
+                        file: "src/utils.ts",
+                        line: 10,
+                        severity: "warning",
+                        category: "style",
+                        confidence: 0.85,
+                        title: "Use const instead of let",
+                        explanation: "The variable is never reassigned",
+                        suggestion: "",
+                    },
+                ],
+            };
+            const result = (0, validate_1.validateStructuredResponse)(response);
+            (0, vitest_1.expect)(result.valid).toBe(true);
+            (0, vitest_1.expect)(result.errors).toHaveLength(0);
+        });
+        (0, vitest_1.it)("should validate response with empty summary", () => {
+            const response = {
+                summary: "",
+                comments: [
+                    {
+                        file: "src/utils.ts",
+                        line: 10,
+                        severity: "warning",
+                        category: "style",
+                        confidence: 0.85,
+                        title: "Use const instead of let",
+                        explanation: "The variable is never reassigned",
+                        suggestion: "",
+                    },
+                ],
+            };
+            const result = (0, validate_1.validateStructuredResponse)(response);
+            (0, vitest_1.expect)(result.valid).toBe(true);
+        });
+        (0, vitest_1.it)("should fail for non-object response", () => {
+            const result = (0, validate_1.validateStructuredResponse)("not an object");
+            (0, vitest_1.expect)(result.valid).toBe(false);
+            (0, vitest_1.expect)(result.errors[0]).toContain("must be an object");
+        });
+        (0, vitest_1.it)("should fail for missing comments array", () => {
+            const response = { summary: "No comments" };
+            const result = (0, validate_1.validateStructuredResponse)(response);
+            (0, vitest_1.expect)(result.valid).toBe(false);
+            (0, vitest_1.expect)(result.errors[0]).toContain("'comments' must be an array");
+        });
+        (0, vitest_1.it)("should fail for invalid severity", () => {
+            const response = {
+                comments: [
+                    {
+                        file: "src/utils.ts",
+                        line: 10,
+                        severity: "invalid",
+                        category: "style",
+                        confidence: 0.85,
+                        title: "Test",
+                        explanation: "Test",
+                        suggestion: "",
+                    },
+                ],
+            };
+            const result = (0, validate_1.validateStructuredResponse)(response);
+            (0, vitest_1.expect)(result.valid).toBe(false);
+            (0, vitest_1.expect)(result.errors[0]).toContain("severity");
+        });
+        (0, vitest_1.it)("should fail for invalid category", () => {
+            const response = {
+                comments: [
+                    {
+                        file: "src/utils.ts",
+                        line: 10,
+                        severity: "warning",
+                        category: "invalid",
+                        confidence: 0.85,
+                        title: "Test",
+                        explanation: "Test",
+                        suggestion: "",
+                    },
+                ],
+            };
+            const result = (0, validate_1.validateStructuredResponse)(response);
+            (0, vitest_1.expect)(result.valid).toBe(false);
+            (0, vitest_1.expect)(result.errors[0]).toContain("category");
+        });
+        (0, vitest_1.it)("should fail for confidence out of range", () => {
+            const response = {
+                comments: [
+                    {
+                        file: "src/utils.ts",
+                        line: 10,
+                        severity: "warning",
+                        category: "style",
+                        confidence: 1.5,
+                        title: "Test",
+                        explanation: "Test",
+                        suggestion: "",
+                    },
+                ],
+            };
+            const result = (0, validate_1.validateStructuredResponse)(response);
+            (0, vitest_1.expect)(result.valid).toBe(false);
+            (0, vitest_1.expect)(result.errors[0]).toContain("confidence");
+        });
+        (0, vitest_1.it)("should fail for negative confidence", () => {
+            const response = {
+                comments: [
+                    {
+                        file: "src/utils.ts",
+                        line: 10,
+                        severity: "warning",
+                        category: "style",
+                        confidence: -0.1,
+                        title: "Test",
+                        explanation: "Test",
+                        suggestion: "",
+                    },
+                ],
+            };
+            const result = (0, validate_1.validateStructuredResponse)(response);
+            (0, vitest_1.expect)(result.valid).toBe(false);
+            (0, vitest_1.expect)(result.errors[0]).toContain("confidence");
+        });
+        (0, vitest_1.it)("should fail for line number less than 1", () => {
+            const response = {
+                comments: [
+                    {
+                        file: "src/utils.ts",
+                        line: 0,
+                        severity: "warning",
+                        category: "style",
+                        confidence: 0.85,
+                        title: "Test",
+                        explanation: "Test",
+                        suggestion: "",
+                    },
+                ],
+            };
+            const result = (0, validate_1.validateStructuredResponse)(response);
+            (0, vitest_1.expect)(result.valid).toBe(false);
+            (0, vitest_1.expect)(result.errors[0]).toContain("line");
+        });
+        (0, vitest_1.it)("should fail for non-integer line number", () => {
+            const response = {
+                comments: [
+                    {
+                        file: "src/utils.ts",
+                        line: 10.5,
+                        severity: "warning",
+                        category: "style",
+                        confidence: 0.85,
+                        title: "Test",
+                        explanation: "Test",
+                        suggestion: "",
+                    },
+                ],
+            };
+            const result = (0, validate_1.validateStructuredResponse)(response);
+            (0, vitest_1.expect)(result.valid).toBe(false);
+            (0, vitest_1.expect)(result.errors[0]).toContain("line");
+        });
+        (0, vitest_1.it)("should fail for empty file path", () => {
+            const response = {
+                comments: [
+                    {
+                        file: "",
+                        line: 10,
+                        severity: "warning",
+                        category: "style",
+                        confidence: 0.85,
+                        title: "Test",
+                        explanation: "Test",
+                        suggestion: "",
+                    },
+                ],
+            };
+            const result = (0, validate_1.validateStructuredResponse)(response);
+            (0, vitest_1.expect)(result.valid).toBe(false);
+            (0, vitest_1.expect)(result.errors[0]).toContain("file");
+        });
+        (0, vitest_1.it)("should fail for empty title", () => {
+            const response = {
+                comments: [
+                    {
+                        file: "src/utils.ts",
+                        line: 10,
+                        severity: "warning",
+                        category: "style",
+                        confidence: 0.85,
+                        title: "",
+                        explanation: "Test",
+                        suggestion: "",
+                    },
+                ],
+            };
+            const result = (0, validate_1.validateStructuredResponse)(response);
+            (0, vitest_1.expect)(result.valid).toBe(false);
+            (0, vitest_1.expect)(result.errors[0]).toContain("title");
+        });
+        (0, vitest_1.it)("should fail for empty explanation", () => {
+            const response = {
+                comments: [
+                    {
+                        file: "src/utils.ts",
+                        line: 10,
+                        severity: "warning",
+                        category: "style",
+                        confidence: 0.85,
+                        title: "Test",
+                        explanation: "",
+                        suggestion: "",
+                    },
+                ],
+            };
+            const result = (0, validate_1.validateStructuredResponse)(response);
+            (0, vitest_1.expect)(result.valid).toBe(false);
+            (0, vitest_1.expect)(result.errors[0]).toContain("explanation");
+        });
+        (0, vitest_1.it)("should validate all valid severity values", () => {
+            const severities = ["critical", "warning", "suggestion", "nitpick"];
+            for (const severity of severities) {
+                const response = {
+                    summary: "",
+                    comments: [
+                        {
+                            file: "src/utils.ts",
+                            line: 10,
+                            severity,
+                            category: "style",
+                            confidence: 0.85,
+                            title: "Test",
+                            explanation: "Test",
+                            suggestion: "",
+                        },
+                    ],
+                };
+                const result = (0, validate_1.validateStructuredResponse)(response);
+                (0, vitest_1.expect)(result.valid).toBe(true);
+            }
+        });
+        (0, vitest_1.it)("should validate all valid category values", () => {
+            const categories = ["bug", "security", "performance", "style", "architecture", "testing"];
+            for (const category of categories) {
+                const response = {
+                    summary: "",
+                    comments: [
+                        {
+                            file: "src/utils.ts",
+                            line: 10,
+                            severity: "warning",
+                            category,
+                            confidence: 0.85,
+                            title: "Test",
+                            explanation: "Test",
+                            suggestion: "",
+                        },
+                    ],
+                };
+                const result = (0, validate_1.validateStructuredResponse)(response);
+                (0, vitest_1.expect)(result.valid).toBe(true);
+            }
+        });
+        (0, vitest_1.it)("should validate response with suggestion", () => {
+            const response = {
+                summary: "",
+                comments: [
+                    {
+                        file: "src/utils.ts",
+                        line: 10,
+                        severity: "warning",
+                        category: "style",
+                        confidence: 0.85,
+                        title: "Use const",
+                        explanation: "Variable is not reassigned",
+                        suggestion: "const x = 5;",
+                    },
+                ],
+            };
+            const result = (0, validate_1.validateStructuredResponse)(response);
+            (0, vitest_1.expect)(result.valid).toBe(true);
+        });
+        (0, vitest_1.it)("should fail for non-string suggestion", () => {
+            const response = {
+                comments: [
+                    {
+                        file: "src/utils.ts",
+                        line: 10,
+                        severity: "warning",
+                        category: "style",
+                        confidence: 0.85,
+                        title: "Test",
+                        explanation: "Test",
+                        suggestion: 123,
+                    },
+                ],
+            };
+            const result = (0, validate_1.validateStructuredResponse)(response);
+            (0, vitest_1.expect)(result.valid).toBe(false);
+            (0, vitest_1.expect)(result.errors[0]).toContain("suggestion");
+        });
+    });
+    (0, vitest_1.describe)("parseStructuredResponse", () => {
+        (0, vitest_1.it)("should parse valid JSON string", () => {
+            const json = JSON.stringify({
+                summary: "Test summary",
+                comments: [
+                    {
+                        file: "src/utils.ts",
+                        line: 10,
+                        severity: "warning",
+                        category: "style",
+                        confidence: 0.85,
+                        title: "Test",
+                        explanation: "Test",
+                        suggestion: "",
+                    },
+                ],
+            });
+            const result = (0, validate_1.parseStructuredResponse)(json);
+            (0, vitest_1.expect)(result.success).toBe(true);
+            (0, vitest_1.expect)(result.data).toBeDefined();
+            (0, vitest_1.expect)(result.data?.comments).toHaveLength(1);
+        });
+        (0, vitest_1.it)("should return error for invalid JSON", () => {
+            const result = (0, validate_1.parseStructuredResponse)("not json");
+            (0, vitest_1.expect)(result.success).toBe(false);
+            (0, vitest_1.expect)(result.error).toContain("JSON parse error");
+        });
+        (0, vitest_1.it)("should return error for invalid structure", () => {
+            const json = JSON.stringify({ comments: "not an array" });
+            const result = (0, validate_1.parseStructuredResponse)(json);
+            (0, vitest_1.expect)(result.success).toBe(false);
+            (0, vitest_1.expect)(result.error).toContain("Validation failed");
+        });
+    });
+    (0, vitest_1.describe)("looksLikeStructuredResponse", () => {
+        (0, vitest_1.it)("should return true for JSON with comments array", () => {
+            const response = '{"comments": []}';
+            (0, vitest_1.expect)((0, validate_1.looksLikeStructuredResponse)(response)).toBe(true);
+        });
+        (0, vitest_1.it)("should return true for JSON with comments and summary", () => {
+            const response = '{"summary": "test", "comments": [{"file": "test.ts"}]}';
+            (0, vitest_1.expect)((0, validate_1.looksLikeStructuredResponse)(response)).toBe(true);
+        });
+        (0, vitest_1.it)("should return false for non-JSON string", () => {
+            (0, vitest_1.expect)((0, validate_1.looksLikeStructuredResponse)("not json")).toBe(false);
+        });
+        (0, vitest_1.it)("should return false for JSON without comments array", () => {
+            (0, vitest_1.expect)((0, validate_1.looksLikeStructuredResponse)('{"summary": "test"}')).toBe(false);
+        });
+        (0, vitest_1.it)("should return false for JSON array", () => {
+            (0, vitest_1.expect)((0, validate_1.looksLikeStructuredResponse)('["item1", "item2"]')).toBe(false);
+        });
+        (0, vitest_1.it)("should return false for empty string", () => {
+            (0, vitest_1.expect)((0, validate_1.looksLikeStructuredResponse)("")).toBe(false);
+        });
+    });
+    (0, vitest_1.describe)("toAIComment", () => {
+        (0, vitest_1.it)("should convert critical severity to error", () => {
+            const comment = {
+                file: "src/test.ts",
+                line: 10,
+                severity: "critical",
+                category: "security",
+                confidence: 0.95,
+                title: "SQL injection risk",
+                explanation: "User input is not sanitized",
+                suggestion: "Use parameterized queries",
+            };
+            const result = (0, review_response_1.toAIComment)(comment);
+            (0, vitest_1.expect)(result.severity).toBe("error");
+            (0, vitest_1.expect)(result.type).toBe("inline");
+            (0, vitest_1.expect)(result.path).toBe("src/test.ts");
+            (0, vitest_1.expect)(result.line).toBe(10);
+        });
+        (0, vitest_1.it)("should convert warning severity to warning", () => {
+            const comment = {
+                file: "src/test.ts",
+                line: 10,
+                severity: "warning",
+                category: "performance",
+                confidence: 0.8,
+                title: "N+1 query",
+                explanation: "Consider eager loading",
+                suggestion: "",
+            };
+            const result = (0, review_response_1.toAIComment)(comment);
+            (0, vitest_1.expect)(result.severity).toBe("warning");
+        });
+        (0, vitest_1.it)("should convert suggestion and nitpick to suggestion", () => {
+            const suggestionComment = {
+                file: "src/test.ts",
+                line: 10,
+                severity: "suggestion",
+                category: "style",
+                confidence: 0.7,
+                title: "Use const",
+                explanation: "Variable is not reassigned",
+                suggestion: "const x = 5;",
+            };
+            const nitpickComment = {
+                file: "src/test.ts",
+                line: 11,
+                severity: "nitpick",
+                category: "style",
+                confidence: 0.6,
+                title: "Spacing issue",
+                explanation: "Missing space after comma",
+                suggestion: "",
+            };
+            (0, vitest_1.expect)((0, review_response_1.toAIComment)(suggestionComment).severity).toBe("suggestion");
+            (0, vitest_1.expect)((0, review_response_1.toAIComment)(nitpickComment).severity).toBe("suggestion");
+        });
+        (0, vitest_1.it)("should include category in title", () => {
+            const comment = {
+                file: "src/test.ts",
+                line: 10,
+                severity: "warning",
+                category: "security",
+                suggestion: "",
+                confidence: 0.9,
+                title: "Hardcoded secret",
+                explanation: "API key should be in environment variable",
+            };
+            const result = (0, review_response_1.toAIComment)(comment);
+            (0, vitest_1.expect)(result.content).toContain("**[Security]");
+            (0, vitest_1.expect)(result.content).toContain("Hardcoded secret");
+        });
+        (0, vitest_1.it)("should include confidence percentage", () => {
+            const comment = {
+                file: "src/test.ts",
+                line: 10,
+                severity: "warning",
+                category: "bug",
+                confidence: 0.87,
+                title: "Null check missing",
+                explanation: "Object could be null",
+                suggestion: "Add null check",
+            };
+            const result = (0, review_response_1.toAIComment)(comment);
+            (0, vitest_1.expect)(result.content).toContain("(confidence: 87%)");
+        });
+        (0, vitest_1.it)("should include suggestion when provided", () => {
+            const comment = {
+                file: "src/test.ts",
+                line: 10,
+                severity: "warning",
+                category: "style",
+                confidence: 0.85,
+                title: "Use const",
+                explanation: "Variable is not reassigned",
+                suggestion: "const x = 5;",
+            };
+            const result = (0, review_response_1.toAIComment)(comment);
+            (0, vitest_1.expect)(result.content).toContain("**Suggestion:**");
+            (0, vitest_1.expect)(result.content).toContain("```");
+            (0, vitest_1.expect)(result.content).toContain("const x = 5;");
+        });
+        (0, vitest_1.it)("should not include suggestion section when not provided", () => {
+            const comment = {
+                file: "src/test.ts",
+                line: 10,
+                severity: "warning",
+                category: "style",
+                confidence: 0.85,
+                title: "Use const",
+                explanation: "Variable is not reassigned",
+                suggestion: "",
+            };
+            const result = (0, review_response_1.toAIComment)(comment);
+            (0, vitest_1.expect)(result.content).not.toContain("**Suggestion:**");
+        });
+    });
+});

package/dist/types/index.d.ts

@@ -1,8 +1,8 @@
 /**
  * Core types for the AI Code Reviewer
  */
-export type Platform = "github";
-export type Provider = "openai";
+export type Platform = "github" | "local";
+export type Provider = "openai" | "ollama";
 export interface ReviewConfig {
     provider: Provider;
     model: string;
@@ -17,6 +17,11 @@ export interface ReviewConfig {
     ignoreFiles?: string[];
     rules?: string[];
     customPrompt?: string;
+    requestTimeout?: number;
+    local?: boolean;
+    base?: string;
+    head?: string;
+    patch?: string;
 }
 export interface PullRequest {
     id: string | number;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "diff-hound",
-  "version": "1.0.2",
+  "version": "1.2.0",
   "description": "AI-powered code review bot for GitHub, GitLab, and Bitbucket",
   "main": "./bin/index.js",
   "bin": {
@@ -16,7 +16,14 @@
     "build": "tsc",
     "start": "node dist/index.js",
     "dev": "ts-node src/index.ts",
-    "lint": "eslint src/**/*.ts"
+    "lint": "eslint src/**/*.ts",
+    "test": "vitest run --config vitest.config.mts",
+    "test:watch": "vitest --config vitest.config.mts",
+    "test:coverage": "vitest run --config vitest.config.mts --coverage",
+    "release": "changeset publish"
+  },
+  "publishConfig": {
+    "provenance": true
   },
   "keywords": [
     "code-review",
@@ -50,8 +57,10 @@
     "@types/node": "^20.6.0",
     "@typescript-eslint/eslint-plugin": "^6.7.0",
     "@typescript-eslint/parser": "^6.7.0",
+    "@vitest/coverage-v8": "^4.0.18",
     "eslint": "^8.49.0",
     "ts-node": "^10.9.1",
-    "typescript": "^5.2.2"
+    "typescript": "^5.2.2",
+    "vitest": "^4.0.18"
   }
 }