@effect-agent/pr-review 0.1.0-beta.8 → 0.1.0-beta.80

package/src/cli.ts

@@ -1,213 +0,0 @@
-import { NodeRuntime, NodeServices } from "@effect/platform-node";
-import { Console, Effect, Layer, Option, Schema } from "effect";
-import { BudgetExceeded } from "effect-agent";
-import { Command as CliCommand, Flag } from "effect/unstable/cli";
-
-import { InvalidEffortInput, parseEffortPosition, type EffortPosition } from "./internal/effort.ts";
-import { PrReview, type RunReviewOptions } from "./internal/factory.ts";
-import { gitHubReviewLayers, resolveReviewTarget } from "./internal/github-env.ts";
-import { fingerprintUnchanged } from "./internal/github.ts";
-import {
-  anthropicClientLayer,
-  DEFAULT_MODEL,
-  DEFAULT_PROVIDER,
-  describeReviewModel,
-  makeAnthropicReviewModel,
-  makeOpenAiReviewModel,
-  openAiClientLayer,
-  type ReviewProvider,
-} from "./internal/providers.ts";
-import { ReviewPublicationPlan } from "./internal/render.ts";
-import type { ReviewRunOutcome } from "./internal/run.ts";
-
-// ---------------------------------------------------------------------------
-// The CLI entrypoint: resolve which pull request to review (flags first, then
-// the GitHub Actions event environment), run one bounded ephemeral review,
-// and either print the validated publication plan (default: dry run) or post
-// it as a pull-request review (--post).
-// ---------------------------------------------------------------------------
-
-const repoFlag = Flag.string("repo").pipe(
-  Flag.optional,
-  Flag.withDescription("Repository as owner/name; defaults to GITHUB_REPOSITORY."),
-);
-const prFlag = Flag.integer("pr").pipe(
-  Flag.optional,
-  Flag.withDescription("Pull request number; defaults to the GITHUB_EVENT_PATH payload."),
-);
-const providerFlag = Flag.string("provider").pipe(
-  Flag.withDefault<string>(DEFAULT_PROVIDER),
-  Flag.withDescription('Model provider: "openai" (default) or "anthropic".'),
-);
-const modelFlag = Flag.string("model").pipe(
-  Flag.optional,
-  Flag.withDescription(
-    `Model id (defaults: openai ${DEFAULT_MODEL.openai}, anthropic ${DEFAULT_MODEL.anthropic}).`,
-  ),
-);
-const effortFlag = Flag.string("effort").pipe(
-  Flag.optional,
-  Flag.withDescription(
-    'Reasoning effort: "low", "medium", "high", "xhigh", "max", or a number in [0, 1] resolved onto the provider\'s own ladder.',
-  ),
-);
-const postFlag = Flag.boolean("post").pipe(
-  Flag.withDescription("Post the review to GitHub; without it the plan prints to stdout."),
-);
-const applyVerdictFlag = Flag.boolean("apply-verdict").pipe(
-  Flag.withDescription(
-    "Map the model verdict onto APPROVE/REQUEST_CHANGES instead of always COMMENT.",
-  ),
-);
-const fanOutFlag = Flag.boolean("fan-out").pipe(
-  Flag.withDescription(
-    "Fan the review out to bounded per-unit subagent reviewers (S1 attached delegation) instead of one flat reviewer.",
-  ),
-);
-const ignoreFlag = Flag.string("ignore").pipe(
-  Flag.withDefault(""),
-  Flag.withDescription(
-    'Comma-separated glob patterns removed from the review surface, e.g. "**/*.lock,dist/**".',
-  ),
-);
-const maxFindingsFlag = Flag.integer("max-findings").pipe(
-  Flag.optional,
-  Flag.withDescription("Findings bound (1-20); the schema cap of 20 applies regardless."),
-);
-const skipUnchangedFlag = Flag.boolean("skip-unchanged").pipe(
-  Flag.withDescription(
-    "Skip when the changeset fingerprint matches the last posted review (explicit runs review unconditionally by default).",
-  ),
-);
-
-/** An unknown --provider value; the two supported providers are spelled out. */
-class UnknownProvider extends Schema.TaggedError<UnknownProvider>()("UnknownProvider", {
-  provider: Schema.String,
-}) {
-  override get message() {
-    return `Unknown provider '${this.provider}': expected "openai" or "anthropic".`;
-  }
-}
-
-const decodeProvider = (raw: string): Effect.Effect<ReviewProvider, UnknownProvider> =>
-  raw === "openai" || raw === "anthropic"
-    ? Effect.succeed(raw)
-    : Effect.fail(UnknownProvider.make({ provider: raw }));
-
-const command = CliCommand.make(
-  "pr-review",
-  {
-    repo: repoFlag,
-    pr: prFlag,
-    provider: providerFlag,
-    model: modelFlag,
-    effort: effortFlag,
-    post: postFlag,
-    applyVerdict: applyVerdictFlag,
-    fanOut: fanOutFlag,
-    ignore: ignoreFlag,
-    maxFindings: maxFindingsFlag,
-    skipUnchanged: skipUnchangedFlag,
-  },
-  (flags) =>
-    Effect.gen(function* () {
-      const provider = yield* decodeProvider(flags.provider);
-      const target = yield* resolveReviewTarget({
-        repository: Option.getOrUndefined(flags.repo),
-        number: Option.getOrUndefined(flags.pr),
-      });
-      const model = Option.getOrUndefined(flags.model);
-      const effortRaw = Option.getOrUndefined(flags.effort);
-      let effort: EffortPosition | undefined;
-      if (effortRaw !== undefined) {
-        effort = parseEffortPosition(effortRaw);
-        if (effort === undefined) {
-          return yield* InvalidEffortInput.make({ input: effortRaw });
-        }
-      }
-      const shared = {
-        applyVerdict: flags.applyVerdict,
-        ignore: flags.ignore
-          .split(",")
-          .map((pattern) => pattern.trim())
-          .filter((pattern) => pattern.length > 0),
-        maxFindings: Option.getOrUndefined(flags.maxFindings),
-        modelLabel: describeReviewModel(provider, model, effort),
-      };
-
-      yield* Console.log(
-        `Reviewing ${target.repository}#${target.number} with ${provider}:${model ?? DEFAULT_MODEL[provider]} (${flags.post ? "posting" : "dry run"}${flags.fanOut ? ", fan-out" : ""})...`,
-      );
-
-      const githubLayers = gitHubReviewLayers(target);
-      // Fingerprint check and run under ONE provide, sharing the cached
-      // pull-request snapshot; None means "unchanged, skipped".
-      const runOrSkip = <E, R, FingerprintE, FingerprintR>(reviewer: {
-        readonly run: (runOptions?: RunReviewOptions) => Effect.Effect<ReviewRunOutcome, E, R>;
-        readonly fingerprint: Effect.Effect<string, FingerprintE, FingerprintR>;
-      }) =>
-        Effect.gen(function* () {
-          if (flags.skipUnchanged) {
-            const current = yield* reviewer.fingerprint;
-            if (yield* fingerprintUnchanged(current)) {
-              return Option.none<ReviewRunOutcome>();
-            }
-          }
-          return Option.some(yield* reviewer.run({ post: flags.post }));
-        });
-
-      let result: Option.Option<ReviewRunOutcome>;
-      if (provider === "anthropic") {
-        const boundModel = makeAnthropicReviewModel(model, effort);
-        const reviewer = flags.fanOut
-          ? PrReview.makeFanOut({ ...shared, model: boundModel })
-          : PrReview.make({ ...shared, model: boundModel });
-        result = yield* runOrSkip(reviewer).pipe(
-          Effect.provide(Layer.merge(githubLayers, anthropicClientLayer)),
-        );
-      } else {
-        const boundModel = makeOpenAiReviewModel(model, effort);
-        const reviewer = flags.fanOut
-          ? PrReview.makeFanOut({ ...shared, model: boundModel })
-          : PrReview.make({ ...shared, model: boundModel });
-        result = yield* runOrSkip(reviewer).pipe(
-          Effect.provide(Layer.merge(githubLayers, openAiClientLayer)),
-        );
-      }
-
-      if (Option.isNone(result)) {
-        yield* Console.log("Skipped: changeset unchanged since the last posted review.");
-        return;
-      }
-      const outcome = result.value;
-
-      yield* Console.log(
-        `Review finished in ${outcome.turns} turn(s): verdict ${outcome.review.verdict}, ` +
-          `${outcome.plan.comments.length} inline comment(s), ${outcome.plan.demoted.length} demoted finding(s).`,
-      );
-      if (outcome.published !== undefined) {
-        yield* Console.log(`Posted ${outcome.published.event} review: ${outcome.published.url}`);
-      } else {
-        const encodedPlan = yield* Schema.encodeEffect(ReviewPublicationPlan)(outcome.plan);
-        yield* Console.log(JSON.stringify(encodedPlan, null, 2));
-      }
-    }),
-).pipe(
-  CliCommand.withDescription(
-    "Review one GitHub pull request with an @effect-agent/pr-review reviewer and post the validated result as a pull-request review.",
-  ),
-);
-
-const program = CliCommand.run(command, { version: "0.0.0" }).pipe(
-  Effect.tapError((error) =>
-    Console.error(
-      Schema.is(BudgetExceeded)(error)
-        ? `Budget exceeded: ${error.limit} observed ${error.observedValue}, limit ${error.limitValue}.`
-        : String(error),
-    ),
-  ),
-  Effect.scoped,
-  Effect.provide(NodeServices.layer),
-);
-
-NodeRuntime.runMain(program, { disableErrorReporting: true });

