@blogic-cz/agent-tools 1.7.4 → 1.8.0

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