argus-reviewer-e2e 0.1.3 → 0.3.0

package/dist/api.d.ts

@@ -7,6 +7,7 @@ import { Config, defineConfig } from './config.js';
 import { ErrorRecord } from './journal/schema.js';
 import { Logger } from './log.js';
 export { defineConfig };
+export { DecisionClient, DecisionError, JEV_DEFAULT_MODEL, type DecisionAnswer, type DecisionClientOptions, type DecisionErrorKind, type DecisionQuestion, } from './vision/decisions.js';
 /**
  * Test-facing API (R13). Test files are plain TypeScript using a `td` object:
  *
@@ -91,6 +92,7 @@ export declare class TdSession {
     private constructor();
     static create(opts: TdSessionOptions): Promise<TdSession>;
     get visionCalls(): number;
+    get cacheStats(): import("./engine/loop.js").CacheStats;
     /** Non-fatal anomalies observed by the engine — journaled as evidence. */
     get errorRecords(): ErrorRecord[];
     get failed(): boolean;

package/dist/api.js

@@ -4,6 +4,7 @@ import { loadFlow, saveFlow } from './cache/store.js';
 import { Ledger } from './vision/ledger.js';
 import { defineConfig } from './config.js';
 export { defineConfig };
+export { DecisionClient, DecisionError, JEV_DEFAULT_MODEL, } from './vision/decisions.js';
 const KEY_ALIASES = {
     tab: 'Tab',
     enter: 'Enter',
@@ -89,6 +90,9 @@ export class TdSession {
     get visionCalls() {
         return this.engine.visionCalls;
     }
+    get cacheStats() {
+        return this.engine.cacheStats;
+    }
     /** Non-fatal anomalies observed by the engine — journaled as evidence. */
     get errorRecords() {
         return this.engine.errorRecords;

package/dist/cache/store.d.ts

@@ -1,4 +1,5 @@
 import { FingerprintRecord } from './fingerprint.js';
+export declare const FLOW_CACHE_SCHEMA_VERSION: 1;
 /** A cached assertion verdict, keyed on (question, page-state hash). */
 export interface CachedAssert {
     question: string;
@@ -9,6 +10,7 @@ export interface CachedAssert {
     model: string | undefined;
 }
 export interface FlowCache {
+    schemaVersion?: typeof FLOW_CACHE_SCHEMA_VERSION;
     steps: FingerprintRecord[];
     asserts?: CachedAssert[];
 }

package/dist/cache/store.js

@@ -1,6 +1,7 @@
 import { readFile } from 'node:fs/promises';
 import { join } from 'node:path';
 import { writeAtomicJson } from '../fsutil.js';
+export const FLOW_CACHE_SCHEMA_VERSION = 1;
 function sortKeys(_, value) {
     if (value !== null && typeof value === 'object' && !Array.isArray(value)) {
         const entries = Object.entries(value).sort(([a], [b]) => a.localeCompare(b));
@@ -19,11 +20,17 @@ export async function loadFlow(cacheDir, flowName) {
         if (!parsed || typeof parsed !== 'object' || Array.isArray(parsed)) {
             return undefined;
         }
-        const { steps, asserts } = parsed;
+        const { schemaVersion, steps, asserts } = parsed;
         if (!Array.isArray(steps)) {
             return undefined;
         }
-        const out = { steps: steps };
+        if (schemaVersion !== undefined && schemaVersion !== FLOW_CACHE_SCHEMA_VERSION) {
+            return undefined;
+        }
+        const out = {
+            ...(schemaVersion === FLOW_CACHE_SCHEMA_VERSION ? { schemaVersion } : {}),
+            steps: steps,
+        };
         if (Array.isArray(asserts))
             out.asserts = asserts;
         return out;
@@ -37,5 +44,5 @@ export async function loadFlow(cacheDir, flowName) {
     }
 }
 export async function saveFlow(cacheDir, flowName, steps, asserts) {
-    await writeAtomicJson(flowPath(cacheDir, flowName), { steps, asserts: asserts ?? [] }, sortKeys);
+    await writeAtomicJson(flowPath(cacheDir, flowName), { schemaVersion: FLOW_CACHE_SCHEMA_VERSION, steps, asserts: asserts ?? [] }, sortKeys);
 }

package/dist/cli.d.ts

@@ -3,6 +3,14 @@ import { Config } from './config.js';
 import { type ExecFn } from './detect.js';
 import { BrowserDriver } from './driver/browser.js';
 import { VisionClient } from './engine/loop.js';
+import { type PrMeta } from './evidence/ci.js';
+import { type Evidence } from './evidence/link.js';
+import { type SecretsScanResult } from './review/secrets.js';
+import { type TriageRecord } from './review/triage.js';
+import { type FindingAdjudicationAudit } from './review/adjudicate.js';
+import { type ProbeRecord } from './probe/queue.js';
+import { type HeadBinding } from './report/manifest.js';
+import { CallCost } from './vision/cost.js';
 export interface CliDeps {
     cwd?: string;
     env?: NodeJS.ProcessEnv;
@@ -21,5 +29,134 @@ interface PrFile {
     previous_filename?: string;
     patch?: string;
 }
+export interface ReviewFinding {
+    file: string;
+    line?: number;
+    severity: string;
+    category?: string;
+    message: string;
+    /** U8 — Jev true-positive probability (absent = unadjudicated). */
+    p?: number;
+    /** R1 — committable replacement lines for the commented range (parse-bounded). */
+    suggestion?: string;
+    /** R1 — first line of the replaced range; absent = single-line fix at `line`. */
+    startLine?: number;
+    evidence?: Evidence;
+}
+/** KTD3 — one pre-rendered inline review comment; posters POST it verbatim. */
+export interface ReviewComment {
+    path: string;
+    line: number;
+    start_line?: number;
+    start_side?: 'RIGHT';
+    side: 'RIGHT';
+    body: string;
+    /** R10 — path:line:bodyFirstLine:hash8(suggestion); a corrected suggestion re-posts. */
+    dedupKey: string;
+}
+interface CodeReviewReport {
+    ok: boolean;
+    skipped: boolean;
+    summary: string;
+    verdict: 'pass' | 'needs_changes' | 'approve';
+    findings: ReviewFinding[];
+    /** Inline-comment cap consumed by the sticky poster (Tencent max_comments pull). */
+    maxComments?: number;
+    /** R3/KTD2 — poster gate: 'request_changes' only for proven blockers. */
+    reviewEvent: 'comment' | 'request_changes';
+    /** Blocker-severity findings a sandbox probe reproduced. */
+    provenBlockers: number;
+    /** Blocker-severity findings at/above the Jev P(true-positive) gate. */
+    highConfidenceBlockers: number;
+    /** KTD3 — eligibility-filtered, severity-sorted, sanitized, capped. */
+    reviewComments: ReviewComment[];
+    /** Eligible findings dropped by the maxComments cap. */
+    commentsOverflow: number;
+    /** B.2 probe audit records — present only when the sandbox lane ran. */
+    probes?: ProbeRecord[];
+    /** Why an enabled lane bowed out (fork gate, no docker, no harness…). */
+    probeLaneSkipped?: string;
+    /** Secrets-lane audit — masked candidates, adjudication verdicts, skip reason. */
+    secretsScan?: SecretsScanResult | {
+        skipped: string;
+    };
+    /** U7 triage record — Jev pre-review signals (annotate/route, never gates). */
+    triage?: TriageRecord;
+    /** U8 adjudication audit — per-finding p + suppressed records. */
+    findingAdjudication?: FindingAdjudicationAudit;
+    calls: CallCost[];
+    visionCostUsd: number;
+    tokens: number;
+    model: string;
+    budgetExceeded: boolean;
+    /** Identity relationship between the report source and checkout. */
+    headBinding?: HeadBinding;
+}
+/**
+ * Split `git diff` text into per-file PrFile entries — the local-diff
+ * equivalent of the PR-files API response (which also reports `patch`
+ * per file). `+++ b/` names new/copied files; `--- a/` covers deletions.
+ */
+export declare function filesFromUnifiedDiff(diff: string): PrFile[];
+/**
+ * `--fixture <dir>` seam: the dir is a real git repo with an
+ * `argus-fixture-base` ref (the merge base) and HEAD at the PR head —
+ * scripts/demo.mjs materializes it. Returns the same diff/files/meta
+ * the GitHub paths would produce, so every downstream lane (chunking,
+ * secrets scan, evidence linkage) runs its real code path.
+ */
+export declare function loadFixture(dir: string, exec?: ExecFn): Promise<{
+    files: PrFile[];
+    meta: PrMeta;
+    diff: string;
+} | {
+    skipped: string;
+}>;
 export declare function buildPatchChunks(files: PrFile[], contexts?: Record<string, string>): string[];
+export declare function parseCodeReview(content: string): {
+    summary: string;
+    verdict: 'pass' | 'needs_changes' | 'approve';
+    findings: CodeReviewReport['findings'];
+};
+/**
+ * KTD1 — a surviving synthesized finding's suggestion is restored verbatim
+ * from its pre-synthesis original, matched on file + line + whitespace-
+ * normalized message. With no pre-image the synthesized copy is dropped:
+ * synthesis output is ungrounded model text, never committable code.
+ */
+export declare function carryForwardSuggestions(findings: CodeReviewReport['findings'], originals: CodeReviewReport['findings']): CodeReviewReport['findings'];
+/**
+ * R3/KTD2 — Jev P(true-positive) at/above which a blocker-severity finding
+ * counts as proven for the REQUEST_CHANGES gate. This is a different axis
+ * from `review.findingThreshold` (P(false-positive) for nit/q suppression)
+ * — never reuse that knob. 0.7: high-confidence without demanding
+ * near-certainty from a calibrated scorer.
+ */
+export declare const P_TRUE_POSITIVE_THRESHOLD = 0.7;
+/**
+ * KTD2 — the poster-facing review gate, computed once at report assembly
+ * on linkedFindings (post-adjudication `p`, post-probe `evidence`,
+ * secrets-lane `pLive` already carried as `p`) and serialized into
+ * code-review.json; posters read `reviewEvent`, never recompute.
+ * Unadjudicated blockers (no p, not reproduced) never escalate —
+ * degrade-open by design. The two counts overlap deliberately: a
+ * reproduced AND Jev-confident finding is reported under both.
+ */
+export declare function computeReviewEvent(findings: ReviewFinding[], blockSeverities: string[], allowRequestChanges: boolean): {
+    reviewEvent: 'comment' | 'request_changes';
+    provenBlockers: number;
+    highConfidenceBlockers: number;
+};
+/**
+ * KTD3 — pre-render the inline review surface: eligibility-filtered
+ * (R8's static half — real path, positive integer line), severity-sorted
+ * before the maxComments cap so nits can't crowd out bugs (R2), sanitized
+ * (R5), suggestion-fenced, each carrying a dedupKey (R10). Posters consume
+ * `comments` verbatim — dedup + live-diff validation + POST, no render
+ * policy. `overflow` is the count of eligible findings past the cap.
+ */
+export declare function renderReviewComments(findings: ReviewFinding[], maxComments?: number): {
+    comments: ReviewComment[];
+    overflow: number;
+};
 export {};