@open-cr-agent/cli 0.1.2 → 0.3.0

package/dist/memory.js

@@ -2,8 +2,8 @@ import { constants, existsSync } from "node:fs";
 import { lstat, mkdir, open, readdir, readFile } from "node:fs/promises";
 import { dirname, join, resolve } from "node:path";
 import { parseArgs } from "node:util";
-import { MEMORY_PATH, parseMemory, serializeMemory, } from "@open-cr-agent/core";
-import { findRepositoryRoot } from "@open-cr-agent/vcs-local";
+import { MEMORY_PATH, parseMemory, serializeMemory } from "@open-cr-agent/core/internal";
+import { findRepositoryRoot } from "@open-cr-agent/vcs-local/internal";
 import { UsageError } from "./review/args.js";
 import { SESSIONS_DIR } from "./review/command.js";
 import { forTerminal } from "./review/terminal.js";

package/dist/metrics.d.ts

@@ -0,0 +1,47 @@
+import { type Severity, type Verification } from "@open-cr-agent/core";
+import type { Output } from "./review/progress.js";
+export declare const METRICS_VERSION = 1;
+export declare const METRICS_USAGE = "Usage: ocra metrics [options]\n\nCounts over the finished reviews in .ocra/sessions: runs, cost, findings,\nwhat reviewers later fixed or dismissed, per reviewer. Reads each session's\nreport.json (report version 1); nothing calls a model.\n\nOptions:\n  --sessions <dir>     Sessions directory (default: .ocra/sessions of this repository)\n  --since <date>       Only runs started at or after this ISO 8601 date\n  --format <text|json> Output format (default: text); the JSON carries \"version\": 1\n  -h, --help           Show help\n";
+export interface ReviewerMetrics {
+    tasks: number;
+    failedTasks: number;
+    findings: number;
+    costUsd: number;
+    fixed: number;
+    dismissed: number;
+    acceptanceRate: number | null;
+}
+export interface Metrics {
+    version: typeof METRICS_VERSION;
+    sessionsDir: string;
+    since?: string;
+    runs: {
+        total: number;
+        byVerdict: Record<string, number>;
+        incomplete: number;
+        unreadable: number;
+    };
+    cost: {
+        usd: number;
+        inputTokens: number;
+        outputTokens: number;
+        usdPerRun: number | null;
+    };
+    findings: {
+        reported: number;
+        unique: number;
+        bySeverity: Record<Severity, number>;
+        byVerification: Record<Verification, number>;
+    };
+    outcomes: {
+        fixed: number;
+        dismissed: number;
+        acceptanceRate: number | null;
+    };
+    reviewers: Record<string, ReviewerMetrics>;
+}
+export declare function metricsCommand(argv: string[], out: Output, cwd: string): Promise<number>;
+export declare function sessionStart(id: string): Date | undefined;
+export declare function collectMetrics(sessionsDir: string, since?: Date): Promise<Metrics>;
+export declare function renderMetrics(m: Metrics): string;
+//# sourceMappingURL=metrics.d.ts.map

package/dist/metrics.js

