@open-cr-agent/core 0.4.0 → 0.6.0

package/dist/runtime/tools.d.ts

@@ -1,21 +1,5 @@
-import { z } from "zod";
 import type { ToolDefinition } from "../plugin/types.js";
-export declare const MAX_READ_LINES = 400;
-export declare const MAX_SEARCH_RESULTS = 50;
 export declare const MAX_LINE_CHARS = 2000;
 export declare const MAX_RESULT_CHARS = 50000;
-export declare const reportFindingInput: z.ZodObject<{
-    file: z.ZodString;
-    existingCode: z.ZodString;
-    severity: z.ZodEnum<{
-        critical: "critical";
-        suggestion: "suggestion";
-        warning: "warning";
-    }>;
-    title: z.ZodString;
-    body: z.ZodString;
-    suggestion: z.ZodOptional<z.ZodString>;
-    evidence: z.ZodOptional<z.ZodArray<z.ZodString>>;
-}, z.core.$strip>;
 export declare const reviewTools: readonly ToolDefinition[];
 //# sourceMappingURL=tools.d.ts.map

package/dist/runtime/tools.js

@@ -2,8 +2,8 @@ import { z } from "zod";
 import { severitySchema } from "../domain.js";
 import { data as promptData } from "../review/prompt-text.js";
 import { REVIEW_TOOLS } from "../review/tools.js";
-export const MAX_READ_LINES = 400;
-export const MAX_SEARCH_RESULTS = 50;
+const MAX_READ_LINES = 400;
+const MAX_SEARCH_RESULTS = 50;
 // Lines and results are also capped in characters: one line of a minified
 // bundle or a JSON fixture can be megabytes, and every step resends it.
 export const MAX_LINE_CHARS = 2_000;
@@ -23,7 +23,7 @@ function fitting(lines) {
     }
     return kept;
 }
