@blogic-cz/agent-tools 1.7.5 → 1.8.0

package/src/gh-tool/read/pulls.ts

@@ -0,0 +1,266 @@
+import { Effect, Schema } from "effect";
+import { GitHubService } from "#gh/read/transport";
+import { GitHubCommandError } from "#gh/errors";
+import type { CheckResult } from "#gh/types";
+import { cachedRead, readFence, ReadCache, seedRead } from "./cache";
+import { resolveTarget } from "#gh/pr/snapshot";
+import { gatedRead } from "./gated";
+import { restSnapshot, snapshotDigest } from "./rest";
+import { OPS } from "./classes";
+import { repoSlug } from "./keys";
+import type { RepoRef } from "./keys";
+import { parsePreserving } from "./porcelain";
+
+export const PR_VIEW_FIELDS =
+  "number,url,title,headRefName,baseRefName,headRefOid,state,isDraft,mergeable,body,author,reviewDecision,reviewRequests,createdAt,headRepositoryOwner,mergeCommit";
+export const PR_LIST_FIELDS =
+  "number,url,title,headRefName,baseRefName,state,isDraft,mergeable,author,createdAt,reviewDecision,headRepositoryOwner";
+export type PrListFilter = {
+  state: string;
+  limit: number;
+  author: string | null;
+  base: string | null;
+  head: string | null;
+  search: string | null;
+};
+export type PrSelector = { by: "number"; number: number } | { by: "currentBranch" };
+const Pull = Schema.Struct({
+  number: Schema.Number,
+  url: Schema.String,
+  title: Schema.String,
+  headRefName: Schema.String,
+  baseRefName: Schema.String,
+  state: Schema.String,
+  isDraft: Schema.Boolean,
+  mergeable: Schema.Literals(["MERGEABLE", "CONFLICTING", "UNKNOWN"]),
+  author: Schema.optional(
+    Schema.Struct({ login: Schema.String, is_bot: Schema.optional(Schema.Boolean) }),
+  ),
+  createdAt: Schema.optional(Schema.String),
+  reviewDecision: Schema.optional(Schema.String),
+  headRepositoryOwner: Schema.optional(Schema.Struct({ login: Schema.String })),
+});
+
+const PullView = Schema.Struct({
+  ...Pull.fields,
+  headRefOid: Schema.optional(Schema.String),
+  headSha: Schema.optional(Schema.NullOr(Schema.String)),
+  baseSha: Schema.optional(Schema.NullOr(Schema.String)),
+  body: Schema.String,
+  author: Schema.Struct({ login: Schema.String, is_bot: Schema.Boolean }),
+  reviewDecision: Schema.Literals(["APPROVED", "CHANGES_REQUESTED", "REVIEW_REQUIRED", ""]),
+  reviewRequests: Schema.mutable(
+    Schema.Array(
+      Schema.Union([
+        Schema.Struct({ __typename: Schema.Literal("User"), login: Schema.String }),
+        Schema.Struct({
+          __typename: Schema.Literal("Team"),
+          name: Schema.String,
+          slug: Schema.String,
+        }),
+      ]),
+    ),
+  ),
+  mergeCommit: Schema.optional(Schema.NullOr(Schema.Struct({ oid: Schema.String }))),
+});
+export type PrView = typeof PullView.Type;
+export type PrListItem = typeof Pull.Type;
+const Check = Schema.Struct({
+  name: Schema.String,
+  state: Schema.String,
+  bucket: Schema.String,
+  link: Schema.String,
+});
+
+export const prHead = Effect.fn("reads.prHead")(function* (
+  repo: RepoRef,
+  pr: number,
+  consistency: "cached" | "origin" = "cached",
+) {
+  const snapshot = yield* restSnapshot(
+    { op: "prHead", repo, pr },
+    [{ kind: "single", path: `repos/${repoSlug(repo)}/pulls/${pr}` }],
+    consistency,
+  );
+  const head = yield* Effect.try({
+    try: () =>
+      Schema.decodeUnknownSync(
+        Schema.Struct({
+          head: Schema.Struct({ sha: Schema.String }),
+          base: Schema.Struct({ sha: Schema.String }),
+        }),
+      )(snapshot.pages[0]?.body),
+    catch: (error) =>
+      new GitHubCommandError({
+        command: "pr head",
+        exitCode: 0,
+        message: String(error),
+        stderr: String(error),
+      }),
+  });
+  return { headSha: head.head.sha, baseSha: head.base.sha, signature: snapshotDigest(snapshot) };
+});
+
+export const checkSignal = Effect.fn("reads.checkSignal")(function* (repo: RepoRef, sha: string) {
+  const snapshot = yield* restSnapshot({ op: "checkSignal", repo, sha }, [
+    {
+      kind: "pages",
+      path: `repos/${repoSlug(repo)}/commits/${sha}/check-runs`,
+      items: (body) =>
+        Schema.decodeUnknownSync(Schema.Struct({ check_runs: Schema.Array(Schema.Unknown) }))(body)
+          .check_runs,
+    },
+    {
+      kind: "pages",
+      path: `repos/${repoSlug(repo)}/commits/${sha}/status`,
+      items: (body) =>
+        Schema.decodeUnknownSync(Schema.Struct({ statuses: Schema.Array(Schema.Unknown) }))(body)
+          .statuses,
+    },
+  ]);
+  return snapshotDigest(snapshot);
+});
+
+export const prView = Effect.fn("reads.prView")(function* (
+  repo: RepoRef | null,
+  selector: PrSelector,
+  consistency: "cached" | "origin" = "cached",
+) {
+  const gh = yield* GitHubService;
+  const args = [
+    "pr",
+    "view",
+    ...(selector.by === "number" ? [String(selector.number)] : []),
+    ...(repo === null ? [] : ["--repo", repoSlug(repo)]),
+    "--json",
+    PR_VIEW_FIELDS,
+  ];
+  const fetch = () =>
+    gh.runGhJson<PrView>(args).pipe(Effect.map((value) => ({ kind: "fresh" as const, value })));
+  if (selector.by === "currentBranch" || repo === null) {
+    const fence = yield* readFence;
+    const data = (yield* fetch()).value;
+    if (repo !== null && consistency !== "origin" && fence !== null) {
+      const head = yield* prHead(repo, data.number).pipe(Effect.orElseSucceed(() => null));
+      if (head !== null && head.headSha === data.headRefOid)
+        yield* seedRead(
+          { op: "prView", repo, pr: data.number },
+          { data, originFetchedAt: Date.now(), signal: head.signature },
+          fence,
+        );
+    }
+    return data;
+  }
+  return yield* gatedRead({
+    key: { op: "prView", repo, pr: selector.number },
+    consistency,
+    decode: parsePreserving(PullView),
+    fetch: Effect.suspend(() => gh.runGhJson<PrView>(args)),
+    signal: prHead(repo, selector.number).pipe(Effect.map((head) => head.signature)),
+    maxAgeMs: () => OPS.prView.maxAgeMs,
+  });
+});
+
+export const prList = Effect.fn("reads.prList")(function* (
+  repo: RepoRef,
+  filter: PrListFilter,
+  consistency: "cached" | "origin" = "cached",
+) {
+  const gh = yield* GitHubService;
+  const args = [
+    "pr",
+    "list",
+    "--state",
+    filter.state,
+    "--limit",
+    String(filter.limit),
+    "--repo",
+    repoSlug(repo),
+    "--json",
+    PR_LIST_FIELDS,
+  ];
+  for (const [flag, value] of [
+    ["--author", filter.author],
+    ["--base", filter.base],
+    ["--head", filter.head],
+    ["--search", filter.search],
+  ] as const)
+    if (value !== null) args.push(flag, value);
+  return yield* cachedRead({
+    key: { op: "prList", repo, filter },
+    policy: OPS.prList,
+    consistency,
+    decode: parsePreserving(Schema.mutable(Schema.Array(Pull))),
+    fetch: () =>
+      gh
+        .runGhJson<PrListItem[]>(args)
+        .pipe(Effect.map((value) => ({ kind: "fresh" as const, value }))),
+  });
+});
+
+export const prChecks = Effect.fn("reads.prChecks")(function* (
+  repo: RepoRef,
+  pr: number | null,
+  headSha: string | null,
+) {
+  const gh = yield* GitHubService;
+  const fetch = () =>
+    gh
+      .runGhJson<CheckResult[]>([
+        "pr",
+        "checks",
+        ...(pr === null ? [] : [String(pr)]),
+        "--repo",
+        repoSlug(repo),
+        "--json",
+        "name,state,bucket,link",
+      ])
+      .pipe(Effect.map((value) => ({ kind: "fresh" as const, value })));
+  const session = yield* ReadCache;
+  if (session === null || session.store === null) return (yield* fetch()).value;
+  const number = yield* resolveTarget(pr, prView(repo, { by: "currentBranch" }));
+  const head =
+    headSha === null
+      ? yield* prHead(repo, number, "origin").pipe(Effect.orElseSucceed(() => null))
+      : { headSha };
+  if (head === null) return (yield* fetch()).value;
+  const sha = head.headSha;
+  let verified = true;
+  const stableFetch = Effect.gen(function* () {
+    const before = yield* prHead(repo, number, "origin").pipe(Effect.orElseSucceed(() => null));
+    if (before !== null && before.headSha !== sha) return yield* movedHead(number);
+    const value = yield* gh.runGhJson<CheckResult[]>([
+      "pr",
+      "checks",
+      String(number),
+      "--repo",
+      repoSlug(repo),
+      "--json",
+      "name,state,bucket,link",
+    ]);
+    const after = yield* prHead(repo, number, "origin").pipe(Effect.orElseSucceed(() => null));
+    if (after !== null && after.headSha !== sha) return yield* movedHead(number);
+    verified = before !== null && after !== null;
+    return value;
+  });
+  return yield* gatedRead({
+    key: { op: "prChecks", repo, pr: number, headSha: sha },
+    decode: parsePreserving(Schema.mutable(Schema.Array(Check))),
+    fetch: stableFetch,
+    cacheableWhen: () => verified,
+    signal: checkSignal(repo, sha),
+    maxAgeMs: (value) =>
+      value.length === 0 || value.some((check) => check.bucket === "pending")
+        ? 15000
+        : OPS.prChecks.maxAgeMs,
+  });
+});
+
+const movedHead = (pr: number) =>
+  new GitHubCommandError({
+    command: `gh-tool pr checks --pr ${pr}`,
+    exitCode: 1,
+    message: "PR head changed while collecting checks",
+    stderr: "PR head changed while collecting checks",
+    retryable: true,
+  });

