diff-hound 1.0.2 → 1.2.0

package/dist/platforms/local.js

@@ -0,0 +1,247 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.LocalPlatform = void 0;
+const child_process_1 = require("child_process");
+const util_1 = require("util");
+const fs_1 = __importDefault(require("fs"));
+const path_1 = __importDefault(require("path"));
+const execFileAsync = (0, util_1.promisify)(child_process_1.execFile);
+/**
+ * Local platform adapter — reviews local git diffs without any remote API calls.
+ * Always operates in dry-run mode (output to stdout).
+ */
+class LocalPlatform {
+    constructor(config) {
+        this.repoPath = process.cwd();
+        this.base = config.base || "";
+        this.head = config.head || "HEAD";
+        this.patchFile = config.patch;
+    }
+    static async create(config) {
+        const platform = new LocalPlatform(config);
+        // If using a patch file, validate it exists
+        if (platform.patchFile) {
+            const patchPath = path_1.default.resolve(platform.patchFile);
+            if (!fs_1.default.existsSync(patchPath)) {
+                throw new Error(`Patch file not found: ${patchPath}`);
+            }
+            platform.patchFile = patchPath;
+            return platform;
+        }
+        // Validate we're in a git repo
+        try {
+            await execFileAsync("git", ["rev-parse", "--git-dir"], {
+                cwd: platform.repoPath,
+            });
+        }
+        catch {
+            throw new Error(`Not a git repository: ${platform.repoPath}. ` +
+                "Run this command from inside a git repository.");
+        }
+        // Resolve base ref if not provided
+        if (!platform.base) {
+            platform.base = await platform.resolveDefaultBase();
+        }
+        // Validate refs exist
+        await platform.validateRef(platform.base);
+        await platform.validateRef(platform.head);
+        return platform;
+    }
+    /**
+     * Determine a sensible default base ref:
+     * 1. If current branch has an upstream, use the merge base with it
+     * 2. Otherwise, use HEAD~1
+     */
+    async resolveDefaultBase() {
+        try {
+            // Try to get the upstream tracking branch
+            const { stdout } = await execFileAsync("git", ["rev-parse", "--abbrev-ref", "--symbolic-full-name", "@{upstream}"], { cwd: this.repoPath });
+            const upstream = stdout.trim();
+            if (upstream) {
+                // Use merge-base for a cleaner diff
+                const { stdout: mergeBase } = await execFileAsync("git", ["merge-base", upstream, this.head], { cwd: this.repoPath });
+                return mergeBase.trim();
+            }
+        }
+        catch {
+            // No upstream — fall through
+        }
+        // Fallback: diff against previous commit
+        return "HEAD~1";
+    }
+    async validateRef(ref) {
+        try {
+            await execFileAsync("git", ["rev-parse", "--verify", ref], {
+                cwd: this.repoPath,
+            });
+        }
+        catch {
+            throw new Error(`Invalid git ref: '${ref}'. Make sure it exists in this repository.`);
+        }
+    }
+    /**
+     * Returns a single synthetic PullRequest from local git metadata.
+     */
+    async getPullRequests(_repo) {
+        if (this.patchFile) {
+            return [
+                {
+                    id: "local-patch",
+                    number: 0,
+                    title: `Patch: ${path_1.default.basename(this.patchFile)}`,
+                    author: "local",
+                    branch: "patch-file",
+                    baseBranch: "N/A",
+                    updatedAt: new Date(),
+                },
+            ];
+        }
+        // Get current branch name
+        let branch = "unknown";
+        try {
+            const { stdout } = await execFileAsync("git", ["rev-parse", "--abbrev-ref", "HEAD"], { cwd: this.repoPath });
+            branch = stdout.trim();
+        }
+        catch {
+            // Detached HEAD — use commit hash
+            try {
+                const { stdout } = await execFileAsync("git", ["rev-parse", "--short", "HEAD"], { cwd: this.repoPath });
+                branch = stdout.trim();
+            }
+            catch {
+                // ignore
+            }
+        }
+        // Get a short description from the latest commit
+        let title = `Local diff: ${this.base}...${this.head}`;
+        try {
+            const { stdout } = await execFileAsync("git", ["log", "--format=%s", "-1", this.head], { cwd: this.repoPath });
+            title = stdout.trim() || title;
+        }
+        catch {
+            // ignore
+        }
+        // Get author
+        let author = "local";
+        try {
+            const { stdout } = await execFileAsync("git", ["config", "user.name"], { cwd: this.repoPath });
+            author = stdout.trim() || author;
+        }
+        catch {
+            // ignore
+        }
+        return [
+            {
+                id: "local",
+                number: 0,
+                title,
+                author,
+                branch,
+                baseBranch: this.base,
+                updatedAt: new Date(),
+            },
+        ];
+    }
+    /**
+     * Get file changes by running `git diff` or reading a patch file.
+     */
+    async getPullRequestDiff(_repo, _prId) {
+        let diffOutput;
+        if (this.patchFile) {
+            diffOutput = fs_1.default.readFileSync(this.patchFile, "utf-8");
+        }
+        else {
+            const { stdout } = await execFileAsync("git", ["diff", `${this.base}...${this.head}`, "--unified=3"], { cwd: this.repoPath, maxBuffer: 10 * 1024 * 1024 });
+            diffOutput = stdout;
+        }
+        if (!diffOutput.trim()) {
+            return [];
+        }
+        return this.parseGitDiff(diffOutput);
+    }
+    /**
+     * Parse raw `git diff` output into FileChange objects.
+     * This parses the full unified diff format including file headers.
+     */
+    parseGitDiff(diffOutput) {
+        const files = [];
+        // Split on diff headers: "diff --git a/path b/path"
+        const fileDiffs = diffOutput.split(/^diff --git /m).filter(Boolean);
+        for (const fileDiff of fileDiffs) {
+            const lines = fileDiff.split("\n");
+            // Parse the file paths from the first line: "a/path b/path"
+            const headerMatch = lines[0].match(/^a\/(.+?)\s+b\/(.+)$/);
+            if (!headerMatch)
+                continue;
+            const oldPath = headerMatch[1];
+            const newPath = headerMatch[2];
+            // Determine status from the diff metadata lines
+            let status = "modified";
+            let previousFilename;
+            for (const line of lines.slice(1)) {
+                if (line.startsWith("new file")) {
+                    status = "added";
+                    break;
+                }
+                else if (line.startsWith("deleted file")) {
+                    status = "deleted";
+                    break;
+                }
+                else if (line.startsWith("rename from")) {
+                    status = "renamed";
+                    previousFilename = oldPath;
+                    break;
+                }
+                else if (line.startsWith("@@")) {
+                    break; // No more metadata lines
+                }
+            }
+            // Extract the patch content (from first @@ to end)
+            const patchStartIdx = fileDiff.indexOf("\n@@");
+            let patch;
+            if (patchStartIdx !== -1) {
+                patch = fileDiff.substring(patchStartIdx + 1); // +1 to skip the leading \n
+            }
+            // Count additions and deletions from the patch
+            let additions = 0;
+            let deletions = 0;
+            if (patch) {
+                for (const patchLine of patch.split("\n")) {
+                    if (patchLine.startsWith("+") && !patchLine.startsWith("+++")) {
+                        additions++;
+                    }
+                    else if (patchLine.startsWith("-") &&
+                        !patchLine.startsWith("---")) {
+                        deletions++;
+                    }
+                }
+            }
+            files.push({
+                filename: newPath,
+                status,
+                additions,
+                deletions,
+                patch,
+                previousFilename,
+            });
+        }
+        return files;
+    }
+    /**
+     * In local mode, "posting" a comment means printing to stdout.
+     */
+    async postComment(_repo, _prId, _comment) {
+        // Local mode output is handled in main — this is a no-op.
+        // The main loop already handles dry-run printing.
+    }
+    /**
+     * Always returns false — no duplicate tracking in local mode.
+     */
+    async hasAICommented(_repo, _prId) {
+        return false;
+    }
+}
+exports.LocalPlatform = LocalPlatform;