package/src/internal/action-entry.ts

@@ -1,41 +0,0 @@
-import { main } from "../action.ts";
-
-// ---------------------------------------------------------------------------
-// The bundled GitHub Action entrypoint (built by `scripts/build-action.ts`
-// into `action/dist/index.mjs`). A node-runtime action exposes its manifest
-// inputs only as `INPUT_<NAME>` environment variables, so this runtime
-// adapter — the one place the package touches `process.env` directly — maps
-// them onto the PR_REVIEW_* surface `resolveActionInputs` reads, plus the
-// provider and GitHub credentials. Explicit environment variables win over
-// manifest inputs.
-// ---------------------------------------------------------------------------
-
-const INPUT_TO_ENV: ReadonlyArray<readonly [input: string, env: string]> = [
-  ["INPUT_PROVIDER", "PR_REVIEW_PROVIDER"],
-  ["INPUT_MODEL", "PR_REVIEW_MODEL"],
-  ["INPUT_EFFORT", "PR_REVIEW_EFFORT"],
-  ["INPUT_MAX-DURATION-MINUTES", "PR_REVIEW_MAX_DURATION_MINUTES"],
-  ["INPUT_POST", "PR_REVIEW_POST"],
-  ["INPUT_APPLY-VERDICT", "PR_REVIEW_APPLY_VERDICT"],
-  ["INPUT_FAN-OUT", "PR_REVIEW_FAN_OUT"],
-  ["INPUT_GUIDANCE", "PR_REVIEW_GUIDANCE"],
-  ["INPUT_GUIDANCE-FILE", "PR_REVIEW_GUIDANCE_FILE"],
-  ["INPUT_IGNORE", "PR_REVIEW_IGNORE"],
-  ["INPUT_MAX-FINDINGS", "PR_REVIEW_MAX_FINDINGS"],
-  ["INPUT_REVIEW-MODE", "PR_REVIEW_MODE"],
-  ["INPUT_FAIL-ON", "PR_REVIEW_FAIL_ON"],
-  ["INPUT_SKIP-UNCHANGED", "PR_REVIEW_SKIP_UNCHANGED"],
-  ["INPUT_STATE-SECRET", "PR_REVIEW_STATE_SECRET"],
-  ["INPUT_OPENAI-API-KEY", "OPENAI_API_KEY"],
-  ["INPUT_ANTHROPIC-API-KEY", "ANTHROPIC_API_KEY"],
-  ["INPUT_GITHUB-TOKEN", "GITHUB_TOKEN"],
-];
-
-for (const [input, env] of INPUT_TO_ENV) {
-  const value = process.env[input];
-  if (value !== undefined && value !== "" && (process.env[env] ?? "") === "") {
-    process.env[env] = value;
-  }
-}
-
-main();

