@effect-agent/pr-review 0.1.0-beta.23 → 0.1.0-beta.24

package/src/internal/fan-out.ts

@@ -25,6 +25,7 @@ import {
   WalkthroughEntry,
 } from "./review-agent.ts";
 import {
+  MAX_REPORTED_UNASSIGNED_EVIDENCE_SHARDS,
   MAX_REVIEW_UNITS,
   MAX_UNIT_EVIDENCE_SHARDS,
   MAX_UNIT_FILES,
@@ -32,13 +33,13 @@ import {
   planReviewUnits,
   rankAndDedupeConcerns,
   rankAndDedupeFindings,
+  ReviewDiscoveryPass,
   ReviewEvidenceShardId,
   ReviewPassId,
   ReviewRiskCategory,
+  ReviewUnit,
   ReviewUnitId,
-  type ReviewDiscoveryPass,
-  type ReviewUnit,
-  type ReviewUnitPlan,
+  ReviewUnitPlan,
 } from "./review-units.ts";
 
 // ---------------------------------------------------------------------------
@@ -361,6 +362,11 @@ export interface FanOutPipelineOutcome {
   readonly plan: ReviewUnitPlan;
   /** Paths of units with an unsettled pass — retryable scope for the next run. */
   readonly unreviewedPaths: ReadonlyArray<string>;
+  /** Failed stages paired with the leftover paths they still own. */
+  readonly unreviewedPasses: ReadonlyArray<{
+    readonly stage: FailedReviewPass["stage"];
+    readonly paths: ReadonlyArray<string>;
+  }>;
   /** Total settled child turns across every scheduled pass. */
   readonly turns: number;
 }
@@ -372,6 +378,16 @@ export interface FanOutPipelineInput {
   readonly maxFindings?: number | undefined;
   /** Shared run budget observed by every child pass. */
   readonly budget?: RunBudgetHook<BudgetExceeded | BudgetAdapterError> | undefined;
+  /**
+   * Unchanged leftover paths from a prior failed pass. Those units retry only
+   * the recorded stages — no second general discovery on files nobody touched.
+   */
+  readonly retry?:
+    | {
+        readonly paths: ReadonlyArray<string>;
+        readonly stages: ReadonlyArray<FailedReviewPass["stage"]>;
+      }
+    | undefined;
 }
 
 const candidateOrdinal = (index: number): string => String(index + 1).padStart(3, "0");
@@ -587,6 +603,10 @@ interface UnitReviewOutcome {
   readonly requiredVerificationPasses: number;
   readonly completedVerificationPasses: number;
   readonly unreviewedPaths: ReadonlyArray<string>;
+  readonly unreviewedPasses: ReadonlyArray<{
+    readonly stage: FailedReviewPass["stage"];
+    readonly paths: ReadonlyArray<string>;
+  }>;
 }
 
 const reviewUnit = <Provider, ModelProvides, ModelRequires>(
@@ -697,6 +717,10 @@ const reviewUnit = <Provider, ModelProvides, ModelRequires>(
       requiredVerificationPasses,
       completedVerificationPasses,
       unreviewedPaths: failedPasses.length > 0 ? unit.paths : [],
+      unreviewedPasses: failedPasses.map((pass) => ({
+        stage: pass.stage,
+        paths: unit.paths,
+      })),
     } satisfies UnitReviewOutcome;
   });
 
@@ -737,6 +761,121 @@ const composeSummary = (plan: ReviewUnitPlan, assurance: ReviewAssurance): strin
   return parts.join(" ").slice(0, 4_000);
 };
 