@@ -0,0 +1,227 @@
+import { readdir, readFile } from "node:fs/promises";
+import { join, resolve } from "node:path";
+import { parseArgs } from "node:util";
+import { reportOutputSchema, } from "@open-cr-agent/core";
+import { findRepositoryRoot } from "@open-cr-agent/vcs-local/internal";
+import { UsageError } from "./review/args.js";
+import { SESSIONS_DIR } from "./review/command.js";
+import { forTerminal } from "./review/terminal.js";
+export const METRICS_VERSION = 1;
+export const METRICS_USAGE = `Usage: ocra metrics [options]
+
+Counts over the finished reviews in ${SESSIONS_DIR}: runs, cost, findings,
+what reviewers later fixed or dismissed, per reviewer. Reads each session's
+report.json (report version 1); nothing calls a model.
+
+Options:
+  --sessions <dir>     Sessions directory (default: ${SESSIONS_DIR} of this repository)
+  --since <date>       Only runs started at or after this ISO 8601 date
+  --format <text|json> Output format (default: text); the JSON carries "version": ${METRICS_VERSION}
+  -h, --help           Show help
+`;
+export async function metricsCommand(argv, out, cwd) {
+    const { values } = parseArgs({
+        args: argv,
+        allowPositionals: false,
+        strict: true,
+        options: {
+            sessions: { type: "string" },
+            since: { type: "string" },
+            format: { type: "string" },
+            help: { type: "boolean", short: "h" },
+        },
+    });
+    if (values.help) {
+        out.write(METRICS_USAGE);
+        return 0;
+    }
+    const format = values.format ?? "text";
+    if (format !== "text" && format !== "json")
+        throw new UsageError("--format must be text or json");
+    const since = values.since === undefined ? undefined : parseSince(values.since);
+    const sessionsDir = values.sessions
+        ? resolve(cwd, values.sessions)
+        : join(await findRepositoryRoot(cwd), SESSIONS_DIR);
+    const metrics = await collectMetrics(sessionsDir, since);
+    out.write(format === "json" ? `${JSON.stringify(metrics, null, 2)}\n` : renderMetrics(metrics));
+    return 0;
+}
+function parseSince(text) {
+    const date = new Date(text);
+    if (Number.isNaN(date.getTime()))
+        throw new UsageError(`--since needs an ISO 8601 date, not "${text}"`);
+    return date;
+}
+// A session directory is named by its run id, whose first part is the start
+// time (newRunId in core); that is what --since compares against.
+export function sessionStart(id) {
+    const m = /^(\d{4})(\d{2})(\d{2})T(\d{2})(\d{2})(\d{2})Z/.exec(id);
+    if (!m)
+        return undefined;
+    const [, y, mo, d, h, mi, s] = m;
+    return new Date(`${y}-${mo}-${d}T${h}:${mi}:${s}Z`);
+}
+export async function collectMetrics(sessionsDir, since) {
+    const names = (await readdir(sessionsDir).catch(() => []))
+        .filter((n) => !n.startsWith("."))
+        .filter((n) => {
+        const start = sessionStart(n);
+        return since === undefined || (start !== undefined && start >= since);
+    })
+        .sort();
+    const reports = [];
+    let unreadable = 0;
+    for (const name of names) {
+        const report = await readReport(join(sessionsDir, name, "report.json"));
+        if (report)
+            reports.push(report);
+        else
+            unreadable += 1;
+    }
+    return aggregate(reports, {
+        sessionsDir,
+        unreadable,
+        ...(since ? { since: since.toISOString() } : {}),
+    });
+}
+async function readReport(path) {
+    let data;
+    try {
+        data = JSON.parse(await readFile(path, "utf8"));
+    }
+    catch {
+        return undefined;
+    }
+    const parsed = reportOutputSchema.safeParse(data);
+    return parsed.success ? parsed.data : undefined;
+}
+function aggregate(reports, meta) {
+    const byVerdict = {};
+    const bySeverity = { critical: 0, warning: 0, suggestion: 0 };
+    const byVerification = { confirmed: 0, uncertain: 0, unchecked: 0 };
+    const reviewers = new Map();
+    const reviewerOf = new Map();
+    const unique = new Set();
+    const fixed = new Set();
+    const dismissed = new Set();
+    let incomplete = 0;
+    let reported = 0;
+    let usd = 0;
+    let inputTokens = 0;
+    let outputTokens = 0;
+    const forReviewer = (id) => {
+        let r = reviewers.get(id);
+        if (!r) {
+            r = {
+                tasks: 0,
+                failedTasks: 0,
+                findings: 0,
+                costUsd: 0,
+                fixed: 0,
+                dismissed: 0,
+                acceptanceRate: null,
+            };
+            reviewers.set(id, r);
+        }
+        return r;
+    };
+    for (const report of reports) {
+        byVerdict[report.verdict] = (byVerdict[report.verdict] ?? 0) + 1;
+        if (report.coverage.some((c) => c.status === "failed" || c.status === "unreviewed"))
+            incomplete += 1;
+        usd += report.usage.costUsd;
+        inputTokens += report.usage.inputTokens;
+        outputTokens += report.usage.outputTokens;
+        for (const task of report.tasks) {
+            const r = forReviewer(task.reviewer);
+            r.tasks += 1;
+            if (task.status === "failed" || task.status === "timed_out")
+                r.failedTasks += 1;
+            r.costUsd += task.usage.costUsd;
+        }
+        for (const finding of report.findings) {
+            reported += 1;
+            unique.add(finding.fingerprint);
+            bySeverity[finding.severity] += 1;
+            byVerification[finding.verification] += 1;
+            forReviewer(finding.reviewer).findings += 1;
+            if (!reviewerOf.has(finding.fingerprint))
+                reviewerOf.set(finding.fingerprint, finding.reviewer);
+        }
+        for (const f of report.rereview?.fixed ?? [])
+            fixed.add(f.fingerprint);
+        for (const f of report.rereview?.dismissed ?? [])
+            dismissed.add(f.fingerprint);
+    }
+    // A fingerprint can be dismissed in one review and gone in a later one:
+    // the reviewer's decision stands.
+    for (const fp of dismissed)
+        fixed.delete(fp);
+    for (const fp of fixed) {
+        const reviewer = reviewerOf.get(fp);
+        if (reviewer)
+            forReviewer(reviewer).fixed += 1;
+    }
+    for (const fp of dismissed) {
+        const reviewer = reviewerOf.get(fp);
+        if (reviewer)
+            forReviewer(reviewer).dismissed += 1;
+    }
+    for (const r of reviewers.values())
+        r.acceptanceRate = rate(r.fixed, r.dismissed);
+    return {
+        version: METRICS_VERSION,
+        sessionsDir: meta.sessionsDir,
+        ...(meta.since ? { since: meta.since } : {}),
+        runs: { total: reports.length, byVerdict, incomplete, unreadable: meta.unreadable },
+        cost: {
+            usd,
+            inputTokens,
+            outputTokens,
+            usdPerRun: reports.length > 0 ? usd / reports.length : null,
+        },
+        findings: { reported, unique: unique.size, bySeverity, byVerification },
+        outcomes: {
+            fixed: fixed.size,
+            dismissed: dismissed.size,
+            acceptanceRate: rate(fixed.size, dismissed.size),
+        },
+        reviewers: Object.fromEntries([...reviewers].sort(([a], [b]) => a.localeCompare(b))),
+    };
+}
+function rate(fixed, dismissed) {
+    return fixed + dismissed > 0 ? fixed / (fixed + dismissed) : null;
+}
+const percent = (value) => (value === null ? "n/a" : `${Math.round(value * 100)}%`);
+const dollars = (value) => (value === null ? "n/a" : `$${value.toFixed(2)}`);
+export function renderMetrics(m) {
+    const lines = [
+        `Runs: ${m.runs.total}${m.since ? ` since ${m.since}` : ""} (${m.runs.incomplete} incomplete, ${m.runs.unreadable} unreadable)`,
+        `  by verdict: ${entries(m.runs.byVerdict)}`,
+        `Cost: ${dollars(m.cost.usd)} total, ${dollars(m.cost.usdPerRun)} per run · ${m.cost.inputTokens} in / ${m.cost.outputTokens} out tokens`,
+        `Findings: ${m.findings.reported} reported, ${m.findings.unique} unique`,
+        `  by severity: ${entries(m.findings.bySeverity)}`,
+        `  by verification: ${entries(m.findings.byVerification)}`,
+        `Outcomes: ${m.outcomes.fixed} fixed, ${m.outcomes.dismissed} dismissed, acceptance ${percent(m.outcomes.acceptanceRate)}`,
+        "",
+        "Reviewer           Tasks  Failed  Findings  Cost      Fixed  Dismissed  Acceptance",
+    ];
+    for (const [id, r] of Object.entries(m.reviewers)) {
+        lines.push([
+            id.padEnd(18),
+            String(r.tasks).padStart(5),
+            String(r.failedTasks).padStart(7),
+            String(r.findings).padStart(9),
+            dollars(r.costUsd).padStart(9),
+            String(r.fixed).padStart(6),
+            String(r.dismissed).padStart(10),
+            percent(r.acceptanceRate).padStart(11),
+        ].join(" "));
+    }
+    return `${forTerminal(lines.join("\n"))}\n`;
+}
+function entries(record) {
+    const parts = Object.entries(record).filter(([, n]) => n > 0);
+    return parts.length === 0 ? "none" : parts.map(([k, n]) => `${k} ${n}`).join(", ");
+}
+//# sourceMappingURL=metrics.js.map

