@open-cr-agent/core 0.1.0

package/dist/contracts.d.ts

@@ -0,0 +1,77 @@
+import type { ChangeRequest, FileDiff, PriorReview } from "./domain.js";
+import type { ReviewReport } from "./pipeline/report.js";
+export interface CodeMatch {
+    path: string;
+    line: number;
+    text: string;
+}
+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[];
+    }>;
+}
+export type ModelTier = "top" | "standard" | "light";
+export interface AgentTaskSpec {
+    taskId: string;
+    reviewer: string;
+    modelTier: ModelTier;
+    systemPrompt: string;
+    userPrompt: string;
+    context: ReviewContext;
+    timeoutMs: number;
+}
+export interface ReviewContext {
+    readFile(path: string): Promise<string | undefined>;
+    readDiff(path: string): string | undefined;
+    searchCode(literal: string): Promise<CodeMatch[]>;
+}
+export type AgentEvent = {
+    type: "progress";
+    taskId: string;
+    message: string;
+} | {
+    type: "finding";
+    taskId: string;
+    finding: unknown;
+} | ({
+    type: "usage";
+    taskId: string;
+} & Usage) | {
+    type: "done";
+    taskId: string;
+} | {
+    type: "error";
+    taskId: string;
+    error: string;
+    retryable: boolean;
+};
+export interface Usage {
+    inputTokens: number;
+    outputTokens: number;
+    reasoningTokens: number;
+    cachedTokens: number;
+    costUsd: number;
+}
+export interface CompletionRequest {
+    tier: ModelTier;
+    system: string;
+    user: string;
+    timeoutMs: number;
+}
+export interface CompletionResult {
+    text: string;
+    usage: Usage;
+}
+export interface AgentRuntime {
+    readonly name: string;
+    runTask(spec: AgentTaskSpec, signal: AbortSignal): AsyncIterable<AgentEvent>;
+    complete?(request: CompletionRequest, signal: AbortSignal): Promise<CompletionResult>;
+    dispose?(): Promise<void>;
+}
+//# sourceMappingURL=contracts.d.ts.map

package/dist/contracts.js

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

package/dist/diff/hunks.d.ts

@@ -0,0 +1,3 @@
+import type { Hunk } from "../domain.js";
+export declare function parseHunks(lines: readonly string[]): Hunk[];
+//# sourceMappingURL=hunks.d.ts.map

package/dist/diff/hunks.js

@@ -0,0 +1,64 @@
+const HUNK_HEADER = /^@@ -(\d+)(?:,(\d+))? \+(\d+)(?:,(\d+))? @@/;
+export function parseHunks(lines) {
+    const hunks = [];
+    let i = 0;
+    while (i < lines.length) {
+        const header = lines[i];
+        const match = HUNK_HEADER.exec(header);
+        i += 1;
+        if (!match)
+            continue;
+        const hunk = {
+            header,
+            oldStart: Number(match[1]),
+            oldLines: match[2] === undefined ? 1 : Number(match[2]),
+            newStart: Number(match[3]),
+            newLines: match[4] === undefined ? 1 : Number(match[4]),
+            lines: [],
+        };
+        i = readHunkBody(lines, i, hunk);
+        hunks.push(hunk);
+    }
+    return hunks;
+}
+// The body is consumed by the counts in the header rather than by prefixes,
+// because a removed line such as "-- comment" would otherwise look like "--- ".
+function readHunkBody(lines, start, hunk) {
+    let oldRemaining = hunk.oldLines;
+    let newRemaining = hunk.newLines;
+    let oldLine = hunk.oldStart;
+    let newLine = hunk.newStart;
+    let i = start;
+    while (i < lines.length && (oldRemaining > 0 || newRemaining > 0)) {
+        const raw = lines[i];
+        if (raw.startsWith("\\")) {
+            i += 1;
+            continue;
+        }
+        const marker = raw[0] ?? " ";
+        const content = raw.slice(1);
+        let line;
+        if (marker === "+" && newRemaining > 0) {
+            line = { kind: "add", content, newLine: newLine++ };
+            newRemaining -= 1;
+        }
+        else if (marker === "-" && oldRemaining > 0) {
+            line = { kind: "delete", content, oldLine: oldLine++ };
+            oldRemaining -= 1;
+        }
+        else if (marker === " " && oldRemaining > 0 && newRemaining > 0) {
+            line = { kind: "context", content, oldLine: oldLine++, newLine: newLine++ };
+            oldRemaining -= 1;
+            newRemaining -= 1;
+        }
+        else {
+            break;
+        }
+        hunk.lines.push(line);
+        i += 1;
+    }
+    while (lines[i]?.startsWith("\\"))
+        i += 1;
+    return i;
+}
+//# sourceMappingURL=hunks.js.map