package/dist/schemas/review-response.d.ts

@@ -0,0 +1,37 @@
+/**
+ * Types for structured LLM review responses
+ * Replaces free-text parsing with JSON Schema validation
+ */
+export type CommentSeverity = "critical" | "warning" | "suggestion" | "nitpick";
+export type CommentCategory = "bug" | "security" | "performance" | "style" | "architecture" | "testing";
+/**
+ * A single structured comment from the AI review
+ */
+export interface StructuredComment {
+    file: string;
+    line: number;
+    severity: CommentSeverity;
+    category: CommentCategory;
+    confidence: number;
+    title: string;
+    explanation: string;
+    suggestion: string;
+}
+/**
+ * Structured review response from LLM
+ */
+export interface StructuredReviewResponse {
+    summary: string;
+    comments: StructuredComment[];
+}
+/**
+ * Convert a StructuredComment to the legacy AIComment format
+ * for backward compatibility with platform adapters
+ */
+export declare function toAIComment(comment: StructuredComment): {
+    type: "inline";
+    path: string;
+    line: number;
+    content: string;
+    severity: "error" | "warning" | "suggestion";
+};

package/dist/schemas/review-response.js

@@ -0,0 +1,39 @@
+"use strict";
+/**
+ * Types for structured LLM review responses
+ * Replaces free-text parsing with JSON Schema validation
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.toAIComment = toAIComment;
+/**
+ * Convert a StructuredComment to the legacy AIComment format
+ * for backward compatibility with platform adapters
+ */
+function toAIComment(comment) {
+    // Map severity to legacy format
+    const severityMap = {
+        critical: "error",
+        warning: "warning",
+        suggestion: "suggestion",
+        nitpick: "suggestion",
+    };
+    // Build content with rich formatting
+    let content = `**[${capitalize(comment.category)}] ${comment.title}**`;
+    // Add confidence badge
+    const confidencePercent = Math.round(comment.confidence * 100);
+    content += ` (confidence: ${confidencePercent}%)`;
+    content += `\n\n${comment.explanation}`;
+    if (comment.suggestion && comment.suggestion.trim().length > 0) {
+        content += `\n\n**Suggestion:**\n\`\`\`\n${comment.suggestion}\n\`\`\``;
+    }
+    return {
+        type: "inline",
+        path: comment.file,
+        line: comment.line,
+        content,
+        severity: severityMap[comment.severity],
+    };
+}
+function capitalize(str) {
+    return str.charAt(0).toUpperCase() + str.slice(1);
+}

