@blogic-cz/agent-tools 1.16.1 → 1.17.0

package/src/gh-tool/read/graphql-fallback.ts

@@ -0,0 +1,366 @@
+import { Console, Context, Effect, Schema } from "effect";
+import type { JsonRead } from "./rest-porcelain";
+import type { GhError } from "./transport";
+import { parseRest, restGet, restPages, restPull, restReviewDecision } from "./rest-porcelain";
+import { GitHubCommandError } from "#gh/errors";
+import { ghSubprocessEvent, recordRequest } from "./telemetry";
+
+export type Fallback = { source: "REST"; reason: string; unknown: string[] };
+const fallbackResults = new WeakSet<object>();
+export const markFallbackResult = <A extends object>(value: A): A => {
+  fallbackResults.add(value);
+  return value;
+};
+export const isFallbackResult = (value: unknown): boolean =>
+  typeof value === "object" && value !== null && fallbackResults.has(value);
+
+export const FallbackState = Context.Reference<{ notices: Fallback[] } | null>("gh/FallbackState", {
+  defaultValue: () => null,
+});
+const fallbackMessage = (unknown: string[]) =>
+  unknown.length === 0
+    ? "GitHub GraphQL is blocked (rate limit); answered from REST. All fields were provided."
+    : `GitHub GraphQL is blocked (rate limit); answered from REST. Not provided: ${unknown.join(", ")}. A null or UNKNOWN value there means "not provided", never false, unresolved or not approved. If your next step depends on it, retry in a few minutes; if it is still not provided, tell the user. Do not guess.`;
+export const reportFallback = (unknown: string[]) =>
+  Effect.gen(function* () {
+    const notice: Fallback = { source: "REST", reason: "GitHub GraphQL rate limit", unknown };
+    const state = yield* FallbackState;
+    state?.notices.push(notice);
+    if (state === null) yield* Console.warn(fallbackMessage(unknown));
+    yield* recordRequest({
+      ...ghSubprocessEvent(["api", "graphql"], 0),
+      method: "FALLBACK",
+      endpoint: "graphql-to-rest",
+      outcome: "fallback",
+    });
+    return notice;
+  });
+export const withFallbackOutput = <A, E, R>(program: Effect.Effect<A, E, R>) =>
+  Effect.gen(function* () {
+    const current = yield* Console.Console;
+    const state = { notices: [] as Fallback[] };
+    let warned = false;
+    const flushWarning = () => {
+      if (warned || state.notices.length === 0) return;
+      warned = true;
+      current.warn(
+        fallbackMessage([...new Set(state.notices.flatMap((notice) => notice.unknown))]),
+      );
+    };
+    const console = {
+      ...current,
+      log: (...args: readonly unknown[]) => {
+        flushWarning();
+        current.log(
+          ...args.map((arg) => {
+            if (state.notices.length === 0 || typeof arg !== "string") return arg;
+            try {
+              const value: unknown = JSON.parse(arg);
+              if (value === null || typeof value !== "object") return arg;
+              const fallback = {
+                source: "REST",
+                reason: "GitHub GraphQL rate limit",
+                unknown: [...new Set(state.notices.flatMap((notice) => notice.unknown))],
+              };
+              return JSON.stringify(
+                Array.isArray(value) ? { items: value, fallback } : { ...value, fallback },
+                null,
+                arg.includes("\n") ? 2 : undefined,
+              );
+            } catch {
+              return arg;
+            }
+          }),
+        );
+      },
+    };
+    return yield* program.pipe(
+      Effect.provideService(FallbackState, state),
+      Effect.provideService(Console.Console, console),
+      Effect.ensuring(Effect.sync(flushWarning)),
+    );
+  });
+const Comment = Schema.Struct({
+  id: Schema.Number,
+  node_id: Schema.String,
+  in_reply_to_id: Schema.optional(Schema.NullOr(Schema.Number)),
+  path: Schema.String,
+  line: Schema.NullOr(Schema.Number),
+  body: Schema.String,
+  user: Schema.Struct({ login: Schema.String }),
+  commit_id: Schema.String,
+});
+const Reviewer = Schema.Struct({ login: Schema.String, type: Schema.optional(Schema.String) });
+export const restGraphql = (
+  query: string,
+  variables: Record<string, string | number | null>,
+  read: JsonRead,
+): Effect.Effect<unknown, GhError> | null => {
+  if (
+    (query.includes("mutation") && !query.includes("submitPullRequestReview")) ||
+    typeof variables.owner !== "string" ||
+    typeof variables.name !== "string" ||
+    typeof variables.pr !== "number"
+  )
+    return null;
+  const repo = `${variables.owner}/${variables.name}`;
+  const pr = variables.pr;
+  const root = `repos/${repo}/pulls/${pr}`;
+  if (
+    query.includes("states: [PENDING]") ||
+    query.includes("... on PullRequestReview {") ||
+    query.includes("submitPullRequestReview")
+  )
+    return pendingRest(query, variables, read, root, repo, variables.pr);
+  if (query.includes("reviewThreads"))
+    return Effect.gen(function* () {
+      const comments = (yield* parseRest(
+        Schema.Array(Schema.Array(Comment)),
+        yield* restPages(read, `${root}/comments`),
+      )).flat();
+      const groups = new Map<number, Array<typeof Comment.Type>>();
+      for (const comment of comments) {
+        const rootId = comment.in_reply_to_id ?? comment.id;
+        const group = groups.get(rootId) ?? [];
+        group.push(comment);
+        groups.set(rootId, group);
+      }
+      const nodes = [...groups.entries()].map(([rootId, group]) => ({
+        id: `rest-thread:${rootId}`,
+        isResolved: null,
+        comments: {
+          nodes: group
+            .toSorted((a, b) => Number(b.id === rootId) - Number(a.id === rootId))
+            .map((item) => ({
+              id: item.node_id,
+              databaseId: item.id,
+              path: item.path,
+              line: item.line,
+              body: item.body,
+              author: { login: item.user.login },
+              commit: { oid: item.commit_id },
+              replyTo:
+                item.in_reply_to_id === undefined || item.in_reply_to_id === null
+                  ? null
+                  : { id: String(item.in_reply_to_id) },
+            })),
+          pageInfo: { hasNextPage: false, endCursor: null },
+        },
+      }));
+      const pull = yield* restPull(read, repo, String(pr));
+      const reviewDecision = query.includes("reviewDecision")
+        ? yield* restReviewDecision(read, {
+            repo,
+            number: pr,
+            baseRefName: pull.baseRefName,
+            headSha: pull.headSha,
+          })
+        : pull.reviewDecision;
+      const fallback = yield* reportFallback([
+        "review thread resolution",
+        ...(query.includes("reviewDecision") && reviewDecision === "UNKNOWN"
+          ? ["reviewDecision"]
+          : []),
+      ]);
+      return {
+        fallback,
+        repository: {
+          pullRequest: {
+            ...pull,
+            reviewDecision,
+            reviewRequests: {
+              nodes: pull.reviewRequests.map((reviewer) => ({ requestedReviewer: reviewer })),
+            },
+            reviewThreads: { nodes, pageInfo: { hasNextPage: false, endCursor: null } },
+          },
+        },
+      };
+    });
+  if (query.includes("reviews(last:") && query.includes("reviewRequests"))
+    return Effect.gen(function* () {
+      const reviews = (yield* parseRest(
+        Schema.Array(
+          Schema.Array(
+            Schema.Struct({
+              user: Schema.NullOr(Reviewer),
+              state: Schema.String,
+              submitted_at: Schema.NullOr(Schema.String),
+            }),
+          ),
+        ),
+        yield* restPages(read, `${root}/reviews`),
+      )).flat();
+      const requested = yield* parseRest(
+        Schema.Struct({
+          users: Schema.Array(Reviewer),
+          teams: Schema.Array(Schema.Struct({ name: Schema.String })),
+        }),
+        yield* restGet(read, `${root}/requested_reviewers`),
+      );
+      const fallback = yield* reportFallback([]);
+      return {
+        fallback,
+        repository: {
+          pullRequest: {
+            reviewRequests: {
+              nodes: [
+                ...requested.users.map((user) => ({
+                  requestedReviewer: {
+                    __typename: user.type === "Bot" ? "Bot" : "User",
+                    login: user.login,
+                  },
+                })),
+                ...requested.teams.map((team) => ({
+                  requestedReviewer: { __typename: "Team", name: team.name },
+                })),
+              ],
+            },
+            reviews: {
+              nodes: reviews.map((review) => ({
+                author: review.user === null ? null : { login: review.user.login },
+                state: review.state,
+                submittedAt: review.submitted_at,
+              })),
+            },
+          },
+        },
+      };
+    });
+  return null;
+};
+export const isGraphqlLimit = (error: unknown) =>
+  error instanceof GitHubCommandError &&
+  /rate.?limit|already exceeded|secondary limit|abuse detection|HTTP 429/i.test(error.stderr);
+export const rateLimitResponse = (stdout: string): string | null => {
+  try {
+    const value = Schema.decodeUnknownSync(
+      Schema.Struct({
+        errors: Schema.optional(Schema.Array(Schema.Unknown)),
+        type: Schema.optional(Schema.String),
+        code: Schema.optional(Schema.String),
+        message: Schema.optional(Schema.String),
+      }),
+    )(JSON.parse(stdout));
+    const detail = JSON.stringify(value.errors ?? value);
+    return /RATE_LIMIT|graphql_rate_limit|rate limit|secondary limit/i.test(detail) ? detail : null;
+  } catch {
+    return null;
+  }
+};
+export const graphqlLimitError = () =>
+  new GitHubCommandError({
+    command: "gh api graphql",
+    exitCode: 1,
+    message: "GraphQL rate limit already exceeded",
+    stderr: "GraphQL rate limit already exceeded",
+  });
+
+const PendingReview = Schema.Struct({
+  id: Schema.Number,
+  node_id: Schema.String,
+  state: Schema.String,
+  body: Schema.NullOr(Schema.String),
+  user: Schema.NullOr(Schema.Struct({ login: Schema.String })),
+  pull_request_url: Schema.String,
+});
+const pendingRest = (
+  query: string,
+  variables: Record<string, string | number | null>,
+  read: JsonRead,
+  root: string,
+  repo: string,
+  pr: number,
+): Effect.Effect<unknown, GhError> =>
+  Effect.gen(function* () {
+    const reviews = (yield* parseRest(
+      Schema.Array(Schema.Array(PendingReview)),
+      yield* restPages(read, `${root}/reviews`),
+    )).flat();
+    const viewer = yield* parseRest(
+      Schema.Struct({ login: Schema.String }),
+      yield* restGet(read, "user"),
+    );
+    const pageInfo = { hasNextPage: false, endCursor: null };
+    if (query.includes("states: [PENDING]")) {
+      const fallback = yield* reportFallback([]);
+      return {
+        fallback,
+        viewer,
+        repository: {
+          pullRequest: {
+            reviews: {
+              nodes: reviews
+                .filter((review) => review.state === "PENDING")
+                .map((review) => ({
+                  id: review.node_id,
+                  state: review.state,
+                  author: review.user,
+                })),
+              pageInfo,
+            },
+          },
+        },
+      };
+    }
+    const review = reviews.find((item) => item.node_id === variables.reviewId);
+    if (
+      review === undefined ||
+      review.state !== "PENDING" ||
+      review.user?.login !== viewer.login ||
+      review.pull_request_url !== `https://api.github.com/${root}`
+    )
+      return yield* new GitHubCommandError({
+        command: "gh-tool pr submit-review",
+        exitCode: 1,
+        message: "REST could not verify an owned pending review on this PR",
+        stderr: "REST could not verify an owned pending review on this PR",
+      });
+    if (query.includes("submitPullRequestReview")) {
+      if (
+        typeof variables.event !== "string" ||
+        !["COMMENT", "APPROVE", "REQUEST_CHANGES"].includes(variables.event) ||
+        typeof variables.body !== "string"
+      )
+        return yield* new GitHubCommandError({
+          command: "gh-tool pr submit-review",
+          exitCode: 1,
+          message: "Invalid review event or body",
+          stderr: "Invalid review event or body",
+        });
+      const result = yield* parseRest(
+        Schema.Struct({ node_id: Schema.String, state: Schema.String }),
+        yield* read([
+          "api",
+          "--method",
+          "POST",
+          `${root}/reviews/${review.id}/events`,
+          "-f",
+          `event=${variables.event}`,
+          "-f",
+          `body=${variables.body}`,
+        ]),
+      );
+      const fallback = yield* reportFallback([]);
+      return {
+        fallback,
+        submitPullRequestReview: { pullRequestReview: { id: result.node_id, state: result.state } },
+      };
+    }
+    const comments = (yield* parseRest(
+      Schema.Array(Schema.Array(Schema.Struct({ body: Schema.String }))),
+      yield* restPages(read, `${root}/reviews/${review.id}/comments`),
+    )).flat();
+    const fallback = yield* reportFallback([]);
+    return {
+      fallback,
+      viewer,
+      node: {
+        id: review.node_id,
+        state: review.state,
+        body: review.body,
+        author: review.user,
+        pullRequest: { number: pr, repository: { nameWithOwner: repo } },
+        comments: { nodes: comments, pageInfo },
+      },
+    };
+  });

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

