@kevinrabun/judges-cli 3.124.0

package/dist/reports/public-repo-report.js

@@ -0,0 +1,579 @@
+import { execFileSync } from "child_process";
+import { mkdtempSync, readdirSync, readFileSync, rmSync, statSync, writeFileSync, mkdirSync } from "fs";
+import { tmpdir } from "os";
+import { basename, dirname, extname, join, resolve } from "path";
+import { evaluateWithTribunal } from "../evaluators/index.js";
+const DEFAULT_MAX_FILE_BYTES = 300_000;
+const DEFAULT_MAX_FILES = 600;
+const DEFAULT_MAX_FINDINGS_IN_REPORT = 150;
+const DEFAULT_CREDENTIAL_MODE = "standard";
+const INCLUDE_EXTENSIONS = new Set([
+    ".ts",
+    ".tsx",
+    ".js",
+    ".jsx",
+    ".mjs",
+    ".cjs",
+    ".py",
+    ".go",
+    ".rs",
+    ".java",
+    ".cs",
+    ".cpp",
+    ".cc",
+    ".cxx",
+    ".c",
+    ".h",
+    ".hpp",
+    ".hh",
+    ".inl",
+    ".ps1",
+    ".psm1",
+]);
+const EXCLUDED_DIRS = new Set([
+    ".git",
+    ".github",
+    ".vscode",
+    "node_modules",
+    "build",
+    "dist",
+    "bin",
+    "obj",
+    "out",
+    "third_party",
+    "extern",
+    "external",
+    "deps",
+    "vendor",
+    "vcpkg_installed",
+    "cmake-build-debug",
+    "cmake-build-release",
+]);
+function normalizeLanguageFromExtension(filePath) {
+    const extension = extname(filePath).toLowerCase();
+    switch (extension) {
+        case ".ts":
+        case ".tsx":
+            return "typescript";
+        case ".js":
+        case ".jsx":
+        case ".mjs":
+        case ".cjs":
+            return "javascript";
+        case ".py":
+            return "python";
+        case ".go":
+            return "go";
+        case ".rs":
+            return "rust";
+        case ".java":
+            return "java";
+        case ".cs":
+            return "csharp";
+        case ".cpp":
+        case ".cc":
+        case ".cxx":
+        case ".c":
+        case ".h":
+        case ".hpp":
+        case ".hh":
+        case ".inl":
+            return "cpp";
+        case ".ps1":
+        case ".psm1":
+            return "powershell";
+        default:
+            return "unknown";
+    }
+}
+function severityOrder(severity) {
+    switch (severity) {
+        case "critical":
+            return 5;
+        case "high":
+            return 4;
+        case "medium":
+            return 3;
+        case "low":
+            return 2;
+        case "info":
+            return 1;
+    }
+}
+function severityRiskWeight(severity) {
+    switch (severity) {
+        case "critical":
+            return 100;
+        case "high":
+            return 70;
+        case "medium":
+            return 40;
+        case "low":
+            return 15;
+        case "info":
+            return 5;
+    }
+}
+function normalizeFindingText(value) {
+    return value.trim().toLowerCase().replace(/\s+/g, " ");
+}
+function confidenceFactor(confidence) {
+    if (typeof confidence !== "number" || Number.isNaN(confidence)) {
+        return 0.75;
+    }
+    const bounded = Math.max(0, Math.min(1, confidence));
+    return 0.6 + bounded * 0.4;
+}
+function fixabilityFactor(finding) {
+    if (finding.suggestedFix?.trim()) {
+        return 1.1;
+    }
+    if (finding.recommendation?.trim()) {
+        return 1;
+    }
+    return 0.9;
+}
+function findingRiskScore(finding) {
+    const severityWeight = severityRiskWeight(finding.severity);
+    return Number((severityWeight * confidenceFactor(finding.confidence) * fixabilityFactor(finding)).toFixed(2));
+}
+function findingClusterKey(finding) {
+    return [
+        finding.ruleId,
+        normalizeFindingText(finding.title),
+        normalizeFindingText(finding.description),
+        normalizeFindingText(finding.recommendation),
+    ].join("|");
+}
+function clusterAndRankFindings(findings) {
+    const clusters = new Map();
+    for (const finding of findings) {
+        const key = findingClusterKey(finding);
+        const existing = clusters.get(key);
+        if (!existing) {
+            clusters.set(key, {
+                representative: finding,
+                items: [finding],
+                files: new Set([finding.file]),
+            });
+            continue;
+        }
+        existing.items.push(finding);
+        existing.files.add(finding.file);
+        if (findingRiskScore(finding) > findingRiskScore(existing.representative)) {
+            existing.representative = finding;
+        }
+    }
+    return [...clusters.values()]
+        .map((cluster) => ({
+        finding: cluster.representative,
+        occurrences: cluster.items.length,
+        affectedFiles: cluster.files.size,
+        riskScore: findingRiskScore(cluster.representative),
+    }))
+        .sort((a, b) => {
+        const riskDiff = b.riskScore - a.riskScore;
+        if (riskDiff !== 0)
+            return riskDiff;
+        const severityDiff = severityOrder(b.finding.severity) - severityOrder(a.finding.severity);
+        if (severityDiff !== 0)
+            return severityDiff;
+        return a.finding.ruleId.localeCompare(b.finding.ruleId);
+    });
+}
+function getEvidenceSnippet(content, lineNumbers, contextRadius = 1) {
+    if (!lineNumbers || lineNumbers.length === 0) {
+        return undefined;
+    }
+    const lines = content.split("\n");
+    const firstLine = lineNumbers[0];
+    if (!Number.isFinite(firstLine) || firstLine < 1 || firstLine > lines.length) {
+        return undefined;
+    }
+    const start = Math.max(1, firstLine - contextRadius);
+    const end = Math.min(lines.length, firstLine + contextRadius);
+    const snippet = lines
+        .slice(start - 1, end)
+        .map((line, idx) => `${start + idx}: ${line}`)
+        .join("\n")
+        .trim();
+    return snippet.length > 0 ? snippet : undefined;
+}
+function countBySeverity(findings) {
+    const counts = {
+        critical: 0,
+        high: 0,
+        medium: 0,
+        low: 0,
+        info: 0,
+    };
+    for (const finding of findings) {
+        counts[finding.severity] += 1;
+    }
+    return counts;
+}
+function compileExcludeRegexes(patterns) {
+    if (!patterns || patterns.length === 0)
+        return [];
+    return patterns.map((pattern) => {
+        try {
+            return new RegExp(pattern, "i");
+        }
+        catch {
+            // Invalid regex from user input — treat as literal string match
+            return new RegExp(pattern.replace(/[.*+?^${}()|[\]\\]/g, "\\$&"), "i");
+        }
+    });
+}
+function isLikelyNonProductionPath(path) {
+    return /(^|\/)(test|tests|__tests__|spec|specs|e2e)(\/|\.|$)|\.(?:test|tests|spec|specs|e2e)\.[^/]+$|mock|fixture|fixtures|(^|\/)docs(-|\/)i18n(\/|$)|(^|\/)docs(\/|$)/i.test(path);
+}
+function shouldSuppressFindingForPath(path, finding) {
+    if (!isLikelyNonProductionPath(path)) {
+        return false;
+    }
+    const nonProdSuppressPrefixes = [
+        "A11Y-",
+        "API-",
+        "AUTH-",
+        "CACHE-",
+        "CFG-",
+        "CICD-",
+        "CLOUD-",
+        "COMP-",
+        "COMPAT-",
+        "CONC-",
+        "COST-",
+        "CYBER-",
+        "DATA-",
+        "DEPS-",
+        "DB-",
+        "DOC-",
+        "ERR-",
+        "ETHICS-",
+        "I18N-",
+        "LOGPRIV-",
+        "MAINT-",
+        "OBS-",
+        "PERF-",
+        "PORTA-",
+        "RATE-",
+        "REL-",
+        "SCALE-",
+        "SOV-",
+        "STRUCT-",
+        "SWDEV-",
+        "TEST-",
+        "UX-",
+    ];
+    if (nonProdSuppressPrefixes.some((prefix) => finding.ruleId.startsWith(prefix))) {
+        return true;
+    }
+    if (/^AUTH-/.test(finding.ruleId) && /hardcoded credentials/i.test(finding.title)) {
+        return true;
+    }
+    if (/^DATA-/.test(finding.ruleId) && /hardcoded/i.test(finding.title)) {
+        return true;
+    }
+    if (finding.ruleId === "STRUCT-008") {
+        return true;
+    }
+    return false;
+}
+function withCredentialMode(mode, action) {
+    const previous = process.env.JUDGES_CREDENTIAL_MODE;
+    if (mode === "strict") {
+        process.env.JUDGES_CREDENTIAL_MODE = "strict";
+    }
+    else {
+        delete process.env.JUDGES_CREDENTIAL_MODE;
+    }
+    try {
+        return action();
+    }
+    finally {
+        if (typeof previous === "string") {
+            process.env.JUDGES_CREDENTIAL_MODE = previous;
+        }
+        else {
+            delete process.env.JUDGES_CREDENTIAL_MODE;
+        }
+    }
+}
+function walkSourceFiles(repoPath, maxFileBytes, maxFiles, excludePathRegexes = []) {
+    const files = [];
+    const visit = (currentPath, relativePrefix = "") => {
+        if (files.length >= maxFiles)
+            return;
+        const entries = readdirSync(currentPath, { withFileTypes: true });
+        for (const entry of entries) {
+            if (files.length >= maxFiles)
+                return;
+            const absolutePath = join(currentPath, entry.name);
+            const relativePath = relativePrefix ? `${relativePrefix}/${entry.name}` : entry.name;
+            if (excludePathRegexes.some((regex) => regex.test(relativePath))) {
+                continue;
+            }
+            if (entry.isDirectory()) {
+                if (EXCLUDED_DIRS.has(entry.name))
+                    continue;
+                visit(absolutePath, relativePath);
+                continue;
+            }
+            if (!entry.isFile())
+                continue;
+            const extension = extname(entry.name).toLowerCase();
+            if (!INCLUDE_EXTENSIONS.has(extension))
+                continue;
+            const stat = statSync(absolutePath);
+            if (stat.size > maxFileBytes)
+                continue;
+            const content = readFileSync(absolutePath, "utf8");
+            files.push({
+                absolutePath,
+                relativePath,
+                language: normalizeLanguageFromExtension(absolutePath),
+                content,
+            });
+        }
+    };
+    visit(repoPath);
+    return files;
+}
+function buildMarkdownReport(params) {
+    const { repoUrl, branch, commitSha, analyzedFiles, evaluations, maxFindingsInReport } = params;
+    const allFindings = evaluations.flatMap((entry) => entry.findings.map((finding) => ({ ...finding, file: entry.path })));
+    const rankedFindings = clusterAndRankFindings(allFindings);
+    const sourceByPath = new Map(analyzedFiles.map((file) => [file.relativePath, file.content]));
+    const averageScore = evaluations.length > 0
+        ? Math.round(evaluations.reduce((sum, entry) => sum + entry.score, 0) / evaluations.length)
+        : 100;
+    const failCount = evaluations.filter((entry) => entry.verdict === "fail").length;
+    const warningCount = evaluations.filter((entry) => entry.verdict === "warning").length;
+    const passCount = evaluations.filter((entry) => entry.verdict === "pass").length;
+    const overallVerdict = failCount > 0 ? "fail" : warningCount > 0 ? "warning" : "pass";
+    const severityCounts = countBySeverity(allFindings);
+    const mustFixEnabled = evaluations.some((entry) => entry.mustFixGateTriggered !== undefined);
+    const mustFixTriggeredFileCount = evaluations.filter((entry) => entry.mustFixGateTriggered).length;
+    const mustFixMatchedCount = evaluations.reduce((sum, entry) => sum + (entry.mustFixMatchedCount ?? 0), 0);
+    const mustFixRuleIds = [...new Set(evaluations.flatMap((entry) => entry.mustFixMatchedRuleIds ?? []))];
+    const judgeScoreAverages = new Map();
+    for (const fileEvaluation of evaluations) {
+        for (const evaluation of fileEvaluation.judgeEvaluations) {
+            const aggregate = judgeScoreAverages.get(evaluation.judgeId) ??
+                { name: evaluation.judgeName, scores: [], findings: [] };
+            aggregate.scores.push(evaluation.score);
+            aggregate.findings.push(...evaluation.findings);
+            judgeScoreAverages.set(evaluation.judgeId, aggregate);
+        }
+    }
+    const judgeRows = [...judgeScoreAverages.entries()]
+        .map(([judgeId, aggregate]) => {
+        const avgScore = Math.round(aggregate.scores.reduce((sum, value) => sum + value, 0) / aggregate.scores.length);
+        const findingCounts = countBySeverity(aggregate.findings);
+        return {
+            judgeId,
+            judgeName: aggregate.name,
+            avgScore,
+            findingCounts,
+        };
+    })
+        .sort((a, b) => a.avgScore - b.avgScore);
+    const worstFiles = [...evaluations]
+        .sort((a, b) => a.score - b.score)
+        .slice(0, 80);
+    let md = `# Public Repository Full Judges Report\n\n`;
+    md += `Generated from **${repoUrl}**`;
+    if (branch)
+        md += ` (branch: \`${branch}\`)`;
+    if (commitSha)
+        md += ` at commit \`${commitSha}\``;
+    md += ` on ${new Date().toISOString()}.\n\n`;
+    md += `## Scope\n\n`;
+    md += `- Files analyzed: **${analyzedFiles.length}**\n`;
+    md += `- Judges applied: **full tribunal (${judgeRows.length})**\n\n`;
+    md += `## Executive Summary\n\n`;
+    md += `- Overall verdict: **${overallVerdict.toUpperCase()}**\n`;
+    md += `- Average file score: **${averageScore}/100**\n`;
+    md += `- File verdict distribution: PASS ${passCount}, WARNING ${warningCount}, FAIL ${failCount}\n`;
+    md += `- Total findings: **${allFindings.length}** (critical ${severityCounts.critical}, high ${severityCounts.high}, medium ${severityCounts.medium}, low ${severityCounts.low}, info ${severityCounts.info})\n`;
+    md += `- Unique root-cause clusters: **${rankedFindings.length}**\n\n`;
+    if (mustFixEnabled) {
+        md += `## Must-Fix Gate Summary\n\n`;
+        md += `- Triggered files: **${mustFixTriggeredFileCount}/${evaluations.length}**\n`;
+        md += `- Matched must-fix findings: **${mustFixMatchedCount}**\n`;
+        md += `- Matched rule IDs: ${mustFixRuleIds.length > 0 ? mustFixRuleIds.map((id) => `\`${id}\``).join(", ") : "none"}\n\n`;
+    }
+    md += `## Per-Judge Breakdown\n\n`;
+    md += `| Judge | Avg Score | Critical | High | Medium | Low | Info |\n`;
+    md += `|---|---:|---:|---:|---:|---:|---:|\n`;
+    for (const row of judgeRows) {
+        md += `| ${row.judgeName} | ${row.avgScore} | ${row.findingCounts.critical} | ${row.findingCounts.high} | ${row.findingCounts.medium} | ${row.findingCounts.low} | ${row.findingCounts.info} |\n`;
+    }
+    md += `\n`;
+    md += `## Highest-Risk Findings (Top ${Math.min(maxFindingsInReport, rankedFindings.length)})\n\n`;
+    for (const entry of rankedFindings.slice(0, maxFindingsInReport)) {
+        const finding = entry.finding;
+        const lines = finding.lineNumbers?.length ? ` (lines ${finding.lineNumbers.join(", ")})` : "";
+        const evidence = sourceByPath.has(finding.file)
+            ? getEvidenceSnippet(sourceByPath.get(finding.file) ?? "", finding.lineNumbers)
+            : undefined;
+        md += `### [${finding.severity.toUpperCase()}] ${finding.ruleId} — ${finding.title}\n`;
+        md += `- Risk score: ${entry.riskScore}\n`;
+        md += `- File: \`${finding.file}\`${lines}\n`;
+        md += `- Occurrences: ${entry.occurrences} across ${entry.affectedFiles} file(s)\n`;
+        if (typeof finding.confidence === "number") {
+            md += `- Confidence: ${Math.round(Math.max(0, Math.min(1, finding.confidence)) * 100)}%\n`;
+        }
+        md += `- Description: ${finding.description}\n`;
+        md += `- Recommendation: ${finding.recommendation}\n`;
+        if (evidence) {
+            md += `- Evidence:\n\n\`\`\`\n${evidence}\n\`\`\`\n`;
+        }
+        if (finding.suggestedFix?.trim()) {
+            md += `- Suggested fix:\n\n\`\`\`\n${finding.suggestedFix.trim()}\n\`\`\`\n`;
+        }
+        if (finding.reference) {
+            md += `- Reference: ${finding.reference}\n`;
+        }
+        md += `\n`;
+    }
+    md += `## Lowest-Scoring Files (Top ${Math.min(80, worstFiles.length)})\n\n`;
+    md += `| File | Language | Score | Verdict | Findings |\n`;
+    md += `|---|---|---:|---|---:|\n`;
+    for (const entry of worstFiles) {
+        md += `| \`${entry.path}\` | ${entry.language} | ${entry.score} | ${entry.verdict.toUpperCase()} | ${entry.findings.length} |\n`;
+    }
+    md += `\n## Notes and Limitations\n\n`;
+    md += `- This report is based on static heuristic and structural analysis of repository source files.\n`;
+    md += `- Runtime behavior, production telemetry, and deployment controls should be reviewed separately.\n`;
+    md += `- Large/binary/generated/vendor files are intentionally excluded for signal quality.\n`;
+    return {
+        markdown: md,
+        overallVerdict,
+        averageScore,
+        totalFindings: allFindings.length,
+    };
+}
+function clonePublicRepo(repoUrl, branch) {
+    const safeName = basename(repoUrl).replace(/\.git$/i, "") || "repo";
+    const parentDir = mkdtempSync(join(tmpdir(), "judges-public-repo-"));
+    const targetDir = join(parentDir, safeName);
+    const args = ["clone", "--depth", "1"];
+    if (branch) {
+        args.push("--branch", branch, "--single-branch");
+    }
+    args.push(repoUrl, targetDir);
+    execFileSync("git", args, { stdio: "pipe" });
+    return targetDir;
+}
+function getCommitSha(repoPath) {
+    try {
+        return execFileSync("git", ["rev-parse", "HEAD"], {
+            cwd: repoPath,
+            stdio: "pipe",
+        })
+            .toString()
+            .trim();
+    }
+    catch {
+        return undefined;
+    }
+}
+export function generateRepoReportFromLocalPath(options) {
+    const maxFileBytes = options.maxFileBytes ?? DEFAULT_MAX_FILE_BYTES;
+    const maxFiles = options.maxFiles ?? DEFAULT_MAX_FILES;
+    const maxFindingsInReport = options.maxFindingsInReport ?? DEFAULT_MAX_FINDINGS_IN_REPORT;
+    const credentialMode = options.credentialMode ?? DEFAULT_CREDENTIAL_MODE;
+    const includeAstFindings = options.includeAstFindings ?? true;
+    const minConfidence = options.minConfidence;
+    const mustFixGate = options.mustFixGate;
+    const repoPath = resolve(options.repoPath);
+    const excludePathRegexes = compileExcludeRegexes(options.excludePathRegexes);
+    const files = walkSourceFiles(repoPath, maxFileBytes, maxFiles, excludePathRegexes);
+    if (files.length === 0) {
+        throw new Error("No eligible source files found in the repository path.");
+    }
+    const evaluations = withCredentialMode(credentialMode, () => files.map((file) => {
+        const verdict = evaluateWithTribunal(file.content, file.language, undefined, {
+            includeAstFindings,
+            minConfidence,
+            mustFixGate,
+        });
+        const judgeEvaluations = verdict.evaluations.map((evaluation) => ({
+            ...evaluation,
+            findings: evaluation.findings.filter((finding) => !shouldSuppressFindingForPath(file.relativePath, finding)),
+        }));
+        const findings = judgeEvaluations.flatMap((evaluation) => evaluation.findings);
+        return {
+            path: file.relativePath,
+            language: file.language,
+            score: verdict.overallScore,
+            verdict: verdict.overallVerdict,
+            judgeEvaluations,
+            findings,
+            mustFixGateTriggered: verdict.mustFixGate?.triggered,
+            mustFixMatchedCount: verdict.mustFixGate?.matchedCount,
+            mustFixMatchedRuleIds: verdict.mustFixGate?.matchedRuleIds,
+        };
+    }));
+    const commitSha = getCommitSha(repoPath);
+    const report = buildMarkdownReport({
+        repoUrl: options.repoLabel ?? repoPath,
+        branch: options.branch,
+        commitSha,
+        analyzedFiles: files,
+        evaluations,
+        maxFindingsInReport,
+    });
+    let outputPath;
+    if (options.outputPath) {
+        outputPath = resolve(options.outputPath);
+        mkdirSync(dirname(outputPath), { recursive: true });
+        writeFileSync(outputPath, report.markdown, "utf8");
+    }
+    return {
+        markdown: report.markdown,
+        outputPath,
+        analyzedFileCount: files.length,
+        totalFindings: report.totalFindings,
+        averageScore: report.averageScore,
+        overallVerdict: report.overallVerdict,
+    };
+}
+export function generatePublicRepoReport(options) {
+    if (!/^https?:\/\//i.test(options.repoUrl)) {
+        throw new Error("repoUrl must be a public HTTP(S) repository URL.");
+    }
+    const clonePath = clonePublicRepo(options.repoUrl, options.branch);
+    try {
+        const report = generateRepoReportFromLocalPath({
+            repoPath: clonePath,
+            repoLabel: options.repoUrl,
+            branch: options.branch,
+            maxFiles: options.maxFiles,
+            maxFileBytes: options.maxFileBytes,
+            maxFindingsInReport: options.maxFindingsInReport,
+            excludePathRegexes: options.excludePathRegexes,
+            credentialMode: options.credentialMode,
+            includeAstFindings: options.includeAstFindings,
+            minConfidence: options.minConfidence,
+            mustFixGate: options.mustFixGate,
+            outputPath: options.outputPath,
+        });
+        return {
+            markdown: report.markdown,
+            outputPath: report.outputPath,
+            analyzedFileCount: report.analyzedFileCount,
+            totalFindings: report.totalFindings,
+            averageScore: report.averageScore,
+            overallVerdict: report.overallVerdict,
+            clonePath,
+        };
+    }
+    finally {
+        if (!options.keepClone) {
+            rmSync(clonePath, { recursive: true, force: true });
+        }
+    }
+}