-export const reportFindingInput = z.object({
+const reportFindingInput = z.object({
     file: z.string().min(1).describe("Path of a file in <ocra_review_files>"),
     existingCode: z
         .string()

package/dist/sarif/candidates.d.ts

@@ -1,6 +1,6 @@
 import type { LineRange, Severity } from "../domain.js";
 import type { SarifRun } from "./schema.js";
-export interface SarifTool {
+interface SarifTool {
     name: string;
     slug: string;
     version?: string;
@@ -24,4 +24,5 @@ export interface SarifCandidates {
     };
 }
 export declare function sarifCandidates(run: SarifRun): SarifCandidates;
+export {};
 //# sourceMappingURL=candidates.d.ts.map

package/dist/sarif/schema.d.ts

@@ -37,7 +37,7 @@ declare const result: z.ZodObject<{
         }, z.core.$loose>>;
     }, z.core.$loose>>>;
 }, z.core.$loose>;
-export declare const sarifRunSchema: z.ZodObject<{
+declare const sarifRunSchema: z.ZodObject<{
     tool: z.ZodObject<{
         driver: z.ZodObject<{
             name: z.ZodString;
@@ -83,7 +83,7 @@ export declare const sarifRunSchema: z.ZodObject<{
         }, z.core.$loose>>>;
     }, z.core.$loose>>>;
 }, z.core.$loose>;
-export declare const sarifLogSchema: z.ZodObject<{
+declare const sarifLogSchema: z.ZodObject<{
     version: z.ZodLiteral<"2.1.0">;
     runs: z.ZodArray<z.ZodObject<{
         tool: z.ZodObject<{

package/dist/sarif/schema.js

@@ -1,5 +1,5 @@
 import { z } from "zod";
-import { OcraError } from "../errors.js";
+import { errorMessage, OcraError } from "../errors.js";
 // The part of SARIF 2.1.0 an import reads. Objects are loose: a log carries
 // far more than this, and none of it is trusted beyond what is checked here.
 // https://docs.oasis-open.org/sarif/sarif/v2.1.0/sarif-v2.1.0.html
@@ -34,7 +34,7 @@ const result = z.looseObject({
     message,
     locations: z.array(location).optional(),
 });
-export const sarifRunSchema = z.looseObject({
+const sarifRunSchema = z.looseObject({
     tool: z.looseObject({
         driver: z.looseObject({
             name: z.string().min(1),
@@ -45,7 +45,7 @@ export const sarifRunSchema = z.looseObject({
     }),
     results: z.array(result).optional(),
 });
-export const sarifLogSchema = z.looseObject({
+const sarifLogSchema = z.looseObject({
     version: z.literal("2.1.0"),
     runs: z.array(sarifRunSchema),
 });
@@ -61,7 +61,7 @@ export function parseSarifLog(text) {
         data = JSON.parse(text);
     }
     catch (error) {
-        throw new SarifError(`not valid JSON: ${error.message}`);
+        throw new SarifError(`not valid JSON: ${errorMessage(error)}`);
     }
     const parsed = sarifLogSchema.safeParse(data);
     if (!parsed.success)

package/dist/session/jsonl.d.ts

@@ -1,9 +1,9 @@
-import type { ReviewEvent } from "../pipeline/report.js";
+import type { ReviewEvent } from "../report/report.js";
 export declare const EVENTS_FILE = "events.jsonl";
 export declare const REPORT_FILE = "report.json";
 export declare class JsonlSessionWriter {
-    readonly id: string;
     readonly dir: string;
+    readonly id: string;
     constructor(sessionsDir: string, id?: string);
     write(event: ReviewEvent): void;
 }

package/dist/session/jsonl.js

@@ -1,15 +1,16 @@
 import { appendFileSync, closeSync, constants, lstatSync, mkdirSync, openSync, writeFileSync, writeSync, } from "node:fs";
 import { dirname, join } from "node:path";
-import { OcraError } from "../errors.js";
-import { serializeOutput, toReportOutput } from "../pipeline/output.js";
+import { isNotFound, OcraError } from "../errors.js";
 import { newRunId } from "../pipeline/run-id.js";
+import { toReportOutput } from "../report/output.js";
+import { serializeOutput } from "../report/serialize.js";
 export const EVENTS_FILE = "events.jsonl";
 export const REPORT_FILE = "report.json";
 // Events are appended synchronously, one JSON object per line, so the log
 // stays valid and ordered even if the process dies mid-run.
 export class JsonlSessionWriter {
-    id;
     dir;
+    id;
     constructor(sessionsDir, id = newRunId()) {
         this.id = id;
         // The sessions directory lives in the reviewed tree, which may carry
@@ -44,7 +45,7 @@ function refuseSymlink(path) {
         }
     }
     catch (error) {
-        if (error.code !== "ENOENT")
+        if (!isNotFound(error))
             throw error;
     }
 }

package/dist/triage.d.ts

@@ -1,11 +1,11 @@
 import type { FileDiff, RiskTier } from "./domain.js";
-export interface TriagePolicy {
+interface TriagePolicy {
     trivialMaxLines: number;
     liteMaxLines: number;
     maxFilesBeforeFull: number;
     sensitivePathPatterns: RegExp[];
     sensitivePathWords: ReadonlySet<string>;
 }
-export declare const defaultTriagePolicy: TriagePolicy;
 export declare function triage(diffs: readonly FileDiff[], policy?: TriagePolicy): RiskTier;
+export {};
 //# sourceMappingURL=triage.d.ts.map

package/dist/triage.js

@@ -1,4 +1,4 @@
-export const defaultTriagePolicy = {
+const defaultTriagePolicy = {
     trivialMaxLines: 10,
     liteMaxLines: 100,
     maxFilesBeforeFull: 20,

package/dist/vcs.d.ts

@@ -0,0 +1,15 @@
+import type { CodeMatch } from "./contracts.js";
+import type { ChangeRequest, FileDiff, PriorReview } from "./domain.js";
+import type { ReviewReport } from "./report/report.js";
+export interface VcsAdapter {
+    readonly name: string;
+    getChangeRequest(): Promise<ChangeRequest>;
+    getDiff(): Promise<FileDiff[]>;
+    readFile(path: string): Promise<string | undefined>;
+    searchCode(literal: string): Promise<CodeMatch[]>;
+    getPriorReview(): Promise<PriorReview | undefined>;
+    publish(report: ReviewReport): Promise<{
+        warnings: string[];
+    }>;
+}
+//# sourceMappingURL=vcs.d.ts.map

package/dist/vcs.js

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=vcs.js.map

package/dist/verify/prompt.d.ts

@@ -1,11 +1,5 @@
 import { z } from "zod";
 import type { Finding } from "../domain.js";
-export declare const verificationVerdictSchema: z.ZodEnum<{
-    confirmed: "confirmed";
-    refuted: "refuted";
-    uncertain: "uncertain";
-}>;
-export type VerificationVerdict = z.infer<typeof verificationVerdictSchema>;
 export declare const verificationResponseSchema: z.ZodArray<z.ZodObject<{
     index: z.ZodNumber;
     verdict: z.ZodEnum<{

package/dist/verify/prompt.js

@@ -1,6 +1,6 @@
 import { z } from "zod";
 import { data, join, labelled, oneLine, section } from "../review/prompt-text.js";
-export const verificationVerdictSchema = z.enum(["confirmed", "refuted", "uncertain"]);
+const verificationVerdictSchema = z.enum(["confirmed", "refuted", "uncertain"]);
 export const verificationResponseSchema = z.array(z.object({
     index: z.number().int(),
     verdict: verificationVerdictSchema,

package/dist/verify/verify.d.ts

@@ -1,7 +1,7 @@
-import type { AgentRuntime, Effort, ReviewContext, Usage } from "../contracts.js";
+import type { SpendTracker } from "../agent/budget.js";
+import { type AgentCallSettings } from "../agent/settings.js";
+import type { AgentRuntime, ReviewContext, Usage } from "../contracts.js";
 import type { FileDiff, Finding } from "../domain.js";
-import type { SpendTracker } from "../pipeline/budget.js";
-export declare const VERIFY_TIMEOUT_MS = 120000;
 export interface RefutedFinding {
     fingerprint: string;
     file: string;
@@ -23,7 +23,7 @@ export interface VerifyOptions {
     signal: AbortSignal;
     concurrency: number;
     budget?: Pick<SpendTracker, "exhausted" | "add">;
-    effort?: Effort | undefined;
+    call?: AgentCallSettings | undefined;
 }
 export declare function verifyFindings(findings: readonly Finding[], options: VerifyOptions): Promise<VerificationResult>;
 export declare function markUnchecked(findings: readonly Finding[]): Finding[];

package/dist/verify/verify.js

@@ -1,9 +1,9 @@
+import { parseJsonAnswer } from "../agent/json.js";
+import { mapWithConcurrency } from "../agent/pool.js";
+import { agentCall } from "../agent/settings.js";
 import { errorMessage, OcraError, usageSpent } from "../errors.js";
-import { agentCall } from "../pipeline/agents.js";
-import { parseJsonAnswer } from "../pipeline/helpers.js";
-import { mapWithConcurrency } from "../pipeline/pool.js";
 import { buildVerificationPrompt, fileExcerpt, verificationResponseSchema } from "./prompt.js";
-export const VERIFY_TIMEOUT_MS = 120_000;
+const VERIFY_TIMEOUT_MS = 120_000;
 // Precision without losing recall to doubt: a finding is dropped only when
 // the verifier says the code shown proves it wrong. Any failure keeps it.
 export async function verifyFindings(findings, options) {
@@ -41,7 +41,7 @@ export async function verifyFindings(findings, options) {
             const prompt = buildVerificationPrompt(file, group, patch, content === undefined ? undefined : fileExcerpt(content, group));
             const answer = await complete({
                 tier: "standard",
-                ...agentCall("verifier", options.effort),
+                ...agentCall("verifier", options.call),
                 system: prompt.system,
                 user: prompt.user,
                 timeoutMs: VERIFY_TIMEOUT_MS,

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@open-cr-agent/core",
-  "version": "0.4.0",
+  "version": "0.6.0",
   "description": "Domain types, review pipeline stages and plugin contracts for Open-CR-Agent",
   "keywords": [
     "code-review",

package/dist/pipeline/agents.js

@@ -1,55 +0,0 @@
-export const EFFORT_LEVELS = [
-    "none",
-    "minimal",
-    "low",
-    "medium",
-    "high",
-];
-export const AGENT_ROLES = ["verifier", "judge", "helper"];
-export const ROLE_TIERS = {
-    verifier: "standard",
-    judge: "top",
-    helper: "light",
-};
-// A reviewer's effort covers every call made on its behalf: its review
-// tasks and its plan call.
-export function reviewerEffort(reviewer, settings) {
-    return settings.reviewerOverrides?.[reviewer.id]?.effort ?? settings.effort?.[reviewer.modelTier];
-}
-export function roleEffort(role, settings) {
-    return settings.roles?.[role]?.effort ?? settings.effort?.[ROLE_TIERS[role]];
-}
-// The enabled reviewers and the roles, each with its tier and effort.
-export function resolveAgents(reviewers, settings) {
-    const agent = (id, tier, effort) => effort === undefined ? { id, tier } : { id, tier, effort };
-    return [
-        ...reviewers
-            .filter((r) => settings.reviewerOverrides?.[r.id]?.enabled !== false)
-            .map((r) => agent(r.id, r.modelTier, reviewerEffort(r, settings))),
-        ...AGENT_ROLES.map((role) => agent(role, ROLE_TIERS[role], roleEffort(role, settings))),
-    ];
-}
-// The request fields that name an agent and its effort.
-export function agentCall(agent, effort) {
-    return effort === undefined ? { agent } : { agent, effort };
-}
-// Said once per run, so a configured effort that never reached a model is
-// not mistaken for one that did.
-export function effortWarnings(agents, runtime) {
-    const asked = agents.filter((a) => a.effort !== undefined);
-    if (asked.length === 0)
-        return [];
-    const { appliedTo } = runtime;
-    if (!appliedTo) {
-        return [
-            `the ${runtime.name} runtime does not apply reasoning effort yet; the effort configured for ${asked.map((a) => a.id).join(", ")} was not sent`,
-        ];
-    }
-    const refused = asked.filter((a) => appliedTo.call(runtime, a.id)?.effort === false);
-    return refused.length === 0
-        ? []
-        : [
-            `the endpoint refused the reasoning effort for ${refused.map((a) => a.id).join(", ")}; those calls were sent again without it`,
-        ];
-}
-//# sourceMappingURL=agents.js.map

package/dist/pipeline/helpers.d.ts

@@ -1,6 +0,0 @@
-import type { FileGrouper } from "../bundle/grouping.js";
-import type { AgentRuntime, Effort, Usage } from "../contracts.js";
-export declare const HELPER_TIMEOUT_MS = 60000;
-export declare function runtimeGrouper(runtime: AgentRuntime, signal: AbortSignal, onUsage: (usage: Usage) => void, effort?: Effort): FileGrouper | undefined;
-export declare function parseJsonAnswer(text: string): unknown;
-//# sourceMappingURL=helpers.d.ts.map

package/dist/pipeline/output.d.ts

@@ -1,77 +0,0 @@
-import type { Usage } from "../contracts.js";
-import type { ChangeRequest, RiskTier, Severity, Verdict, Verification } from "../domain.js";
-import type { JudgeDecisions } from "../judge/judge.js";
-import type { MemoryEntry } from "../memory/memory.js";
-import type { RefutedFinding } from "../verify/verify.js";
-import type { SkippedCell } from "./matrix.js";
-import type { ReviewPreview } from "./preview.js";
-import type { RunProvenance } from "./provenance.js";
-import type { AnchoringSummary, CoverageEntry, ReviewReport, TaskOutcome } from "./report.js";
-export declare const REPORT_VERSION = 1;
-export interface OutputFinding {
-    fingerprint: string;
-    reviewer: string;
-    category: string;
-    severity: Severity;
-    verification: Verification;
-    file: string;
-    lines?: {
-        start: number;
-        end: number;
-    };
-    inDiff: boolean;
-    status: "new" | "unfixed";
-    title: string;
-    body: string;
-    suggestion?: string;
-    evidence: string[];
-    code: string;
-    lowConfidence?: true;
-    provenance?: {
-        task: string;
-        model?: string;
-    };
-}
-export interface OutputPriorFinding {
-    fingerprint: string;
-    title: string;
-    file: string;
-    severity: Severity;
-    verification: Verification;
-}
-export interface ReportOutput {
-    version: typeof REPORT_VERSION;
-    runId?: string;
-    changeRequest: ChangeRequest;
-    tier: RiskTier;
-    verdict: Verdict;
-    summary: string;
-    scope?: ReviewReport["scope"];
-    coverage: CoverageEntry[];
-    findings: OutputFinding[];
-    unverifiedCriticals: number;
-    refuted: RefutedFinding[];
-    remembered: MemoryEntry[];
-    judgement?: JudgeDecisions;
-    rereview?: Record<"fixed" | "notReproduced" | "notRechecked" | "unchanged" | "dismissed", OutputPriorFinding[]>;
-    tasks: TaskOutcome[];
-    skipped: SkippedCell[];
-    bundles: {
-        label: string;
-        files: string[];
-    }[];
-    anchoring?: AnchoringSummary;
-    spendLimit?: ReviewReport["spendLimit"];
-    provenance?: RunProvenance;
-    usage: Usage;
-    warnings: string[];
-}
-export declare function toReportOutput(report: ReviewReport): ReportOutput;
-export declare const PLAN_VERSION = 1;
-export type PlanOutput = {
-    version: typeof PLAN_VERSION;
-} & ReviewPreview;
-export declare function toPlanOutput(preview: ReviewPreview): PlanOutput;
-export declare function isUnsafeCodePoint(code: number): boolean;
-export declare function serializeOutput(value: unknown, indent?: number): string;
-//# sourceMappingURL=output.d.ts.map

package/dist/pipeline/output.js

@@ -1,132 +0,0 @@
-// The published shape of a review: `--format json` and a session's
-// report.json. It is a contract with scripts and CI, so it carries a version
-// and only what a reader can rely on; internal fields (per-run ids, how each
-// finding was anchored, code signatures, platform state) stay out, though the
-// anchoring counts of the whole run are in. Change it
-// only by adding optional fields, or by a new version.
-export const REPORT_VERSION = 1;
-export function toReportOutput(report) {
-    const output = {
-        version: REPORT_VERSION,
-        runId: report.runId,
-        changeRequest: report.changeRequest,
-        tier: report.tier,
-        verdict: report.verdict,
-        summary: report.summary,
-        coverage: report.coverage,
-        findings: report.findings.map(outputFinding),
-        unverifiedCriticals: report.unverifiedCriticals,
-        refuted: report.refuted,
-        remembered: report.remembered,
-        tasks: report.tasks,
-        skipped: report.skipped,
-        bundles: report.bundles,
-        usage: report.usage,
-        warnings: report.warnings,
-    };
-    if (report.scope)
-        output.scope = report.scope;
-    if (report.judgement)
-        output.judgement = report.judgement;
-    if (report.anchoring)
-        output.anchoring = report.anchoring;
-    if (report.spendLimit)
-        output.spendLimit = report.spendLimit;
-    if (report.provenance)
-        output.provenance = report.provenance;
-    if (report.rereview) {
-        const r = report.rereview;
-        output.rereview = {
-            fixed: r.fixed.map(outputPrior),
-            notReproduced: r.notReproduced.map(outputPrior),
-            notRechecked: r.notRechecked.map(outputPrior),
-            unchanged: r.unchanged.map(outputPrior),
-            dismissed: r.dismissed.map(outputPrior),
-        };
-    }
-    return output;
-}
-function outputFinding(f) {
-    const output = {
-        fingerprint: f.fingerprint,
-        reviewer: f.reviewer,
-        category: f.category,
-        severity: f.severity,
-        verification: f.verification ?? "unchecked",
-        file: f.file,
-        inDiff: f.anchor.inDiff,
-        status: f.status === "unfixed" ? "unfixed" : "new",
-        title: f.title,
-        body: f.body,
-        evidence: f.evidence,
-        code: f.existingCode,
-    };
-    if (f.lineRange)
-        output.lines = { start: f.lineRange.start, end: f.lineRange.end };
-    if (f.suggestion !== undefined)
-        output.suggestion = f.suggestion;
-    if (f.lowConfidence)
-        output.lowConfidence = true;
-    output.provenance =
-        f.provenance.model === undefined
-            ? { task: f.provenance.task }
-            : { task: f.provenance.task, model: f.provenance.model };
-    return output;
-}
-function outputPrior(f) {
-    return {
-        fingerprint: f.fingerprint,
-        title: f.title,
-        file: f.file,
-        severity: f.severity,
-        verification: f.verification ?? "unchecked",
-    };
-}
-// The published shape of `ocra review --plan --format json`, versioned like
-// the report. The preview is already free of internal fields; the version
-// makes the contract explicit.
-export const PLAN_VERSION = 1;
-export function toPlanOutput(preview) {
-    return {
-        version: PLAN_VERSION,
-        changeRequest: preview.changeRequest,
-        tier: preview.tier,
-        selected: preview.selected,
-        excluded: preview.excluded,
-        bundles: preview.bundles,
-        groupingSkipped: preview.groupingSkipped,
-        tasks: preview.tasks,
-        skipped: preview.skipped,
-        promptTokens: preview.promptTokens,
-        // Added in version 1 without a bump: a new field older readers ignore.
-        planCalls: preview.planCalls,
-        warnings: preview.warnings,
-    };
-}
-// Characters a terminal or an editor acts on: C0 controls but tab and
-// newline, DEL and C1 controls (ANSI and OSC escapes), line and paragraph
-// separators, and bidirectional marks and overrides ("Trojan Source"). One
-// definition for every output: terminal text replaces them, JSON escapes them.
-export function isUnsafeCodePoint(code) {
-    return ((code <= 0x1f && code !== 0x09 && code !== 0x0a) ||
-        (code >= 0x7f && code <= 0x9f) ||
-        code === 0x061c ||
-        code === 0x200e ||
-        code === 0x200f ||
-        code === 0x2028 ||
-        code === 0x2029 ||
-        (code >= 0x202a && code <= 0x202e) ||
-        (code >= 0x2066 && code <= 0x2069));
-}
-// JSON for files and stdout. JSON.stringify escapes C0 controls but not the
-// rest; model and pull request text reaches these files.
-export function serializeOutput(value, indent = 2) {
-    let out = "";
-    for (const char of JSON.stringify(value, null, indent)) {
-        const code = char.codePointAt(0) ?? 0;
-        out +=
-            code > 0x1f && isUnsafeCodePoint(code) ? `\\u${code.toString(16).padStart(4, "0")}` : char;
-    }
-    return out;
-}
-//# sourceMappingURL=output.js.map