@blogic-cz/agent-tools 1.7.5 → 1.9.0

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)));

package/src/gh-tool/read/review-guards.ts

@@ -0,0 +1,61 @@
+import { Effect } from "effect";
+import { GitHubService } from "#gh/read/transport";
+import type { RepoRef } from "./keys";
+import { repoSlug } from "./keys";
+import { PENDING_REVIEWS_QUERY, PENDING_REVIEW_CONTENT_QUERY } from "./review-model";
+import type { EditableComment, ReviewCommentById } from "./review-model";
+
+export const reviewGuards = {
+  requestedReviewers: (repo: RepoRef, pr: number) =>
+    Effect.gen(function* () {
+      const gh = yield* GitHubService;
+      return yield* gh.runGhJson<{ requested_reviewers?: unknown }>([
+        "api",
+        `repos/${repoSlug(repo)}/pulls/${pr}`,
+      ]);
+    }),
+  commentById: (commentId: number) =>
+    Effect.gen(function* () {
+      const gh = yield* GitHubService;
+      return yield* gh.runGhJson<ReviewCommentById>([
+        "api",
+        `repos/{owner}/{repo}/pulls/comments/${commentId}`,
+      ]);
+    }),
+  editableComment: (repo: RepoRef, kind: "review" | "issue", commentId: number) =>
+    Effect.gen(function* () {
+      const gh = yield* GitHubService;
+      return yield* gh.runGhJson<EditableComment>([
+        "api",
+        `repos/${repoSlug(repo)}/${kind === "review" ? "pulls" : "issues"}/comments/${commentId}`,
+      ]);
+    }),
+  viewer: () =>
+    Effect.gen(function* () {
+      const gh = yield* GitHubService;
+      return yield* gh.runGhJson<{ login: string }>(["api", "user"]);
+    }),
+  pullNumber: (repo: RepoRef, pr: number) =>
+    Effect.gen(function* () {
+      const gh = yield* GitHubService;
+      return yield* gh.runGhJson<{ number: number }>([
+        "api",
+        `repos/${repoSlug(repo)}/pulls/${pr}`,
+      ]);
+    }),
+  pendingReviews: (repo: RepoRef, pr: number, after: string | null) =>
+    Effect.gen(function* () {
+      const gh = yield* GitHubService;
+      return yield* gh.runGraphQL(PENDING_REVIEWS_QUERY, {
+        owner: repo.owner,
+        name: repo.name,
+        pr,
+        after,
+      });
+    }),
+  pendingReviewContent: (reviewId: string, after: string | null) =>
+    Effect.gen(function* () {
+      const gh = yield* GitHubService;
+      return yield* gh.runGraphQL(PENDING_REVIEW_CONTENT_QUERY, { reviewId, after });
+    }),
+};

package/src/gh-tool/read/review-model.ts

