@open-cr-agent/core 0.4.0 → 0.6.0

package/dist/pipeline/plan-output.js

@@ -0,0 +1,109 @@
+import { z } from "zod";
+import { EFFORT_LEVELS } from "../agent/settings.js";
+import { riskTierSchema } from "../domain.js";
+import { changeRequestSchema, skippedCellSchema } from "../report/output-schema.js";
+import { exclusionReasonSchema } from "../select/select.js";
+// The published shape of `ocra review --plan --format json` without what
+// the CLI adds (where each setting came from), versioned like the report: a
+// version only gains optional fields. The type is derived from the schema,
+// and the CLI publishes the JSON Schema of the whole output.
+export const PLAN_VERSION = 1;
+const inputCostSchema = z.discriminatedUnion("status", [
+    z.strictObject({ model: z.string(), status: z.literal("priced"), usd: z.number() }),
+    z.strictObject({ model: z.string(), status: z.literal("unpriced") }),
+    z.strictObject({ model: z.string(), status: z.literal("unknown") }),
+]);
+const planTaskSchema = z.strictObject({
+    taskId: z.string(),
+    reviewer: z.string(),
+    bundle: z.string(),
+    files: z.array(z.string()),
+    promptTokens: z.int().nonnegative(),
+    effort: z.enum(EFFORT_LEVELS).exactOptional(),
+    models: z.array(z.string()).exactOptional(),
+    planPromptTokens: z.int().nonnegative().exactOptional(),
+    inputCost: inputCostSchema.exactOptional(),
+});
+export const planOutputSchema = z.strictObject({
+    version: z.literal(PLAN_VERSION),
+    changeRequest: changeRequestSchema,
+    tier: riskTierSchema,
+    selected: z.array(z.string()),
+    excluded: z.array(z.strictObject({ path: z.string(), reason: exclusionReasonSchema })),
+    bundles: z.array(z.strictObject({ label: z.string(), files: z.array(z.string()) })),
+    groupingSkipped: z.boolean(),
+    tasks: z.array(planTaskSchema),
+    skipped: z.array(skippedCellSchema),
+    promptTokens: z.int().nonnegative(),
+    // Added in version 1 without a bump: a new field older readers ignore.
+    planCalls: z.int().nonnegative(),
+    // Added in version 1 without a bump, like planCalls.
+    inputCost: z
+        .strictObject({
+        usd: z.number(),
+        priced: z.int().nonnegative(),
+        unpriced: z.int().nonnegative(),
+        unknown: z.int().nonnegative(),
+    })
+        .exactOptional(),
+    warnings: z.array(z.string()),
+});
+export function toPlanOutput(preview) {
+    const { changeRequest: c, inputCost } = preview;
+    return {
+        version: PLAN_VERSION,
+        changeRequest: {
+            id: c.id,
+            title: c.title,
+            description: c.description,
+            baseSha: c.baseSha,
+            headSha: c.headSha,
+            ...(c.override ? { override: { by: c.override.by, reason: c.override.reason } } : {}),
+        },
+        tier: preview.tier,
+        selected: [...preview.selected],
+        excluded: preview.excluded.map((e) => ({ path: e.path, reason: e.reason })),
+        bundles: preview.bundles.map((b) => ({ label: b.label, files: [...b.files] })),
+        groupingSkipped: preview.groupingSkipped,
+        tasks: preview.tasks.map(planTask),
+        skipped: preview.skipped.map((s) => ({
+            reviewer: s.reviewer,
+            bundle: s.bundle,
+            reason: s.reason,
+        })),
+        promptTokens: preview.promptTokens,
+        planCalls: preview.planCalls,
+        ...(inputCost
+            ? {
+                inputCost: {
+                    usd: inputCost.usd,
+                    priced: inputCost.priced,
+                    unpriced: inputCost.unpriced,
+                    unknown: inputCost.unknown,
+                },
+            }
+            : {}),
+        warnings: [...preview.warnings],
+    };
+}
+function planTask(t) {
+    const cost = t.inputCost;
+    return {
+        taskId: t.taskId,
+        reviewer: t.reviewer,
+        bundle: t.bundle,
+        files: [...t.files],
+        promptTokens: t.promptTokens,
+        ...(t.effort === undefined ? {} : { effort: t.effort }),
+        ...(t.models ? { models: [...t.models] } : {}),
+        ...(t.planPromptTokens === undefined ? {} : { planPromptTokens: t.planPromptTokens }),
+        ...(cost
+            ? {
+                inputCost: cost.status === "priced"
+                    ? { model: cost.model, status: cost.status, usd: cost.usd }
+                    : { model: cost.model, status: cost.status },
+            }
+            : {}),
+    };
+}
+//# sourceMappingURL=plan-output.js.map