package/dist/schemas/review-response.json

@@ -0,0 +1,68 @@
+{
+    "$schema": "http://json-schema.org/draft-07/schema#",
+    "title": "StructuredReviewResponse",
+    "description": "Structured output format for code review responses",
+    "type": "object",
+    "properties": {
+        "summary": {
+            "type": "string",
+            "description": "Optional overall summary of the review"
+        },
+        "comments": {
+            "type": "array",
+            "description": "List of review comments",
+            "items": {
+                "$ref": "#/definitions/StructuredComment"
+            }
+        }
+    },
+    "required": ["summary", "comments"],
+    "additionalProperties": false,
+    "definitions": {
+        "StructuredComment": {
+            "type": "object",
+            "properties": {
+                "file": {
+                    "type": "string",
+                    "description": "Path to the file being commented on"
+                },
+                "line": {
+                    "type": "integer",
+                    "description": "Line number in the file (1-based)",
+                    "minimum": 1
+                },
+                "severity": {
+                    "type": "string",
+                    "enum": ["critical", "warning", "suggestion", "nitpick"],
+                    "description": "Severity level of the issue"
+                },
+                "category": {
+                    "type": "string",
+                    "enum": ["bug", "security", "performance", "style", "architecture", "testing"],
+                    "description": "Category of the issue"
+                },
+                "confidence": {
+                    "type": "number",
+                    "description": "Confidence score from 0.0 to 1.0",
+                    "minimum": 0,
+                    "maximum": 1
+                },
+                "title": {
+                    "type": "string",
+                    "description": "One-line summary (max 80 characters)",
+                    "maxLength": 80
+                },
+                "explanation": {
+                    "type": "string",
+                    "description": "Detailed explanation of the issue"
+                },
+                "suggestion": {
+                    "type": "string",
+                    "description": "Suggested code fix (optional)"
+                }
+            },
+            "required": ["file", "line", "severity", "category", "confidence", "title", "explanation", "suggestion"],
+            "additionalProperties": false
+        }
+    }
+}

package/dist/schemas/validate.d.ts

