@effect-agent/pr-review 0.1.0-beta.12 → 0.1.0-beta.13

package/src/internal/fixtures.ts

@@ -28,6 +28,7 @@ import {
 /** One fixture file: its changeset entry plus optional head content. */
 export class FixtureFile extends Schema.Class<FixtureFile>("@effect-agent/pr-review/FixtureFile")({
   file: ChangedFile,
+  baseContent: Schema.optionalKey(Schema.String.check(Schema.isMaxLength(MAX_FILE_CHARS))),
   headContent: Schema.optionalKey(Schema.String.check(Schema.isMaxLength(MAX_FILE_CHARS))),
 }) {}
 
@@ -57,12 +58,21 @@ const requireChanged = (
 /** Deterministic `PullRequestSource` over one fixture pull request. */
 export const fixturePullRequestSourceLayer = (
   fixture: FixturePullRequest,
-): Layer.Layer<PullRequestSource> =>
-  Layer.succeed(PullRequestSource)(
+): Layer.Layer<PullRequestSource> => {
+  const files = fixture.files.map((entry) =>
+    entry.file.patch !== undefined
+      ? entry.file
+      : ChangedFile.make({
+          ...entry.file,
+          ...(entry.baseContent === undefined ? {} : { reviewBaseContent: entry.baseContent }),
+          ...(entry.headContent === undefined ? {} : { reviewHeadContent: entry.headContent }),
+        }),
+  );
+  return Layer.succeed(PullRequestSource)(
     PullRequestSource.of({
       metadata: Effect.succeed(fixture.metadata),
-      changedFiles: Effect.succeed(fixture.files.map((entry) => entry.file)),
-      anchorFiles: Effect.succeed(fixture.files.map((entry) => entry.file)),
+      changedFiles: Effect.succeed(files),
+      anchorFiles: Effect.succeed(files),
       readFile: (path) =>
         Effect.gen(function* () {
           const relative = yield* normalizeRepoRelativePath(path);
@@ -77,6 +87,7 @@ export const fixturePullRequestSourceLayer = (
         }),
     }),
   );
+};
 
 /** In-memory publisher: records every plan and mints a deterministic receipt. */
 export const collectingReviewPublisherLayer = (

package/src/internal/github.ts

@@ -313,21 +313,13 @@ export const gitHubPullRequestSourceLayer: Layer.Layer<
     const metadata = yield* Effect.cached(
       fetchMetadata.pipe(Effect.provideService(HttpClient.HttpClient, client)),
     );
-    const changedFiles = yield* Effect.cached(
+    const rawFiles = yield* Effect.cached(
       fetchFiles.pipe(Effect.provideService(HttpClient.HttpClient, client)),
     );
 
-    const readFile = (path: string) =>
+    const readRepositoryFile = (path: string, ref: string) =>
       Effect.gen(function* () {
         const relative = yield* normalizeRepoRelativePath(path);
-        const files = yield* changedFiles;
-        if (!files.some((file) => file.path === relative)) {
-          return yield* ReviewInputViolation.make({
-            input: relative,
-            reason: "Path is not part of this pull request's changeset.",
-          });
-        }
-        const head = yield* metadata;
         const encodedPath = relative.split("/").map(encodeURIComponent).join("/");
         const response = yield* executeOk(
           "readFile",
@@ -336,12 +328,32 @@ export const gitHubPullRequestSourceLayer: Layer.Layer<
               `${target.apiUrl}/repos/${target.repository}/contents/${encodedPath}`,
             ).pipe(
               HttpClientRequest.accept("application/vnd.github.raw+json"),
-              HttpClientRequest.setUrlParams({ ref: head.headSha }),
+              HttpClientRequest.setUrlParams({ ref }),
             ),
             target.token,
           ),
         ).pipe(Effect.provideService(HttpClient.HttpClient, client));
-        const text = yield* response.text.pipe(Effect.mapError(failWith("readFile")));
+        const buffer = yield* response.arrayBuffer.pipe(Effect.mapError(failWith("readFile")));
+        if (buffer.byteLength > MAX_FILE_CHARS) {
+          return yield* ReviewInputViolation.make({
+            input: relative,
+            reason: `File is larger than the ${MAX_FILE_CHARS}-byte read bound.`,
+          });
+        }
+        const text = yield* Effect.try({
+          try: () => new TextDecoder("utf-8", { fatal: true }).decode(buffer),
+          catch: () =>
+            ReviewInputViolation.make({
+              input: relative,
+              reason: "File is not valid UTF-8 text.",
+            }),
+        });
+        if (text.includes("\u0000")) {
+          return yield* ReviewInputViolation.make({
+            input: relative,
+            reason: "File contains binary NUL bytes.",
+          });
+        }
         if (text.length > MAX_FILE_CHARS) {
           return yield* ReviewInputViolation.make({
             input: relative,
@@ -351,6 +363,55 @@ export const gitHubPullRequestSourceLayer: Layer.Layer<
         return text;
       });
 
+    const changedFiles = yield* Effect.cached(
+      Effect.gen(function* () {
+        const [files, pullRequest] = yield* Effect.all([rawFiles, metadata]);
+        return yield* Effect.forEach(
+          files,
+          (file) => {
+            if (file.patch !== undefined) return Effect.succeed(file);
+            const basePath = file.previousPath ?? file.path;
+            const base =
+              file.status === "added"
+                ? Effect.succeed(Option.none<string>())
+                : readRepositoryFile(basePath, pullRequest.baseSha ?? pullRequest.baseRef).pipe(
+                    Effect.option,
+                  );
+            const head =
+              file.status === "removed"
+                ? Effect.succeed(Option.none<string>())
+                : readRepositoryFile(file.path, pullRequest.headSha).pipe(Effect.option);
+            return Effect.all({ base, head }).pipe(
+              Effect.map(({ base, head }) =>
+                ChangedFile.make({
+                  ...file,
+                  ...(Option.isSome(base) ? { reviewBaseContent: base.value } : {}),
+                  ...(Option.isSome(head) ? { reviewHeadContent: head.value } : {}),
+                }),
+              ),
+            );
+          },
+          { concurrency: 4 },
+        );
+      }),
+    );
+
+    const readFile = (path: string) =>
+      Effect.gen(function* () {
+        const relative = yield* normalizeRepoRelativePath(path);
+        const files = yield* changedFiles;
+        const file = files.find((candidate) => candidate.path === relative);
+        if (file === undefined) {
+          return yield* ReviewInputViolation.make({
+            input: relative,
+            reason: "Path is not part of this pull request's changeset.",
+          });
+        }
+        if (file.reviewHeadContent !== undefined) return file.reviewHeadContent;
+        const head = yield* metadata;
+        return yield* readRepositoryFile(relative, head.headSha);
+      });
+
     return PullRequestSource.of({ metadata, changedFiles, anchorFiles: changedFiles, readFile });
   }),
 );

package/src/internal/render.ts

@@ -192,7 +192,7 @@ export const anchorViolation = (
 ): string | undefined => {
   const file = files.find((candidate) => candidate.path === finding.path);
   if (file === undefined) return "path is not part of the changeset";
-  if (file.patch === undefined) return "file has no textual diff";
+  if (file.patch === undefined) return "file has no anchorable textual diff";
   if (finding.endLine < finding.startLine) return "endLine precedes startLine";
   if (finding.endLine - finding.startLine + 1 > 100) return "range is implausibly large";
   const anchors = commentableLines(file.patch);

package/src/internal/review-agent.ts

@@ -1,8 +1,14 @@
 import { Effect, Schema } from "effect";
-import { Agent, AgentPolicy, ToolExecutionClass } from "effect-agent";
+import { Agent, AgentPolicy, ToolExecutionClass, ToolResultBounds } from "effect-agent";
 import { Tool, Toolkit } from "effect/unstable/ai";
 
-import { annotatePatch, ChangedFileStatus, ChangedPath } from "./diff.ts";
+import {
+  annotatePatch,
+  ChangedFileStatus,
+  ChangedPath,
+  hasReviewableContent,
+  renderReviewContent,
+} from "./diff.ts";
 import {
   normalizeRepoRelativePath,
   PullRequestSource,
@@ -27,6 +33,9 @@ export const MAX_CONCERNS = 10;
 /** Annotated patches larger than this are truncated with an explicit marker. */
 const MAX_PATCH_CHARS = 60_000;
 
+/** The encoded Tool result must retain one complete bounded content fallback. */
+export const REVIEW_TOOL_RESULT_MAX_BYTES = 2 * 1024 * 1024;
+
 /** One `read_file` slice never exceeds this many lines. */
 const MAX_SLICE_LINES = 1_000;
 const DEFAULT_SLICE_LINES = 400;
@@ -43,6 +52,8 @@ export class ChangedFileSummary extends Schema.Class<ChangedFileSummary>(
   additions: Schema.Int.check(Schema.isGreaterThanOrEqualTo(0)),
   deletions: Schema.Int.check(Schema.isGreaterThanOrEqualTo(0)),
   hasTextualDiff: Schema.Boolean,
+  /** True when a missing patch was recovered as bounded UTF-8 base/head content. */
+  hasReviewableContent: Schema.Boolean,
 }) {}
 
 export class ChangedFilesView extends Schema.Class<ChangedFilesView>(
@@ -82,10 +93,13 @@ export class FileDiffView extends Schema.Class<FileDiffView>(
 )({
   path: ChangedPath,
   status: ChangedFileStatus,
+  reviewMode: Schema.Literals(["diff", "content", "unavailable"]),
   /**
    * The unified diff with explicit RIGHT-side line numbers: `R<n>` marks a
    * line present in the new file version (only those may anchor findings);
-   * `-` marks removed lines. Empty when no textual diff exists.
+   * `-` marks removed lines. For content fallback, `B<n>` and `H<n>`
+   * identify base/head lines for reading only; they are never valid anchors.
+   * Empty only when neither a patch nor bounded textual content exists.
    */
   annotatedPatch: Schema.String,
   truncated: Schema.Boolean,
@@ -98,7 +112,7 @@ export class FileDiffView extends Schema.Class<FileDiffView>(
 // security (the run stays bounded by AgentPolicy regardless).
 export const ReadFileDiff = Tool.make("read_file_diff", {
   description:
-    "Read the annotated unified diff of one changed file. Lines marked R<number> exist in the new version and are the only valid finding anchors.",
+    "Read one changed file's review evidence. A normal unified diff marks valid anchors as R<number>. When GitHub omitted the diff, bounded base/head content is returned with B/H line labels for review but no valid inline anchors.",
   parameters: FileDiffQuery,
   success: FileDiffView,
   failure: Schema.Union([PullRequestSourceFailure, ReviewInputViolation]),
@@ -158,6 +172,7 @@ export const listChangedFilesHandler = (_query: ListChangedFilesQuery) =>
           additions: file.additions,
           deletions: file.deletions,
           hasTextualDiff: file.patch !== undefined,
+          hasReviewableContent: hasReviewableContent(file),
         }),
       ),
     });
@@ -179,11 +194,20 @@ export const readFileDiffHandler = (query: FileDiffQuery) =>
         reason: "Path is not part of this pull request's changeset.",
       });
     }
-    const annotated = file.patch === undefined ? "" : annotatePatch(file.patch);
-    const truncated = annotated.length > MAX_PATCH_CHARS;
+    const contentEvidence = renderReviewContent(file);
+    const reviewMode =
+      file.patch !== undefined
+        ? ("diff" as const)
+        : contentEvidence !== undefined
+          ? ("content" as const)
+          : ("unavailable" as const);
+    const annotated =
+      file.patch === undefined ? (contentEvidence ?? "") : annotatePatch(file.patch);
+    const truncated = reviewMode === "diff" && annotated.length > MAX_PATCH_CHARS;
     return FileDiffView.make({
       path: file.path,
       status: file.status,
+      reviewMode,
       annotatedPatch: truncated
         ? `${annotated.slice(0, MAX_PATCH_CHARS)}\n[diff truncated]`
         : annotated,
@@ -337,7 +361,7 @@ export const makeReviewInstructions =
       ...resolveGuidance(options.guidance, mission),
       "Work in this order:",
       "1. Call list_changed_files once to see the changeset.",
-      "2. Call read_file_diff for every file you review. In its output, only lines marked R<number> exist in the new version; those numbers are the only valid values for startLine and endLine. Never anchor a finding to a removed (-) line.",
+      "2. Call read_file_diff for every file you review. A normal diff marks new-version anchors as R<number>; only those numbers are valid startLine/endLine values. When GitHub omitted a diff, the tool may return bounded base/head content marked B/H instead. Review that content, but report its defects as non-anchored concerns because B/H lines cannot anchor GitHub comments. Never anchor a finding to a removed (-), B, or H line.",
       "3. Call read_file when you need surrounding context the diff does not show. ONLY files in the changeset are readable: a request for any other path (an import, a neighbor, a config) returns a failed result — do not retry it; reason from the diff instead and note the gap honestly in your summary when it matters.",
       "4. Review for real defects first: correctness, security, concurrency, resource leaks, error handling, API misuse. Style nits are least important. Do not praise; do not restate the diff.",
       "When the diff adds or changes a test, check that it can actually fail: a test that would still pass with the bug present is theatre, not coverage. The usual tell is a loose assertion standing where an exact one belongs — >= or a truthiness check over an expected value, or a snapshot that absorbs whatever it is handed.",
@@ -363,6 +387,7 @@ export const defaultReviewPolicy = AgentPolicy.make({
   // Keep enough output/summary headroom for the 200k-class provider window;
   // tool-heavy histories prune before the engine spends a summarization call.
   contextTokenLimit: 150_000,
+  toolResultBounds: ToolResultBounds.make({ maxBytes: REVIEW_TOOL_RESULT_MAX_BYTES }),
   // Budget soft landing (RUN-018): an exhausted reviewer returns its partial
   // review on one final tool-free turn instead of failing the whole run.
   onExhaustion: "final-answer",

package/src/internal/review-state.ts

@@ -443,9 +443,29 @@ export const selectedPullRequestSourceLayer = (
     Effect.gen(function* () {
       const source = yield* PullRequestSource;
       const selectedPaths = new Set(selection.files.map((file) => file.path));
+      const selectedFiles = source.changedFiles.pipe(
+        Effect.map((fullFiles) => {
+          const fullByPath = new Map(fullFiles.map((file) => [file.path, file] as const));
+          return selection.files.map((file) => {
+            if (file.patch !== undefined) return file;
+            const full = fullByPath.get(file.path);
+            return full === undefined
+              ? file
+              : ChangedFile.make({
+                  ...file,
+                  ...(full.reviewBaseContent === undefined
+                    ? {}
+                    : { reviewBaseContent: full.reviewBaseContent }),
+                  ...(full.reviewHeadContent === undefined
+                    ? {}
+                    : { reviewHeadContent: full.reviewHeadContent }),
+                });
+          });
+        }),
+      );
       return PullRequestSource.of({
         metadata: source.metadata,
-        changedFiles: Effect.succeed(selection.files),
+        changedFiles: selectedFiles,
         anchorFiles: source.anchorFiles,
         readFile: (path) =>
           selectedPaths.has(path)

package/src/internal/review-units.ts

@@ -1,7 +1,7 @@
 import { Schema } from "effect";
 
 import type { ChangedFile } from "./diff.ts";
-import { ChangedPath } from "./diff.ts";
+import { ChangedPath, isReviewableFile } from "./diff.ts";
 import type { FindingSeverity } from "./review-agent.ts";
 import { ReviewFinding } from "./review-agent.ts";
 
@@ -48,7 +48,7 @@ export class ReviewUnitPlan extends Schema.Class<ReviewUnitPlan>(
   /** True when the source returned fewer files than the pull request has. */
   truncated: Schema.Boolean,
   units: Schema.Array(ReviewUnit).check(Schema.isMaxLength(MAX_REVIEW_UNITS)),
-  /** Changed files without a textual diff; no finding can anchor to them. */
+  /** Changed files with neither a textual diff nor bounded base/head text. */
   undiffablePaths: Schema.Array(ChangedPath).check(Schema.isMaxLength(300)),
   /**
    * Diffable files beyond the fan-out capacity (MAX_REVIEW_UNITS units of
@@ -58,8 +58,12 @@ export class ReviewUnitPlan extends Schema.Class<ReviewUnitPlan>(
   unassignedPaths: Schema.Array(ChangedPath).check(Schema.isMaxLength(300)),
 }) {}
 
-const fileCost = (file: ChangedFile): number =>
-  file.additions + file.deletions + FILE_OVERHEAD_LINES;
+const fileCost = (file: ChangedFile): number => {
+  const contentChars =
+    (file.reviewBaseContent?.length ?? 0) + (file.reviewHeadContent?.length ?? 0);
+  const contentWeight = Math.ceil(contentChars / 200);
+  return file.additions + file.deletions + contentWeight + FILE_OVERHEAD_LINES;
+};
 
 const unitOf = (index: number, files: ReadonlyArray<ChangedFile>): ReviewUnit =>
   ReviewUnit.make({
@@ -76,10 +80,12 @@ const unitOf = (index: number, files: ReadonlyArray<ChangedFile>): ReviewUnit =>
  * then packed greedily in that order under the soft changed-line budget and
  * the hard per-unit file bound. Capacity is finite and explicit:
  *
- * - files without a textual diff are not delegated — no finding can anchor
- *   to them (anchor validation demands a parsed patch), so they surface in
- *   `undiffablePaths` instead of consuming a child's budget;
- * - diffable files beyond `MAX_REVIEW_UNITS` full units surface in
+ * - files without a textual diff are still delegated when the source
+ *   recovered complete bounded UTF-8 base/head content. Findings from that
+ *   evidence cannot anchor inline and are reported as concerns;
+ * - files with neither form of textual evidence surface in
+ *   `undiffablePaths` instead of laundering missing coverage;
+ * - reviewable files beyond `MAX_REVIEW_UNITS` full units surface in
  *   `unassignedPaths` so the review can report them as unreviewed, never
  *   silently truncated.
  */
@@ -88,14 +94,14 @@ export const planReviewUnits = (
   options: { readonly totalChangedFiles: number },
 ): ReviewUnitPlan => {
   const ordered = [...files].sort((left, right) => (left.path < right.path ? -1 : 1));
-  const diffable = ordered.filter((file) => file.patch !== undefined);
-  const undiffable = ordered.filter((file) => file.patch === undefined);
+  const reviewable = ordered.filter(isReviewableFile);
+  const undiffable = ordered.filter((file) => !isReviewableFile(file));
 
   const groups: Array<Array<ChangedFile>> = [];
   const unassigned: Array<ChangedFile> = [];
   let current: Array<ChangedFile> = [];
   let currentCost = 0;
-  for (const file of diffable) {
+  for (const file of reviewable) {
     const cost = fileCost(file);
     const wouldOverflow =
       current.length >= MAX_UNIT_FILES ||