package/dist/pipeline/plan.d.ts

@@ -1,12 +1,11 @@
 import { type Bundle } from "../bundle/bundle.js";
 import type { AgentRuntime, ReviewContext, Usage } from "../contracts.js";
 import type { ChangeRequest, FileDiff, RiskTier } from "../domain.js";
-import { type MemoryEntry } from "../memory/memory.js";
-import { type RepoRule } from "../rules/repo-rules.js";
+import { type RememberedEntry } from "../memory/memory.js";
+import type { ReviewEvent } from "../report/report.js";
+import { type SourcedRule } from "../rules/repo-rules.js";
 import { type FileDecision } from "../select/select.js";
-import type { ReviewEvent } from "./report.js";
-import type { ReviewHooks, ReviewOptions } from "./run.js";
-export declare const GUIDELINES_PATH = "AGENTS.md";
+import type { ReviewHooks, ReviewOptions } from "./options.js";
 export interface ReviewPlan {
     changeRequest: ChangeRequest;
     decisions: FileDecision[];
@@ -20,12 +19,12 @@ export interface ReviewPlan {
     };
     context: ReviewContext;
     guidelines: string | undefined;
-    repoRules: RepoRule[];
-    memory: MemoryEntry[];
+    repoRules: SourcedRule[];
+    memory: RememberedEntry[];
     usage: Usage[];
     warnings: string[];
 }