package/src/gh-tool/read/reads.ts

@@ -0,0 +1,306 @@
+import { Effect, Schema } from "effect";
+import { GitHubService } from "#gh/read/transport";
+import { GitHubCommandError } from "#gh/errors";
+import type { CheckRunAnnotation } from "#gh/types";
+import { cachedRead, ReadCache } from "./cache";
+import { OPS } from "./classes";
+import { repoSlug } from "./keys";
+import { issueView, issueList, issueComments } from "./issues";
+import { prView, prList, prChecks, prHead, checkSignal } from "./pulls";
+import { prComments, prReviews, reviewThreads, lastHumanReviewer } from "./reviews";
+import { reviewGuards } from "./review-guards";
+import type { RepoRef, RunFilter } from "./keys";
+import {
+  parsePreserving,
+  RUN_LIST_FIELDS,
+  RUN_VIEW_FIELDS,
+  WorkflowRun,
+  WorkflowRunDetail,
+  WorkflowJob,
+} from "./porcelain";
+
+export type JobRef = { readonly id: number; readonly status: string };
+
+const completedAttemptJobs = Effect.fn("reads.completedAttemptJobs")(function* (
+  repo: RepoRef,
+  runId: number,
+  attempt: number,
+) {
+  const gh = yield* GitHubService;
+  const Job = Schema.Struct({ id: Schema.Number, name: Schema.String });
+  const result = yield* cachedRead({
+    key: { op: "completedAttemptJobs", repo, runId, attempt },
+    policy: OPS.completedAttemptJobs,
+    decode: parsePreserving(
+      Schema.Struct({ jobs: Schema.mutable(Schema.Array(Job)), completed: Schema.Boolean }),
+    ),
+    cacheableWhen: (value) => value.completed,
+    fetch: () =>
+      Effect.gen(function* () {
+        const run = yield* gh.runGhJson<{ status?: string }>([
+          "api",
+          `repos/${repoSlug(repo)}/actions/runs/${runId}/attempts/${attempt}`,
+        ]);
+        const jobs: Array<typeof Job.Type> = [];
+        for (let page = 1; ; page += 1) {
+          const response = yield* gh.runGhJson<{ jobs?: Array<typeof Job.Type> }>([
+            "api",
+            `repos/${repoSlug(repo)}/actions/runs/${runId}/attempts/${attempt}/jobs?per_page=100&page=${page}`,
+          ]);
+          if (response.jobs === undefined)
+            return yield* new GitHubCommandError({
+              command: "attempt jobs",
+              exitCode: 0,
+              message: "Attempt jobs unavailable",
+              stderr: "Attempt jobs unavailable",
+            });
+          jobs.push(...response.jobs);
+          if (response.jobs.length < 100)
+            return {
+              kind: "fresh" as const,
+              value: { jobs, completed: run.status === "completed" },
+            };
+        }
+      }),
+  });
+  return result.jobs;
+});
+
+export const resolveRepo = Effect.fn("reads.resolveRepo")(function* (repo: string | null) {
+  if (repo !== null) {
+    const [owner, name, extra] = repo.split("/");
+    if (owner && name && extra === undefined) return { owner, name };
+    return yield* new GitHubCommandError({
+      message: `Invalid repository: ${repo}`,
+      command: "gh-tool --repo",
+      exitCode: 1,
+      stderr: "Expected owner/name",
+    });
+  }
+  const gh = yield* GitHubService;
+  return yield* gh.getRepoRef();
+});
+
+const runList = Effect.fn("reads.runList")(function* (
+  repo: RepoRef,
+  filter: RunFilter,
+  consistency: "cached" | "origin" = "cached",
+) {
+  const gh = yield* GitHubService;
+  const args = [
+    "run",
+    "list",
+    "--repo",
+    repoSlug(repo),
+    "--json",
+    RUN_LIST_FIELDS,
+    "--limit",
+    String(filter.limit),
+  ];
+  for (const [flag, value] of [
+    ["--workflow", filter.workflow],
+    ["--branch", filter.branch],
+    ["--status", filter.status],
+    ["--event", filter.event],
+  ] as const)
+    if (value !== null && value !== undefined) args.push(flag, value);
+  return yield* cachedRead({
+    key: { op: "runList", repo, filter },
+    policy: OPS.runList,
+    consistency,
+    decode: parsePreserving(Schema.Array(WorkflowRun)),
+    fetch: () =>
+      gh
+        .runGhJson<ReadonlyArray<WorkflowRun>>(args)
+        .pipe(Effect.map((value) => ({ kind: "fresh" as const, value }))),
+  });
+});
+
+const runView = Effect.fn("reads.runView")(function* (
+  repo: RepoRef,
+  runId: number,
+  consistency: "cached" | "origin" = "cached",
+) {
+  const gh = yield* GitHubService;
+  const run = yield* cachedRead({
+    key: { op: "runView", repo, runId },
+    policy: OPS.runView,
+    consistency,
+    decode: parsePreserving(WorkflowRunDetail),
+    policyForValue: (value) =>
+      value.status === "completed" ? { kind: "ttl", ttlMs: 300000 } : OPS.runView,
+    fetch: () =>
+      gh
+        .runGhJson<WorkflowRunDetail>([
+          "run",
+          "view",
+          String(runId),
+          "--repo",
+          repoSlug(repo),
+          "--json",
+          RUN_VIEW_FIELDS,
+        ])
+        .pipe(Effect.map((value) => ({ kind: "fresh" as const, value }))),
+  });
+  if (run.status !== "completed" || consistency === "origin") return run;
+  return yield* cachedRead({
+    key: { op: "runView", repo, runId, attempt: run.attempt },
+    policy: { kind: "immutable" },
+    decode: parsePreserving(WorkflowRunDetail),
+    fetch: () => Effect.succeed({ kind: "fresh" as const, value: run }),
+  });
+});
+
+const runJobs = Effect.fn("reads.runJobs")(function* (repo: RepoRef, runId: number) {
+  const run = yield* runView(repo, runId);
+  return yield* cachedRead({
+    key: { op: "runJobs", repo, runId, attempt: run.attempt },
+    policy: run.status === "completed" ? { kind: "immutable" } : OPS.runJobs,
+    decode: parsePreserving(Schema.Array(WorkflowJob)),
+    fetch: () => Effect.succeed({ kind: "fresh" as const, value: run.jobs }),
+  });
+});
+
+const runLog = Effect.fn("reads.runLog")(function* (
+  repo: RepoRef,
+  runId: number,
+  failedOnly: boolean,
+  jobId: number | null,
+) {
+  const gh = yield* GitHubService;
+  const run = yield* runView(repo, runId);
+  const args = [
+    "run",
+    "view",
+    String(runId),
+    "--repo",
+    repoSlug(repo),
+    failedOnly ? "--log-failed" : "--log",
+    "--attempt",
+    String(run.attempt),
+  ];
+  if (jobId !== null) args.push("--job", String(jobId));
+  return yield* cachedRead({
+    key: { op: "runLog", repo, runId, attempt: run.attempt, failedOnly, jobId },
+    policy: run.status === "completed" ? { kind: "immutable" } : OPS.runLog,
+    decode: parsePreserving(Schema.String),
+    fetch: () =>
+      gh
+        .runGh(args)
+        .pipe(Effect.map((result) => ({ kind: "fresh" as const, value: result.stdout }))),
+  });
+});
+
+export const rawJobLog = Effect.fn("reads.rawJobLog")(function* (path: string) {
+  const gh = yield* GitHubService;
+  return yield* gh
+    .runGh(["api", path, "--allow-escape-sequences"])
+    .pipe(
+      Effect.catchTag("GitHubCommandError", (error) =>
+        `${error.stderr}${error.message}`.includes("unknown flag: --allow-escape-sequences")
+          ? gh.runGh(["api", path])
+          : Effect.fail(error),
+      ),
+    );
+});
+const jobLog = Effect.fn("reads.jobLog")(function* (repo: RepoRef, job: JobRef) {
+  return yield* cachedRead({
+    key: { op: "jobLog", repo, jobId: job.id },
+    policy: job.status === "completed" ? { kind: "immutable" } : OPS.jobLog,
+    decode: parsePreserving(Schema.String),
+    fetch: () =>
+      rawJobLog(`repos/${repoSlug(repo)}/actions/jobs/${job.id}/logs`).pipe(
+        Effect.map((result) => ({ kind: "fresh" as const, value: result.stdout })),
+      ),
+  });
+});
+
+const Annotation = Schema.Struct({
+  path: Schema.String,
+  start_line: Schema.Number,
+  end_line: Schema.Number,
+  start_column: Schema.NullOr(Schema.Number),
+  end_column: Schema.NullOr(Schema.Number),
+  annotation_level: Schema.Literals(["notice", "warning", "failure"]),
+  message: Schema.String,
+  title: Schema.NullOr(Schema.String),
+  raw_details: Schema.NullOr(Schema.String),
+});
+const annotations = Effect.fn("reads.annotations")(function* (repo: RepoRef, job: JobRef) {
+  const gh = yield* GitHubService;
+  return yield* cachedRead({
+    key: { op: "annotations", repo, jobId: job.id },
+    policy: job.status === "completed" ? { kind: "immutable" } : OPS.annotations,
+    decode: parsePreserving(Schema.Array(Annotation)),
+    fetch: () =>
+      gh
+        .runGhJson<ReadonlyArray<CheckRunAnnotation>>([
+          "api",
+          `repos/${repoSlug(repo)}/check-runs/${job.id}/annotations`,
+          "--paginate",
+        ])
+        .pipe(Effect.map((value) => ({ kind: "fresh" as const, value }))),
+  });
+});
+
+const JobIdentity = Schema.NullOr(Schema.Struct({ runId: Schema.Number, attempt: Schema.Number }));
+const jobIdentity = Effect.fn("reads.jobIdentity")(function* (repo: RepoRef, jobId: number) {
+  const gh = yield* GitHubService;
+  const session = yield* ReadCache;
+  const path = `repos/${repoSlug(repo)}/actions/jobs/${jobId}`;
+  return yield* cachedRead({
+    key: { op: "jobIdentity", repo, jobId },
+    policy: OPS.jobIdentity,
+    decode: parsePreserving(JobIdentity),
+    fetch: () =>
+      (session === null || session.store === null
+        ? gh.runGhJson<{ run_id: number; run_attempt: number }>(["api", path])
+        : gh
+            .apiRequest<{ run_id: number; run_attempt: number }>({ path })
+            .pipe(Effect.map((response) => response.body))
+      ).pipe(
+        Effect.flatMap((job) =>
+          Effect.try({
+            try: () =>
+              Schema.decodeUnknownSync(JobIdentity)({
+                runId: job.run_id,
+                attempt: job.run_attempt,
+              }),
+            catch: (error) =>
+              new GitHubCommandError({
+                command: `GET ${path}`,
+                exitCode: 0,
+                message: String(error),
+                stderr: String(error),
+              }),
+          }),
+        ),
+        Effect.catchTag("GitHubNotFoundError", () => Effect.succeed(null)),
+        Effect.map((value) => ({ kind: "fresh" as const, value })),
+      ),
+  });
+});
+
+export const reads = {
+  completedAttemptJobs,
+  jobIdentity,
+  reviewGuards,
+  prComments,
+  prReviews,
+  reviewThreads,
+  lastHumanReviewer,
+  prView,
+  prList,
+  prChecks,
+  prHead,
+  checkSignal,
+  runList,
+  runView,
+  runJobs,
+  runLog,
+  jobLog,
+  annotations,
+  issueView,
+  issueList,
+  issueComments,
+};