package/dist/diff/index.d.ts

@@ -0,0 +1,3 @@
+export { parseHunks } from "./hunks.js";
+export { parseUnifiedDiff } from "./parse.js";
+//# sourceMappingURL=index.d.ts.map

package/dist/diff/index.js

@@ -0,0 +1,3 @@
+export { parseHunks } from "./hunks.js";
+export { parseUnifiedDiff } from "./parse.js";
+//# sourceMappingURL=index.js.map

package/dist/diff/parse.d.ts

@@ -0,0 +1,3 @@
+import type { FileDiff } from "../domain.js";
+export declare function parseUnifiedDiff(text: string): FileDiff[];
+//# sourceMappingURL=parse.d.ts.map

package/dist/diff/parse.js

@@ -0,0 +1,116 @@
+import { parseHunks } from "./hunks.js";
+import { readQuotedToken } from "./quoted-path.js";
+const FILE_HEADER = "diff --git ";
+export function parseUnifiedDiff(text) {
+    const lines = splitLines(text);
+    const sections = [];
+    for (const line of lines) {
+        if (line.startsWith(FILE_HEADER))
+            sections.push([line]);
+        else
+            sections.at(-1)?.push(line);
+    }
+    return sections.map(parseFileSection);
+}
+// Trailing CRs are dropped so a diff saved with CRLF endings parses like any
+// other; reviewers compare normalized text, so CRLF content loses nothing.
+function splitLines(text) {
+    const lines = text.split("\n").map((l) => (l.endsWith("\r") ? l.slice(0, -1) : l));
+    if (lines.at(-1) === "")
+        lines.pop();
+    return lines;
+}
+function parseFileSection(lines) {
+    const header = parseHeaderPaths(lines[0].slice(FILE_HEADER.length));
+    let oldPath = header?.oldPath ?? "";
+    let newPath = header?.newPath ?? "";
+    let kind = "modified";
+    let isBinary = false;
+    let i = 1;
+    for (; i < lines.length && !lines[i].startsWith("@@"); i += 1) {
+        const line = lines[i];
+        if (line.startsWith("new file mode"))
+            kind = "added";
+        else if (line.startsWith("deleted file mode"))
+            kind = "deleted";
+        else if (line.startsWith("rename from ")) {
+            oldPath = unquote(line.slice("rename from ".length));
+            kind = "renamed";
+        }
+        else if (line.startsWith("rename to "))
+            newPath = unquote(line.slice("rename to ".length));
+        else if (line.startsWith("copy from ")) {
+            oldPath = unquote(line.slice("copy from ".length));
+            kind = "added";
+        }
+        else if (line.startsWith("copy to "))
+            newPath = unquote(line.slice("copy to ".length));
+        else if (line.startsWith("Binary files ") || line === "GIT binary patch")
+            isBinary = true;
+        else if (line.startsWith("--- "))
+            oldPath = parseMarkerPath(line.slice(4)) ?? oldPath;
+        else if (line.startsWith("+++ "))
+            newPath = parseMarkerPath(line.slice(4)) ?? newPath;
+    }
+    const hunks = parseHunks(lines.slice(i));
+    let additions = 0;
+    let deletions = 0;
+    for (const line of hunks.flatMap((h) => h.lines)) {
+        if (line.kind === "add")
+            additions += 1;
+        else if (line.kind === "delete")
+            deletions += 1;
+    }
+    return {
+        oldPath,
+        newPath,
+        kind,
+        isBinary,
+        additions,
+        deletions,
+        hunks,
+        patch: lines.join("\n"),
+    };
+}
+function parseHeaderPaths(rest) {
+    const quotedOld = readQuotedToken(rest, 0);
+    if (quotedOld) {
+        const newRaw = rest.slice(quotedOld.end + 1);
+        return { oldPath: stripPrefix(quotedOld.value), newPath: stripPrefix(unquote(newRaw)) };
+    }
+    const quotedNewAt = rest.indexOf(' "');
+    if (quotedNewAt >= 0) {
+        return {
+            oldPath: stripPrefix(rest.slice(0, quotedNewAt)),
+            newPath: stripPrefix(unquote(rest.slice(quotedNewAt + 1))),
+        };
+    }
+    // Unquoted paths may contain spaces, so "a/x b/x" is split at its midpoint
+    // when both halves name the same file, which is the only unambiguous case.
+    const mid = (rest.length - 1) / 2;
+    if (Number.isInteger(mid) && rest[mid] === " ") {
+        const oldPath = stripPrefix(rest.slice(0, mid));
+        const newPath = stripPrefix(rest.slice(mid + 1));
+        if (oldPath === newPath)
+            return { oldPath, newPath };
+    }
+    const split = rest.indexOf(" b/");
+    if (split < 0)
+        return undefined;
+    return {
+        oldPath: stripPrefix(rest.slice(0, split)),
+        newPath: stripPrefix(rest.slice(split + 1)),
+    };
+}
+function parseMarkerPath(rest) {
+    const quoted = readQuotedToken(rest, 0);
+    const path = quoted ? quoted.value : rest.split("\t")[0];
+    return path === "/dev/null" ? undefined : stripPrefix(path);
+}
+function unquote(raw) {
+    return readQuotedToken(raw, 0)?.value ?? raw;
+}
+function stripPrefix(path) {
+    return path.startsWith("a/") || path.startsWith("b/") ? path.slice(2) : path;
+}
+//# sourceMappingURL=parse.js.map