package/dist/review-conversation.d.ts

@@ -0,0 +1,87 @@
+/**
+ * Multi-Turn Review Conversation
+ *
+ * Enables interactive, stateful review sessions where developers and
+ * the tribunal engage in a conversation about findings. This transforms
+ * the evaluation from a one-shot report into a collaborative review:
+ *
+ * - Developer asks "why?" about a finding → tribunal explains reasoning
+ * - Developer provides context → tribunal adjusts confidence
+ * - Developer requests re-evaluation → tribunal focuses on specific areas
+ * - Developer disputes a finding → tribunal logs disagreement and adjusts
+ *
+ * Designed for MCP tool sessions and VS Code extension interactions.
+ */
+import type { Finding, TribunalVerdict } from "./types.js";
+export type ConversationRole = "developer" | "tribunal" | "system";
+export type MessageIntent = "explain" | "context" | "dispute" | "accept" | "re-evaluate" | "focus" | "summary" | "general";
+export interface ConversationMessage {
+    id: string;
+    role: ConversationRole;
+    intent: MessageIntent;
+    content: string;
+    timestamp: string;
+    /** Finding this message relates to (if applicable) */
+    findingRef?: string;
+    /** Metadata about the action taken */
+    metadata?: Record<string, unknown>;
+}
+export interface ReviewConversation {
+    /** Unique conversation ID */
+    conversationId: string;
+    /** File under review */
+    filePath: string;
+    /** Language of the file */
+    language: string;
+    /** Current state of the conversation */
+    state: ConversationState;
+    /** All messages in order */
+    messages: ConversationMessage[];
+    /** Current findings (may be updated during conversation) */
+    findings: Finding[];
+    /** Original verdict from initial evaluation */
+    originalVerdict?: TribunalVerdict;
+    /** Accumulated developer context that affects evaluation */
+    developerContext: DeveloperContext;
+    /** Conversation started at */
+    startedAt: string;
+    /** Last activity */
+    lastActivityAt: string;
+}
+export type ConversationState = "active" | "resolved" | "paused" | "escalated";
+export interface DeveloperContext {
+    /** Reasons provided by developer for specific findings */
+    explanations: Map<string, string>;
+    /** Findings the developer disputes */
+    disputed: Set<string>;
+    /** Findings the developer accepts */
+    accepted: Set<string>;
+    /** Additional context (frameworks, libraries, constraints) */
+    additionalContext: string[];
+    /** Focus areas for re-evaluation */
+    focusAreas: string[];
+}
+/**
+ * Start a new review conversation for a file evaluation.
+ */
+export declare function startReviewConversation(filePath: string, language: string, verdict: TribunalVerdict): ReviewConversation;
+/**
+ * Process a developer message and generate a tribunal response.
+ */
+export declare function processMessage(conversation: ReviewConversation, content: string, intent: MessageIntent, findingRef?: string): ConversationMessage;
+/**
+ * Get the current state of outstanding findings in the conversation.
+ */
+export declare function getOutstandingFindings(conversation: ReviewConversation): {
+    unaddressed: Finding[];
+    accepted: Finding[];
+    disputed: Finding[];
+};
+/**
+ * Check if all findings have been addressed (accepted or disputed).
+ */
+export declare function isConversationResolved(conversation: ReviewConversation): boolean;
+/**
+ * Export the conversation as a reviewable markdown report.
+ */
+export declare function exportConversationAsMarkdown(conversation: ReviewConversation): string;