-export type PlanOptions = Pick<ReviewOptions & ReviewHooks, "vcs" | "rules" | "readTrusted" | "selection" | "bundling" | "grouper" | "effort" | "roles"> & {
+export type PlanOptions = Pick<ReviewOptions & ReviewHooks, "vcs" | "rules" | "readTrusted" | "accountMemory" | "selection" | "bundling" | "grouper" | "effort" | "roles"> & {
     runId?: string;
     runtime?: AgentRuntime;
     reviewOnly?: ReadonlySet<string>;

package/dist/pipeline/plan.js

@@ -1,21 +1,21 @@
+import { roleCall } from "../agent/settings.js";
 import { bundleFiles, defaultBundlePolicy } from "../bundle/bundle.js";
-import { MEMORY_PATH, parseMemory } from "../memory/memory.js";
-import { parseRepoRules, REPO_RULES_PATH } from "../rules/repo-rules.js";
+import { runtimeGrouper } from "../bundle/runtime-grouper.js";
+import { MEMORY_PATH, mergeMemory, parseMemory } from "../memory/memory.js";
+import { parseRepoRules, REPO_RULES_PATH, } from "../rules/repo-rules.js";
 import { defaultSelectionPolicy, selectFiles } from "../select/select.js";
 import { triage } from "../triage.js";
-import { roleEffort } from "./agents.js";
 import { reviewContext } from "./context.js";
-import { runtimeGrouper } from "./helpers.js";
 import { rank } from "./matrix.js";
 import { newRunId } from "./run-id.js";
-export const GUIDELINES_PATH = "AGENTS.md";
+const GUIDELINES_PATH = "AGENTS.md";
 export async function planReview(options, emit, signal) {
     const { vcs } = options;
     const readTrusted = options.readTrusted ?? ((path) => vcs.readFile(path));
     const changeRequest = await vcs.getChangeRequest();
     emit({ type: "run_started", runId: options.runId ?? newRunId(), changeRequest });
     const diffs = await vcs.getDiff();
-    const decisions = selectFiles(diffs, options.selection ?? defaultSelectionPolicy);
+    const decisions = selectFiles(diffs, { ...defaultSelectionPolicy, ...options.selection });
     const selected = decisions.filter((d) => d.selected).map((d) => d.diff);
     const tier = triage(selected);
     emit({
@@ -32,7 +32,7 @@ export async function planReview(options, emit, signal) {
     const usage = [];
     const grouper = options.grouper ??
         (options.runtime
-            ? runtimeGrouper(options.runtime, signal, (u) => usage.push(u), roleEffort("helper", options))
+            ? runtimeGrouper(options.runtime, signal, (u) => usage.push(u), roleCall("helper", options))
             : undefined);
     const widened = options.reviewOnly && options.priorTier && rank(tier) > rank(options.priorTier)
         ? { from: options.priorTier, to: tier }
@@ -59,8 +59,11 @@ export async function planReview(options, emit, signal) {
         ...(widened ? { widened } : {}),
         context: reviewContext(vcs, diffs),
         guidelines,
-        repoRules: [...(options.rules ?? []), ...fileRules],
-        memory: memoryText === undefined ? [] : parseMemory(memoryText),
+        repoRules: [
+            ...(options.rules ?? []),
+            ...fileRules.map((rule) => ({ ...rule, source: "repository" })),
+        ],
+        memory: mergeMemory(memoryText === undefined ? [] : parseMemory(memoryText), options.accountMemory ?? []),
         usage,
         warnings: bundled.warnings,
     };

package/dist/pipeline/preview.d.ts

@@ -1,8 +1,8 @@
 import type { Effort } from "../contracts.js";
 import type { ChangeRequest, RiskTier } from "../domain.js";
-import type { ReviewerDefinition } from "../review/reviewer.js";
 import type { FileDecision } from "../select/select.js";
-import { type ReviewerOverrides, type SkippedCell } from "./matrix.js";
+import { type SkippedCell } from "./matrix.js";
+import type { ReviewOptions } from "./options.js";
 import { type PlanOptions } from "./plan.js";
 export interface PreviewTask {
     taskId: string;
@@ -12,7 +12,20 @@ export interface PreviewTask {
     promptTokens: number;
     planPromptTokens?: number;
     effort?: Effort;
+    models?: string[];
+    inputCost?: InputCost;
 }
+type InputCost = {
+    model: string;
+    status: "priced";
+    usd: number;
+} | {
+    model: string;
+    status: "unpriced";
+} | {
+    model: string;
+    status: "unknown";
+};
 export interface ReviewPreview {
     changeRequest: ChangeRequest;
     tier: RiskTier;
@@ -32,13 +45,17 @@ export interface ReviewPreview {
     skipped: SkippedCell[];
     promptTokens: number;
     planCalls: number;
+    inputCost?: {
+        usd: number;
+        priced: number;
+        unpriced: number;
+        unknown: number;
+    };
     warnings: string[];
 }
-export type PreviewOptions = Omit<PlanOptions, "runtime"> & {
-    reviewers?: readonly ReviewerDefinition[];
-    reviewerOverrides?: ReviewerOverrides;
-    ultra?: boolean;
-    maxTasks?: number;
+export type PreviewOptions = Omit<PlanOptions, "runtime"> & Omit<ReviewOptions, "vcs" | "runtime"> & {
+    inputPrice?: (model: string) => number | undefined;
 };
 export declare function previewReview(options: PreviewOptions): Promise<ReviewPreview>;
+export {};
 //# sourceMappingURL=preview.d.ts.map

package/dist/pipeline/preview.js

@@ -1,9 +1,9 @@
+import { reviewerCall } from "../agent/settings.js";
 import { defaultBundlePolicy } from "../bundle/bundle.js";
 import { memoryFor } from "../memory/memory.js";
 import { buildReviewPrompt } from "../review/prompt.js";
 import { correctnessReviewer } from "../review/reviewers/correctness.js";
 import { resolveRules } from "../rules/resolve.js";
-import { reviewerEffort } from "./agents.js";
 import { isLargeBundle } from "./execute.js";
 import { planTasks } from "./matrix.js";
 import { planReview } from "./plan.js";
@@ -13,8 +13,8 @@ export async function previewReview(options) {
     const plan = await planReview(options, () => { }, new AbortController().signal);
     const reviewers = options.reviewers ?? [correctnessReviewer];
     const planned = planTasks(plan.bundles, reviewers, plan.tier, options.reviewerOverrides, {
-        ultra: options.ultra === true,
-        ...(options.maxTasks !== undefined ? { maxTasks: options.maxTasks } : {}),
+        ultra: options.mode?.ultra === true,
+        ...(options.limits?.maxTasks !== undefined ? { maxTasks: options.limits?.maxTasks } : {}),
         hasGuidelines: Boolean(plan.guidelines?.trim()),
     });
     const { cells } = planned;
@@ -38,14 +38,21 @@ export async function previewReview(options) {
             files,
             promptTokens: tokens(prompt),
         };
-        const effort = reviewerEffort(cell.reviewer, options);
-        if (effort !== undefined)
-            task.effort = effort;
+        const call = reviewerCall(cell.reviewer, options);
+        if (call.effort !== undefined)
+            task.effort = call.effort;
+        const models = call.models ?? options.models?.[cell.reviewer.modelTier];
+        if (models?.length)
+            task.models = [...models];
         const key = `${cell.reviewer.id}\0${cell.bundle.label}`;
-        if ((options.ultra || isLargeBundle(cell.bundle.files)) && !plannedBundles.has(key)) {
+        if ((options.mode?.ultra || isLargeBundle(cell.bundle.files)) && !plannedBundles.has(key)) {
             plannedBundles.add(key);
             task.planPromptTokens = tokens(buildReviewPrompt({ ...input, forPlanning: true }));
         }
+        const first = task.models?.[0];
+        if (first !== undefined && options.inputPrice) {
+            task.inputCost = inputCost(first, options.inputPrice(first), task.promptTokens + (task.planPromptTokens ?? 0));
+        }
         return task;
     });
     const policy = options.bundling ?? defaultBundlePolicy;
@@ -60,6 +67,7 @@ export async function previewReview(options) {
         skipped: planned.skipped,
         promptTokens: tasks.reduce((sum, t) => sum + t.promptTokens + (t.planPromptTokens ?? 0), 0),
         planCalls: tasks.filter((t) => t.planPromptTokens !== undefined).length,
+        ...(tasks.some((t) => t.inputCost) ? { inputCost: totalInputCost(tasks) } : {}),
         warnings: [
             ...plan.warnings,
             ...(planned.limited?.length
@@ -70,6 +78,22 @@ export async function previewReview(options) {
         ],
     };
 }
+function inputCost(model, price, promptTokens) {
+    if (price === undefined)
+        return { model, status: "unknown" };
+    if (price === 0)
+        return { model, status: "unpriced" };
+    return { model, status: "priced", usd: (promptTokens * price) / 1_000_000 };
+}
+function totalInputCost(tasks) {
+    const total = { usd: 0, priced: 0, unpriced: 0, unknown: 0 };
+    for (const { inputCost } of tasks) {
+        if (inputCost?.status === "priced")
+            total.usd += inputCost.usd;
+        total[inputCost?.status ?? "unknown"] += 1;
+    }
+    return total;
+}
 // Four characters per token: an estimate, not a tokenizer.
 function tokens(prompt) {
     return Math.ceil((prompt.system.length + prompt.user.length) / 4);

package/dist/pipeline/provenance.d.ts

@@ -1,24 +1,15 @@
-import type { AgentRuntime, AppliedSampling, Effort, ModelTier, Sampling } from "../contracts.js";
+import type { ResolvedAgent, ReviewerOverrides } from "../agent/settings.js";
+import type { AgentRuntime, AppliedSampling, Sampling } from "../contracts.js";
+import type { AgentProvenance, RunProvenance } from "../report/provenance.js";
 import type { ReviewerDefinition } from "../review/reviewer.js";
-import type { ResolvedAgent } from "./agents.js";
-import type { ReviewerOverrides } from "./matrix.js";
-export interface RunProvenance {
-    ocraVersion: string;
-    promptHash: string;
-    configHash: string;
-    sampling: AppliedSampling;
-    agents?: Record<string, AgentProvenance>;
-}
-export interface AgentProvenance {
-    tier: ModelTier;
-    effort?: Effort;
-    applied?: boolean;
-    notApplied?: (keyof Sampling)[];
-}
+import type { SourcedRule } from "../rules/repo-rules.js";
 export interface ProvenanceInput {
     ocraVersion: string;
     configHash: string;
     sampling?: Sampling;
+    accountSettings?: {
+        version: string | null;
+    };
 }
 export declare function stableHash(value: unknown): string;
 export declare function promptHash(reviewers: readonly ReviewerDefinition[], overrides?: ReviewerOverrides): string;
@@ -26,5 +17,5 @@ export declare function appliedSampling(runtime: {
     readonly sampling?: AppliedSampling;
 }, requested?: Sampling): AppliedSampling;
 export declare function agentProvenance(agents: readonly ResolvedAgent[], runtime: Pick<AgentRuntime, "appliedTo">): Record<string, AgentProvenance>;
-export declare function runProvenance(input: ProvenanceInput, runtime: Pick<AgentRuntime, "sampling" | "appliedTo">, reviewers: readonly ReviewerDefinition[], agents: readonly ResolvedAgent[], overrides?: ReviewerOverrides): RunProvenance;
+export declare function runProvenance(input: ProvenanceInput, runtime: Pick<AgentRuntime, "sampling" | "appliedTo">, reviewers: readonly ReviewerDefinition[], agents: readonly ResolvedAgent[], overrides?: ReviewerOverrides, rules?: readonly SourcedRule[]): RunProvenance;
 //# sourceMappingURL=provenance.d.ts.map

package/dist/pipeline/provenance.js

@@ -1,6 +1,6 @@
-import { createHash } from "node:crypto";
 import { RELOCATE_SYSTEM_PROMPT } from "../anchor/relocate.js";
 import { GROUPING_SYSTEM_PROMPT } from "../bundle/grouping.js";
+import { shortHash } from "../hash.js";
 import { JUDGE_SYSTEM_PROMPT } from "../judge/prompt.js";
 import { PLAN_SYSTEM_PROMPT } from "../review/plan-phase.js";
 import { buildReviewPrompt } from "../review/prompt.js";
@@ -8,7 +8,7 @@ import { VERIFY_SYSTEM_PROMPT } from "../verify/prompt.js";
 // A short digest of a JSON value, the same whatever order its keys were
 // written in.
 export function stableHash(value) {
-    return createHash("sha256").update(canonicalJson(value)).digest("hex").slice(0, 16);
+    return shortHash(canonicalJson(value));
 }
 function canonicalJson(value) {
     if (Array.isArray(value))
@@ -58,18 +58,19 @@ export function appliedSampling(runtime, requested = {}) {
 }
 // A runtime that cannot say what it applied applied no effort.
 export function agentProvenance(agents, runtime) {
-    const entries = agents.map(({ id, tier, effort }) => {
+    const entries = agents.map(({ id, tier, effort, models }) => {
+        const base = { tier, ...(models ? { models: [...models] } : {}) };
         if (effort === undefined)
-            return [id, { tier }];
+            return [id, base];
         if (!runtime.appliedTo)
-            return [id, { tier, effort, applied: false }];
+            return [id, { ...base, effort, applied: false }];
         const applied = runtime.appliedTo(id);
         if (!applied)
-            return [id, { tier, effort }];
+            return [id, { ...base, effort }];
         return [
             id,
             {
-                tier,
+                ...base,
                 effort,
                 applied: applied.effort,
                 ...(applied.notApplied?.length ? { notApplied: [...applied.notApplied] } : {}),
@@ -78,13 +79,24 @@ export function agentProvenance(agents, runtime) {
     });
     return Object.fromEntries(entries);
 }
-export function runProvenance(input, runtime, reviewers, agents, overrides) {
+export function runProvenance(input, runtime, reviewers, agents, overrides, rules = []) {
     return {
         ocraVersion: input.ocraVersion,
         promptHash: promptHash(reviewers, overrides),
         configHash: input.configHash,
         sampling: appliedSampling(runtime, input.sampling),
         agents: agentProvenance(agents, runtime),
+        ...(rules.length > 0 ? { rules: rules.map(ruleProvenance) } : {}),
+        ...(input.accountSettings
+            ? { accountSettings: { version: input.accountSettings.version } }
+            : {}),
+    };
+}
+function ruleProvenance({ path, rule, source }) {
+    return {
+        path: typeof path === "string" ? [path] : [...path],
+        rule,
+        ...(source ? { source } : {}),
     };
 }
 //# sourceMappingURL=provenance.js.map

package/dist/pipeline/run.d.ts

@@ -1,47 +1,5 @@
-import type { AnchorContext } from "../anchor/anchor.js";
-import type { BundlePolicy } from "../bundle/bundle.js";
-import type { FileGrouper } from "../bundle/grouping.js";
-import type { AgentRuntime, VcsAdapter } from "../contracts.js";
-import type { ReviewerDefinition } from "../review/reviewer.js";
-import type { RepoRule } from "../rules/repo-rules.js";
-import type { SarifLog } from "../sarif/schema.js";
-import type { SelectionPolicy } from "../select/select.js";
-import { type RoleSettings, type TierEfforts } from "./agents.js";
-import { type ReviewerOverrides } from "./matrix.js";
-import { type ProvenanceInput } from "./provenance.js";
-import { type ReviewEvent, type ReviewReport } from "./report.js";
-export { GUIDELINES_PATH } from "./plan.js";
-export interface ReviewOptions {
-    vcs: VcsAdapter;
-    runtime: AgentRuntime;
-    reviewers?: readonly ReviewerDefinition[];
-    reviewerOverrides?: ReviewerOverrides;
-    effort?: TierEfforts;
-    roles?: RoleSettings;
-    rules?: readonly RepoRule[];
-    readTrusted?: (path: string) => Promise<string | undefined>;
-    selection?: SelectionPolicy;
-    concurrency?: number;
-    taskTimeoutMs?: number;
-    runTimeoutMs?: number;
-    verify?: boolean;
-    judge?: boolean;
-    maxCostUsd?: number;
-    maxTasks?: number;
-    fullReview?: boolean;
-    ultra?: boolean;
-    sarif?: readonly SarifLog[];
-    runId?: string;
-    provenance?: ProvenanceInput;
-    signal?: AbortSignal;
-    onEvent?: (event: ReviewEvent) => void;
-}
-export interface ReviewHooks {
-    bundling?: BundlePolicy;
-    grouper?: FileGrouper;
-    relocate?: AnchorContext["relocate"] | false;
-    abortGraceMs?: number;
-}
+import type { ReviewReport } from "../report/report.js";
+import { type ReviewHooks, type ReviewOptions } from "./options.js";
 export declare function review(options: ReviewOptions): Promise<ReviewReport>;
 export declare function reviewWithHooks(options: ReviewOptions & ReviewHooks): Promise<ReviewReport>;
 //# sourceMappingURL=run.d.ts.map