@@ -0,0 +1,286 @@
+export const REVIEW_THREADS_QUERY = `
+  query($owner: String!, $name: String!, $pr: Int!, $after: String) {
+    repository(owner: $owner, name: $name) {
+      pullRequest(number: $pr) {
+        reviewThreads(first: 100, after: $after) {
+          nodes {
+            id
+            isResolved
+            comments(first: 100) {
+              nodes {
+                id
+                databaseId
+                path
+                line
+                body
+                author { login }
+                commit { oid }
+              }
+              pageInfo { hasNextPage endCursor }
+            }
+          }
+          pageInfo {
+            hasNextPage
+            endCursor
+          }
+        }
+      }
+    }
+  }
+`;
+
+export const REVIEW_THREAD_COMMENTS_QUERY = `
+  query($threadId: ID!, $after: String) {
+    node(id: $threadId) {
+      ... on PullRequestReviewThread {
+        comments(first: 100, after: $after) {
+          nodes {
+            id
+            databaseId
+            path
+            line
+            body
+            author { login }
+            commit { oid }
+          }
+          pageInfo { hasNextPage endCursor }
+        }
+      }
+    }
+  }
+`;
+
+export const RESOLVE_THREAD_MUTATION = `
+  mutation($threadId: ID!) {
+    resolveReviewThread(input: {threadId: $threadId}) {
+      thread { id isResolved }
+    }
+  }
+`;
+
+export const PENDING_REVIEWS_QUERY = `
+  query($owner: String!, $name: String!, $pr: Int!, $after: String) {
+    viewer { login }
+    repository(owner: $owner, name: $name) {
+      pullRequest(number: $pr) {
+        reviews(first: 100, after: $after, states: [PENDING]) {
+          nodes {
+            id
+            state
+            author { login }
+          }
+          pageInfo { hasNextPage endCursor }
+        }
+      }
+    }
+  }
+`;
+
+export const PENDING_REVIEW_CONTENT_QUERY = `
+  query($reviewId: ID!, $after: String) {
+    viewer { login }
+    node(id: $reviewId) {
+      ... on PullRequestReview {
+        id
+        state
+        body
+        author { login }
+        pullRequest {
+          number
+          repository { nameWithOwner }
+        }
+        comments(first: 100, after: $after) {
+          nodes { body }
+          pageInfo { hasNextPage endCursor }
+        }
+      }
+    }
+  }
+`;
+
+export const SUBMIT_REVIEW_MUTATION = `
+  mutation($reviewId: ID!, $event: PullRequestReviewEvent!, $body: String) {
+    submitPullRequestReview(input: { pullRequestReviewId: $reviewId, event: $event, body: $body }) {
+      pullRequestReview { id state }
+    }
+  }
+`;
+
+export const LAST_HUMAN_REVIEWER_QUERY = `
+  query($owner: String!, $name: String!, $pr: Int!) {
+    repository(owner: $owner, name: $name) {
+      pullRequest(number: $pr) {
+        reviewRequests(first: 100) {
+          nodes {
+            requestedReviewer {
+              __typename
+              ... on User { login }
+              ... on Team { name }
+              ... on Bot { login }
+            }
+          }
+        }
+        reviews(last: 100) {
+          nodes {
+            author { login }
+            state
+            submittedAt
+          }
+        }
+      }
+    }
+  }
+`;
+
+// ---------------------------------------------------------------------------
+// Internal types
+// ---------------------------------------------------------------------------
+
+export type ThreadNode = {
+  id: string;
+  isResolved: boolean;
+  comments: {
+    nodes: Array<{
+      id: string;
+      databaseId: number;
+      path: string;
+      line: number;
+      body: string;
+      author: { login: string };
+      commit: { oid: string } | null;
+    }>;
+    pageInfo?: { hasNextPage: boolean; endCursor: string | null };
+  };
+};
+
+export type ThreadCommentsQueryResult = {
+  node: { comments: ThreadNode["comments"] } | null;
+};
+
+export type ThreadsQueryResult = {
+  repository: {
+    pullRequest: {
+      reviewThreads: {
+        nodes: ThreadNode[];
+        pageInfo: {
+          hasNextPage: boolean;
+          endCursor: string | null;
+        };
+      };
+    };
+  };
+};
+
+export type ResolveThreadResult = {
+  resolveReviewThread: {
+    thread: { id: string; isResolved: boolean };
+  };
+};
+
+export type PendingReviewsQueryResult = {
+  viewer: { login: string };
+  repository: {
+    pullRequest: {
+      reviews: {
+        nodes: Array<{
+          id: string;
+          state: string;
+          author: { login: string };
+        }>;
+        pageInfo: { hasNextPage: boolean; endCursor: string | null };
+      };
+    };
+  };
+};
+
+export type PendingReviewContentQueryResult = {
+  viewer: { login: string };
+  node: {
+    id: string;
+    state: string;
+    body: string | null;
+    author: { login: string };
+    pullRequest: { number: number; repository: { nameWithOwner: string } };
+    comments: {
+      nodes: Array<{ body: string }>;
+      pageInfo: { hasNextPage: boolean; endCursor: string | null };
+    };
+  } | null;
+};
+
+export type SubmitReviewResult = {
+  submitPullRequestReview: {
+    pullRequestReview: { id: string; state: string };
+  };
+};
+
+export type RequestedReviewerNode = {
+  __typename: string;
+  login?: string;
+  name?: string;
+} | null;
+
+export type LastHumanReviewerQueryResult = {
+  repository: {
+    pullRequest: {
+      reviewRequests: {
+        nodes: Array<{ requestedReviewer: RequestedReviewerNode }>;
+      };
+      reviews: {
+        nodes: Array<{
+          author: { login: string } | null;
+          state: string;
+          submittedAt: string | null;
+        }>;
+      };
+    };
+  };
+};
+
+export type RawReviewComment = {
+  id: number;
+  in_reply_to_id: number | null;
+  user: { login: string };
+  body: string;
+  path: string;
+  line: number;
+  created_at: string;
+  updated_at: string;
+  pull_request_review_id?: number | null;
+  commit_id?: string | null;
+};
+
+export type RawIssueComment = {
+  id: number;
+  user: { login: string };
+  body: string;
+  created_at: string;
+  html_url: string;
+};
+
+export type RawPullRequestReview = {
+  id: number;
+  user: { login: string } | null;
+  state: string;
+  body: string | null;
+  submitted_at: string | null;
+  html_url: string;
+  commit_id?: string | null;
+};
+
+export type ReviewCommentById = {
+  id: number;
+  in_reply_to_id: number | null;
+  pull_request_url: string;
+};
+
+export type EditableComment = {
+  id: number;
+  user: { login: string };
+  html_url: string;
+  updated_at: string;
+  pull_request_url?: string;
+  issue_url?: string;
+};
+
+export const REST_PAGE_SIZE = 100;

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