package/src/internal/coverage.ts

@@ -1,245 +0,0 @@
-import { Option, Schema } from "effect";
-import type { RunEvent } from "effect-agent";
-
-import type { ChangedFile } from "./diff.ts";
-import { FileReviewDelegationFailure, FileReviewRequest, FileReviewUnitResult } from "./fan-out.ts";
-import { FileDiffQuery } from "./review-agent.ts";
-import { planReviewUnits } from "./review-units.ts";
-
-// ---------------------------------------------------------------------------
-// Host-owned coverage. Model summaries are untrusted prose; the check result
-// is based on deterministic unit planning plus the semantic Tool events that
-// prove which required review operations actually settled successfully.
-// ---------------------------------------------------------------------------
-
-export const ReviewShape = Schema.Literals(["flat", "fan-out"]);
-export type ReviewShape = typeof ReviewShape.Type;
-
-export class FailedReviewUnit extends Schema.Class<FailedReviewUnit>(
-  "@effect-agent/pr-review/FailedReviewUnit",
-)({
-  unitId: Schema.NonEmptyString.check(Schema.isMaxLength(32)),
-  errorTag: Schema.NonEmptyString.check(Schema.isMaxLength(256)),
-}) {}
-
-export class ReviewCoverage extends Schema.Class<ReviewCoverage>(
-  "@effect-agent/pr-review/ReviewCoverage",
-)({
-  status: Schema.Literals(["complete", "incomplete"]),
-  requiredPaths: Schema.Array(Schema.NonEmptyString.check(Schema.isMaxLength(512))).check(
-    Schema.isMaxLength(300),
-  ),
-  reviewedPaths: Schema.Array(Schema.NonEmptyString.check(Schema.isMaxLength(512))).check(
-    Schema.isMaxLength(300),
-  ),
-  unreviewedPaths: Schema.Array(Schema.NonEmptyString.check(Schema.isMaxLength(512))).check(
-    Schema.isMaxLength(300),
-  ),
-  failedUnits: Schema.Array(FailedReviewUnit).check(Schema.isMaxLength(8)),
-  reasons: Schema.Array(Schema.NonEmptyString.check(Schema.isMaxLength(1_000))).check(
-    Schema.isMaxLength(20),
-  ),
-}) {}
-
-interface ToolTrace {
-  readonly declared: Map<string, Extract<RunEvent, { readonly _tag: "ToolCallDeclared" }>>;
-  readonly succeeded: Map<string, Extract<RunEvent, { readonly _tag: "ToolCallSucceeded" }>>;
-  readonly failed: Map<string, Extract<RunEvent, { readonly _tag: "ToolCallFailed" }>>;
-}
-
-const toolTrace = (events: ReadonlyArray<RunEvent>): ToolTrace => {
-  const declared = new Map<string, Extract<RunEvent, { readonly _tag: "ToolCallDeclared" }>>();
-  const succeeded = new Map<string, Extract<RunEvent, { readonly _tag: "ToolCallSucceeded" }>>();
-  const failed = new Map<string, Extract<RunEvent, { readonly _tag: "ToolCallFailed" }>>();
-  for (const event of events) {
-    if (event._tag === "ToolCallDeclared") declared.set(event.toolCallId, event);
-    if (event._tag === "ToolCallSucceeded") succeeded.set(event.toolCallId, event);
-    if (event._tag === "ToolCallFailed") failed.set(event.toolCallId, event);
-  }
-  return { declared, succeeded, failed };
-};
-
-const sortedUnique = (values: Iterable<string>): ReadonlyArray<string> =>
-  [...new Set(values)].sort((left, right) => (left < right ? -1 : left > right ? 1 : 0));
-
-const boundedListReason = (label: string, values: Iterable<string>): string => {
-  const items = sortedUnique(values);
-  const prefix = `${label} (${items.length}): `;
-  let rendered = prefix;
-  for (let index = 0; index < items.length; index += 1) {
-    const item = items[index] ?? "";
-    const separator = index === 0 ? "" : ", ";
-    const omitted = items.length - index - 1;
-    const suffix = omitted === 0 ? "" : ` … (+${omitted} more)`;
-    if (`${rendered}${separator}${item}${suffix}`.length > 1_000) {
-      const omission = `… (+${items.length - index} more)`;
-      return `${rendered.slice(0, 1_000 - omission.length)}${omission}`;
-    }
-    rendered = `${rendered}${separator}${item}`;
-  }
-  return rendered;
-};
-
-const flatCoverage = (
-  files: ReadonlyArray<ChangedFile>,
-  totalFiles: number,
-  trace: ToolTrace,
-): ReviewCoverage => {
-  const requiredPaths = sortedUnique(files.map((file) => file.path));
-  const reviewed = new Set<string>();
-  const failedPaths = new Set<string>();
-  for (const [toolCallId, declaration] of trace.declared) {
-    if (declaration.toolName !== "read_file_diff") continue;
-    const query = Schema.decodeUnknownOption(FileDiffQuery)(declaration.parameters);
-    if (Option.isNone(query)) continue;
-    if (trace.succeeded.has(toolCallId)) reviewed.add(query.value.path);
-    if (trace.failed.has(toolCallId)) failedPaths.add(query.value.path);
-  }
-  const undiffable = files.filter((file) => file.patch === undefined).map((file) => file.path);
-  const unreviewed = requiredPaths.filter(
-    (path) => !reviewed.has(path) || undiffable.includes(path) || failedPaths.has(path),
-  );
-  const reasons: Array<string> = [];
-  if (files.length < totalFiles) {
-    reasons.push(`review range exposed ${files.length} of ${totalFiles} required files`);
-  }
-  if (undiffable.length > 0) {
-    reasons.push(boundedListReason("required paths have no textual diff", undiffable));
-  }
-  if (failedPaths.size > 0) {
-    reasons.push(boundedListReason("diff reads failed", failedPaths));
-  }
-  if (unreviewed.length > 0) {
-    reasons.push(boundedListReason("required paths were not successfully reviewed", unreviewed));
-  }
-  return ReviewCoverage.make({
-    status: reasons.length === 0 ? "complete" : "incomplete",
-    requiredPaths,
-    reviewedPaths: sortedUnique(reviewed),
-    unreviewedPaths: sortedUnique(unreviewed),
-    failedUnits: [],
-    reasons,
-  });
-};
-
-const fanOutCoverage = (
-  files: ReadonlyArray<ChangedFile>,
-  totalFiles: number,
-  trace: ToolTrace,
-): ReviewCoverage => {
-  const plan = planReviewUnits(files, { totalChangedFiles: totalFiles });
-  const declarationsByUnit = new Map<
-    string,
-    Array<{ readonly id: string; readonly paths: ReadonlyArray<string> }>
-  >();
-  for (const [toolCallId, declaration] of trace.declared) {
-    if (declaration.toolName !== "delegate_file_review") continue;
-    const request = Schema.decodeUnknownOption(FileReviewRequest)(declaration.parameters);
-    if (Option.isNone(request)) continue;
-    const declarations = declarationsByUnit.get(request.value.unitId) ?? [];
-    declarations.push({ id: toolCallId, paths: request.value.paths });
-    declarationsByUnit.set(request.value.unitId, declarations);
-  }
-
-  const reviewed = new Set<string>();
-  const unreviewed = new Set<string>([...plan.undiffablePaths, ...plan.unassignedPaths]);
-  const failedUnits: Array<FailedReviewUnit> = [];
-  const reasons: Array<string> = [];
-  for (const unit of plan.units) {
-    const declarations = declarationsByUnit.get(unit.unitId) ?? [];
-    const expectedPaths = [...unit.paths];
-    const exact = declarations.filter(
-      (declaration) =>
-        declaration.paths.length === expectedPaths.length &&
-        declaration.paths.every((path, index) => path === expectedPaths[index]),
-    );
-    const successful = exact.filter((declaration) => {
-      const event = trace.succeeded.get(declaration.id);
-      if (event === undefined || trace.failed.has(declaration.id)) return false;
-      const result = Schema.decodeUnknownOption(FileReviewUnitResult)(event.result);
-      return Option.isSome(result) && result.value.unitId === unit.unitId;
-    });
-    if (declarations.length === 1 && exact.length === 1 && successful.length === 1) {
-      for (const path of unit.paths) reviewed.add(path);
-      continue;
-    }
-    for (const path of unit.paths) unreviewed.add(path);
-    const failure = declarations
-      .map((declaration) => trace.failed.get(declaration.id))
-      .find((event) => event !== undefined);
-    const returnedFailure = declarations
-      .map((declaration) => trace.succeeded.get(declaration.id))
-      .filter((event) => event !== undefined)
-      .map((event) => Schema.decodeUnknownOption(FileReviewDelegationFailure)(event.result))
-      .find(Option.isSome);
-    failedUnits.push(
-      FailedReviewUnit.make({
-        unitId: unit.unitId,
-        errorTag:
-          failure?.errorTag ??
-          (returnedFailure !== undefined
-            ? returnedFailure.value._tag === "FileReviewUnitFailed"
-              ? `${returnedFailure.value._tag}:${returnedFailure.value.childErrorTag}`
-              : returnedFailure.value._tag
-            : undefined) ??
-          (declarations.length === 0
-            ? "UnitNotAssigned"
-            : declarations.length > 1
-              ? "UnitAssignedMultipleTimes"
-              : exact.length === 0
-                ? "UnitAssignmentMismatch"
-                : "UnitDidNotSettleSuccessfully"),
-      }),
-    );
-  }
-  if (plan.truncated) {
-    reasons.push(`review range exposed ${files.length} of ${totalFiles} required files`);
-  }
-  if (plan.undiffablePaths.length > 0) {
-    reasons.push(boundedListReason("required paths have no textual diff", plan.undiffablePaths));
-  }
-  if (plan.unassignedPaths.length > 0) {
-    reasons.push(boundedListReason("fan-out capacity left paths unassigned", plan.unassignedPaths));
-  }
-  if (failedUnits.length > 0) {
-    reasons.push(
-      boundedListReason(
-        "review units did not complete",
-        failedUnits.map((unit) => `${unit.unitId} (${unit.errorTag})`),
-      ),
-    );
-  }
-  return ReviewCoverage.make({
-    status: reasons.length === 0 ? "complete" : "incomplete",
-    requiredPaths: sortedUnique(files.map((file) => file.path)),
-    reviewedPaths: sortedUnique(reviewed),
-    unreviewedPaths: sortedUnique(unreviewed),
-    failedUnits,
-    reasons,
-  });
-};
-
-/** Assess one settled run without trusting its prose summary or verdict. */
-export const assessReviewCoverage = (input: {
-  readonly shape: ReviewShape;
-  readonly files: ReadonlyArray<ChangedFile>;
-  readonly totalFiles: number;
-  readonly anchorFiles: ReadonlyArray<ChangedFile>;
-  readonly totalAnchorFiles: number;
-  readonly events: ReadonlyArray<RunEvent>;
-}): ReviewCoverage => {
-  const trace = toolTrace(input.events);
-  const coverage =
-    input.shape === "fan-out"
-      ? fanOutCoverage(input.files, input.totalFiles, trace)
-      : flatCoverage(input.files, input.totalFiles, trace);
-  if (input.anchorFiles.length >= input.totalAnchorFiles) return coverage;
-  return ReviewCoverage.make({
-    ...coverage,
-    status: "incomplete",
-    reasons: [
-      ...coverage.reasons,
-      `full pull-request anchor surface exposed ${input.anchorFiles.length} of ${input.totalAnchorFiles} required files`,
-    ],
-  });
-};