package/dist/diff/quoted-path.d.ts

@@ -0,0 +1,6 @@
+export interface QuotedToken {
+    value: string;
+    end: number;
+}
+export declare function readQuotedToken(text: string, start: number): QuotedToken | undefined;
+//# sourceMappingURL=quoted-path.d.ts.map

package/dist/diff/quoted-path.js

@@ -0,0 +1,46 @@
+const SIMPLE_ESCAPES = {
+    a: 0x07,
+    b: 0x08,
+    t: 0x09,
+    n: 0x0a,
+    v: 0x0b,
+    f: 0x0c,
+    r: 0x0d,
+    '"': 0x22,
+    "\\": 0x5c,
+};
+// Git C-quotes paths with special characters and encodes non-ASCII bytes as
+// octal escapes, so the escapes must be decoded as UTF-8 bytes, not code points.
+export function readQuotedToken(text, start) {
+    if (text[start] !== '"')
+        return undefined;
+    const encoder = new TextEncoder();
+    const bytes = [];
+    let i = start + 1;
+    while (i < text.length) {
+        const ch = text[i];
+        if (ch === '"') {
+            return { value: new TextDecoder().decode(new Uint8Array(bytes)), end: i + 1 };
+        }
+        if (ch !== "\\") {
+            bytes.push(...encoder.encode(ch));
+            i += 1;
+            continue;
+        }
+        const next = text[i + 1] ?? "";
+        const octal = /^[0-7]{3}/.exec(text.slice(i + 1, i + 4));
+        if (octal) {
+            bytes.push(Number.parseInt(octal[0], 8));
+            i += 4;
+        }
+        else if (next in SIMPLE_ESCAPES) {
+            bytes.push(SIMPLE_ESCAPES[next]);
+            i += 2;
+        }
+        else {
+            return undefined;
+        }
+    }
+    return undefined;
+}
+//# sourceMappingURL=quoted-path.js.map

package/dist/domain.d.ts