package/src/gh-tool/read/rest.ts

@@ -0,0 +1,111 @@
+import { Effect, Schema } from "effect";
+import { GitHubService } from "#gh/read/transport";
+import { GitHubCommandError } from "#gh/errors";
+import { cachedRead, ReadCache } from "./cache";
+import { OPS } from "./classes";
+import { digest } from "./keys";
+import type { ReadKey } from "./keys";
+import { parsePreserving } from "./porcelain";
+
+const Page = Schema.Struct({
+  path: Schema.String,
+  etag: Schema.NullOr(Schema.String),
+  body: Schema.Unknown,
+});
+const Snapshot = Schema.Struct({ pages: Schema.Array(Page) });
+export type RestSnapshot = typeof Snapshot.Type;
+export type RestSource =
+  | { readonly path: string; readonly kind: "single" }
+  | {
+      readonly path: string;
+      readonly kind: "pages";
+      readonly items: (body: unknown) => readonly unknown[];
+    };
+
+export const restSnapshot = Effect.fn("reads.restSnapshot")(function* (
+  key: ReadKey & { op: "prHead" | "checkSignal" | "issueComments" | "prComments" | "prReviews" },
+  sources: readonly RestSource[],
+  consistency: "cached" | "origin" = "cached",
+) {
+  const gh = yield* GitHubService;
+  const session = yield* ReadCache;
+  return yield* cachedRead({
+    key,
+    policy: OPS[key.op],
+    consistency,
+    validateOrigin: true,
+    decode: parsePreserving(Snapshot),
+    fetch: (previous: { value: RestSnapshot } | null) =>
+      Effect.gen(function* () {
+        const pages: Array<typeof Page.Type> = [];
+        let unchanged = previous !== null;
+        for (const source of sources) {
+          let page = 1;
+          while (true) {
+            const path =
+              source.kind === "single"
+                ? source.path
+                : `${source.path}${source.path.includes("?") ? "&" : "?"}per_page=100&page=${page}`;
+            const prior = previous?.value.pages.find((item) => item.path === path);
+            const request = {
+              path,
+              ...(prior?.etag === null || prior?.etag === undefined
+                ? {}
+                : { ifNoneMatch: prior.etag }),
+            };
+            const response = yield* session?.store === null || session === null
+              ? gh.runGh(["api", path]).pipe(
+                  Effect.flatMap((result) =>
+                    Effect.try({
+                      try: () => ({
+                        status: 200,
+                        body: JSON.parse(result.stdout) as unknown,
+                        etag: undefined,
+                      }),
+                      catch: (error) =>
+                        new GitHubCommandError({
+                          command: `GET ${path}`,
+                          exitCode: 0,
+                          message: `Failed to parse response: ${String(error)}`,
+                          stderr: `Failed to parse response: ${String(error)}`,
+                        }),
+                    }),
+                  ),
+                )
+              : gh.apiRequest<unknown>(request);
+            if (response.status === 304 && prior === undefined)
+              return yield* new GitHubCommandError({
+                command: `GET ${path}`,
+                exitCode: 304,
+                message: "304 without a cached page",
+                stderr: "304 without a cached page",
+              });
+            const body =
+              response.status === 304 && prior !== undefined ? prior.body : response.body;
+            const etag = response.etag ?? (response.status === 304 ? (prior?.etag ?? null) : null);
+            unchanged = unchanged && response.status === 304;
+            pages.push({ path, etag, body });
+            if (source.kind === "single") break;
+            const count = yield* Effect.try({
+              try: () => source.items(body).length,
+              catch: (error) =>
+                new GitHubCommandError({
+                  command: `GET ${path}`,
+                  exitCode: 0,
+                  message: `Invalid paginated response: ${String(error)}`,
+                  stderr: `Invalid paginated response: ${String(error)}`,
+                }),
+            });
+            if (count < 100) break;
+            page += 1;
+          }
+        }
+        return unchanged
+          ? { kind: "unchanged" as const }
+          : { kind: "fresh" as const, value: { pages } };
+      }),
+  });
+});
+
+export const snapshotDigest = (snapshot: RestSnapshot): string =>
+  digest(JSON.stringify(snapshot.pages.map((page) => page.body)));