package/src/internal/diff.ts

@@ -1,134 +0,0 @@
-import { Schema } from "effect";
-
-// ---------------------------------------------------------------------------
-// Changed-file and unified-diff primitives shared by the tool surface, the
-// publication planner, and the GitHub adapter. The parser is deterministic
-// and bounded; it never throws on malformed hunks — unparseable patch text
-// simply yields no commentable lines, which fails findings closed.
-// ---------------------------------------------------------------------------
-
-/** A repository-relative file path as transported values carry it. */
-export const ChangedPath = Schema.NonEmptyString.check(Schema.isMaxLength(512));
-
-/** GitHub's changed-file status vocabulary, kept verbatim. */
-export const ChangedFileStatus = Schema.Literals([
-  "added",
-  "removed",
-  "modified",
-  "renamed",
-  "copied",
-  "changed",
-  "unchanged",
-]);
-
-/** One file changed by the pull request, with its optional textual patch. */
-export class ChangedFile extends Schema.Class<ChangedFile>("@effect-agent/pr-review/ChangedFile")({
-  path: ChangedPath,
-  status: ChangedFileStatus,
-  additions: Schema.Int.check(Schema.isGreaterThanOrEqualTo(0)),
-  deletions: Schema.Int.check(Schema.isGreaterThanOrEqualTo(0)),
-  /** Present for renames/copies: the path the file previously had. */
-  previousPath: Schema.optionalKey(ChangedPath),
-  /** Unified-diff hunks; absent for binary or oversized files. */
-  patch: Schema.optionalKey(Schema.String),
-}) {}
-
-/** One parsed line of a unified diff, with both coordinate systems. */
-export interface PatchLine {
-  readonly kind: "context" | "add" | "del";
-  readonly oldLine: number | undefined;
-  readonly newLine: number | undefined;
-  readonly text: string;
-}
-
-const HUNK_HEADER = /^@@ -(\d+)(?:,\d+)? \+(\d+)(?:,\d+)? @@/;
-
-/**
- * Parse unified-diff hunk text into coordinate-tagged lines. Lines outside a
- * recognized hunk header are ignored rather than guessed at.
- */
-export const parsePatch = (patch: string): ReadonlyArray<PatchLine> => {
-  const lines: Array<PatchLine> = [];
-  let oldLine = 0;
-  let newLine = 0;
-  let inHunk = false;
-  for (const raw of patch.split("\n")) {
-    const header = HUNK_HEADER.exec(raw);
-    if (header !== null) {
-      oldLine = Number(header[1]);
-      newLine = Number(header[2]);
-      inHunk = true;
-      continue;
-    }
-    if (!inHunk) continue;
-    if (raw.startsWith("+")) {
-      lines.push({ kind: "add", oldLine: undefined, newLine, text: raw.slice(1) });
-      newLine += 1;
-    } else if (raw.startsWith("-")) {
-      lines.push({ kind: "del", oldLine, newLine: undefined, text: raw.slice(1) });
-      oldLine += 1;
-    } else if (raw.startsWith(" ") || raw === "") {
-      lines.push({ kind: "context", oldLine, newLine, text: raw.slice(1) });
-      oldLine += 1;
-      newLine += 1;
-    } else if (raw.startsWith("\\")) {
-      // "" — metadata, not a diff line.
-    } else {
-      // Unrecognized content ends the current hunk conservatively.
-      inHunk = false;
-    }
-  }
-  return lines;
-};
-
-/**
- * The new-file line numbers a GitHub review comment may anchor to on the
- * RIGHT side: every added or context line that appears in the diff.
- */
-export const commentableLines = (patch: string): ReadonlySet<number> => {
-  const lines = new Set<number>();
-  for (const line of parsePatch(patch)) {
-    if (line.newLine !== undefined) lines.add(line.newLine);
-  }
-  return lines;
-};
-
-/**
- * Render a patch with explicit RIGHT-side line numbers so the model can
- * anchor findings without arithmetic. `R<n>` marks a line that exists in the
- * new version of the file (`+` added, blank context); deleted lines keep a
- * bare `-` marker and no number.
- */
-export const annotatePatch = (patch: string): string => {
-  const output: Array<string> = [];
-  let oldLine = 0;
-  let newLine = 0;
-  let inHunk = false;
-  for (const raw of patch.split("\n")) {
-    const header = HUNK_HEADER.exec(raw);
-    if (header !== null) {
-      oldLine = Number(header[1]);
-      newLine = Number(header[2]);
-      inHunk = true;
-      output.push(raw);
-      continue;
-    }
-    if (!inHunk) continue;
-    if (raw.startsWith("+")) {
-      output.push(`R${newLine} + ${raw.slice(1)}`);
-      newLine += 1;
-    } else if (raw.startsWith("-")) {
-      output.push(`      - ${raw.slice(1)}`);
-      oldLine += 1;
-    } else if (raw.startsWith(" ") || raw === "") {
-      output.push(`R${newLine}   ${raw.slice(1)}`);
-      oldLine += 1;
-      newLine += 1;
-    } else if (raw.startsWith("\\")) {
-      output.push(`        ${raw}`);
-    } else {
-      inHunk = false;
-    }
-  }
-  return output.join("\n");
-};