@open-cr-agent/vcs-github 0.1.2 → 0.2.0

package/dist/adapter.d.ts

@@ -1,18 +1,10 @@
-import { type ChangeRequest, type CodeMatch, type FileDiff, type PriorReview, type ReviewReport, type VcsAdapter } from "@open-cr-agent/core";
+import { type CodeSource, type History, PlatformReview } from "@open-cr-agent/vcs-platform";
 import { type GitHubApi, type PullRequest } from "./client.js";
 export interface GitHubPullRequest {
     owner: string;
     repo: string;
     number: number;
 }
-export type CodeSource = Pick<VcsAdapter, "getDiff" | "readFile" | "searchCode">;
-export interface History {
-    filesChangedSince(from: string, to: string): Promise<{
-        files: string[];
-    } | {
-        reason: string;
-    }>;
-}
 export interface GitHubAdapterOptions {
     pullRequest: GitHubPullRequest;
     api: GitHubApi;
@@ -23,39 +15,7 @@ export interface GitHubAdapterOptions {
     snapshot?: PullRequest;
 }
 export declare const DEFAULT_BOT_LOGIN = "github-actions[bot]";
-export declare function declinesFinding(reply: string): boolean;
-export declare class GitHubAdapter implements VcsAdapter {
-    private readonly options;
-    readonly name = "github";
-    private pullRequest;
-    private previous;
-    private reviewThreads;
-    private issueComments;
-    private readonly writers;
-    private prior;
+export declare class GitHubAdapter extends PlatformReview {
     constructor(options: GitHubAdapterOptions);
-    getChangeRequest(): Promise<ChangeRequest>;
-    private override;
-    private unedited;
-    private canWrite;
-    getDiff(): Promise<FileDiff[]>;
-    readFile(path: string): Promise<string | undefined>;
-    searchCode(literal: string): Promise<CodeMatch[]>;
-    getPriorReview(): Promise<PriorReview | undefined>;
-    private priorState;
-    private changesSince;
-    private repliesByPeople;
-    publish(report: ReviewReport): Promise<{
-        warnings: string[];
-    }>;
-    private syncChangeRequest;
-    private resolveFixedThreads;
-    private lastEditor;
-    private isBot;
-    private postReview;
-    private threads;
-    private pr;
-    private comments;
-    private summaryComment;
 }
 //# sourceMappingURL=adapter.d.ts.map

package/dist/adapter.js

@@ -1,297 +1,105 @@
-import { errorMessage, } from "@open-cr-agent/core";
+import { errorMessage } from "@open-cr-agent/core";
+import { PlatformReview, } from "@open-cr-agent/vcs-platform";
 import { GitHubApiError, } from "./client.js";
-import { FINDING_MARKER, inlineComment, renderSummary } from "./render.js";
-import { readState, SUMMARY_MARKER } from "./state.js";
 export const DEFAULT_BOT_LOGIN = "github-actions[bot]";
-const OVERRIDE = /^\/ocra override ([0-9a-fA-F]{40}(?:[0-9a-fA-F]{24})?)\s+(\S.*)$/m;
-const MAX_OVERRIDE_REASON = 300;
-const MAX_REPLIES = 3;
-const MAX_REPLY_CHARS = 1_000;
-const DECLINE = /^(won['’]?t fix|wontfix|will not fix|by design|false positive|not a bug|working as intended|intended behaviou?r)(?=$|[\s.,;:!—–-])/i;
-const COMMAND = /^\/ocra dismiss\b/im;
-// A dismissal takes a clear decline: an explicit `/ocra dismiss`, or a reply
-// that opens with a decline and does not ask. Words anywhere else in a reply
-// ("this is not intended", "is this by design?", "acknowledged, will fix")
-// do not dismiss, since a dismissed finding leaves the verdict. Disagreement
-// ("I disagree") keeps the finding reported.
-export function declinesFinding(reply) {
-    if (COMMAND.test(reply))
-        return true;
-    const opening = reply
-        .trim()
-        .split(/(?<=[.!?])\s|\n/)[0]
-        ?.trim() ?? "";
-    return DECLINE.test(opening) && !opening.endsWith("?");
+// A GitHub pull request as ocra's review conversation (vcs-platform).
+export class GitHubAdapter extends PlatformReview {
+    constructor(options) {
+        super({
+            name: "github",
+            platform: new GitHubPlatform(options),
+            code: options.code,
+            ...(options.history ? { history: options.history } : {}),
+        });
+    }
 }
-export class GitHubAdapter {
+class GitHubPlatform {
     options;
-    name = "github";
+    text = { changeRequest: "pull request", authority: "write access" };
     pullRequest;
-    previous;
-    reviewThreads;
-    issueComments;
-    writers = new Map();
-    prior;
+    // The REST comments behind the platform's, for their GraphQL node ids.
+    listed = new Map();
     constructor(options) {
         this.options = options;
     }
-    async getChangeRequest() {
+    // REST names the Actions bot "github-actions[bot]", GraphQL "github-actions".
+    async bot() {
+        const login = this.options.botLogin;
+        return { login, is: (other) => other === login || `${other}[bot]` === login };
+    }
+    async changeRequest() {
         const pr = await this.pr();
         const { owner, repo } = this.options.pullRequest;
-        const override = await this.override(pr);
         return {
             id: `${owner}/${repo}#${pr.number}`,
             title: pr.title,
             description: pr.body ?? "",
             baseSha: pr.base.sha,
             headSha: pr.head.sha,
-            ...(override ? { override } : {}),
+            ...(pr.user ? { author: pr.user.login } : {}),
         };
     }
-    // "Break glass": `/ocra override <commit> <reason>` from someone with
-    // write access other than the author lets a blocking verdict pass for that
-    // commit only, so a later push with new problems needs a new decision. The
-    // author can never overrule the review of their own change. Comments are
-    // best effort: without them there is simply no override.
-    async override(pr) {
-        const comments = await this.comments().catch(() => []);
-        const author = pr.user?.login;
-        let found;
-        for (const c of comments) {
-            const login = c.user?.login;
-            const match = OVERRIDE.exec(c.body);
-            if (!match || !login || login === author || this.isBot(login))
-                continue;
-            // ocra's own summary is never a command, whichever account posted it.
-            if (c.body.includes(SUMMARY_MARKER))
-                continue;
-            const [, commit = "", reason = ""] = match;
-            // The full commit id: a short prefix can be matched by a new commit.
-            if (commit.toLowerCase() !== pr.head.sha)
-                continue;
-            if (!(await this.unedited(c.node_id, login)) || !(await this.canWrite(login)))
-                continue;
-            found = { by: login, reason: reason.trim().slice(0, MAX_OVERRIDE_REASON) };
-        }
-        return found;
+    async comments() {
+        const comments = await this.options.api.listIssueComments(this.options.pullRequest.number);
+        return comments.map((c) => {
+            const id = String(c.id);
+            this.listed.set(id, c);
+            return { id, body: c.body, ...(c.user ? { author: c.user.login } : {}) };
+        });
     }
-    // Anyone with write access can edit anyone's comment, and GitHub keeps
-    // showing the original author: a command counts only when nobody else
-    // edited it. Unknown means no.
-    async unedited(nodeId, login) {
+    // GitHub keeps who edited a comment in GraphQL only, by node id.
+    async editor(comment) {
+        const nodeId = this.listed.get(comment.id)?.node_id;
         if (!nodeId)
-            return false;
-        try {
-            const editor = await this.options.api.commentEditor(nodeId);
-            return editor === undefined || editor === login;
-        }
-        catch {
-            return false;
-        }
+            throw new Error("the comment has no node id to look up its editor");
+        return this.options.api.commentEditor(nodeId);
     }
-    // Write access from the repository's permissions, memoized per login;
-    // a failed lookup means no.
     canWrite(login) {
-        let known = this.writers.get(login);
-        if (!known) {
-            known = this.options.api.canWrite(login).catch(() => false);
-            this.writers.set(login, known);
-        }
-        return known;
-    }
-    getDiff() {
-        return this.options.code.getDiff();
-    }
-    readFile(path) {
-        return this.options.code.readFile(path);
-    }
-    searchCode(literal) {
-        return this.options.code.searchCode(literal);
-    }
-    async getPriorReview() {
-        const prior = await this.priorState();
-        if ("untrusted" in prior)
-            return { findings: [], fullReviewReason: prior.untrusted };
-        const { state } = prior;
-        if (!state)
-            return undefined;
-        const { dismissed, replies } = await this.repliesByPeople(state.findings);
-        return {
-            findings: state.findings.map((f) => dismissed.has(f.fingerprint) ? { ...f, dismissed: true } : f),
-            ...(await this.changesSince(state)),
-            ...(state.tier ? { tier: state.tier } : {}),
-            ...(Object.keys(replies).length > 0 ? { replies } : {}),
-        };
-    }
-    // Anyone with write access can edit the summary comment, including a pull
-    // request's author. Every part of the state is then suspect: a head skips
-    // their next changes, a `commented` flag hides a finding from both the
-    // inline comments and the summary. So the state counts only when ocra was
-    // the last to edit the comment; otherwise the run starts over.
-    priorState() {
-        this.prior ??= (async () => {
-            const comment = await this.summaryComment();
-            const state = comment ? readState(comment.body) : undefined;
-            if (!comment || !state)
-                return {};
-            const editor = await this.lastEditor(comment);
-            if (editor === undefined) {
-                return { untrusted: "could not check who last edited the previous review's summary" };
-            }
-            if (!this.isBot(editor)) {
-                return { untrusted: "the previous review's summary was edited by someone else" };
-            }
-            return { state };
-        })();
-        return this.prior;
-    }
-    async changesSince(state) {
-        const { history } = this.options;
-        if (!state.head)
-            return { fullReviewReason: "the previous review did not record its commit" };
-        if (!history)
-            return { fullReviewReason: "no repository history to compare with" };
-        const head = (await this.pr()).head.sha;
-        const changed = await history.filesChangedSince(state.head, head);
-        if ("reason" in changed)
-            return { fullReviewReason: changed.reason };
-        return {
-            changedSince: {
-                head: state.head,
-                files: [...new Set([...changed.files, ...(state.pending ?? [])])],
-            },
-        };
+        return this.options.api.canWrite(login);
+    }
+    async threads() {
+        const threads = await this.options.api.listReviewThreads(this.options.pullRequest.number);
+        return threads.map((t) => ({
+            id: t.id,
+            resolved: t.isResolved,
+            ...(t.resolvedBy ? { resolvedBy: t.resolvedBy } : {}),
+            comments: t.comments.map((c) => ({
+                author: c.author,
+                body: c.body,
+                ...(c.editor ? { editor: c.editor } : {}),
+            })),
+        }));
     }
-    // A thread of ocra's that a reviewer resolved, or answered with a clear
-    // "won't fix", dismisses its finding. A reviewer is someone with write
-    // access other than the pull request's author, in a comment nobody else
-    // edited: otherwise the author could resolve or argue a finding away. Any
-    // other reply from a reviewer dismisses nothing, but the judge weighs it
-    // when the finding comes back (and cannot drop a confirmed critical for
-    // it). Replies are collected for every thread of ocra's, not only tracked
-    // findings, so a finding a reply argued away does not return without it.
-    // Thread data is best effort: without it nothing is dismissed or replied.
-    async repliesByPeople(findings) {
-        const commented = new Set(findings.filter((f) => f.commented).map((f) => f.fingerprint));
-        const author = (await this.pr()).user?.login;
-        const reviewer = async (login) => login !== undefined && login !== author && !this.isBot(login) && (await this.canWrite(login));
-        const threads = await this.threads().catch(() => []);
-        const dismissed = new Set();
-        const replies = {};
-        for (const thread of threads) {
-            const [first, ...rest] = thread.comments;
-            const fingerprint = first && FINDING_MARKER.exec(first.body)?.[1];
-            if (!first || !fingerprint || !this.isBot(first.author))
-                continue;
-            const said = [];
-            let declined = false;
-            for (const r of rest) {
-                const own = r.editor === undefined || r.editor === r.author;
-                if (!own || !(await reviewer(r.author)))
-                    continue;
-                if (declinesFinding(r.body))
-                    declined = true;
-                else if (r.body.trim() !== "")
-                    said.push(r.body.trim().slice(0, MAX_REPLY_CHARS));
-            }
-            if (commented.has(fingerprint)) {
-                const resolved = thread.isResolved && (await reviewer(thread.resolvedBy));
-                if (resolved || declined) {
-                    dismissed.add(fingerprint);
-                    continue;
-                }
-            }
-            if (said.length > 0)
-                replies[fingerprint] = said.slice(-MAX_REPLIES);
-        }
-        return { dismissed, replies };
+    async publishFindings(report, fresh) {
+        const changeRequests = await this.syncChangeRequest(report);
+        const posted = await this.postReview(report, fresh, changeRequests.request);
+        return { posted, warnings: changeRequests.warnings, finish: changeRequests.withdraw };
     }
-    async publish(report) {
-        const { number } = this.options.pullRequest;
-        const pr = await this.pr();
-        const previous = await this.summaryComment();
-        const prior = await this.priorState();
-        const trusted = "state" in prior ? prior.state : undefined;
-        const before = trusted?.findings ?? [];
-        const alreadyCommented = new Set([
-            ...before.filter((f) => f.commented).map((f) => f.fingerprint),
-            ...(trusted?.posted ?? []),
-        ]);
-        const fresh = report.findings.flatMap((f) => {
-            if (alreadyCommented.has(f.fingerprint))
-                return [];
-            const comment = inlineComment(f);
-            return comment ? [{ fingerprint: f.fingerprint, comment }] : [];
-        });
-        const changeRequests = await this.syncChangeRequest(number, report);
-        const posted = await this.postReview(number, pr.head.sha, report, fresh, changeRequests.request);
-        const commented = new Set([...alreadyCommented, ...posted]);
-        const current = new Set(report.findings.map((f) => f.fingerprint));
-        const rereview = report.rereview;
-        const quiet = [
-            ...(rereview?.notReproduced ?? []),
-            ...(rereview?.notRechecked ?? []),
-            ...(rereview?.unchanged ?? []),
-            ...(rereview?.dismissed ?? []),
-        ];
-        // Low-confidence findings (--ultra) are shown, not counted; stored as
-        // ordinary findings they would count on the next push.
-        const state = [
-            ...report.findings
-                .filter((f) => !f.lowConfidence)
-                .map((f) => ({
-                fingerprint: f.fingerprint,
-                title: f.title,
-                file: f.file,
-                severity: f.severity,
-                commented: commented.has(f.fingerprint),
-                ...(f.quote ? { quote: f.quote } : {}),
-                ...(f.verification ? { verification: f.verification } : {}),
-            })),
-            ...quiet.filter((f) => !current.has(f.fingerprint)),
-        ];
-        const pending = report.coverage
-            .filter((c) => c.status === "failed" || c.status === "unreviewed")
-            .map((c) => c.path);
-        const tracked = new Set(state.map((f) => f.fingerprint));
-        const untracked = [...commented].filter((fp) => !tracked.has(fp));
-        const body = renderSummary({
-            report,
-            commented,
-            state: {
-                findings: state,
-                head: report.changeRequest.headSha,
-                pending,
-                tier: report.tier,
-                ...(untracked.length > 0 ? { posted: untracked } : {}),
-            },
-        });
-        if (previous)
-            await this.options.api.updateIssueComment(previous.id, body);
+    async writeSummary(existing, body) {
+        if (existing)
+            await this.options.api.updateIssueComment(Number(existing.id), body);
         else
-            await this.options.api.createIssueComment(number, body);
-        return {
-            warnings: [
-                ...changeRequests.warnings,
-                ...(await changeRequests.withdraw()),
-                ...(await this.resolveFixedThreads(number, report)),
-            ],
-        };
+            await this.options.api.createIssueComment(this.options.pullRequest.number, body);
+    }
+    resolveThread(id) {
+        return this.options.api.resolveReviewThread(id);
     }
     // With requestChanges on, ocra's "changes requested" follows the verdict:
     // requested once while it blocks, withdrawn (dismissed) once it no longer
     // does. GitHub keeps a reviewer's last blocking review until it is
     // dismissed, so otherwise a fixed pull request stayed blocked.
-    async syncChangeRequest(number, report) {
+    async syncChangeRequest(report) {
         const none = { request: false, warnings: [], withdraw: async () => [] };
         if (this.options.requestChanges !== true)
             return none;
+        const { number } = this.options.pullRequest;
+        const bot = await this.bot();
         // An override lets the commit pass, so it lifts the request too.
         const blocking = report.verdict === "significant_concerns" && report.changeRequest.override === undefined;
         let active;
         try {
             active = (await this.options.api.listReviews(number))
-                .filter((r) => r.state === "CHANGES_REQUESTED" && r.user && this.isBot(r.user.login))
+                .filter((r) => r.state === "CHANGES_REQUESTED" && r.user && bot.is(r.user.login))
                 .map((r) => r.id);
         }
         catch (error) {
@@ -317,48 +125,15 @@ export class GitHubAdapter {
             },
         };
     }
-    // Resolving threads is a courtesy: the summary already lists what was
-    // fixed, so a failure here is a warning, not a failed publish.
-    async resolveFixedThreads(number, report) {
-        const fixed = new Set((report.rereview?.fixed ?? []).filter((f) => f.commented).map((f) => f.fingerprint));
-        if (fixed.size === 0)
-            return [];
-        try {
-            for (const thread of await this.threads()) {
-                const first = thread.comments[0];
-                const fingerprint = first && FINDING_MARKER.exec(first.body)?.[1];
-                if (thread.isResolved || !fingerprint || !fixed.has(fingerprint))
-                    continue;
-                if (!this.isBot(first.author))
-                    continue;
-                await this.options.api.resolveReviewThread(thread.id);
-            }
-            return [];
-        }
-        catch (error) {
-            return [`could not resolve the threads of fixed findings: ${errorMessage(error)}`];
-        }
-    }
-    // The account that last edited the comment (ocra itself when nobody did),
-    // or undefined when that cannot be told.
-    async lastEditor(comment) {
-        if (!comment.node_id)
-            return undefined;
-        try {
-            return (await this.options.api.commentEditor(comment.node_id)) ?? this.options.botLogin;
-        }
-        catch {
-            return undefined;
-        }
-    }
-    // REST names the Actions bot "github-actions[bot]", GraphQL "github-actions".
-    isBot(login) {
-        return login === this.options.botLogin || `${login}[bot]` === this.options.botLogin;
-    }
     // Returns the fingerprints that now have inline comments. GitHub rejects
     // positions outside its own diff with 422; those findings then stay in the
     // summary instead of failing the publish.
-    async postReview(number, commitId, report, fresh, requestChanges) {
+    async postReview(report, inline, requestChanges) {
+        const { number } = this.options.pullRequest;
+        let fresh = inline.map((f) => ({
+            fingerprint: f.finding.fingerprint,
+            comment: reviewComment(f),
+        }));
         // GitHub rejects the whole review when one comment sits on a file it
         // shows no diff for (too large, too many files); those go to the summary.
         if (fresh.length > 0) {
@@ -369,7 +144,7 @@ export class GitHubAdapter {
         if (fresh.length === 0 && !requestChanges)
             return [];
         const review = {
-            commit_id: commitId,
+            commit_id: (await this.pr()).head.sha,
             event: requestChanges ? "REQUEST_CHANGES" : "COMMENT",
             body: `ocra: ${report.findings.length} finding(s); details in the summary comment.`,
         };
@@ -391,23 +166,20 @@ export class GitHubAdapter {
             return [];
         }
     }
-    threads() {
-        this.reviewThreads ??= this.options.api.listReviewThreads(this.options.pullRequest.number);
-        return this.reviewThreads;
-    }
     pr() {
         this.pullRequest ??= this.options.snapshot
             ? Promise.resolve(this.options.snapshot)
             : this.options.api.getPullRequest(this.options.pullRequest.number);
         return this.pullRequest;
     }
-    comments() {
-        this.issueComments ??= this.options.api.listIssueComments(this.options.pullRequest.number);
-        return this.issueComments;
-    }
-    summaryComment() {
-        this.previous ??= this.comments().then((comments) => comments.findLast((c) => c.user?.login === this.options.botLogin && c.body.includes(SUMMARY_MARKER)));
-        return this.previous;
-    }
+}
+function reviewComment({ finding, body }) {
+    const { start, end } = finding.lineRange;
+    const comment = { path: finding.file, line: end, side: "RIGHT", body };
+    if (start !== end) {
+        comment.start_line = start;
+        comment.start_side = "RIGHT";
+    }
+    return comment;
 }
 //# sourceMappingURL=adapter.js.map

package/dist/client.js

@@ -1,5 +1,5 @@
+import { MAX_ATTEMPTS, retryDecision } from "@open-cr-agent/vcs-platform";
 import { z } from "zod";
-import { MAX_ATTEMPTS, retryDecision } from "./retry.js";
 // Commit ids reach git as arguments; anything else is refused at the boundary.
 const sha = z.string().regex(/^[0-9a-f]{40}([0-9a-f]{24})?$/, "not a commit id");
 const pullRequestSchema = z.object({

package/dist/index.d.ts

@@ -1,6 +1,4 @@
 export * from "./adapter.js";
 export * from "./client.js";
 export * from "./plugin.js";
-export * from "./render.js";
-export * from "./state.js";
 //# sourceMappingURL=index.d.ts.map

package/dist/index.js

@@ -1,6 +1,4 @@
 export * from "./adapter.js";
 export * from "./client.js";
 export * from "./plugin.js";
-export * from "./render.js";
-export * from "./state.js";
 //# sourceMappingURL=index.js.map

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@open-cr-agent/vcs-github",
-  "version": "0.1.2",
+  "version": "0.2.0",
   "description": "GitHub pull request adapter for Open-CR-Agent",
   "keywords": [
     "code-review",
@@ -30,7 +30,8 @@
     "!dist/**/*.map"
   ],
   "dependencies": {
-    "@open-cr-agent/core": "0.1.2",
+    "@open-cr-agent/core": "0.2.0",
+    "@open-cr-agent/vcs-platform": "0.2.0",
     "zod": "^4.6.5"
   },
   "publishConfig": {

package/dist/render.d.ts

@@ -1,15 +0,0 @@
-import { type Finding, type ReviewReport } from "@open-cr-agent/core";
-import type { ReviewComment } from "./client.js";
-import { type ReviewState } from "./state.js";
-export declare function safeMarkdown(text: string): string;
-export declare function codeSpan(text: string): string;
-export declare const FINDING_MARKER: RegExp;
-export declare function inlineBody(f: Finding): string;
-export declare function inlineComment(f: Finding): ReviewComment | undefined;
-export interface SummaryInput {
-    report: ReviewReport;
-    commented: ReadonlySet<string>;
-    state: ReviewState;
-}
-export declare function renderSummary({ report, commented, state }: SummaryInput): string;
-//# sourceMappingURL=render.d.ts.map

package/dist/render.js

@@ -1,189 +0,0 @@
-import { coverageGaps, } from "@open-cr-agent/core";
-import { SUMMARY_MARKER, writeState } from "./state.js";
-// GitHub rejects comments over 65,536 characters.
-const MAX_SUMMARY_CHARS = 65_000;
-const ICON = { critical: "🔴", warning: "🟠", suggestion: "🔵" };
-const VERIFICATION = {
-    confirmed: "verified",
-    uncertain: "unverified (verifier unsure)",
-    unchecked: "not verified",
-};
-// A run that reviewed nothing has no verdict to announce, and one that missed
-// files or could not verify a critical finding says so next to its verdict.
-function headline(report) {
-    const { notReviewed, nothingReviewed } = coverageGaps(report.coverage);
-    if (nothingReviewed)
-        return "⏸️ Not reviewed";
-    const incomplete = notReviewed > 0 || report.unverifiedCriticals > 0;
-    const overridden = report.verdict === "significant_concerns" && report.changeRequest.override
-        ? " · overridden"
-        : "";
-    return `${VERDICT[report.verdict]}${overridden}${incomplete ? " · incomplete" : ""}`;
-}
-// Who overrode a blocking verdict, or how someone entitled to can.
-function overrideNote(report) {
-    if (report.verdict !== "significant_concerns")
-        return [];
-    const override = report.changeRequest.override;
-    if (override) {
-        return [
-            "",
-            `**Overridden** by @\u200b${safeMarkdown(override.by)} for ${codeSpan(report.changeRequest.headSha.slice(0, 7))}: ${safeMarkdown(override.reason)}`,
-        ];
-    }
-    return [
-        "",
-        `Someone with write access other than the author can let this commit pass by commenting \`/ocra override ${report.changeRequest.headSha} <reason>\`.`,
-    ];
-}
-function verification(f) {
-    return VERIFICATION[f.verification ?? "unchecked"];
-}
-const VERDICT = {
-    approved: "✅ Approved",
-    approved_with_comments: "💬 Approved with comments",
-    minor_issues: "⚠️ Minor issues",
-    significant_concerns: "🛑 Significant concerns",
-};
-// Model text is untrusted: it may not close our markup, mention people,
-// pull in images, spell one of ocra's commands (`/ocra …`, which would count
-// if ocra posted as a person with write access), or become a link at all. A
-// pull request can plant an address for a reviewer to repeat (the adversarial
-// probe saw one), and a bot comment lends it credibility. Inline links lose
-// their `](`, and every `]:` is escaped, so no link reference definition
-// (`[1]: https://…`) can form, at line start or inside a blockquote or list
-// item, and no reference-style link (`[x][1]`, `[x][]`, `[1]`) has anything
-// to resolve to. Web addresses get a zero-width space in their scheme or
-// after `www`, which GitHub's autolinking needs intact, so they read the
-// same and stay text; email addresses already lose theirs at the `@`.
-export function safeMarkdown(text) {
-    return text
-        .replaceAll("<!--", "&lt;!--")
-        .replace(/<\/?[a-zA-Z][^>]*>/g, (tag) => tag.replaceAll("<", "&lt;"))
-        .replace(/@(?=[A-Za-z0-9-])/g, "@\u200b")
-        .replace(/!\[/g, "!\u200b[")
-        .replace(/\/(?=ocra)/gi, "/\u200b")
-        .replace(/\b(https?|ftp)(?=:\/\/)/gi, "$1\u200b")
-        .replace(/\bwww(?=\.)/gi, "www\u200b")
-        .replaceAll("](", "]\\(")
-        .replaceAll("]:", "]\\:");
-}
-// File paths come from the diff, so the author controls them: a backtick or
-// newline must not end the code span and let markup through, and angle
-// brackets must not form ocra's HTML-comment markers in the raw body.
-export function codeSpan(text) {
-    const safe = text
-        .replaceAll("`", "\u02cb")
-        .replace(/[\r\n]+/g, " ")
-        .replaceAll("<", "\u2039")
-        .replaceAll(">", "\u203a");
-    return `\`${safe}\``;
-}
-function location(f) {
-    if (!f.lineRange)
-        return codeSpan(f.file);
-    const { start, end } = f.lineRange;
-    return codeSpan(`${f.file}:${start === end ? start : `${start}-${end}`}`);
-}
-export const FINDING_MARKER = /<!-- ocra:finding ([0-9a-f]{16}) -->/;
-export function inlineBody(f) {
-    const parts = [
-        `<!-- ocra:finding ${f.fingerprint} -->`,
-        `${ICON[f.severity]} **${safeMarkdown(f.title)}** · ${f.severity} · ${verification(f)} · ${f.reviewer}${f.lowConfidence ? " · low confidence" : ""}`,
-        "",
-        safeMarkdown(f.body),
-    ];
-    if (f.suggestion)
-        parts.push("", `**Suggestion:** ${safeMarkdown(f.suggestion)}`);
-    return parts.join("\n");
-}
-export function inlineComment(f) {
-    if (!f.lineRange || !f.anchor.inDiff)
-        return undefined;
-    const comment = {
-        path: f.file,
-        line: f.lineRange.end,
-        side: "RIGHT",
-        body: inlineBody(f),
-    };
-    if (f.lineRange.start !== f.lineRange.end) {
-        comment.start_line = f.lineRange.start;
-        comment.start_side = "RIGHT";
-    }
-    return comment;
-}
-export function renderSummary({ report, commented, state }) {
-    const counts = ["critical", "warning", "suggestion"]
-        .map((s) => `${report.findings.filter((f) => f.severity === s).length} ${s}`)
-        .join(", ");
-    const lines = [
-        SUMMARY_MARKER,
-        `## ocra review · ${headline(report)}`,
-        "",
-        safeMarkdown(report.summary),
-        ...overrideNote(report),
-        "",
-        `**${report.findings.length} finding(s)** (${counts}) · risk tier \`${report.tier}\``,
-    ];
-    if (report.scope?.mode === "incremental") {
-        lines.push("", `Reviewed only what changed since ${codeSpan(report.scope.since.slice(0, 7))}.`);
-    }
-    else if (report.scope) {
-        lines.push("", `Reviewed every file again: ${safeMarkdown(report.scope.reason)}.`);
-    }
-    // Only true while no confirmed critical blocks, and low-confidence
-    // findings do not count at all.
-    const unverified = report.verdict === "significant_concerns"
-        ? 0
-        : report.findings.filter((f) => f.severity === "critical" && f.verification !== "confirmed" && !f.lowConfidence).length;
-    if (unverified > 0) {
-        lines.push("", `${unverified} critical finding(s) are not verified, so they cap the verdict at minor issues.`);
-    }
-    if (report.unverifiedCriticals > 0) {
-        lines.push("", `**Incomplete:** verification failed or ran out of budget for ${report.unverifiedCriticals} critical finding(s); check them yourself.`);
-    }
-    const inSummary = report.findings.filter((f) => !commented.has(f.fingerprint));
-    if (inSummary.length > 0) {
-        lines.push("", "### Findings outside the diff");
-        for (const f of inSummary) {
-            lines.push(`- ${ICON[f.severity]} ${location(f)} **${safeMarkdown(f.title)}** _(${verification(f)}${f.lowConfidence ? ", low confidence" : ""})_: ${safeMarkdown(f.body).replaceAll("\n", " ")}`);
-        }
-    }
-    if (report.remembered.length > 0) {
-        lines.push("", `${report.remembered.length} finding(s) matched \`.ocra/memory.json\` and are not repeated.`);
-    }
-    const rereview = report.rereview;
-    if (rereview && rereview.fixed.length > 0) {
-        lines.push("", "### Fixed since the last review");
-        for (const f of rereview.fixed)
-            lines.push(`- ~~${safeMarkdown(f.title)}~~ ${codeSpan(f.file)}`);
-    }
-    if (rereview && rereview.notReproduced.length > 0) {
-        lines.push("", "### Not reported this time, code unchanged", "", "Still open and counted in the verdict until the code changes or a reviewer dismisses them.", "");
-        for (const f of rereview.notReproduced)
-            lines.push(`- ${ICON[f.severity]} ${safeMarkdown(f.title)} ${codeSpan(f.file)} _(${verification(f)})_`);
-    }
-    if (rereview && rereview.unchanged.length > 0) {
-        lines.push("", "### Still open in unchanged files", "", "Reported earlier in files not changed since; they count in the verdict.", "");
-        for (const f of rereview.unchanged)
-            lines.push(`- ${ICON[f.severity]} ${safeMarkdown(f.title)} ${codeSpan(f.file)} _(${verification(f)})_`);
-    }
-    if (rereview && rereview.dismissed.length > 0) {
-        lines.push("", "### Dismissed by reviewers");
-        for (const f of rereview.dismissed)
-            lines.push(`- ${safeMarkdown(f.title)} ${codeSpan(f.file)}`);
-    }
-    if (rereview && rereview.notRechecked.length > 0) {
-        lines.push("", "### Not re-checked this time", "", "Their files were not reviewed in this run; they stay open and count in the verdict.", "");
-        for (const f of rereview.notRechecked)
-            lines.push(`- ${ICON[f.severity]} ${safeMarkdown(f.title)} ${codeSpan(f.file)} _(${verification(f)})_`);
-    }
-    const failed = report.coverage.filter((c) => c.status === "failed" || c.status === "unreviewed");
-    const { costUsd, inputTokens, outputTokens } = report.usage;
-    lines.push("", "_The verdict is advice from language models that read the change itself, and can be swayed by text in it. Do not use it as a security gate._", "", "<details><summary>Coverage and cost</summary>", "", `${report.coverage.filter((c) => c.status === "reviewed").length} reviewed · ${report.coverage.filter((c) => c.status === "unchanged").length} unchanged since the last review · ${failed.length} not reviewed · ${report.coverage.filter((c) => c.status === "excluded").length} excluded · ${inputTokens} in / ${outputTokens} out tokens · $${costUsd.toFixed(4)}`, ...failed.map((c) => `- not reviewed: ${codeSpan(c.path)}`), "", "</details>");
-    const text = lines.join("\n");
-    const footer = `\n\n${writeState(state)}`;
-    const room = MAX_SUMMARY_CHARS - footer.length;
-    return (text.length > room ? `${text.slice(0, room - 40)}\n\n…(truncated)` : text) + footer;
-}
-//# sourceMappingURL=render.js.map

package/dist/retry.d.ts

@@ -1,11 +0,0 @@
-export declare const MAX_ATTEMPTS = 3;
-export interface RetryDecision {
-    retry: boolean;
-    waitMs: number;
-}
-export declare function retryDecision(method: string, idempotent: boolean, outcome: {
-    status: number;
-    headers: Headers;
-    body: string;
-} | "network_error", attempt: number, now?: number): RetryDecision;
-//# sourceMappingURL=retry.d.ts.map

package/dist/retry.js

@@ -1,38 +0,0 @@
-// GitHub answers bursts with 429 or a 403 "secondary rate limit", and has
-// short 5xx outages. One such answer during publish used to throw away a
-// paid review, so requests are retried a bounded number of times.
-export const MAX_ATTEMPTS = 3;
-const MAX_WAIT_MS = 60_000;
-// A request GitHub refused without acting on it (rate limits) can always be
-// repeated. A 5xx or a lost connection may have happened after GitHub acted,
-// so only requests that are safe to repeat retry then: POST would post the
-// same comment or review twice.
-export function retryDecision(method, idempotent, outcome, attempt, now = Date.now()) {
-    const stop = { retry: false, waitMs: 0 };
-    if (attempt >= MAX_ATTEMPTS)
-        return stop;
-    const backoff = 1_000 * 2 ** (attempt - 1);
-    const safe = idempotent || method === "GET";
-    if (outcome === "network_error")
-        return safe ? { retry: true, waitMs: backoff } : stop;
-    const { status, headers, body } = outcome;
-    const rateLimited = status === 429 ||
-        (status === 403 &&
-            (headers.get("x-ratelimit-remaining") === "0" || /secondary rate limit/i.test(body)));
-    if (rateLimited)
-        return { retry: true, waitMs: rateLimitWait(headers, now) ?? backoff };
-    if (safe && status >= 500)
-        return { retry: true, waitMs: backoff };
-    return stop;
-}
-function rateLimitWait(headers, now) {
-    const after = Number(headers.get("retry-after"));
-    if (Number.isFinite(after) && after > 0)
-        return Math.min(after * 1_000, MAX_WAIT_MS);
-    const reset = Number(headers.get("x-ratelimit-reset"));
-    if (Number.isFinite(reset) && reset > 0) {
-        return Math.min(Math.max(reset * 1_000 - now, 0), MAX_WAIT_MS);
-    }
-    return undefined;
-}
-//# sourceMappingURL=retry.js.map

package/dist/state.d.ts

@@ -1,14 +0,0 @@
-import type { PriorFinding } from "@open-cr-agent/core";
-import { type RiskTier } from "@open-cr-agent/core";
-export declare const SUMMARY_MARKER = "<!-- ocra:review -->";
-export declare const MAX_WRITTEN_STATE_CHARS = 30000;
-export interface ReviewState {
-    findings: PriorFinding[];
-    head?: string;
-    pending?: string[];
-    posted?: string[];
-    tier?: RiskTier;
-}
-export declare function readState(body: string): ReviewState | undefined;
-export declare function writeState(state: ReviewState): string;
-//# sourceMappingURL=state.d.ts.map

package/dist/state.js

@@ -1,110 +0,0 @@
-import { RISK_TIERS, severitySchema, verificationSchema } from "@open-cr-agent/core";
-import { z } from "zod";
-export const SUMMARY_MARKER = "<!-- ocra:review -->";
-// Only a state block that ends the comment counts: author-controlled text
-// (file paths, titles) is printed above it and must not be able to plant one.
-const STATE_PATTERN = /<!-- ocra:state v1 ([A-Za-z0-9+/=]+) -->\s*$/;
-const MAX_STATE_FINDINGS = 500;
-const MAX_STATE_CHARS = 60_000;
-// Written states stay well under what is read, so the summary text keeps room
-// in GitHub's 65,536-character comment limit.
-export const MAX_WRITTEN_STATE_CHARS = 30_000;
-const MAX_PENDING_FILES = 1_000;
-const MAX_POSTED = 1_000;
-const SHA = /^[0-9a-f]{40}([0-9a-f]{24})?$/;
-const stateSchema = z.object({
-    findings: z
-        .array(z.object({
-        fingerprint: z.string().regex(/^[0-9a-f]{16}$/),
-        title: z.string().max(300),
-        file: z.string().max(1_000),
-        severity: severitySchema,
-        commented: z.boolean(),
-        quote: z
-            .object({
-            lines: z.number().int().positive().max(1_000),
-            hash: z.string().regex(/^[0-9a-f]{16}$/),
-        })
-            .optional(),
-        verification: verificationSchema.optional(),
-    }))
-        .max(MAX_STATE_FINDINGS),
-    head: z.string().regex(SHA).optional(),
-    pending: z.array(z.string().max(1_000)).max(MAX_PENDING_FILES).optional(),
-    posted: z
-        .array(z.string().regex(/^[0-9a-f]{16}$/))
-        .max(MAX_POSTED)
-        .optional(),
-    tier: z.enum(RISK_TIERS).optional(),
-});
-// The state lives in a comment anyone with write access can edit, so it is
-// validated and bounded, and the adapter ignores it when someone other than
-// ocra edited the comment. Dismissals are never stored: they are recomputed
-// from review threads on every run.
-export function readState(body) {
-    const encoded = STATE_PATTERN.exec(body)?.[1];
-    if (!encoded || encoded.length > MAX_STATE_CHARS)
-        return undefined;
-    try {
-        const parsed = stateSchema.safeParse(JSON.parse(Buffer.from(encoded, "base64").toString("utf8")));
-        if (!parsed.success)
-            return undefined;
-        const { head, pending, posted, tier } = parsed.data;
-        return {
-            findings: parsed.data.findings.map(({ quote, verification, ...finding }) => ({
-                ...finding,
-                ...(quote ? { quote } : {}),
-                ...(verification ? { verification } : {}),
-            })),
-            ...(head ? { head } : {}),
-            ...(pending ? { pending } : {}),
-            ...(posted?.length ? { posted } : {}),
-            ...(tier ? { tier } : {}),
-        };
-    }
-    catch {
-        return undefined;
-    }
-}
-export function writeState(state) {
-    const kept = state.findings.slice(0, MAX_STATE_FINDINGS).map((f) => ({
-        fingerprint: f.fingerprint,
-        title: f.title.slice(0, 300),
-        file: f.file.slice(0, 1_000),
-        severity: f.severity,
-        commented: f.commented,
-        ...(f.quote ? { quote: f.quote } : {}),
-        ...(f.verification ? { verification: f.verification } : {}),
-    }));
-    // Without the full list of unfinished files the next run could skip one of
-    // them, so a list that does not fit drops the head and forces a full review.
-    const pending = state.pending ?? [];
-    const scope = state.head && pending.length <= MAX_PENDING_FILES
-        ? {
-            head: state.head,
-            ...(pending.length > 0 ? { pending: pending.map((p) => p.slice(0, 1_000)) } : {}),
-        }
-        : {};
-    // Too large a state first loses its scope (a full review next time), then
-    // findings from the end of the list (this run's come first, most severe
-    // first); a dropped finding's inline comment may be posted again.
-    const extras = {
-        ...(state.posted?.length ? { posted: state.posted.slice(-MAX_POSTED) } : {}),
-        ...(state.tier ? { tier: state.tier } : {}),
-    };
-    let encoded = encode(kept, { ...scope, ...extras });
-    if (encoded.length > MAX_WRITTEN_STATE_CHARS)
-        encoded = encode(kept, extras);
-    if (encoded.length > MAX_WRITTEN_STATE_CHARS)
-        encoded = encode(kept, {});
-    let count = kept.length;
-    while (encoded.length > MAX_WRITTEN_STATE_CHARS && count > 0) {
-        count = Math.floor(count * 0.8);
-        encoded = encode(kept.slice(0, count), {});
-    }
-    return `<!-- ocra:state v1 ${encoded} -->`;
-}
-function encode(findings, scope) {
-    return Buffer.from(JSON.stringify({ findings, ...scope }), "utf8").toString("base64");
-}
-//# sourceMappingURL=state.js.map