@open-cr-agent/core 0.5.0 → 0.6.0

package/dist/{pipeline → report}/output-schema.d.ts

@@ -1,50 +1,37 @@
 import { z } from "zod";
-import { type ReportOutput } from "./output.js";
-export declare const outputFindingSchema: z.ZodObject<{
-    fingerprint: z.ZodString;
-    reviewer: z.ZodString;
-    category: z.ZodString;
-    severity: z.ZodEnum<{
-        critical: "critical";
-        suggestion: "suggestion";
-        warning: "warning";
-    }>;
-    verification: z.ZodEnum<{
-        confirmed: "confirmed";
-        uncertain: "uncertain";
-        unchecked: "unchecked";
-    }>;
-    file: z.ZodString;
-    lines: z.ZodOptional<z.ZodObject<{
-        start: z.ZodInt;
-        end: z.ZodInt;
-    }, z.core.$strict>>;
-    inDiff: z.ZodBoolean;
-    status: z.ZodEnum<{
-        new: "new";
-        unfixed: "unfixed";
-    }>;
+export declare const REPORT_VERSION = 1;
+export declare const changeRequestSchema: z.ZodObject<{
+    id: z.ZodString;
     title: z.ZodString;
-    body: z.ZodString;
-    suggestion: z.ZodOptional<z.ZodString>;
-    evidence: z.ZodArray<z.ZodString>;
-    code: z.ZodString;
-    lowConfidence: z.ZodOptional<z.ZodLiteral<true>>;
-    provenance: z.ZodOptional<z.ZodObject<{
-        task: z.ZodString;
-        model: z.ZodOptional<z.ZodString>;
+    description: z.ZodString;
+    baseSha: z.ZodString;
+    headSha: z.ZodString;
+    override: z.ZodExactOptional<z.ZodObject<{
+        by: z.ZodString;
+        reason: z.ZodString;
     }, z.core.$strict>>;
 }, z.core.$strict>;
+export declare const skippedCellSchema: z.ZodObject<{
+    reviewer: z.ZodString;
+    bundle: z.ZodString;
+    reason: z.ZodEnum<{
+        below_tier: "below_tier";
+        disabled: "disabled";
+        no_guidelines: "no_guidelines";
+        no_matching_files: "no_matching_files";
+        task_limit: "task_limit";
+    }>;
+}, z.core.$strict>;
 export declare const reportOutputSchema: z.ZodObject<{
     version: z.ZodLiteral<1>;
-    runId: z.ZodOptional<z.ZodString>;
+    runId: z.ZodExactOptional<z.ZodString>;
     changeRequest: z.ZodObject<{
         id: z.ZodString;
         title: z.ZodString;
         description: z.ZodString;
         baseSha: z.ZodString;
         headSha: z.ZodString;
-        override: z.ZodOptional<z.ZodObject<{
+        override: z.ZodExactOptional<z.ZodObject<{
             by: z.ZodString;
             reason: z.ZodString;
         }, z.core.$strict>>;
@@ -61,7 +48,7 @@ export declare const reportOutputSchema: z.ZodObject<{
         significant_concerns: "significant_concerns";
     }>;
     summary: z.ZodString;
-    scope: z.ZodOptional<z.ZodDiscriminatedUnion<[z.ZodObject<{
+    scope: z.ZodExactOptional<z.ZodDiscriminatedUnion<[z.ZodObject<{
         mode: z.ZodLiteral<"incremental">;
         since: z.ZodString;
     }, z.core.$strict>, z.ZodObject<{
@@ -104,7 +91,7 @@ export declare const reportOutputSchema: z.ZodObject<{
             unchecked: "unchecked";
         }>;
         file: z.ZodString;
-        lines: z.ZodOptional<z.ZodObject<{
+        lines: z.ZodExactOptional<z.ZodObject<{
             start: z.ZodInt;
             end: z.ZodInt;
         }, z.core.$strict>>;
@@ -115,13 +102,18 @@ export declare const reportOutputSchema: z.ZodObject<{
         }>;
         title: z.ZodString;
         body: z.ZodString;
-        suggestion: z.ZodOptional<z.ZodString>;
+        suggestion: z.ZodExactOptional<z.ZodString>;
+        fix: z.ZodExactOptional<z.ZodObject<{
+            startLine: z.ZodInt;
+            endLine: z.ZodInt;
+            replacement: z.ZodString;
+        }, z.core.$strict>>;
         evidence: z.ZodArray<z.ZodString>;
         code: z.ZodString;
-        lowConfidence: z.ZodOptional<z.ZodLiteral<true>>;
-        provenance: z.ZodOptional<z.ZodObject<{
+        lowConfidence: z.ZodExactOptional<z.ZodLiteral<true>>;
+        provenance: z.ZodExactOptional<z.ZodObject<{
             task: z.ZodString;
-            model: z.ZodOptional<z.ZodString>;
+            model: z.ZodExactOptional<z.ZodString>;
         }, z.core.$strict>>;
     }, z.core.$strict>>;
     unverifiedCriticals: z.ZodInt;
@@ -137,12 +129,12 @@ export declare const reportOutputSchema: z.ZodObject<{
         title: z.ZodString;
         reason: z.ZodString;
         added: z.ZodOptional<z.ZodString>;
-        source: z.ZodOptional<z.ZodEnum<{
+        source: z.ZodExactOptional<z.ZodEnum<{
             account: "account";
             repository: "repository";
         }>>;
     }, z.core.$strip>>;
-    judgement: z.ZodOptional<z.ZodObject<{
+    judgement: z.ZodExactOptional<z.ZodObject<{
         merged: z.ZodArray<z.ZodObject<{
             kept: z.ZodString;
             merged: z.ZodArray<z.ZodString>;
@@ -168,7 +160,7 @@ export declare const reportOutputSchema: z.ZodObject<{
             reason: z.ZodString;
         }, z.core.$strict>>;
     }, z.core.$strict>>;
-    rereview: z.ZodOptional<z.ZodObject<{
+    rereview: z.ZodExactOptional<z.ZodObject<{
         fixed: z.ZodArray<z.ZodObject<{
             fingerprint: z.ZodString;
             title: z.ZodString;
@@ -183,6 +175,7 @@ export declare const reportOutputSchema: z.ZodObject<{
                 uncertain: "uncertain";
                 unchecked: "unchecked";
             }>;
+            reviewer: z.ZodExactOptional<z.ZodString>;
         }, z.core.$strict>>;
         notReproduced: z.ZodArray<z.ZodObject<{
             fingerprint: z.ZodString;
@@ -198,6 +191,7 @@ export declare const reportOutputSchema: z.ZodObject<{
                 uncertain: "uncertain";
                 unchecked: "unchecked";
             }>;
+            reviewer: z.ZodExactOptional<z.ZodString>;
         }, z.core.$strict>>;
         notRechecked: z.ZodArray<z.ZodObject<{
             fingerprint: z.ZodString;
@@ -213,6 +207,7 @@ export declare const reportOutputSchema: z.ZodObject<{
                 uncertain: "uncertain";
                 unchecked: "unchecked";
             }>;
+            reviewer: z.ZodExactOptional<z.ZodString>;
         }, z.core.$strict>>;
         unchanged: z.ZodArray<z.ZodObject<{
             fingerprint: z.ZodString;
@@ -228,6 +223,7 @@ export declare const reportOutputSchema: z.ZodObject<{
                 uncertain: "uncertain";
                 unchecked: "unchecked";
             }>;
+            reviewer: z.ZodExactOptional<z.ZodString>;
         }, z.core.$strict>>;
         dismissed: z.ZodArray<z.ZodObject<{
             fingerprint: z.ZodString;
@@ -243,6 +239,7 @@ export declare const reportOutputSchema: z.ZodObject<{
                 uncertain: "uncertain";
                 unchecked: "unchecked";
             }>;
+            reviewer: z.ZodExactOptional<z.ZodString>;
         }, z.core.$strict>>;
     }, z.core.$strict>>;
     tasks: z.ZodArray<z.ZodObject<{
@@ -256,7 +253,7 @@ export declare const reportOutputSchema: z.ZodObject<{
             failed: "failed";
             timed_out: "timed_out";
         }>;
-        error: z.ZodOptional<z.ZodString>;
+        error: z.ZodExactOptional<z.ZodString>;
         findings: z.ZodInt;
         durationMs: z.ZodNumber;
         usage: z.ZodObject<{
@@ -282,7 +279,7 @@ export declare const reportOutputSchema: z.ZodObject<{
         label: z.ZodString;
         files: z.ZodArray<z.ZodString>;
     }, z.core.$strict>>;
-    anchoring: z.ZodOptional<z.ZodObject<{
+    anchoring: z.ZodExactOptional<z.ZodObject<{
         byMethod: z.ZodRecord<z.ZodEnum<{
             cross_file: "cross_file";
             file: "file";
@@ -293,56 +290,56 @@ export declare const reportOutputSchema: z.ZodObject<{
         ambiguous: z.ZodInt;
         relocationCalls: z.ZodInt;
     }, z.core.$strict>>;
-    spendLimit: z.ZodOptional<z.ZodObject<{
+    spendLimit: z.ZodExactOptional<z.ZodObject<{
         usd: z.ZodNumber;
-        reached: z.ZodOptional<z.ZodEnum<{
+        reached: z.ZodExactOptional<z.ZodEnum<{
             review: "review";
             total: "total";
         }>>;
     }, z.core.$strict>>;
-    provenance: z.ZodOptional<z.ZodObject<{
+    provenance: z.ZodExactOptional<z.ZodObject<{
         ocraVersion: z.ZodString;
         promptHash: z.ZodString;
         configHash: z.ZodString;
         sampling: z.ZodObject<{
-            temperature: z.ZodOptional<z.ZodNumber>;
-            seed: z.ZodOptional<z.ZodInt>;
-            notApplied: z.ZodOptional<z.ZodArray<z.ZodEnum<{
+            temperature: z.ZodExactOptional<z.ZodNumber>;
+            seed: z.ZodExactOptional<z.ZodInt>;
+            notApplied: z.ZodExactOptional<z.ZodArray<z.ZodEnum<{
                 seed: "seed";
                 temperature: "temperature";
             }>>>;
         }, z.core.$strict>;
-        agents: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodObject<{
+        agents: z.ZodExactOptional<z.ZodRecord<z.ZodString, z.ZodObject<{
             tier: z.ZodEnum<{
                 light: "light";
                 standard: "standard";
                 top: "top";
             }>;
-            models: z.ZodOptional<z.ZodArray<z.ZodString>>;
-            effort: z.ZodOptional<z.ZodEnum<{
+            models: z.ZodExactOptional<z.ZodArray<z.ZodString>>;
+            effort: z.ZodExactOptional<z.ZodEnum<{
                 high: "high";
                 low: "low";
                 medium: "medium";
                 minimal: "minimal";
                 none: "none";
             }>>;
-            applied: z.ZodOptional<z.ZodBoolean>;
-            notApplied: z.ZodOptional<z.ZodArray<z.ZodEnum<{
+            applied: z.ZodExactOptional<z.ZodBoolean>;
+            notApplied: z.ZodExactOptional<z.ZodArray<z.ZodEnum<{
                 seed: "seed";
                 temperature: "temperature";
             }>>>;
         }, z.core.$strict>>>;
-        rules: z.ZodOptional<z.ZodArray<z.ZodObject<{
+        rules: z.ZodExactOptional<z.ZodArray<z.ZodObject<{
             path: z.ZodArray<z.ZodString>;
             rule: z.ZodString;
-            source: z.ZodOptional<z.ZodEnum<{
+            source: z.ZodExactOptional<z.ZodEnum<{
                 account: "account";
                 plugin: "plugin";
                 repository: "repository";
                 shared: "shared";
             }>>;
         }, z.core.$strict>>>;
-        accountSettings: z.ZodOptional<z.ZodObject<{
+        accountSettings: z.ZodExactOptional<z.ZodObject<{
             version: z.ZodNullable<z.ZodString>;
         }, z.core.$strict>>;
     }, z.core.$strict>>;
@@ -355,9 +352,6 @@ export declare const reportOutputSchema: z.ZodObject<{
     }, z.core.$strict>;
     warnings: z.ZodArray<z.ZodString>;
 }, z.core.$strict>;
-type OutputFromSchema = z.output<typeof reportOutputSchema>;
-export declare function asSchemaOutput(output: ReportOutput): OutputFromSchema;
 export declare const REPORT_SCHEMA_ID = "https://ocra.majincheng.com/schema/report.v1.json";
 export declare function reportJsonSchema(): Record<string, unknown>;
-export {};
 //# sourceMappingURL=output-schema.d.ts.map

package/dist/{pipeline → report}/output-schema.js

@@ -1,15 +1,22 @@
 import { z } from "zod";
+import { EFFORT_LEVELS } from "../agent/settings.js";
+import { MODEL_TIERS } from "../contracts.js";
 import { anchorMethodSchema, riskTierSchema, severitySchema, verdictSchema, verificationSchema, } from "../domain.js";
 import { memoryEntrySchema } from "../memory/memory.js";
+import { skipReasonSchema } from "../pipeline/matrix.js";
 import { exclusionReasonSchema } from "../select/select.js";
-import { EFFORT_LEVELS } from "./agents.js";
-import { skipReasonSchema } from "./matrix.js";
-import { REPORT_VERSION } from "./output.js";
 import { taskStatusSchema } from "./report.js";
-// The JSON report as a schema: what `toReportOutput` writes, no more. Every
-// object is strict, so a field added to the output without a schema change
-// fails the tests, and the published JSON Schema (docs/schema/report.v1.json)
-// is generated from here, never written by hand.
+// 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;
+// The JSON report as a schema, the one definition of its shape: the
+// `ReportOutput` type is derived from it, and the published JSON Schema
+// (docs/schema/report.v1.json) is generated from it. Every object is strict,
+// so a field `toReportOutput` writes without a schema change fails the tests.
 const usageSchema = z.strictObject({
     inputTokens: z.number(),
     outputTokens: z.number(),
@@ -17,13 +24,13 @@ const usageSchema = z.strictObject({
     cachedTokens: z.number(),
     costUsd: z.number(),
 });
-const changeRequestSchema = z.strictObject({
+export const changeRequestSchema = z.strictObject({
     id: z.string(),
     title: z.string(),
     description: z.string(),
     baseSha: z.string(),
     headSha: z.string(),
-    override: z.strictObject({ by: z.string(), reason: z.string() }).optional(),
+    override: z.strictObject({ by: z.string(), reason: z.string() }).exactOptional(),
 });
 const coverageEntrySchema = z.discriminatedUnion("status", [
     z.strictObject({
@@ -37,23 +44,33 @@ const coverageEntrySchema = z.discriminatedUnion("status", [
     }),
 ]);
 const linesSchema = z.strictObject({ start: z.int().positive(), end: z.int().positive() });
-export const outputFindingSchema = z.strictObject({
+const fixSchema = z
+    .strictObject({
+    startLine: z.int().positive(),
+    endLine: z.int().positive(),
+    replacement: z.string(),
+})
+    .refine((f) => f.endLine >= f.startLine, { message: "endLine is before startLine" });
+const outputFindingSchema = z.strictObject({
     fingerprint: z.string(),
     reviewer: z.string(),
     category: z.string(),
     severity: severitySchema,
     verification: verificationSchema,
     file: z.string(),
-    lines: linesSchema.optional(),
+    lines: linesSchema.exactOptional(),
     inDiff: z.boolean(),
     status: z.enum(["new", "unfixed"]),
     title: z.string(),
     body: z.string(),
-    suggestion: z.string().optional(),
+    suggestion: z.string().exactOptional(),
+    fix: fixSchema.exactOptional(),
     evidence: z.array(z.string()),
     code: z.string(),
-    lowConfidence: z.literal(true).optional(),
-    provenance: z.strictObject({ task: z.string(), model: z.string().optional() }).optional(),
+    lowConfidence: z.literal(true).exactOptional(),
+    provenance: z
+        .strictObject({ task: z.string(), model: z.string().exactOptional() })
+        .exactOptional(),
 });
 const outputPriorFindingSchema = z.strictObject({
     fingerprint: z.string(),
@@ -61,6 +78,7 @@ const outputPriorFindingSchema = z.strictObject({
     file: z.string(),
     severity: severitySchema,
     verification: verificationSchema,
+    reviewer: z.string().exactOptional(),
 });
 const refutedFindingSchema = z.strictObject({
     fingerprint: z.string(),
@@ -89,12 +107,12 @@ const taskOutcomeSchema = z.strictObject({
     bundle: z.string(),
     files: z.array(z.string()),
     status: taskStatusSchema,
-    error: z.string().optional(),
+    error: z.string().exactOptional(),
     findings: z.int().nonnegative(),
     durationMs: z.number(),
     usage: usageSchema,
 });
-const skippedCellSchema = z.strictObject({
+export const skippedCellSchema = z.strictObject({
     reviewer: z.string(),
     bundle: z.string(),
     reason: skipReasonSchema,
@@ -110,46 +128,46 @@ const scopeSchema = z.discriminatedUnion("mode", [
 ]);
 const priorList = z.array(outputPriorFindingSchema);
 const samplingSchema = z.strictObject({
-    temperature: z.number().optional(),
-    seed: z.int().optional(),
-    notApplied: z.array(z.enum(["temperature", "seed"])).optional(),
+    temperature: z.number().exactOptional(),
+    seed: z.int().exactOptional(),
+    notApplied: z.array(z.enum(["temperature", "seed"])).exactOptional(),
 });
 const agentProvenanceSchema = z.strictObject({
-    tier: z.enum(["top", "standard", "light"]),
-    models: z.array(z.string()).optional(),
-    effort: z.enum(EFFORT_LEVELS).optional(),
-    applied: z.boolean().optional(),
-    notApplied: z.array(z.enum(["temperature", "seed"])).optional(),
+    tier: z.enum(MODEL_TIERS),
+    models: z.array(z.string()).exactOptional(),
+    effort: z.enum(EFFORT_LEVELS).exactOptional(),
+    applied: z.boolean().exactOptional(),
+    notApplied: z.array(z.enum(["temperature", "seed"])).exactOptional(),
 });
 const provenanceSchema = z.strictObject({
     ocraVersion: z.string(),
     promptHash: z.string(),
     configHash: z.string(),
     sampling: samplingSchema,
-    agents: z.record(z.string(), agentProvenanceSchema).optional(),
+    agents: z.record(z.string(), agentProvenanceSchema).exactOptional(),
     rules: z
         .array(z.strictObject({
         path: z.array(z.string()),
         rule: z.string(),
-        source: z.enum(["repository", "shared", "account", "plugin"]).optional(),
+        source: z.enum(["repository", "shared", "account", "plugin"]).exactOptional(),
     }))
-        .optional(),
-    accountSettings: z.strictObject({ version: z.string().nullable() }).optional(),
+        .exactOptional(),
+    accountSettings: z.strictObject({ version: z.string().nullable() }).exactOptional(),
 });
 export const reportOutputSchema = z.strictObject({
     version: z.literal(REPORT_VERSION),
-    runId: z.string().optional(),
+    runId: z.string().exactOptional(),
     changeRequest: changeRequestSchema,
     tier: riskTierSchema,
     verdict: verdictSchema,
     summary: z.string(),
-    scope: scopeSchema.optional(),
+    scope: scopeSchema.exactOptional(),
     coverage: z.array(coverageEntrySchema),
     findings: z.array(outputFindingSchema),
     unverifiedCriticals: z.int().nonnegative(),
     refuted: z.array(refutedFindingSchema),
-    remembered: z.array(memoryEntrySchema.extend({ source: z.enum(["repository", "account"]).optional() })),
-    judgement: judgeDecisionsSchema.optional(),
+    remembered: z.array(memoryEntrySchema.extend({ source: z.enum(["repository", "account"]).exactOptional() })),
+    judgement: judgeDecisionsSchema.exactOptional(),
     rereview: z
         .strictObject({
         fixed: priorList,
@@ -158,21 +176,18 @@ export const reportOutputSchema = z.strictObject({
         unchanged: priorList,
         dismissed: priorList,
     })
-        .optional(),
+        .exactOptional(),
     tasks: z.array(taskOutcomeSchema),
     skipped: z.array(skippedCellSchema),
     bundles: z.array(z.strictObject({ label: z.string(), files: z.array(z.string()) })),
-    anchoring: anchoringSummarySchema.optional(),
+    anchoring: anchoringSummarySchema.exactOptional(),
     spendLimit: z
-        .strictObject({ usd: z.number(), reached: z.enum(["review", "total"]).optional() })
-        .optional(),
-    provenance: provenanceSchema.optional(),
+        .strictObject({ usd: z.number(), reached: z.enum(["review", "total"]).exactOptional() })
+        .exactOptional(),
+    provenance: provenanceSchema.exactOptional(),
     usage: usageSchema,
     warnings: z.array(z.string()),
 });
-export function asSchemaOutput(output) {
-    return output;
-}
 export const REPORT_SCHEMA_ID = "https://ocra.majincheng.com/schema/report.v1.json";
 // JSON Schema (draft 2020-12) for `--format json` and a session's
 // report.json, for validators and code generators outside this codebase.

package/dist/report/output.d.ts

@@ -0,0 +1,8 @@
+import type { z } from "zod";
+import { type reportOutputSchema } from "./output-schema.js";
+import type { ReviewReport } from "./report.js";
+export type ReportOutput = z.output<typeof reportOutputSchema>;
+export type OutputFinding = ReportOutput["findings"][number];
+export type OutputPriorFinding = NonNullable<ReportOutput["rereview"]>["fixed"][number];
+export declare function toReportOutput(report: ReviewReport): ReportOutput;
+//# sourceMappingURL=output.d.ts.map