@@ -17,6 +17,7 @@ const IssueListItem = Schema.Struct({
   url: Schema.String,
   labels: Schema.mutable(Schema.Array(Label)),
   assignees: Schema.mutable(Schema.Array(Login)),
+  author: Schema.NullOr(Login),
   createdAt: Schema.String,
 });
 const IssueView = Schema.Struct({
@@ -25,6 +26,18 @@ const IssueView = Schema.Struct({
   body: Schema.String,
   closedAt: Schema.NullOr(Schema.String),
 });
+const IssueNodeLookup = Schema.Struct({
+  repository: Schema.NullOr(
+    Schema.Struct({
+      issue: Schema.NullOr(
+        Schema.Struct({
+          id: Schema.String,
+          url: Schema.optional(Schema.String),
+        }),
+      ),
+    }),
+  ),
+});
 const IssueComment = Schema.Struct({
   id: Schema.Number,
   user: Login,
@@ -39,7 +52,7 @@ export type IssueListFilter = {
   limit: number;
   includeBody?: boolean;
 };
-export const ISSUE_LIST_FIELDS = "number,title,state,url,labels,assignees,createdAt";
+export const ISSUE_LIST_FIELDS = "number,title,state,url,labels,assignees,author,createdAt";
 export const ISSUE_VIEW_FIELDS =
   "number,title,state,url,labels,assignees,author,body,createdAt,closedAt";
 
@@ -69,6 +82,15 @@ export const issueView = Effect.fn("reads.issueView")(function* (
   });
 });
 
+export const issueNode = Effect.fn("reads.issueNode")(function* (repo: RepoRef, issue: number) {
+  const gh = yield* GitHubService;
+  const response = yield* gh.runGraphQL(
+    "query($owner: String!, $name: String!, $number: Int!) { repository(owner: $owner, name: $name) { issue(number: $number) { id url } } }",
+    { owner: repo.owner, name: repo.name, number: issue },
+  );
+  return parsePreserving(IssueNodeLookup)(response).repository?.issue ?? null;
+});
+
 export const issueList = Effect.fn("reads.issueList")(function* (
   repo: RepoRef,
   filter: IssueListFilter,

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

@@ -8,13 +8,14 @@ import { gatedRead } from "./gated";
 import { restSnapshot, snapshotDigest } from "./rest";
 import { OPS } from "./classes";
 import { repoSlug } from "./keys";
+import { isFallbackResult } from "./graphql-fallback";
 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";
+  "number,url,title,headRefName,baseRefName,headRefOid,state,isDraft,mergeable,body,author,reviewRequests,createdAt,headRepositoryOwner,mergeCommit,reviewDecision";
 export const PR_LIST_FIELDS =
-  "number,url,title,headRefName,baseRefName,state,isDraft,mergeable,author,createdAt,reviewDecision,headRepositoryOwner";
+  "number,url,title,headRefName,baseRefName,state,isDraft,mergeable,author,createdAt,headRepositoryOwner,reviewDecision";
 export type PrListFilter = {
   state: string;
   limit: number;
@@ -38,7 +39,7 @@ const Pull = Schema.Struct({
   ),
   createdAt: Schema.optional(Schema.String),
   reviewDecision: Schema.optional(Schema.String),
-  headRepositoryOwner: Schema.optional(Schema.Struct({ login: Schema.String })),
+  headRepositoryOwner: Schema.optional(Schema.NullOr(Schema.Struct({ login: Schema.String }))),
 });
 
 const PullView = Schema.Struct({
@@ -48,7 +49,13 @@ const PullView = Schema.Struct({
   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", ""]),
+  reviewDecision: Schema.Literals([
+    "APPROVED",
+    "CHANGES_REQUESTED",
+    "REVIEW_REQUIRED",
+    "UNKNOWN",
+    "",
+  ]),
   reviewRequests: Schema.mutable(
     Schema.Array(
       Schema.Union([
@@ -159,7 +166,7 @@ export const prView = Effect.fn("reads.prView")(function* (
   if (selector.by === "currentBranch" || repo === null) {
     const fence = yield* readFence;
     const data = (yield* fetch()).value;
-    if (repo !== null && consistency !== "origin" && fence !== null) {
+    if (repo !== null && consistency !== "origin" && fence !== null && !("fallback" in data)) {
       const head = yield* prHead(repo, data.number).pipe(Effect.orElseSucceed(() => null));
       if (head !== null && head.headSha === data.headRefOid)
         yield* seedRead(
@@ -177,6 +184,7 @@ export const prView = Effect.fn("reads.prView")(function* (
     fetch: Effect.suspend(() => gh.runGhJson<PrView>(args)),
     signal: prHead(repo, selector.number).pipe(Effect.map((head) => head.signature)),
     maxAgeMs: () => OPS.prView.maxAgeMs,
+    cacheableWhen: (value) => !("fallback" in value),
   });
 });
 
@@ -214,6 +222,8 @@ export const prList = Effect.fn("reads.prList")(function* (
       gh
         .runGhJson<PrListItem[]>(args)
         .pipe(Effect.map((value) => ({ kind: "fresh" as const, value }))),
+    cacheableWhen: (value) =>
+      !isFallbackResult(value) && value.every((item) => !("fallback" in item)),
   });
 });
 
@@ -353,7 +363,7 @@ type PrReviewTriageSummaryPage = {
       };
       readonly reviewThreads: {
         readonly nodes: ReadonlyArray<{
-          readonly isResolved: boolean;
+          readonly isResolved: boolean | null;
           readonly comments: {
             readonly nodes: ReadonlyArray<{ readonly replyTo: { readonly id: string } | null }>;
           };
@@ -376,7 +386,7 @@ export type PrReviewTriageSummary = {
     readonly reviewRequests: ReadonlyArray<{ readonly login: string }>;
   };
   readonly summary: {
-    readonly unresolvedReviewThreadsCount: number;
+    readonly unresolvedReviewThreadsCount: number | null;
     readonly unrepliedReviewThreadsCount: number;
   };
   readonly checks: ReadonlyArray<{ readonly name: string; readonly bucket: string }>;
@@ -392,14 +402,16 @@ export const prReviewTriageSummary = Effect.fn("reads.prReviewTriageSummary")(fu
     PR_REVIEW_TRIAGE_SUMMARY_QUERY,
     variables,
   )) as PrReviewTriageSummaryPage;
-  const firstPage = first.repository.pullRequest;
+  let firstPage = first.repository.pullRequest;
   let unresolvedReviewThreadsCount = 0;
+  let resolutionUnknown = false;
   let unrepliedReviewThreadsCount = 0;
   const countThreads = (
     threads: PrReviewTriageSummaryPage["repository"]["pullRequest"]["reviewThreads"]["nodes"],
   ) => {
     for (const thread of threads) {
-      if (!thread.isResolved) unresolvedReviewThreadsCount++;
+      if (thread.isResolved === null) resolutionUnknown = true;
+      if (thread.isResolved === false) unresolvedReviewThreadsCount++;
       if (!thread.comments.nodes.some((comment) => comment.replyTo !== null))
         unrepliedReviewThreadsCount++;
     }
@@ -413,6 +425,12 @@ export const prReviewTriageSummary = Effect.fn("reads.prReviewTriageSummary")(fu
       after: pageInfo.endCursor,
     })) as PrReviewTriageSummaryPage;
     const pullRequest = response.repository.pullRequest;
+    if ("fallback" in response) {
+      unresolvedReviewThreadsCount = 0;
+      unrepliedReviewThreadsCount = 0;
+      resolutionUnknown = false;
+      firstPage = pullRequest;
+    }
     countThreads(pullRequest.reviewThreads.nodes);
     pageInfo = pullRequest.reviewThreads.pageInfo;
   }
@@ -451,7 +469,10 @@ export const prReviewTriageSummary = Effect.fn("reads.prReviewTriageSummary")(fu
       mergeable: firstPage.mergeable,
       reviewRequests,
     },
-    summary: { unresolvedReviewThreadsCount, unrepliedReviewThreadsCount },
+    summary: {
+      unresolvedReviewThreadsCount: resolutionUnknown ? null : unresolvedReviewThreadsCount,
+      unrepliedReviewThreadsCount,
+    },
     checks,
   };
 });
@@ -464,3 +485,32 @@ const movedHead = (pr: number) =>
     stderr: "PR head changed while collecting checks",
     retryable: true,
   });
+
+export const prReviewDecision = Effect.fn("reads.prReviewDecision")(function* (
+  repo: RepoRef,
+  pr: number,
+) {
+  const gh = yield* GitHubService;
+  const result = yield* gh.runGhJson<unknown>([
+    "pr",
+    "view",
+    String(pr),
+    "--repo",
+    repoSlug(repo),
+    "--json",
+    "reviewDecision",
+  ]);
+  return yield* Effect.try({
+    try: () =>
+      Schema.decodeUnknownSync(Schema.Struct({ reviewDecision: PullView.fields.reviewDecision }))(
+        result,
+      ).reviewDecision,
+    catch: (cause) =>
+      new GitHubCommandError({
+        command: "pr view",
+        exitCode: 1,
+        message: "Invalid review decision",
+        stderr: String(cause),
+      }),
+  });
+});

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

@@ -5,7 +5,7 @@ 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 { issueView, issueList, issueComments, issueNode } from "./issues";
 import {
   prView,
   prList,
@@ -14,6 +14,7 @@ import {
   prBody,
   checkSignal,
   prReviewTriageSummary,
+  prReviewDecision,
 } from "./pulls";
 import { prComments, prReviews, reviewThreads, lastHumanReviewer } from "./reviews";
 import { reviewGuards } from "./review-guards";
@@ -40,6 +41,7 @@ const RateLimitResponse = Schema.Struct({
     }),
   ),
 });
+const ViewerLogin = Schema.Struct({ viewer: Schema.Struct({ login: Schema.String }) });
 
 export type RateLimitResource = {
   readonly limit: number;
@@ -110,6 +112,12 @@ export const getPRStatusRateLimit = Effect.fn("reads.getPRStatusRateLimit")(func
   return { core, graphql } satisfies PRStatusRateLimit;
 });
 
+export const viewerLogin = Effect.fn("reads.viewerLogin")(function* () {
+  const gh = yield* GitHubService;
+  const response = yield* gh.runGraphQL("query { viewer { login } }", {});
+  return parsePreserving(ViewerLogin)(response).viewer;
+});
+
 const completedAttemptJobs = Effect.fn("reads.completedAttemptJobs")(function* (
   repo: RepoRef,
   runId: number,
@@ -384,6 +392,7 @@ export const reads = {
   prList,
   prChecks,
   prReviewTriageSummary,
+  prReviewDecision,
   prHead,
   prBody,
   checkSignal,
@@ -396,4 +405,6 @@ export const reads = {
   issueView,
   issueList,
   issueComments,
+  issueNode,
+  viewerLogin,
 };