@@ -0,0 +1,126 @@
+import { z } from "zod";
+export declare const severitySchema: z.ZodEnum<{
+    critical: "critical";
+    suggestion: "suggestion";
+    warning: "warning";
+}>;
+export type Severity = z.infer<typeof severitySchema>;
+export declare const findingStatusSchema: z.ZodEnum<{
+    new: "new";
+    unfixed: "unfixed";
+}>;
+export type FindingStatus = z.infer<typeof findingStatusSchema>;
+export declare const lineRangeSchema: z.ZodObject<{
+    start: z.ZodNumber;
+    end: z.ZodNumber;
+}, z.core.$strip>;
+export type LineRange = z.infer<typeof lineRangeSchema>;
+export declare const reportedFindingSchema: z.ZodObject<{
+    category: z.ZodString;
+    severity: z.ZodEnum<{
+        critical: "critical";
+        suggestion: "suggestion";
+        warning: "warning";
+    }>;
+    file: z.ZodString;
+    existingCode: z.ZodString;
+    title: z.ZodString;
+    body: z.ZodString;
+    suggestion: z.ZodOptional<z.ZodString>;
+    evidence: z.ZodDefault<z.ZodArray<z.ZodString>>;
+}, z.core.$strip>;
+export type ReportedFinding = z.infer<typeof reportedFindingSchema>;
+export type AnchorMethod = "hunk" | "file" | "cross_file" | "relocated" | "file_level";
+export interface QuoteSignature {
+    lines: number;
+    hash: string;
+}
+export declare const verificationSchema: z.ZodEnum<{
+    confirmed: "confirmed";
+    uncertain: "uncertain";
+    unchecked: "unchecked";
+}>;
+export type Verification = z.infer<typeof verificationSchema>;
+export interface Finding extends ReportedFinding {
+    id: string;
+    fingerprint: string;
+    reviewer: string;
+    lineRange?: LineRange;
+    anchor: {
+        method: AnchorMethod;
+        inDiff: boolean;
+        ambiguous?: true;
+    };
+    status: FindingStatus;
+    lowConfidence?: boolean;
+    quote?: QuoteSignature;
+    verification?: Verification;
+    replies?: string[];
+}
+export type FileChangeKind = "added" | "modified" | "deleted" | "renamed";
+export type DiffLine = {
+    kind: "context";
+    content: string;
+    oldLine: number;
+    newLine: number;
+} | {
+    kind: "add";
+    content: string;
+    newLine: number;
+} | {
+    kind: "delete";
+    content: string;
+    oldLine: number;
+};
+export interface Hunk {
+    header: string;
+    oldStart: number;
+    oldLines: number;
+    newStart: number;
+    newLines: number;
+    lines: DiffLine[];
+}
+export interface FileDiff {
+    oldPath: string;
+    newPath: string;
+    kind: FileChangeKind;
+    isBinary: boolean;
+    additions: number;
+    deletions: number;
+    hunks: Hunk[];
+    patch: string;
+}
+export interface ChangeRequest {
+    id: string;
+    title: string;
+    description: string;
+    baseSha: string;
+    headSha: string;
+    override?: {
+        by: string;
+        reason: string;
+    };
+}
+export type RiskTier = "trivial" | "lite" | "full";
+export type Verdict = "approved" | "approved_with_comments" | "minor_issues" | "significant_concerns";
+export interface PriorFinding {
+    fingerprint: string;
+    title: string;
+    file: string;
+    severity: Severity;
+    commented: boolean;
+    dismissed?: boolean;
+    quote?: QuoteSignature;
+    verification?: Verification;
+}
+export interface PriorReview {
+    findings: PriorFinding[];
+    changedSince?: {
+        head: string;
+        files: string[];
+    };
+    fullReviewReason?: string;
+    tier?: RiskTier;
+    replies?: Readonly<Record<string, readonly string[]>>;
+}
+//# sourceMappingURL=domain.d.ts.map

package/dist/domain.js

@@ -0,0 +1,23 @@
+import { z } from "zod";
+export const severitySchema = z.enum(["critical", "warning", "suggestion"]);
+// A finding in a report is new or reported before; fixed and dismissed
+// earlier findings are listed separately (report.rereview).
+export const findingStatusSchema = z.enum(["new", "unfixed"]);
+export const lineRangeSchema = z.object({
+    start: z.number().int().positive(),
+    end: z.number().int().positive(),
+});
+export const reportedFindingSchema = z.object({
+    category: z.string().min(1),
+    severity: severitySchema,
+    file: z.string().min(1),
+    existingCode: z.string().min(1),
+    title: z.string().min(1),
+    body: z.string().min(1),
+    suggestion: z.string().optional(),
+    evidence: z.array(z.string()).default([]),
+});
+// What Verify concluded about a finding it kept. "unchecked" covers a skipped
+// or failed verification. Refuted findings are dropped, so have no value here.
+export const verificationSchema = z.enum(["confirmed", "uncertain", "unchecked"]);
+//# sourceMappingURL=domain.js.map

package/dist/errors.d.ts