@@ -0,0 +1,27 @@
+import type { StructuredReviewResponse } from "./review-response";
+/**
+ * Simple validation for structured review response
+ * Note: OpenAI's JSON Schema response_format already validates the structure,
+ * but we add runtime validation for safety and to handle any edge cases.
+ */
+export interface ValidationResult {
+    valid: boolean;
+    errors: string[];
+}
+/**
+ * Validate a structured review response
+ */
+export declare function validateStructuredResponse(data: unknown): ValidationResult;
+/**
+ * Parse and validate a JSON string into a structured response
+ */
+export declare function parseStructuredResponse(json: string): {
+    success: boolean;
+    data?: StructuredReviewResponse;
+    error?: string;
+};
+/**
+ * Check if a response looks like it might be structured JSON
+ * (starts with { and contains expected fields)
+ */
+export declare function looksLikeStructuredResponse(response: string): boolean;

package/dist/schemas/validate.js

@@ -0,0 +1,108 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.validateStructuredResponse = validateStructuredResponse;
+exports.parseStructuredResponse = parseStructuredResponse;
+exports.looksLikeStructuredResponse = looksLikeStructuredResponse;
+/**
+ * Validate a structured review response
+ */
+function validateStructuredResponse(data) {
+    const errors = [];
+    if (typeof data !== "object" || data === null) {
+        return { valid: false, errors: ["Response must be an object"] };
+    }
+    const response = data;
+    // Check comments array exists
+    if (!Array.isArray(response.comments)) {
+        errors.push("'comments' must be an array");
+        return { valid: false, errors };
+    }
+    // Validate each comment
+    const validSeverities = ["critical", "warning", "suggestion", "nitpick"];
+    const validCategories = ["bug", "security", "performance", "style", "architecture", "testing"];
+    for (let i = 0; i < response.comments.length; i++) {
+        const comment = response.comments[i];
+        const prefix = `comments[${i}]`;
+        if (typeof comment !== "object" || comment === null) {
+            errors.push(`${prefix} must be an object`);
+            continue;
+        }
+        const c = comment;
+        // Required fields
+        if (typeof c.file !== "string" || c.file.length === 0) {
+            errors.push(`${prefix}.file is required and must be a non-empty string`);
+        }
+        if (typeof c.line !== "number" || !Number.isInteger(c.line) || c.line < 1) {
+            errors.push(`${prefix}.line must be a positive integer`);
+        }
+        if (!validSeverities.includes(c.severity)) {
+            errors.push(`${prefix}.severity must be one of: ${validSeverities.join(", ")}`);
+        }
+        if (!validCategories.includes(c.category)) {
+            errors.push(`${prefix}.category must be one of: ${validCategories.join(", ")}`);
+        }
+        if (typeof c.confidence !== "number" || c.confidence < 0 || c.confidence > 1) {
+            errors.push(`${prefix}.confidence must be a number between 0 and 1`);
+        }
+        if (typeof c.title !== "string" || c.title.length === 0) {
+            errors.push(`${prefix}.title is required and must be a non-empty string`);
+        }
+        if (typeof c.explanation !== "string" || c.explanation.length === 0) {
+            errors.push(`${prefix}.explanation is required and must be a non-empty string`);
+        }
+        // Required fields (OpenAI strict mode requires all properties)
+        if (typeof c.suggestion !== "string") {
+            errors.push(`${prefix}.suggestion is required and must be a string (can be empty)`);
+        }
+    }
+    // Check summary (required but can be empty)
+    if (typeof response.summary !== "string") {
+        errors.push("'summary' is required and must be a string (can be empty)");
+    }
+    return {
+        valid: errors.length === 0,
+        errors,
+    };
+}
+/**
+ * Parse and validate a JSON string into a structured response
+ */
+function parseStructuredResponse(json) {
+    try {
+        const parsed = JSON.parse(json);
+        const validation = validateStructuredResponse(parsed);
+        if (!validation.valid) {
+            return {
+                success: false,
+                error: `Validation failed: ${validation.errors.join("; ")}`,
+            };
+        }
+        return {
+            success: true,
+            data: parsed,
+        };
+    }
+    catch (e) {
+        return {
+            success: false,
+            error: `JSON parse error: ${e instanceof Error ? e.message : String(e)}`,
+        };
+    }
+}
+/**
+ * Check if a response looks like it might be structured JSON
+ * (starts with { and contains expected fields)
+ */
+function looksLikeStructuredResponse(response) {
+    const trimmed = response.trim();
+    if (!trimmed.startsWith("{")) {
+        return false;
+    }
+    try {
+        const parsed = JSON.parse(trimmed);
+        return Array.isArray(parsed.comments);
+    }
+    catch {
+        return false;
+    }
+}

package/dist/schemas/validate.test.d.ts

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