package/dist/review/args.d.ts

@@ -1,13 +1,20 @@
+import { OcraError } from "@open-cr-agent/core";
 import type { LocalTarget } from "@open-cr-agent/vcs-local";
-export type OutputFormat = "text" | "json";
+export type OutputFormat = "text" | "json" | "sarif";
 export interface PullRequestTarget {
     number: number;
     repo?: string;
     publish: boolean;
 }
+export interface MergeRequestTarget {
+    iid: number;
+    project?: string;
+    publish: boolean;
+}
 export interface ReviewArgs {
     target: LocalTarget;
     pullRequest?: PullRequestTarget;
+    mergeRequest?: MergeRequestTarget;
     format: OutputFormat;
     output?: string;
     ignoreRepoConfig?: true;
@@ -16,9 +23,14 @@ export interface ReviewArgs {
     ultra?: true;
     full?: true;
     plan?: true;
+    importSarif?: string[];
+    configFile?: string;
+    temperature?: number;
+    seed?: number;
 }
-export declare class UsageError extends Error {
+export declare class UsageError extends OcraError {
+    constructor(message: string);
 }
-export declare const REVIEW_USAGE = "Usage: ocra review [options]\n\nReviews uncommitted changes by default.\n\nOptions:\n  --from <ref>       Review changes on --to since it diverged from <ref>\n  --to <ref>         End of the range (default: HEAD)\n  --commit <sha>     Review a single commit\n  --pr <number>      Review a GitHub pull request (needs GITHUB_TOKEN)\n  --repo <owner/name>  Repository of --pr (default: GITHUB_REPOSITORY or origin)\n  --publish          With --pr: post the review to the pull request\n  --full             With --pr: review every file, not only what changed since\n                     the previous review\n  --format <format>  text (default) or json\n  --output <file>    Write the result to a file instead of stdout\n  --reviewers <ids>  Run only these reviewers (comma-separated)\n  --max-cost-usd <n> Spend limit: reviews use 80%, verification and judging the rest\n  --plan             Show files, bundles, review tasks and prompt sizes; call no model\n  --ultra            Favor recall: all reviewers at every tier, two samples each (about 2x cost)\n  --no-repo-config   Ignore .ocra/config.json and its plugins (for untrusted\n                     code); models come from OCRA_MODEL_* variables\n  -h, --help         Show help\n";
+export declare const REVIEW_USAGE = "Usage: ocra review [options]\n\nReviews uncommitted changes by default.\n\nOptions:\n  --from <ref>       Review changes on --to since it diverged from <ref>\n  --to <ref>         End of the range (default: HEAD)\n  --commit <sha>     Review a single commit\n  --pr <number>      Review a GitHub pull request (needs GITHUB_TOKEN)\n  --repo <owner/name>  Repository of --pr (default: GITHUB_REPOSITORY or origin)\n  --mr <iid>         Review a GitLab merge request (needs GITLAB_TOKEN)\n  --project <id|path>  Project of --mr (default: CI_PROJECT_ID or origin)\n  --publish          With --pr or --mr: post the review to it\n  --full             With --pr or --mr: review every file, not only what\n                     changed since the previous review\n  --format <format>  text (default), json, or sarif (SARIF 2.1.0; not with --plan)\n  --output <file>    Write the result to a file instead of stdout\n  --reviewers <ids>  Run only these reviewers (comma-separated)\n  --max-cost-usd <n> Spend limit: reviews use 80%, verification and judging the rest\n  --import-sarif <file>  Add the results of a SARIF 2.1.0 log (Semgrep, CodeQL, \u2026)\n                     that fall on the change; repeatable; not with --plan\n  --plan             Show files, bundles, review tasks and prompt sizes; call no model\n  --ultra            Favor recall: all reviewers at every tier, two samples each (about 2x cost)\n  --temperature <n>  Sampling temperature, 0 to 2 (default: the provider's, or sampling in config)\n  --seed <n>         Sampling seed, where the runtime and provider support one\n  --config <file>    Read this configuration file instead of the repository's\n                     .ocra/config.json; it applies with --no-repo-config too\n  --no-repo-config   Ignore .ocra/config.json and its plugins (for untrusted\n                     code); models come from OCRA_MODEL_* variables or --config\n  -h, --help         Show help\n";
 export declare function parseReviewArgs(argv: string[]): ReviewArgs | "help";
 //# sourceMappingURL=args.d.ts.map

package/dist/review/args.js

@@ -1,5 +1,10 @@
 import { parseArgs } from "node:util";
-export class UsageError extends Error {
+import { OcraError } from "@open-cr-agent/core";
+export class UsageError extends OcraError {
+    constructor(message) {
+        super("INPUT_USAGE", message);
+        this.name = "UsageError";
+    }
 }
 export const REVIEW_USAGE = `Usage: ocra review [options]
 
@@ -11,17 +16,25 @@ Options:
   --commit <sha>     Review a single commit
   --pr <number>      Review a GitHub pull request (needs GITHUB_TOKEN)
   --repo <owner/name>  Repository of --pr (default: GITHUB_REPOSITORY or origin)
-  --publish          With --pr: post the review to the pull request
-  --full             With --pr: review every file, not only what changed since
-                     the previous review
-  --format <format>  text (default) or json
+  --mr <iid>         Review a GitLab merge request (needs GITLAB_TOKEN)
+  --project <id|path>  Project of --mr (default: CI_PROJECT_ID or origin)
+  --publish          With --pr or --mr: post the review to it
+  --full             With --pr or --mr: review every file, not only what
+                     changed since the previous review
+  --format <format>  text (default), json, or sarif (SARIF 2.1.0; not with --plan)
   --output <file>    Write the result to a file instead of stdout
   --reviewers <ids>  Run only these reviewers (comma-separated)
   --max-cost-usd <n> Spend limit: reviews use 80%, verification and judging the rest
+  --import-sarif <file>  Add the results of a SARIF 2.1.0 log (Semgrep, CodeQL, …)
+                     that fall on the change; repeatable; not with --plan
   --plan             Show files, bundles, review tasks and prompt sizes; call no model
   --ultra            Favor recall: all reviewers at every tier, two samples each (about 2x cost)
+  --temperature <n>  Sampling temperature, 0 to 2 (default: the provider's, or sampling in config)
+  --seed <n>         Sampling seed, where the runtime and provider support one
+  --config <file>    Read this configuration file instead of the repository's
+                     .ocra/config.json; it applies with --no-repo-config too
   --no-repo-config   Ignore .ocra/config.json and its plugins (for untrusted
-                     code); models come from OCRA_MODEL_* variables
+                     code); models come from OCRA_MODEL_* variables or --config
   -h, --help         Show help
 `;
 export function parseReviewArgs(argv) {
@@ -38,13 +51,21 @@ export function parseReviewArgs(argv) {
     if (positionals.length > 0)
         throw new UsageError(`Unexpected argument: ${positionals[0]}`);
     const format = values.format ?? "text";
-    if (format !== "text" && format !== "json") {
-        throw new UsageError(`--format must be text or json, got ${format}`);
+    if (format !== "text" && format !== "json" && format !== "sarif") {
+        throw new UsageError(`--format must be text, json or sarif, got ${format}`);
     }
     const args = { target: target(values), format };
     const pullRequest = pullRequestTarget(values);
+    const mergeRequest = mergeRequestTarget(values);
+    if (pullRequest && mergeRequest)
+        throw new UsageError("--pr cannot be combined with --mr");
+    if (!pullRequest && !mergeRequest && values.publish) {
+        throw new UsageError("--publish requires --pr or --mr");
+    }
     if (pullRequest)
         args.pullRequest = pullRequest;
+    if (mergeRequest)
+        args.mergeRequest = mergeRequest;
     if (values.output !== undefined)
         args.output = values.output;
     if (values["no-repo-config"])
@@ -52,13 +73,15 @@ export function parseReviewArgs(argv) {
     if (values.ultra)
         args.ultra = true;
     if (values.full) {
-        if (!pullRequest)
-            throw new UsageError("--full needs --pr");
+        if (!pullRequest && !mergeRequest)
+            throw new UsageError("--full needs --pr or --mr");
         args.full = true;
     }
     if (values.plan) {
         if (values.publish)
             throw new UsageError("--plan cannot be combined with --publish");
+        if (format === "sarif")
+            throw new UsageError("--plan has no findings for --format sarif");
         args.plan = true;
     }
     if (values["max-cost-usd"] !== undefined) {
@@ -67,6 +90,30 @@ export function parseReviewArgs(argv) {
             throw new UsageError(`--max-cost-usd must be a positive number, got ${values["max-cost-usd"]}`);
         args.maxCostUsd = max;
     }
+    if (values.temperature !== undefined) {
+        const temperature = Number(values.temperature);
+        if (values.temperature.trim() === "" || !(temperature >= 0 && temperature <= 2)) {
+            throw new UsageError(`--temperature must be a number from 0 to 2, got ${values.temperature}`);
+        }
+        args.temperature = temperature;
+    }
+    if (values.seed !== undefined) {
+        const seed = Number(values.seed);
+        if (!/^\d+$/.test(values.seed) || seed > 2 ** 31 - 1) {
+            throw new UsageError(`--seed must be a whole number from 0 to 2147483647, got ${values.seed}`);
+        }
+        args.seed = seed;
+    }
+    if (values.config !== undefined) {
+        if (values.config === "")
+            throw new UsageError("--config needs a file");
+        args.configFile = values.config;
+    }
+    if (values["import-sarif"] !== undefined && values["import-sarif"].length > 0) {
+        if (values.plan)
+            throw new UsageError("--import-sarif is not used by --plan");
+        args.importSarif = values["import-sarif"];
+    }
     if (values.reviewers !== undefined) {
         const ids = values.reviewers
             .split(",")
@@ -90,13 +137,19 @@ function parse(argv) {
             format: { type: "string" },
             output: { type: "string" },
             "no-repo-config": { type: "boolean" },
+            config: { type: "string" },
             reviewers: { type: "string" },
             "max-cost-usd": { type: "string" },
+            "import-sarif": { type: "string", multiple: true },
             ultra: { type: "boolean" },
+            temperature: { type: "string" },
+            seed: { type: "string" },
             full: { type: "boolean" },
             plan: { type: "boolean" },
             pr: { type: "string" },
             repo: { type: "string" },
+            mr: { type: "string" },
+            project: { type: "string" },
             publish: { type: "boolean" },
             help: { type: "boolean", short: "h" },
         },
@@ -104,8 +157,6 @@ function parse(argv) {
 }
 function pullRequestTarget(values) {
     if (values.pr === undefined) {
-        if (values.publish)
-            throw new UsageError("--publish requires --pr");
         if (values.repo !== undefined)
             throw new UsageError("--repo requires --pr");
         return undefined;
@@ -125,6 +176,29 @@ function pullRequestTarget(values) {
         target.repo = values.repo;
     return target;
 }
+// A GitLab project is a numeric id or a full path, "group/sub/project".
+const PROJECT = /^(\d+|[\w.-]+(\/[\w.-]+)+)$/;
+function mergeRequestTarget(values) {
+    if (values.mr === undefined) {
+        if (values.project !== undefined)
+            throw new UsageError("--project requires --mr");
+        return undefined;
+    }
+    if (values.from !== undefined || values.to !== undefined || values.commit !== undefined) {
+        throw new UsageError("--mr cannot be combined with --from, --to or --commit");
+    }
+    const iid = Number(values.mr);
+    if (!Number.isInteger(iid) || iid <= 0) {
+        throw new UsageError(`--mr must be a merge request number, got ${values.mr}`);
+    }
+    if (values.project !== undefined && !PROJECT.test(values.project)) {
+        throw new UsageError(`--project must be a project id or group/project, got ${values.project}`);
+    }
+    const target = { iid, publish: values.publish === true };
+    if (values.project !== undefined)
+        target.project = values.project;
+    return target;
+}
 function target(values) {
     if (values.commit !== undefined) {
         if (values.from !== undefined || values.to !== undefined) {

package/dist/review/command.d.ts

@@ -1,6 +1,7 @@
 import { type OcraPlugin } from "@open-cr-agent/core";
 import type { ReviewArgs } from "./args.js";
 import { type Output } from "./progress.js";
+import type { RuntimeLoaders } from "./runtimes.js";
 export declare const SESSIONS_DIR = ".ocra/sessions";
 export declare const EXIT: {
     readonly ok: 0;
@@ -14,6 +15,7 @@ export interface ReviewDeps {
     cwd: string;
     env: Readonly<Record<string, string | undefined>>;
     builtinPlugins: readonly OcraPlugin[];
+    runtimes: RuntimeLoaders;
     writeFile(path: string, content: string): Promise<void>;
     now(): number;
     heartbeatMs: number;

package/dist/review/command.js

@@ -1,20 +1,26 @@
 import { join, relative, resolve } from "node:path";
-import { agentsMdReviewerPlugin, correctnessReviewerPlugin, coverageGaps, defaultSelectionPolicy, docsReviewerPlugin, newSessionId, performanceReviewerPlugin, previewReview, runReview, securityReviewerPlugin, sessionJsonlPlugin, startPlugins, toPlanOutput, } from "@open-cr-agent/core";
-import { opencodeRuntimePlugin } from "@open-cr-agent/runtime-opencode";
+import { agentsMdReviewerPlugin, correctnessReviewerPlugin, coverageGaps, docsReviewerPlugin, performanceReviewerPlugin, review, securityReviewerPlugin, sessionJsonlPlugin, startPlugins, } from "@open-cr-agent/core";
+import { defaultSelectionPolicy, newRunId, previewReview, toPlanOutput, } from "@open-cr-agent/core/internal";
 import { githubPlugin } from "@open-cr-agent/vcs-github";
-import { findRepositoryRoot, localGitPlugin } from "@open-cr-agent/vcs-local";
+import { gitlabPlugin } from "@open-cr-agent/vcs-gitlab";
+import { localGitPlugin } from "@open-cr-agent/vcs-local";
+import { findRepositoryRoot } from "@open-cr-agent/vcs-local/internal";
+import { VERSION } from "../version.js";
 import { ConfigError } from "./config.js";
 import { renderPlan } from "./plan-render.js";
 import { ProgressPrinter } from "./progress.js";
+import { configHash, requestedSampling } from "./provenance.js";
 import { renderJson, renderText, safeJson } from "./render.js";
-import { localTarget, pullRequestTarget } from "./target.js";
+import { renderSarif } from "./sarif.js";
+import { loadSarifLogs } from "./sarif-input.js";
+import { localTarget, mergeRequestTarget, pullRequestTarget } from "./target.js";
 import { forTerminal } from "./terminal.js";
 export const SESSIONS_DIR = ".ocra/sessions";
 export const EXIT = { ok: 0, blocking: 1, error: 2, incomplete: 3, interrupted: 130 };
 export const BUILTIN_PLUGINS = [
     localGitPlugin,
     githubPlugin,
-    opencodeRuntimePlugin,
+    gitlabPlugin,
     correctnessReviewerPlugin,
     securityReviewerPlugin,
     performanceReviewerPlugin,
@@ -25,15 +31,21 @@ export const BUILTIN_PLUGINS = [
 export async function reviewCommand(args, io, deps) {
     const root = await findRepositoryRoot(deps.cwd);
     const warn = (message) => io.err.write(`[ocra] Warning: ${forTerminal(message)}\n`);
+    const ignoreRepoConfig = args.ignoreRepoConfig === true;
+    const configFile = args.configFile ? resolve(deps.cwd, args.configFile) : undefined;
+    const localArgs = configFile ? { ...args, configFile } : args;
     const target = args.pullRequest
-        ? await pullRequestTarget(args.pullRequest, deps.cwd, root, deps.env, warn, deps.fetch, args.ignoreRepoConfig === true)
-        : await localTarget(args, deps.cwd, root, deps.env, warn, deps.fetch);
+        ? await pullRequestTarget(args.pullRequest, deps.cwd, root, deps.env, warn, deps.fetch, ignoreRepoConfig, configFile)
+        : args.mergeRequest
+            ? await mergeRequestTarget(args.mergeRequest, deps.cwd, root, deps.env, warn, deps.fetch, ignoreRepoConfig, configFile)
+            : await localTarget(localArgs, deps.cwd, root, deps.env, warn, deps.fetch);
     const { config } = target;
-    const session = { dir: join(root, SESSIONS_DIR), id: newSessionId() };
-    // A plan calls no model and writes no session log.
+    const session = { dir: join(root, SESSIONS_DIR), id: newRunId() };
+    // A plan calls no model, writes no session log and imports no runtime: it
+    // works without the optional runtime-opencode.
     const builtins = args.plan
         ? deps.builtinPlugins.filter((p) => p.name !== sessionJsonlPlugin.name)
-        : deps.builtinPlugins;
+        : [...deps.builtinPlugins, ...(await builtinRuntime(deps.runtimes, config.runtime))];
     const registry = await startPlugins([...builtins, ...target.plugins], {
         settings: args.plan
             ? config.pluginSettings
@@ -61,7 +73,14 @@ export async function reviewCommand(args, io, deps) {
             await deps.writeFile(resolve(deps.cwd, args.output), rendered);
         return EXIT.ok;
     }
-    const runtime = registry.createRuntime(config.runtime, { models: config.models, env: deps.env });
+    const sarif = await loadSarifLogs(args.importSarif ?? [], deps.cwd);
+    const sampling = requestedSampling(config, args);
+    const runtime = registry.createRuntime(config.runtime, {
+        models: config.models,
+        env: deps.env,
+        providers: config.providers,
+        ...(Object.keys(sampling).length > 0 ? { sampling } : {}),
+    });
     const progress = new ProgressPrinter(io.err, { heartbeatMs: deps.heartbeatMs, now: deps.now });
     const interrupt = new AbortController();
     const stopListening = deps.onInterrupt?.(() => {
@@ -70,13 +89,16 @@ export async function reviewCommand(args, io, deps) {
     });
     let report;
     try {
-        report = await runReview({
+        report = await review({
+            runId: session.id,
             signal: interrupt.signal,
             ...runOptions(config),
             reviewerOverrides: overrides,
+            provenance: { ocraVersion: VERSION, configHash: configHash(config, args), sampling },
             ...(args.maxCostUsd !== undefined ? { maxCostUsd: args.maxCostUsd } : {}),
             ...(args.ultra ? { ultra: true } : {}),
             ...(args.full ? { fullReview: true } : {}),
+            ...(sarif.length > 0 ? { sarif } : {}),
             ...(target.readTrusted ? { readTrusted: target.readTrusted } : {}),
             vcs,
             runtime,
@@ -94,7 +116,11 @@ export async function reviewCommand(args, io, deps) {
         await runtime.dispose?.();
     }
     const sessionDir = relative(deps.cwd, join(session.dir, session.id)) || ".";
-    const rendered = args.format === "json" ? renderJson(report) : renderText(report, sessionDir);
+    const rendered = args.format === "json"
+        ? renderJson(report)
+        : args.format === "sarif"
+            ? renderSarif(report, VERSION)
+            : renderText(report, sessionDir);
     if (args.output === undefined) {
         io.out.write(rendered);
     }
@@ -118,10 +144,15 @@ export async function reviewCommand(args, io, deps) {
         finally {
             stopHolding?.();
         }
-        io.err.write("[ocra] Published the review to the pull request\n");
+        io.err.write(`[ocra] Published the review to the ${target.publishesTo ?? "change request"}\n`);
     }
     return exitCode(report, io.err);
 }
+// A runtime not built in comes from a plugin of the configuration.
+async function builtinRuntime(runtimes, name) {
+    const load = Object.hasOwn(runtimes, name) ? runtimes[name] : undefined;
+    return load ? [await load()] : [];
+}
 function runOptions(config) {
     const options = {
         selection: { ...defaultSelectionPolicy, include: config.include, exclude: config.exclude },
@@ -165,7 +196,7 @@ function exitCode(report, err) {
     // Incomplete comes first, even over a blocking verdict: the action lets
     // exit 1 pass unless fail-on-concerns is set, and a review that missed
     // files or could not check a critical finding must never pass.
-    const { notReviewed } = coverageGaps(report.coverage);
+    const { notReviewed } = coverageGaps(report);
     if (notReviewed > 0) {
         err.write(`[ocra] ${notReviewed} selected file(s) were not reviewed; the review is incomplete.\n`);
         return EXIT.incomplete;