@@ -0,0 +1,114 @@
+import { Effect, Schema } from "effect";
+import { GitHubService } from "#gh/read/transport";
+import { cachedRead } from "./cache";
+import { gatedRead } from "./gated";
+import { restSnapshot, snapshotDigest } from "./rest";
+import { OPS } from "./classes";
+import { repoSlug } from "./keys";
+import type { RepoRef } from "./keys";
+import {
+  REVIEW_THREADS_QUERY,
+  REVIEW_THREAD_COMMENTS_QUERY,
+  LAST_HUMAN_REVIEWER_QUERY,
+} from "./review-model";
+import type {
+  ThreadNode,
+  ThreadsQueryResult,
+  ThreadCommentsQueryResult,
+  LastHumanReviewerQueryResult,
+  RawReviewComment,
+  RawPullRequestReview,
+} from "./review-model";
+
+const originThreads = Effect.fn("pr.fetchAllThreadNodes")(function* (
+  repoInfo: RepoRef,
+  pr: number,
+) {
+  const service = yield* GitHubService;
+
+  const nodes: ThreadNode[] = [];
+  let after: string | null = null;
+
+  while (true) {
+    const response = (yield* service.runGraphQL(REVIEW_THREADS_QUERY, {
+      owner: repoInfo.owner,
+      name: repoInfo.name,
+      pr,
+      after,
+    })) as ThreadsQueryResult;
+
+    const page = response.repository.pullRequest.reviewThreads;
+    for (const node of page.nodes) {
+      let commentsAfter = node.comments.pageInfo?.endCursor ?? null;
+      while (node.comments.pageInfo?.hasNextPage && commentsAfter !== null) {
+        const commentsResponse = (yield* service.runGraphQL(REVIEW_THREAD_COMMENTS_QUERY, {
+          threadId: node.id,
+          after: commentsAfter,
+        })) as ThreadCommentsQueryResult;
+        if (commentsResponse.node === null) break;
+        node.comments.nodes.push(...commentsResponse.node.comments.nodes);
+        node.comments.pageInfo = commentsResponse.node.comments.pageInfo;
+        commentsAfter = commentsResponse.node.comments.pageInfo?.endCursor ?? null;
+      }
+      nodes.push(node);
+    }
+
+    if (!page.pageInfo.hasNextPage || page.pageInfo.endCursor === null) {
+      return nodes;
+    }
+
+    after = page.pageInfo.endCursor;
+  }
+});
+
+const reviewPages = (repo: RepoRef, pr: number, op: "prComments" | "prReviews") =>
+  restSnapshot({ op, repo, pr }, [
+    {
+      kind: "pages",
+      path: `repos/${repoSlug(repo)}/pulls/${pr}/${op === "prComments" ? "comments" : "reviews"}`,
+      items: Schema.decodeUnknownSync(Schema.Array(Schema.Unknown)),
+    },
+  ]);
+
+export const prComments = Effect.fn("reads.prComments")(function* (repo: RepoRef, pr: number) {
+  const snapshot = yield* reviewPages(repo, pr, "prComments");
+  return snapshot.pages.flatMap((page) => page.body as RawReviewComment[]);
+});
+export const prReviews = Effect.fn("reads.prReviews")(function* (repo: RepoRef, pr: number) {
+  const snapshot = yield* reviewPages(repo, pr, "prReviews");
+  return snapshot.pages.flatMap((page) => page.body as RawPullRequestReview[]);
+});
+export const reviewThreads = Effect.fn("reads.reviewThreads")(function* (
+  repo: RepoRef,
+  pr: number,
+  consistency: "cached" | "origin" = "cached",
+) {
+  return yield* gatedRead({
+    key: { op: "reviewThreads", repo, pr },
+    consistency,
+    decode: (raw) => Schema.decodeUnknownSync(Schema.Array(Schema.Unknown))(raw) as ThreadNode[],
+    fetch: originThreads(repo, pr),
+    signal: reviewPages(repo, pr, "prComments").pipe(Effect.map(snapshotDigest)),
+    maxAgeMs: () => OPS.reviewThreads.maxAgeMs,
+  });
+});
+export const lastHumanReviewer = Effect.fn("reads.lastHumanReviewer")(function* (
+  repo: RepoRef,
+  pr: number,
+) {
+  const service = yield* GitHubService;
+  return yield* cachedRead({
+    key: { op: "lastHumanReviewer", repo, pr },
+    policy: OPS.lastHumanReviewer,
+    decode: (raw) => raw as LastHumanReviewerQueryResult,
+    fetch: () =>
+      service
+        .runGraphQL(LAST_HUMAN_REVIEWER_QUERY, { owner: repo.owner, name: repo.name, pr })
+        .pipe(
+          Effect.map((value) => ({
+            kind: "fresh" as const,
+            value: value as LastHumanReviewerQueryResult,
+          })),
+        ),
+  });
+});

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