@@ -0,0 +1,8 @@
+import type { Usage } from "./contracts.js";
+export declare class CompletionError extends Error {
+    readonly usage: Usage;
+    constructor(message: string, usage: Usage);
+}
+export declare function usageSpent(error: unknown): Usage | undefined;
+export declare function errorMessage(error: unknown): string;
+//# sourceMappingURL=errors.d.ts.map

package/dist/errors.js

@@ -0,0 +1,16 @@
+// A helper completion that failed on every model has still spent tokens on
+// the attempts; callers record them so reports and spend limits stay true.
+export class CompletionError extends Error {
+    usage;
+    constructor(message, usage) {
+        super(message);
+        this.usage = usage;
+    }
+}
+export function usageSpent(error) {
+    return error instanceof CompletionError ? error.usage : undefined;
+}
+export function errorMessage(error) {
+    return error instanceof Error ? error.message : String(error);
+}
+//# sourceMappingURL=errors.js.map

package/dist/index.d.ts

@@ -0,0 +1,18 @@
+export * from "./anchor/index.js";
+export * from "./bundle/index.js";
+export * from "./contracts.js";
+export * from "./diff/index.js";
+export * from "./domain.js";
+export * from "./errors.js";
+export * from "./judge/index.js";
+export * from "./memory/index.js";
+export * from "./pipeline/index.js";
+export * from "./plugin/index.js";
+export * from "./rereview/index.js";
+export * from "./review/index.js";
+export * from "./rules/index.js";
+export * from "./select/index.js";
+export * from "./session/index.js";
+export * from "./triage.js";
+export * from "./verify/index.js";
+//# sourceMappingURL=index.d.ts.map

package/dist/index.js

@@ -0,0 +1,18 @@
+export * from "./anchor/index.js";
+export * from "./bundle/index.js";
+export * from "./contracts.js";
+export * from "./diff/index.js";
+export * from "./domain.js";
+export * from "./errors.js";
+export * from "./judge/index.js";
+export * from "./memory/index.js";
+export * from "./pipeline/index.js";
+export * from "./plugin/index.js";
+export * from "./rereview/index.js";
+export * from "./review/index.js";
+export * from "./rules/index.js";
+export * from "./select/index.js";
+export * from "./session/index.js";
+export * from "./triage.js";
+export * from "./verify/index.js";
+//# sourceMappingURL=index.js.map

package/dist/judge/index.d.ts

@@ -0,0 +1,4 @@
+export * from "./judge.js";
+export * from "./prompt.js";
+export * from "./verdict.js";
+//# sourceMappingURL=index.d.ts.map

package/dist/judge/index.js

@@ -0,0 +1,4 @@
+export * from "./judge.js";
+export * from "./prompt.js";
+export * from "./verdict.js";
+//# sourceMappingURL=index.js.map

package/dist/judge/judge.d.ts

@@ -0,0 +1,46 @@
+import type { AgentRuntime, Usage } from "../contracts.js";
+import type { ChangeRequest, Finding, PriorFinding, RiskTier, Severity, Verdict } from "../domain.js";
+import { type JudgeResponse } from "./prompt.js";
+export declare const JUDGE_TIMEOUT_MS = 180000;
+export interface JudgeDecisions {
+    merged: {
+        kept: string;
+        merged: string[];
+    }[];
+    dropped: {
+        fingerprint: string;
+        file: string;
+        title: string;
+        reason: string;
+    }[];
+    recalibrated: {
+        fingerprint: string;
+        from: Severity;
+        to: Severity;
+        reason: string;
+    }[];
+}
+export interface JudgeResult {
+    findings: Finding[];
+    verdict: Verdict;
+    summary: string;
+    decisions?: JudgeDecisions;
+    usage: Usage[];
+    warnings: string[];
+}
+export interface JudgeOptions {
+    runtime: AgentRuntime;
+    changeRequest: ChangeRequest;
+    tier: RiskTier;
+    signal: AbortSignal;
+    enabled: boolean;
+    keepDropped?: boolean;
+    carried?: readonly PriorFinding[];
+}
+export declare function judgeFindings(findings: readonly Finding[], options: JudgeOptions): Promise<JudgeResult>;
+export declare function applyDecisions(findings: readonly Finding[], response: JudgeResponse): {
+    findings: Finding[];
+    decisions: JudgeDecisions;
+    warnings: string[];
+};
+//# sourceMappingURL=judge.d.ts.map