+const remapPlanUnitIds = (plan: ReviewUnitPlan, offset: number): ReviewUnitPlan => {
+  if (offset === 0) return plan;
+  const units = plan.units.map((unit, index) =>
+    ReviewUnit.make({
+      ...unit,
+      unitId: `unit-${String(offset + index + 1).padStart(3, "0")}`,
+    }),
+  );
+  const mappedIds = new Map<string, string>();
+  for (const [index, unit] of plan.units.entries()) {
+    const remapped = units[index];
+    if (remapped !== undefined) {
+      mappedIds.set(unit.unitId, remapped.unitId);
+    }
+  }
+  return ReviewUnitPlan.make({
+    ...plan,
+    units,
+    discoveryPasses: plan.discoveryPasses.map((pass) => {
+      const unitId = mappedIds.get(pass.unitId) ?? pass.unitId;
+      return ReviewDiscoveryPass.make({
+        ...pass,
+        unitId,
+        passId: `${unitId}${pass.passId.slice(pass.unitId.length)}`,
+      });
+    }),
+  });
+};
+
+const scheduleFanOutWork = (
+  input: FanOutPipelineInput,
+): {
+  readonly plan: ReviewUnitPlan;
+  readonly passesByUnit: Map<string, ReadonlyArray<ReviewDiscoveryPass>>;
+  readonly overflowRetryPaths: ReadonlyArray<string>;
+} => {
+  const retryPathSet = new Set(input.retry?.paths ?? []);
+  const retryStages = new Set(input.retry?.stages ?? []);
+  if (retryPathSet.size === 0) {
+    const plan = planReviewUnits(input.files, { totalChangedFiles: input.totalChangedFiles });
+    const passesByUnit = new Map<string, Array<ReviewDiscoveryPass>>();
+    for (const pass of plan.discoveryPasses) {
+      const passes = passesByUnit.get(pass.unitId) ?? [];
+      passes.push(pass);
+      passesByUnit.set(pass.unitId, passes);
+    }
+    return { plan, passesByUnit, overflowRetryPaths: [] };
+  }
+  const freshFiles = input.files.filter((file) => !retryPathSet.has(file.path));
+  const retryFiles = input.files.filter((file) => retryPathSet.has(file.path));
+  const freshPlan = planReviewUnits(freshFiles, { totalChangedFiles: input.totalChangedFiles });
+  const retryPlan = remapPlanUnitIds(
+    planReviewUnits(retryFiles, { totalChangedFiles: input.totalChangedFiles }),
+    freshPlan.units.length,
+  );
+  const acceptedFresh = freshPlan.units.slice(0, MAX_REVIEW_UNITS);
+  const acceptedRetry = retryPlan.units.slice(
+    0,
+    Math.max(0, MAX_REVIEW_UNITS - acceptedFresh.length),
+  );
+  const overflowRetryPaths = retryPlan.units
+    .slice(acceptedRetry.length)
+    .flatMap((unit) => [...unit.paths]);
+  const retryPassFilter = (pass: ReviewDiscoveryPass): boolean => {
+    const stage = pass.perspective === "risk-specialist" ? "specialist" : "discovery";
+    return retryStages.has(stage);
+  };
+  const acceptedRetryIds = new Set(acceptedRetry.map((unit) => unit.unitId));
+  let retryPasses = retryPlan.discoveryPasses.filter(
+    (pass) => acceptedRetryIds.has(pass.unitId) && retryPassFilter(pass),
+  );
+  if (
+    retryStages.has("verification") &&
+    !retryStages.has("discovery") &&
+    !retryStages.has("specialist")
+  ) {
+    retryPasses = retryPlan.discoveryPasses.filter((pass) => acceptedRetryIds.has(pass.unitId));
+  }
+  const acceptedFreshIds = new Set(acceptedFresh.map((unit) => unit.unitId));
+  const freshPasses = freshPlan.discoveryPasses.filter((pass) => acceptedFreshIds.has(pass.unitId));
+  const discoveryPasses = [...freshPasses, ...retryPasses];
+  const plan = ReviewUnitPlan.make({
+    totalFiles: input.files.length,
+    truncated: freshPlan.truncated || retryPlan.truncated,
+    units: [...acceptedFresh, ...acceptedRetry],
+    discoveryPasses,
+    undiffablePaths: [
+      ...new Set([...freshPlan.undiffablePaths, ...retryPlan.undiffablePaths]),
+    ].sort(),
+    partialEvidencePaths: [
+      ...new Set([...freshPlan.partialEvidencePaths, ...retryPlan.partialEvidencePaths]),
+    ].sort(),
+    unassignedEvidenceShardCount:
+      freshPlan.unassignedEvidenceShardCount + retryPlan.unassignedEvidenceShardCount,
+    unassignedEvidenceShardIds: [
+      ...freshPlan.unassignedEvidenceShardIds,
+      ...retryPlan.unassignedEvidenceShardIds,
+    ].slice(0, MAX_REPORTED_UNASSIGNED_EVIDENCE_SHARDS),
+    unassignedPaths: [
+      ...new Set([
+        ...freshPlan.unassignedPaths,
+        ...retryPlan.unassignedPaths,
+        ...overflowRetryPaths,
+      ]),
+    ].sort(),
+  });
+  const passesByUnit = new Map<string, Array<ReviewDiscoveryPass>>();
+  for (const pass of discoveryPasses) {
+    const passes = passesByUnit.get(pass.unitId) ?? [];
+    passes.push(pass);
+    passesByUnit.set(pass.unitId, passes);
+  }
+  return { plan, passesByUnit, overflowRetryPaths };
+};
+
 /**
  * Run the complete host-scheduled fan-out pipeline over one selected
  * changeset snapshot: plan, independent discovery, exact verification, and a
@@ -748,13 +887,7 @@ export const runFanOutReview = <Provider, ModelProvides, ModelRequires>(
   input: FanOutPipelineInput,
 ) =>
   Effect.gen(function* () {
-    const plan = planReviewUnits(input.files, { totalChangedFiles: input.totalChangedFiles });
-    const passesByUnit = new Map<string, Array<ReviewDiscoveryPass>>();
-    for (const pass of plan.discoveryPasses) {
-      const passes = passesByUnit.get(pass.unitId) ?? [];
-      passes.push(pass);
-      passesByUnit.set(pass.unitId, passes);
-    }
+    const { plan, passesByUnit, overflowRetryPaths } = scheduleFanOutWork(input);
     const outcomes = yield* Effect.forEach(
       plan.units,
       (unit) => reviewUnit(binding, unit, passesByUnit.get(unit.unitId) ?? [], input),
@@ -865,6 +998,15 @@ export const runFanOutReview = <Provider, ModelProvides, ModelRequires>(
           ...plan.undiffablePaths,
         ]),
       ].sort(),
+      unreviewedPasses: [
+        ...outcomes.flatMap((outcome) => outcome.unreviewedPasses),
+        ...(overflowRetryPaths.length === 0
+          ? []
+          : (input.retry?.stages.length
+              ? input.retry.stages
+              : (["discovery", "specialist", "verification"] as const)
+            ).map((stage) => ({ stage, paths: overflowRetryPaths }))),
+      ],
       turns: outcomes.reduce((total, outcome) => total + outcome.turns, 0),
     } satisfies FanOutPipelineOutcome;
   });

package/src/internal/fingerprint.ts

@@ -1,4 +1,4 @@
-import { Effect } from "effect";
+import { Crypto, Effect, Encoding } from "effect";
 
 import type { ChangedFile } from "./diff.ts";
 
@@ -36,14 +36,14 @@ export const extractFingerprint = (body: string): string | undefined => {
   return last;
 };
 
-/** WebCrypto SHA-256; unavailable crypto is a defect, not an expected failure. */
-const sha256Hex = (text: string): Effect.Effect<string> =>
-  Effect.promise(async () => {
-    const digest = await globalThis.crypto.subtle.digest("SHA-256", new TextEncoder().encode(text));
-    return Array.from(new Uint8Array(digest))
-      .map((byte) => byte.toString(16).padStart(2, "0"))
-      .join("");
-  });
+/** SHA-256 via `Crypto.Crypto`; unavailable crypto is a defect, not an expected failure. */
+const sha256Hex = Effect.fn("sha256Hex")(function* (
+  text: string,
+): Effect.fn.Return<string, never, Crypto.Crypto> {
+  const crypto = yield* Crypto.Crypto;
+  const digest = yield* crypto.digest("SHA-256", new TextEncoder().encode(text)).pipe(Effect.orDie);
+  return Encoding.encodeHex(digest);
+});
 
 const FIELD = "\u0000";
 const RECORD = "\u0001";