@@ -0,0 +1,73 @@
+import { Effect } from "effect";
+
+import { GitHubService } from "#gh/read/transport";
+
+import type { StackMember, StackView } from "#gh/types";
+
+type StacksListResponse = Array<{ number: number }>;
+
+type StackResponse = {
+  number: number;
+  base: { ref: string };
+  open: boolean;
+  pull_requests: Array<{
+    number: number;
+    title: string;
+    state: "open" | "closed";
+    merged_at: string | null;
+    draft: boolean;
+    html_url: string;
+    head: { ref: string };
+    base: { ref: string };
+  }>;
+};
+
+export const readStack = Effect.fn("pr.readStack")(function* (opts: { pr: number }) {
+  const gh = yield* GitHubService;
+  const repo = yield* gh.getRepoInfo();
+  const base = `repos/${repo.owner}/${repo.name}`;
+
+  const unstacked: StackView = {
+    pr: opts.pr,
+    isStacked: false,
+    stackNumber: null,
+    baseRef: null,
+    members: [],
+  };
+
+  // A 404 is the repository having no stacks surface at all, which reads the same as a PR
+  // that belongs to no stack. Every caller gets that reading from here, not its own.
+  const stacks = yield* gh
+    .apiRequest<StacksListResponse>({ path: `${base}/stacks?pull_request=${opts.pr}` })
+    .pipe(Effect.catchTag("GitHubNotFoundError", () => Effect.succeed(null)));
+
+  if (stacks === null) {
+    return unstacked;
+  }
+
+  const stackNumber = stacks.body?.[0]?.number;
+  if (stackNumber === undefined) {
+    return unstacked;
+  }
+
+  const stack = yield* gh.apiRequest<StackResponse>({ path: `${base}/stacks/${stackNumber}` });
+
+  const members: StackMember[] = stack.body.pull_requests.map((member, index) => ({
+    position: index + 1,
+    number: member.number,
+    title: member.title,
+    headRefName: member.head.ref,
+    baseRefName: member.base.ref,
+    state: member.merged_at === null ? member.state : "merged",
+    isDraft: member.draft,
+    url: member.html_url,
+  }));
+
+  return {
+    pr: opts.pr,
+    isStacked: true,
+    stackNumber: stack.body.number,
+    baseRef: stack.body.base.ref,
+    members,
+  } satisfies StackView;
+});