@kevinrabun/judges 3.113.0 → 3.115.0

package/dist/commands/review.js

@@ -17,12 +17,51 @@ import { execFileSync } from "child_process";
 import { readFileSync, writeFileSync, unlinkSync } from "fs";
 import { tmpdir } from "os";
 import { resolve, join, extname } from "path";
+import { createHash } from "node:crypto";
 import { evaluateDiff, evaluateWithTribunal } from "../evaluators/index.js";
 import { evaluateProject } from "../evaluators/project.js";
+// Test hook to override evaluateDiff in unit tests
+let evaluateDiffImpl = evaluateDiff;
+export function __setEvaluateDiffImplForTest(fn) {
+    evaluateDiffImpl = fn ?? evaluateDiff;
+}
 import { parseConfig, loadCascadingConfig } from "../config.js";
 import { loadFeedbackStore, getFpRateByRule } from "./feedback.js";
 import { JUDGES } from "../judges/index.js";
 import { parseGitHubRepo, tryRunGit } from "../tools/command-safety.js";
+import { extractValidatedLlmFindings } from "./llm-benchmark.js";
+export function dedupeComments(comments) {
+    const seen = new Set();
+    const out = [];
+    for (const c of comments) {
+        const key = `${c.path}:${c.line}:${hashBody(c.body)}`;
+        if (seen.has(key))
+            continue;
+        seen.add(key);
+        out.push(c);
+    }
+    return out;
+}
+export function filterAlreadyPostedComments(repo, pr, token, comments) {
+    try {
+        const resp = apiRequest("GET", `/repos/${repo}/pulls/${pr}/comments`, token);
+        const existing = resp.data ?? [];
+        const existingKeys = new Set(existing.map((c) => {
+            const path = c.path;
+            const line = c.line;
+            const body = c.body ?? "";
+            return `${path}:${line}:${hashBody(body)}`;
+        }));
+        return comments.filter((c) => !existingKeys.has(`${c.path}:${c.line}:${hashBody(c.body)}`));
+    }
+    catch (err) {
+        console.error("Failed to fetch existing comments, proceeding without dedupe", err);
+        return comments;
+    }
+}
+function hashBody(body) {
+    return createHash("sha1").update(body).digest("hex").slice(0, 8);
+}
 // ─── Language Detection ─────────────────────────────────────────────────────
 const EXT_TO_LANG = {
     ".ts": "typescript",
@@ -71,8 +110,8 @@ export function parsePatchToHunk(filePath, patch) {
     const changedLineNumbers = [];
     let newLineNum = 0;
     for (const line of lines) {
-        // Hunk header: @@ -10,5 +20,8 @@
-        const hunkMatch = line.match(/^@@ -\d+(?:,\d+)? \+(\d+)(?:,\d+)? @@/);
+        // Hunk header: @@ -10,5 +20,8 @@ (some tools omit trailing space/@@)
+        const hunkMatch = line.match(/^@@\s*-\d+(?:,\d+)?\s+\+(\d+)(?:,\d+)?\s*@@?/);
         if (hunkMatch) {
             newLineNum = parseInt(hunkMatch[1], 10) - 1;
             continue;
@@ -209,7 +248,14 @@ function ghCliRequest(method, endpoint, body) {
         return { status: 0, data: null };
     }
 }
+// Allow test injection of the GitHub API layer
+// eslint-disable-next-line @typescript-eslint/no-explicit-any
+let apiRequestImpl;
 function apiRequest(method, endpoint, token, body) {
+    const impl = apiRequestImpl;
+    if (impl) {
+        return impl(method, endpoint, token, body);
+    }
     if (ghCliAvailable()) {
         return ghCliRequest(method, endpoint, body);
     }
@@ -220,6 +266,102 @@ function apiRequest(method, endpoint, token, body) {
     console.error("Either install the `gh` CLI and run `gh auth login`, or set GITHUB_TOKEN env var.");
     process.exit(1);
 }
+export function __setApiRequestImplForTest(fn) {
+    apiRequestImpl = fn;
+}
+async function callOpenAiChat(prompt, opts) {
+    const baseUrl = opts.baseUrl || "https://api.openai.com/v1/chat/completions";
+    // Node 18+ has global fetch; avoid dynamic imports to keep tsc happy without node-fetch types
+    // eslint-disable-next-line @typescript-eslint/no-explicit-any
+    const fetchImpl = globalThis.fetch;
+    if (!fetchImpl)
+        throw new Error("fetch() not available. Run on Node 18+ or polyfill fetch.");
+    const res = await fetchImpl(baseUrl, {
+        method: "POST",
+        headers: {
+            Authorization: `Bearer ${opts.apiKey}`,
+            "Content-Type": "application/json",
+        },
+        body: JSON.stringify({
+            model: opts.model,
+            messages: [{ role: "user", content: prompt }],
+            max_tokens: opts.maxTokens ?? 800,
+            temperature: 0.2,
+        }),
+    });
+    if (!res.ok) {
+        const text = await res.text().catch(() => "");
+        throw new Error(`LLM request failed: ${res.status} ${res.statusText} ${text}`);
+    }
+    const json = (await res.json());
+    const content = json.choices?.[0]?.message?.content;
+    if (!content)
+        throw new Error("LLM response missing content");
+    return content;
+}
+// test hooks for dependency injection
+let callOpenAiChatImpl = callOpenAiChat;
+export function __setCallOpenAiChatImplForTest(fn) {
+    callOpenAiChatImpl = fn;
+}
+/** Build a single prompt for the entire PR (tribunal mode). */
+function buildLlmPromptForPr(prFiles, maxBytes = 40000) {
+    const snippets = [];
+    for (const f of prFiles) {
+        if (!f.patch)
+            continue;
+        if (Buffer.byteLength(f.patch, "utf-8") > maxBytes)
+            continue; // drop huge patches
+        snippets.push(`--- FILE: ${f.filename} ---\n${f.patch}`);
+    }
+    const combined = snippets.join("\n\n");
+    const prompt = `Review the following PR diff. Return issues with rule IDs, severity, and recommendations.\n\n${combined}`;
+    return { prompt, contextSnippets: snippets.slice(0, 5) };
+}
+export async function runLlmDeepReview(prFiles, args) {
+    const apiKey = process.env.OPENAI_API_KEY;
+    if (!apiKey) {
+        return { warnings: ["OPENAI_API_KEY not set; skipping LLM deep review"] };
+    }
+    const model = args.llmModel || process.env.OPENAI_MODEL || "gpt-4o";
+    const baseUrl = args.llmBaseUrl || process.env.OPENAI_BASE_URL;
+    const { constructTribunalPrompt } = await import("./llm-benchmark.js");
+    const { buildContextSnippets } = await import("../context/context-snippets.js");
+    // Build code blob for tribunal prompt; collapse patches to new content
+    const codeBlobs = [];
+    const snippetsForRag = [];
+    for (const pf of prFiles) {
+        if (!pf.patch)
+            continue;
+        const hunk = parsePatchToHunk(pf.filename, pf.patch);
+        codeBlobs.push(`// FILE: ${pf.filename}\n${hunk.newContent}`);
+        snippetsForRag.push(hunk.newContent);
+    }
+    const codeJoined = codeBlobs.join("\n\n");
+    // Build context snippets (RAG-lite) for prompt grounding
+    const ragSnippets = await buildContextSnippets(snippetsForRag.join("\n\n"), {
+        maxSnippets: 4,
+        chunkSize: 1500,
+    });
+    const contextText = ragSnippets.map((s) => s.snippet);
+    const tribunalPrompt = constructTribunalPrompt(codeJoined, "mixed", contextText);
+    const { prompt: diffPrompt } = buildLlmPromptForPr(prFiles);
+    const combinedPrompt = `${tribunalPrompt}\n\n---\n\nDiff summary for additional context:\n${diffPrompt}`;
+    const content = await callOpenAiChatImpl(combinedPrompt, { apiKey, model, baseUrl, maxTokens: args.llmMaxTokens });
+    // Validate structured findings in LLM output
+    // Use global registry prefixes to validate LLM output
+    const { getValidRulePrefixes } = await import("./llm-benchmark.js");
+    const validation = extractValidatedLlmFindings(content, getValidRulePrefixes());
+    const warnings = validation.errors?.length ? validation.errors : undefined;
+    const summaryLines = [
+        `### 🤖 LLM Deep Review Summary (model: ${model})`,
+        "",
+        validation.ruleIds.length ? `Detected rule IDs: ${validation.ruleIds.join(", ")}` : "No rule IDs detected.",
+        "",
+        content,
+    ];
+    return { summary: summaryLines.join("\n"), warnings };
+}
 // ─── Finding → Review Comment ───────────────────────────────────────────────
 const SEVERITY_EMOJI = {
     critical: "🔴",
@@ -291,7 +433,7 @@ function reviewPrFiles(files, minSeverity, maxComments, options, fpRates, fpThre
             ...options,
             filePath: file.filename,
         };
-        const verdict = evaluateDiff(hunk.newContent, lang, hunk.changedLines, undefined, fileOpts);
+        const verdict = evaluateDiffImpl(hunk.newContent, lang, hunk.changedLines, undefined, fileOpts);
         for (const finding of verdict.findings) {
             // Suppress findings from rules with high FP rates
             if (fpRates && fpThreshold !== undefined) {
@@ -464,7 +606,7 @@ function _buildReviewSummary(result) {
 }
 function parseCommentMeta(comment) {
     // Body format: `🔴 **CRITICAL** — Title here (\`RULE-001\`)`
-    const match = comment.body.match(/\*\*(\w+)\*\*\s*\u2014([^(`]+)\(`([^`]+)`\)/);
+    const match = comment.body.match(/\*\*(\w+)\*\*\s{0,5}\u2014([^(`]{1,500})\(`([^`]+)`\)/);
     if (!match)
         return undefined;
     return {
@@ -554,6 +696,17 @@ export function buildPRReviewNarrative(result) {
         }
         lines.push("");
     }
+    // ── Layer 2 (optional) ───────────────────────────────────────────
+    if (result.llmSummary) {
+        lines.push("### 🤖 Layer 2 — AI Deep Review (LLM)");
+        lines.push("");
+        lines.push(result.llmSummary);
+        lines.push("");
+    }
+    if (result.llmWarnings?.length) {
+        lines.push("> ⚠️ LLM warnings: " + result.llmWarnings.join("; "));
+        lines.push("");
+    }
     // ── Cross-cutting themes ──────────────────────────────────────────
     const byDomain = new Map();
     for (const m of metas) {
@@ -664,6 +817,8 @@ export function parseReviewArgs(argv) {
         minConfidence: 0.6,
         calibrate: true,
         crossFile: false,
+        llmDeepReview: false,
+        autopilot: false,
     };
     for (let i = 3; i < argv.length; i++) {
         const arg = argv[i];
@@ -717,6 +872,22 @@ export function parseReviewArgs(argv) {
                     .map((s) => s.trim())
                     .filter(Boolean);
                 break;
+            case "--llm-deep-review":
+                args.llmDeepReview = true;
+                break;
+            case "--llm-model":
+                args.llmModel = argv[++i];
+                break;
+            case "--llm-base-url":
+                args.llmBaseUrl = argv[++i];
+                break;
+            case "--llm-max-tokens":
+                args.llmMaxTokens = parseInt(argv[++i], 10);
+                break;
+            case "--autopilot":
+            case "--gh-autopilot":
+                args.autopilot = true;
+                break;
             default:
                 // Positional: treat as PR number if numeric
                 if (!arg.startsWith("-") && /^\d+$/.test(arg) && args.pr === 0) {
@@ -727,13 +898,17 @@ export function parseReviewArgs(argv) {
     }
     return args;
 }
-export function runReview(argv) {
+export async function runReview(argv) {
     const args = parseReviewArgs(argv);
     // In JSON mode, redirect informational output to stderr so stdout is pure JSON
     const _stdoutLog = console.log.bind(console);
     if (args.format === "json") {
         console.log = (...a) => console.error(...a);
     }
+    if (args.autopilot) {
+        // Autopilot implies live mode
+        args.dryRun = false;
+    }
     if (args.pr === 0) {
         console.log(`
 Judges Panel — Pull Request Review
@@ -760,6 +935,7 @@ OPTIONS:
   --no-calibrate          Disable feedback-driven confidence calibration (enabled by default)
   --cross-file            Enable cross-file architectural analysis (detects duplication, taint flows)
   --judges <id,id,...>    Only run these judges (comma-separated IDs, e.g. cybersecurity,authentication)
+  --autopilot             Enable PR autopilot (fetch diff, post inline + summary). Implies live mode.
 
 AUTHENTICATION:
   Set GITHUB_TOKEN env var, or install the \`gh\` CLI and run \`gh auth login\`.
@@ -855,14 +1031,25 @@ AUTHENTICATION:
     console.log("");
     // Run analysis
     const result = reviewPrFiles(prFiles, args.minSeverity, args.maxComments, evalOptions, fpRates, fpThreshold, args.crossFile, args.minConfidence);
+    // Deduplicate inline comments to avoid spam on reruns
+    result.comments = dedupeComments(result.comments);
+    // Optional Layer 2 (LLM) augmentation
+    if (args.llmDeepReview) {
+        const { summary, warnings } = await runLlmDeepReview(prFiles, args);
+        if (summary)
+            result.llmSummary = summary;
+        if (warnings?.length)
+            result.llmWarnings = warnings;
+    }
     if (args.format === "json") {
         // Post review to GitHub before outputting JSON
         if (!args.dryRun && (result.comments.length > 0 || args.approve)) {
+            const filteredComments = filterAlreadyPostedComments(repo, args.pr, args.token, result.comments);
             const reviewEvent = result.approved && args.approve ? "APPROVE" : result.approved ? "COMMENT" : "REQUEST_CHANGES";
             const reviewBody = {
                 body: buildPRReviewNarrative(result),
                 event: reviewEvent,
-                comments: result.comments,
+                comments: filteredComments,
             };
             const reviewResp = apiRequest("POST", `/repos/${repo}/pulls/${args.pr}/reviews`, args.token, reviewBody);
             if (reviewResp.status !== 200 && reviewResp.status !== 422) {
@@ -905,10 +1092,11 @@ AUTHENTICATION:
     // Post review to GitHub
     if (result.comments.length > 0 || args.approve) {
         const reviewEvent = result.approved && args.approve ? "APPROVE" : result.approved ? "COMMENT" : "REQUEST_CHANGES";
+        const filteredComments = filterAlreadyPostedComments(repo, args.pr, args.token, result.comments);
         const reviewBody = {
             body: buildPRReviewNarrative(result),
             event: reviewEvent,
-            comments: result.comments,
+            comments: filteredComments,
         };
         const reviewResp = apiRequest("POST", `/repos/${repo}/pulls/${args.pr}/reviews`, args.token, reviewBody);
         if (reviewResp.status === 200 || reviewResp.status === 422) {
@@ -937,3 +1125,21 @@ AUTHENTICATION:
     console.log("");
     process.exit(result.approved ? 0 : 1);
 }
+/**
+ * Programmatic autopilot entrypoint for GitHub App / automations.
+ */
+export function runReviewAutopilot(pr, repo) {
+    const argv = ["node", "judges", "review", "--pr", String(pr), "--autopilot"];
+    if (repo)
+        argv.push("--repo", repo);
+    return runReview(argv);
+}
+// Test exports (non-public API)
+export const __test = {
+    __setCallOpenAiChatImplForTest,
+    __setApiRequestImplForTest,
+    __setEvaluateDiffImplForTest,
+    runLlmDeepReview,
+    // expose for patching in tests
+    __evaluateDiffForTest: evaluateDiff,
+};

package/dist/evaluators/index.js

@@ -218,7 +218,6 @@ function parseInlineSuppressions(code) {
     // Active block suppressions: ruleId → { commentLine, reason }
     const activeBlocks = new Map();
     // Pattern: // judges-ignore[-next-line|-block] RULE-ID [, RULE-ID ...] [-- reason]
-    const suppressPattern = /(?:\/\/|#|\/\*)\s*judges-ignore(?:-(next-line|block))?\s+(.+)$/gi;
     const endBlockPattern = /(?:\/\/|#|\/\*)\s*judges-end-block/i;
     for (let i = 0; i < lines.length; i++) {
         const line = lines[i];
@@ -233,42 +232,67 @@ function parseInlineSuppressions(code) {
             arr.push({ ruleId, kind: "block", commentLine: meta.commentLine, reason: meta.reason });
             lineSuppressed.set(lineNum, arr);
         }
-        // Parse suppression directives
-        let match;
-        suppressPattern.lastIndex = 0;
-        while ((match = suppressPattern.exec(line)) !== null) {
-            const modifier = match[1]?.toLowerCase(); // "next-line", "block", or undefined
-            const rawContent = match[2].replace(/\s*\*\/\s*$/, "");
-            const dashSplit = rawContent.split(/\s+--\s+/);
-            const ruleIds = dashSplit[0].split(/[,\s]+/).filter(Boolean);
-            const reason = dashSplit[1]?.trim() || undefined;
-            const kind = modifier === "next-line" ? "next-line" : modifier === "block" ? "block" : "line";
-            const targetLine = kind === "next-line" ? lineNum + 1 : lineNum;
-            for (const rawId of ruleIds) {
-                const ruleId = rawId === "*" ? "*" : rawId.toUpperCase();
-                if (kind === "block") {
-                    // Start block suppression — applies to all subsequent lines until end-block
-                    activeBlocks.set(ruleId, { commentLine: lineNum, reason });
+        // Parse suppression directives (string-based to avoid regex redos)
+        const ignoreIdx = line.indexOf("judges-ignore");
+        if (ignoreIdx >= 0) {
+            const before = line.substring(0, ignoreIdx).trimEnd();
+            if (before.endsWith("//") || before.endsWith("#") || before.endsWith("/*")) {
+                let rest = line.substring(ignoreIdx + "judges-ignore".length);
+                let modifier;
+                if (rest.toLowerCase().startsWith("-next-line")) {
+                    modifier = "next-line";
+                    rest = rest.substring("-next-line".length);
                 }
-                else {
-                    const arr = lineSuppressed.get(targetLine) ?? [];
-                    arr.push({ ruleId, kind, commentLine: lineNum, reason });
-                    lineSuppressed.set(targetLine, arr);
+                else if (rest.toLowerCase().startsWith("-block")) {
+                    modifier = "block";
+                    rest = rest.substring("-block".length);
+                }
+                const trimmedRest = rest.trimStart();
+                if (trimmedRest.length < rest.length && trimmedRest.length > 0) {
+                    let rawContent = trimmedRest;
+                    if (rawContent.trimEnd().endsWith("*/")) {
+                        rawContent = rawContent.replace("*/", "").trimEnd();
+                    }
+                    const dashSplit = rawContent.split(" -- ");
+                    const ruleIds = dashSplit[0].split(/[, \t]+/).filter(Boolean);
+                    const reason = dashSplit[1]?.trim() || undefined;
+                    const kind = modifier === "next-line" ? "next-line" : modifier === "block" ? "block" : "line";
+                    const targetLine = kind === "next-line" ? lineNum + 1 : lineNum;
+                    for (const rawId of ruleIds) {
+                        const ruleId = rawId === "*" ? "*" : rawId.toUpperCase();
+                        if (kind === "block") {
+                            // Start block suppression — applies to all subsequent lines until end-block
+                            activeBlocks.set(ruleId, { commentLine: lineNum, reason });
+                        }
+                        else {
+                            const arr = lineSuppressed.get(targetLine) ?? [];
+                            arr.push({ ruleId, kind, commentLine: lineNum, reason });
+                            lineSuppressed.set(targetLine, arr);
+                        }
+                    }
                 }
             }
         }
         // File-level suppression: // judges-file-ignore RULE-ID [-- reason]
-        const filePattern = /(?:\/\/|#|\/\*)\s*judges-file-ignore\s+(.+)$/gi;
-        let fileMatch;
-        filePattern.lastIndex = 0;
-        while ((fileMatch = filePattern.exec(line)) !== null) {
-            const rawFileContent = fileMatch[1].replace(/\s*\*\/\s*$/, "");
-            const fileDashSplit = rawFileContent.split(/\s+--\s+/);
-            const ruleIds = fileDashSplit[0].split(/[,\s]+/).filter(Boolean);
-            const reason = fileDashSplit[1]?.trim() || undefined;
-            for (const rawId of ruleIds) {
-                const ruleId = rawId === "*" ? "*" : rawId.toUpperCase();
-                globalSuppressed.push({ ruleId, kind: "file", commentLine: lineNum, reason });
+        const fileIgnoreIdx = line.indexOf("judges-file-ignore");
+        if (fileIgnoreIdx >= 0) {
+            const beforeFile = line.substring(0, fileIgnoreIdx).trimEnd();
+            if (beforeFile.endsWith("//") || beforeFile.endsWith("#") || beforeFile.endsWith("/*")) {
+                const fileRest = line.substring(fileIgnoreIdx + "judges-file-ignore".length);
+                const fileTrimmedRest = fileRest.trimStart();
+                if (fileTrimmedRest.length < fileRest.length && fileTrimmedRest.length > 0) {
+                    let rawFileContent = fileTrimmedRest;
+                    if (rawFileContent.trimEnd().endsWith("*/")) {
+                        rawFileContent = rawFileContent.replace("*/", "").trimEnd();
+                    }
+                    const fileDashSplit = rawFileContent.split(" -- ");
+                    const ruleIds = fileDashSplit[0].split(/[, \t]+/).filter(Boolean);
+                    const reason = fileDashSplit[1]?.trim() || undefined;
+                    for (const rawId of ruleIds) {
+                        const ruleId = rawId === "*" ? "*" : rawId.toUpperCase();
+                        globalSuppressed.push({ ruleId, kind: "file", commentLine: lineNum, reason });
+                    }
+                }
             }
         }
     }
@@ -722,9 +746,11 @@ export function evaluateWithTribunal(code, language, context, options) {
         const modelFindings = calibrated.filter((f) => f.ruleId.startsWith("MFPR-"));
         if (modelFindings.length > 0) {
             // Extract detected model name from the finding title
-            const modelMatch = modelFindings[0].title.match(/matches\s+(.+?)\s+generation/);
-            if (modelMatch) {
-                const detectedModel = modelMatch[1];
+            const title = modelFindings[0].title;
+            const mIdx = title.indexOf("matches ");
+            const gIdx = mIdx >= 0 ? title.indexOf(" generation", mIdx + 8) : -1;
+            if (mIdx >= 0 && gIdx > mIdx) {
+                const detectedModel = title.substring(mIdx + 8, gIdx).trim();
                 const feedbackStore = loadFeedbackStore();
                 if (feedbackStore.entries.length > 0) {
                     const modelProfile = buildModelCalibrationProfile(feedbackStore, detectedModel);

package/dist/github-app.d.ts

@@ -19,7 +19,11 @@
  *      - JUDGES_PRIVATE_KEY    — PEM private key (or path via JUDGES_PRIVATE_KEY_PATH)
  *      - JUDGES_WEBHOOK_SECRET — Webhook secret for signature verification
  */
+import { evaluateWithTribunal } from "./evaluators/index.js";
+import { evaluateProject } from "./evaluators/project.js";
 import type { Severity } from "./types.js";
+export declare let evaluateWithTribunalImpl: typeof evaluateWithTribunal;
+export declare let evaluateProjectImpl: typeof evaluateProject;
 export interface GitHubAppConfig {
     /** GitHub App ID */
     appId: string;
@@ -39,6 +43,8 @@ export interface GitHubAppConfig {
     diffOnly?: boolean;
     /** Path to .judgesrc.json config (optional) */
     configPath?: string;
+    /** Enable Layer 2 (LLM) deep review augmentation */
+    llmDeepReview?: boolean;
 }
 interface WebhookPayload {
     action: string;
@@ -98,8 +104,23 @@ interface WebhookResult {
 export declare const EXT_TO_LANG: Record<string, string>;
 export declare function detectLanguage(filePath: string): string | undefined;
 export declare function generateJwt(appId: string, privateKey: string): string;
+declare function ghApi(method: string, path: string, token: string, body?: unknown): Promise<{
+    status: number;
+    data: unknown;
+}>;
+export declare function __setGhApiImplForTest(fn: typeof ghApi | undefined): void;
+interface LlmOptions {
+    apiKey: string;
+    model: string;
+    baseUrl?: string;
+    maxTokens?: number;
+}
+declare function callOpenAiChat(prompt: string, opts: LlmOptions): Promise<string>;
+export declare function __setCallOpenAiChatImplForTest(fn: typeof callOpenAiChat): void;
+declare function getInstallationToken(appId: string, privateKey: string, installationId: number): Promise<string>;
 export declare function verifyWebhookSignature(payload: string, signature: string | undefined, secret: string): boolean;
 export declare function parsePatchToHunk(filePath: string, patch: string): DiffHunk;
+declare function reviewPullRequest(payload: WebhookPayload, token: string, config: GitHubAppConfig): Promise<WebhookResult>;
 /**
  * Handle an incoming GitHub webhook event.
  * This is the primary entry point — can be used in serverless functions,
@@ -107,6 +128,20 @@ export declare function parsePatchToHunk(filePath: string, patch: string): DiffH
  */
 export declare function handleWebhook(event: string, payload: string | WebhookPayload, signature: string | undefined, config: GitHubAppConfig): Promise<WebhookResult>;
 export declare function loadAppConfig(): GitHubAppConfig;
+export declare function __setEvaluateWithTribunalForTest(fn: typeof evaluateWithTribunal | undefined): void;
+export declare function __setEvaluateProjectForTest(fn: typeof evaluateProject | undefined): void;
+export declare function getEvaluateWithTribunalImpl(): typeof evaluateWithTribunal;
+export declare function __getEvaluateWithTribunalImplForTest(): typeof evaluateWithTribunal;
+export declare const __test: {
+    __setCallOpenAiChatImplForTest: typeof __setCallOpenAiChatImplForTest;
+    __getInstallationTokenForTest: (fn: typeof getInstallationToken) => void;
+    __setGhApiImplForTest: typeof __setGhApiImplForTest;
+    __setEvaluateWithTribunalForTest: typeof __setEvaluateWithTribunalForTest;
+    __setEvaluateProjectForTest: typeof __setEvaluateProjectForTest;
+    __getEvaluateWithTribunalImplForTest: typeof __getEvaluateWithTribunalImplForTest;
+    parsePatchToHunk: typeof parsePatchToHunk;
+    reviewPullRequest: typeof reviewPullRequest;
+};
 /**
  * Start a standalone HTTP server that listens for GitHub webhooks.
  * Usage: `judges app serve --port 3000`