@@ -80,4 +80,10 @@ const canonicalChangeset = (files: ReadonlyArray<ChangedFile>): string =>
 export const computeChangesetFingerprint = (
   files: ReadonlyArray<ChangedFile>,
   signature: string,
-): Effect.Effect<string> => sha256Hex(`${canonicalChangeset(files)}${SECTION}${signature}`);
+): Effect.Effect<string, never, Crypto.Crypto> =>
+  sha256Hex(`${canonicalChangeset(files)}${SECTION}${signature}`);
+
+/** Profile fingerprints are SHA-256 over configuration-only signatures. */
+export const computeProfileFingerprint = (
+  signature: string,
+): Effect.Effect<string, never, Crypto.Crypto> => sha256Hex(signature);

package/src/internal/fixtures.ts

@@ -120,6 +120,7 @@ export const staticPriorReviews = (
   options: {
     readonly state?: Option.Option<ReviewState> | undefined;
     readonly comparison?: ReviewHeadComparison | undefined;
+    readonly treeComparison?: ReviewHeadComparison | undefined;
   } = {},
 ): PriorReviews["Service"] =>
   PriorReviews.of({
@@ -129,6 +130,10 @@ export const staticPriorReviews = (
       options.comparison === undefined
         ? Effect.fail(PriorReviewLookupFailure.make({ reason: "no fixture comparison" }))
         : Effect.succeed(options.comparison),
+    compareTrees: () =>
+      options.treeComparison === undefined
+        ? Effect.fail(PriorReviewLookupFailure.make({ reason: "no fixture tree comparison" }))
+        : Effect.succeed(options.treeComparison),
   });
 
 /** Layer form for consumers whose Effect explicitly requires `PriorReviews`. */
@@ -137,6 +142,7 @@ export const staticPriorReviewsLayer = (
   options: {
     readonly state?: Option.Option<ReviewState> | undefined;
     readonly comparison?: ReviewHeadComparison | undefined;
+    readonly treeComparison?: ReviewHeadComparison | undefined;
   } = {},
 ): Layer.Layer<PriorReviews> =>
   Layer.succeed(PriorReviews)(staticPriorReviews(fingerprint, options));

package/src/internal/github.ts

@@ -130,8 +130,9 @@ const GitHubReviewCommentWire = Schema.Struct({
   node_id: Schema.String,
   path: Schema.String,
   body: Schema.String,
-  line: Schema.NullOr(Schema.Int),
-  original_line: Schema.NullOr(Schema.Int),
+  // Outdated comments omit `line` entirely instead of sending null.
+  line: Schema.optionalKey(Schema.NullOr(Schema.Int)),
+  original_line: Schema.optionalKey(Schema.NullOr(Schema.Int)),
   start_line: Schema.optionalKey(Schema.NullOr(Schema.Int)),
   original_start_line: Schema.optionalKey(Schema.NullOr(Schema.Int)),
 });
@@ -578,8 +579,11 @@ export const gitHubReviewRetirementHostLayer: Layer.Layer<
         }).pipe(
           Effect.map((comments) =>
             comments.map((comment) => {
-              const endLine = comment.line ?? comment.original_line;
-              const startLine = comment.start_line ?? comment.original_start_line ?? endLine;
+              const positiveLine = (value: number | null | undefined): number | null =>
+                value !== undefined && value !== null && value > 0 ? value : null;
+              const endLine = positiveLine(comment.line ?? comment.original_line);
+              const startLine =
+                positiveLine(comment.start_line ?? comment.original_start_line) ?? endLine;
               return RetirableReviewComment.make({
                 nodeId: comment.node_id,
                 path: comment.path,
@@ -672,6 +676,15 @@ export class PriorReviews extends Context.Service<
       baseSha: string,
       headSha: string,
     ) => Effect.Effect<ReviewHeadComparison, PriorReviewLookupFailure>;
+    /**
+     * Two-dot tree comparison (`base..head`). Used when the reviewed head is
+     * not a git ancestor so a rebase or amend can still name the paths whose
+     * blob contents actually changed.
+     */
+    readonly compareTrees: (
+      baseSha: string,
+      headSha: string,
+    ) => Effect.Effect<ReviewHeadComparison, PriorReviewLookupFailure>;
   }
 >()("@effect-agent/pr-review/PriorReviews") {}
 
@@ -775,12 +788,12 @@ export const gitHubPriorReviewsLayer: Layer.Layer<
         }
         return { latestFingerprint: latest, latestState };
       }).pipe(Effect.provideService(HttpClient.HttpClient, client));
-    const compareHeads = (baseSha: string, headSha: string) =>
+    const compareCommits = (baseSha: string, headSha: string, separator: "..." | "..") =>
       Effect.gen(function* () {
         const response = yield* HttpClient.execute(
           withCommonHeaders(
             HttpClientRequest.get(
-              `${target.apiUrl}/repos/${target.repository}/compare/${encodeURIComponent(baseSha)}...${encodeURIComponent(headSha)}`,
+              `${target.apiUrl}/repos/${target.repository}/compare/${encodeURIComponent(baseSha)}${separator}${encodeURIComponent(headSha)}`,
             ).pipe(HttpClientRequest.acceptJson),
             target.token,
           ),
@@ -803,6 +816,21 @@ export const gitHubPriorReviewsLayer: Layer.Layer<
           truncated: files.length >= MAX_CHANGED_FILES,
         });
       }).pipe(Effect.provideService(HttpClient.HttpClient, client));
+    const compareTrees = (baseSha: string, headSha: string) =>
+      compareCommits(baseSha, headSha, "..").pipe(
+        Effect.map((comparison) =>
+          ReviewHeadComparison.make({
+            // This is a content snapshot, not a lineage claim. Selection
+            // intersects these files with the current PR path set.
+            status: comparison.status === "identical" ? "identical" : "ahead",
+            baseSha,
+            headSha,
+            mergeBaseSha: baseSha,
+            files: comparison.files,
+            truncated: comparison.truncated,
+          }),
+        ),
+      );
     return PriorReviews.of({
       latestFingerprint: readMarkers(Option.none()).pipe(
         Effect.map((markers) => markers.latestFingerprint),
@@ -813,7 +841,8 @@ export const gitHubPriorReviewsLayer: Layer.Layer<
           Effect.map((markers) => markers.latestState),
         );
       }),
-      compareHeads,
+      compareHeads: (baseSha, headSha) => compareCommits(baseSha, headSha, "..."),
+      compareTrees,
     });
   }),
 );