neondeck 1.0.0-beta.4

package/src/modules/github/comments.ts

@@ -0,0 +1,204 @@
+import * as v from 'valibot';
+import { encodePathSegment, githubFetch, githubGraphqlFetch } from './client';
+import {
+  githubIssueCommentApiResponseSchema,
+  githubReviewThreadNodeGraphqlResponseSchema,
+  githubReviewThreadCommentsGraphqlResponseSchema,
+  githubReviewThreadsGraphqlResponseSchema,
+  pullRequestReviewThreadNodeQuery,
+  pullRequestReviewThreadsQuery,
+  reviewThreadCommentsQuery,
+} from './schemas';
+import type {
+  GitHubPullRequestComment,
+  GitHubPullRequestReviewThread,
+  GitHubPullRequestReviewThreadComment,
+  GitHubReviewThreadCommentGraphqlNode,
+  GitHubReviewThreadGraphqlNode,
+} from './schemas';
+
+export async function postPullRequestComment(options: {
+  token: string;
+  owner: string;
+  repo: string;
+  number: number;
+  body: string;
+}): Promise<GitHubPullRequestComment> {
+  const response = await githubFetch(
+    options.token,
+    `https://api.github.com/repos/${encodePathSegment(options.owner)}/${encodePathSegment(options.repo)}/issues/${options.number}/comments`,
+    {
+      method: 'POST',
+      body: JSON.stringify({ body: options.body }),
+    },
+  );
+  const data = v.parse(
+    githubIssueCommentApiResponseSchema,
+    await response.json(),
+  );
+
+  return {
+    id: data.id,
+    nodeId: data.node_id ?? null,
+    url: data.html_url,
+    authorLogin: data.user?.login ?? null,
+    body: data.body,
+    createdAt: data.created_at,
+    updatedAt: data.updated_at,
+  };
+}
+
+export async function fetchPullRequestReviewThreads(options: {
+  token: string;
+  owner: string;
+  repo: string;
+  number: number;
+}): Promise<GitHubPullRequestReviewThread[]> {
+  return (await fetchPullRequestReviewThreadsWithMetadata(options))
+    .reviewThreads;
+}
+
+export async function fetchPullRequestReviewThreadsWithMetadata(options: {
+  token: string;
+  owner: string;
+  repo: string;
+  number: number;
+}): Promise<{
+  reviewThreads: GitHubPullRequestReviewThread[];
+  truncated: boolean;
+}> {
+  const threads: GitHubPullRequestReviewThread[] = [];
+  let cursor: string | null = null;
+  let truncated = false;
+
+  for (let page = 0; page < 5; page += 1) {
+    const data = await githubGraphqlFetch(
+      options.token,
+      pullRequestReviewThreadsQuery,
+      {
+        owner: options.owner,
+        name: options.repo,
+        number: options.number,
+        after: cursor,
+      },
+    );
+    const parsed = v.parse(githubReviewThreadsGraphqlResponseSchema, data);
+    const pullRequest = parsed.data.repository?.pullRequest;
+    if (!pullRequest) break;
+    for (const thread of pullRequest.reviewThreads.nodes ?? []) {
+      threads.push(await normalizeReviewThread(options.token, thread));
+    }
+
+    if (!pullRequest.reviewThreads.pageInfo.hasNextPage) break;
+    if (page === 4) {
+      truncated = true;
+      console.warn(
+        `[neondeck] GitHub review thread fetch reached the page cap for ${options.owner}/${options.repo}#${options.number}; results may be truncated.`,
+      );
+      break;
+    }
+    cursor = pullRequest.reviewThreads.pageInfo.endCursor ?? null;
+    if (!cursor) {
+      truncated = true;
+      break;
+    }
+  }
+
+  return { reviewThreads: threads, truncated };
+}
+
+export async function fetchPullRequestReviewThread(options: {
+  token: string;
+  threadId: string;
+}): Promise<GitHubPullRequestReviewThread> {
+  const data = await githubGraphqlFetch(
+    options.token,
+    pullRequestReviewThreadNodeQuery,
+    { threadId: options.threadId },
+  );
+  const parsed = v.parse(githubReviewThreadNodeGraphqlResponseSchema, data);
+  const thread = parsed.data.node;
+  if (!thread) {
+    throw new Error(
+      `GitHub review thread "${options.threadId}" was not found.`,
+    );
+  }
+  return normalizeReviewThread(options.token, thread);
+}
+
+async function normalizeReviewThread(
+  token: string,
+  thread: GitHubReviewThreadGraphqlNode,
+): Promise<GitHubPullRequestReviewThread> {
+  const comments = await fetchAllReviewThreadComments(token, thread);
+  return {
+    id: thread.id,
+    isResolved: thread.isResolved,
+    isOutdated: thread.isOutdated,
+    path: thread.path ?? null,
+    line: thread.line ?? null,
+    originalLine: thread.originalLine ?? null,
+    diffSide: thread.diffSide ?? null,
+    pullRequestRepo: thread.pullRequest?.repository.nameWithOwner ?? null,
+    pullRequestNumber: thread.pullRequest?.number ?? null,
+    commentsTruncated: comments.truncated,
+    comments: comments.items.map((comment) =>
+      normalizeReviewThreadComment(comment, thread),
+    ),
+  };
+}
+
+async function fetchAllReviewThreadComments(
+  token: string,
+  thread: GitHubReviewThreadGraphqlNode,
+) {
+  const comments = [...(thread.comments.nodes ?? [])];
+  let cursor = thread.comments.pageInfo.endCursor;
+  let hasNextPage = thread.comments.pageInfo.hasNextPage;
+  let truncated = false;
+
+  for (let page = 0; hasNextPage && page < 10;) {
+    page += 1;
+    if (!cursor) {
+      truncated = true;
+      break;
+    }
+    const data = await githubGraphqlFetch(token, reviewThreadCommentsQuery, {
+      threadId: thread.id,
+      after: cursor,
+    });
+    const parsed = v.parse(
+      githubReviewThreadCommentsGraphqlResponseSchema,
+      data,
+    );
+    const node = parsed.data.node;
+    if (!node?.comments) break;
+    comments.push(...(node.comments.nodes ?? []));
+    hasNextPage = node.comments.pageInfo.hasNextPage;
+    if (!hasNextPage) break;
+    cursor = node.comments.pageInfo.endCursor;
+  }
+  truncated = truncated || hasNextPage;
+
+  return { items: comments, truncated };
+}
+
+function normalizeReviewThreadComment(
+  comment: GitHubReviewThreadCommentGraphqlNode,
+  thread: Pick<GitHubReviewThreadGraphqlNode, 'path' | 'line'>,
+): GitHubPullRequestReviewThreadComment {
+  return {
+    id: comment.id,
+    databaseId: comment.databaseId ?? null,
+    authorLogin: comment.author?.login ?? null,
+    body: comment.body,
+    url: comment.url ?? null,
+    path: comment.path ?? thread.path ?? null,
+    line: comment.line ?? thread.line ?? null,
+    originalLine: comment.originalLine ?? null,
+    diffHunk: comment.diffHunk ?? null,
+    reviewId: comment.pullRequestReview?.databaseId ?? null,
+    createdAt: comment.createdAt,
+    updatedAt: comment.updatedAt,
+  };
+}

package/src/modules/github/errors.ts

@@ -0,0 +1,50 @@
+export class GitHubApiError extends Error {
+  constructor(
+    readonly status: number,
+    readonly data: unknown,
+    message: string,
+  ) {
+    super(message);
+    this.name = 'GitHubApiError';
+  }
+}
+
+export function githubErrorMessage(response: Response, data?: unknown) {
+  const rateLimitRemaining = response.headers.get('x-ratelimit-remaining');
+  const rateLimitReset = response.headers.get('x-ratelimit-reset');
+  const retryAfter = response.headers.get('retry-after');
+
+  if (
+    response.status === 429 ||
+    (response.status === 403 && rateLimitRemaining === '0')
+  ) {
+    const retryAt = retryAfter
+      ? ` Retry after ${retryAfter}s.`
+      : rateLimitReset
+        ? ` Rate limit resets at ${new Date(Number(rateLimitReset) * 1000).toISOString()}.`
+        : '';
+    return `GitHub request was rate limited with ${response.status}.${retryAt}`;
+  }
+
+  const detail = githubResponseDetail(data);
+  return `GitHub request failed with ${response.status}${detail ? `: ${detail}` : ''}`;
+}
+
+export function errorMessage(error: unknown) {
+  return error instanceof Error ? error.message : String(error);
+}
+
+export function isRequestTimeout(error: unknown) {
+  return (
+    error instanceof Error &&
+    (error.name === 'TimeoutError' || error.name === 'AbortError')
+  );
+}
+
+function githubResponseDetail(data: unknown) {
+  if (!data || typeof data !== 'object') return null;
+  if ('message' in data && typeof data.message === 'string') {
+    return data.message;
+  }
+  return null;
+}

package/src/modules/github/index.ts

@@ -0,0 +1,92 @@
+export { fetchGitHubLogin } from './client';
+export {
+  getGitHubCheckSummary,
+  getGitHubPullRequest,
+  listGitHubIssues,
+  listGitHubPrQueue,
+} from './actions';
+export { fetchGitHubIssues, type GitHubIssue } from './issues';
+export {
+  buildPullRequestQueries,
+  clearGitHubPullRequestQueueCache,
+  fetchPullRequestQueue,
+} from './queue';
+export {
+  fetchPullRequestCommits,
+  fetchPullRequestCommitsWithMetadata,
+  fetchPullRequestDetail,
+  fetchPullRequestEventState,
+  fetchPullRequestFiles,
+} from './pull-requests';
+export { pullRequestEventStateTruncation } from './state-truncation';
+export type { GitHubPullRequestEventStateTruncation } from './state-truncation';
+export {
+  fetchPullRequestFilesWithCache,
+  readCachedPullRequestFiles,
+  stripPullRequestPatches,
+} from './pr-file-cache';
+export {
+  fetchCheckRunDetails,
+  fetchCheckRunDetailsWithMetadata,
+  fetchCheckSuites,
+  fetchCheckSuitesWithMetadata,
+  fetchCheckSummary,
+  fetchFailingCheckFacts,
+} from './checks';
+export {
+  addPrReviewDraftComment,
+  deletePrReviewNeonSeedsForComments,
+  deletePrReviewDraftComment,
+  discardPrReviewDraft,
+  fetchPullRequestReviews,
+  fetchPullRequestReviewsWithMetadata,
+  readLivePrReviewDraft,
+  readPrReviewDraft,
+  readPrReviewDraftForComment,
+  recordPrReviewNeonSeed,
+  replyToPullRequestReviewThread,
+  resolvePullRequestReviewThread,
+  submitPullRequestReview,
+  unresolvePullRequestReviewThread,
+  updatePrReviewDraftComment,
+  upsertPrReviewDraft,
+  GitHubPrReviewSubmitError,
+} from './reviews';
+export type {
+  GitHubPrReviewDraft,
+  GitHubPrReviewDraftComment,
+  GitHubPrReviewDraftCommentOrigin,
+  GitHubPrReviewDraftCommentSide,
+  GitHubPrReviewDraftStatus,
+  GitHubPrReviewSubmitFailure,
+  GitHubPrReviewVerdict,
+} from './reviews';
+export {
+  fetchPullRequestReviewThread,
+  fetchPullRequestReviewThreads,
+  postPullRequestComment,
+  fetchPullRequestReviewThreadsWithMetadata,
+} from './comments';
+export type {
+  GitHubBranchPushPermissions,
+  GitHubCheckAnnotation,
+  GitHubCheckRunDetail,
+  GitHubCheckSuiteDetail,
+  GitHubCheckSummary,
+  GitHubFailingCheckFact,
+  GitHubDiffSummary,
+  GitHubPullRequest,
+  GitHubPullRequestComment,
+  GitHubPullRequestCommit,
+  GitHubPullRequestDetail,
+  GitHubPullRequestEventState,
+  GitHubPullRequestFile,
+  GitHubPullRequestFiles,
+  GitHubPullRequestQueue,
+  GitHubPullRequestRequestedChangesState,
+  GitHubPullRequestReview,
+  GitHubPullRequestReviewThread,
+  GitHubPullRequestReviewThreadComment,
+  GitHubQueueIssue,
+  PullRequestQueueRelation,
+} from './schemas';

package/src/modules/github/issues.ts

@@ -0,0 +1,116 @@
+import * as v from 'valibot';
+import { encodePathSegment, githubFetch, nextLink } from './client';
+
+export type GitHubIssue = {
+  number: number;
+  title: string;
+  url: string;
+  labels: string[];
+  authorLogin: string | null;
+  assigneeLogins: string[];
+  createdAt: string;
+  updatedAt: string;
+  commentCount: number;
+  bodyExcerpt: string;
+};
+
+export type FetchGitHubIssuesInput = {
+  token: string;
+  owner: string;
+  repo: string;
+  since?: string | null;
+  limit?: number;
+  maxPages?: number;
+  sort?: 'created' | 'updated' | 'comments';
+  direction?: 'asc' | 'desc';
+};
+
+const issueSchema = v.looseObject({
+  number: v.number(),
+  title: v.string(),
+  html_url: v.string(),
+  body: v.optional(v.nullable(v.string())),
+  user: v.nullable(v.looseObject({ login: v.string() })),
+  assignees: v.optional(v.array(v.looseObject({ login: v.string() }))),
+  labels: v.optional(
+    v.array(
+      v.union([
+        v.string(),
+        v.looseObject({
+          name: v.string(),
+        }),
+      ]),
+    ),
+  ),
+  created_at: v.string(),
+  updated_at: v.string(),
+  comments: v.number(),
+  pull_request: v.optional(v.unknown()),
+});
+
+export async function fetchGitHubIssues(input: FetchGitHubIssuesInput) {
+  const limit = Math.max(1, Math.min(200, input.limit ?? 100));
+  const maxPages = Math.max(1, Math.min(10, input.maxPages ?? 3));
+  const params = new URLSearchParams({
+    state: 'open',
+    per_page: String(Math.min(100, limit)),
+    sort: input.sort ?? 'updated',
+    direction: input.direction ?? 'desc',
+  });
+  if (input.since) params.set('since', input.since);
+  let url: string | undefined =
+    `https://api.github.com/repos/${encodePathSegment(input.owner)}/${encodePathSegment(input.repo)}/issues?${params.toString()}`;
+  const issues: GitHubIssue[] = [];
+  let stoppedAtLimit = false;
+  let pageCount = 0;
+
+  while (url && issues.length < limit && pageCount < maxPages) {
+    pageCount += 1;
+    const response = await githubFetch(input.token, url);
+    const page = v.parse(v.array(issueSchema), await response.json());
+    for (const item of page) {
+      if (item.pull_request) continue;
+      if (issues.length >= limit) {
+        stoppedAtLimit = true;
+        break;
+      }
+      issues.push({
+        number: item.number,
+        title: item.title,
+        url: item.html_url,
+        labels: (item.labels ?? []).map((label) =>
+          typeof label === 'string' ? label : label.name,
+        ),
+        authorLogin: item.user?.login ?? null,
+        assigneeLogins: (item.assignees ?? []).map(
+          (assignee) => assignee.login,
+        ),
+        createdAt: item.created_at,
+        updatedAt: item.updated_at,
+        commentCount: item.comments,
+        bodyExcerpt: excerpt(item.body ?? ''),
+      });
+    }
+    const next = nextLink(response.headers.get('link'));
+    if (issues.length >= limit) {
+      stoppedAtLimit = stoppedAtLimit || Boolean(next);
+      url = undefined;
+    } else {
+      url = next;
+    }
+  }
+  const stoppedAtPageLimit = Boolean(url) && pageCount >= maxPages;
+
+  return {
+    items: issues,
+    fetchedAt: new Date().toISOString(),
+    truncated: stoppedAtLimit || stoppedAtPageLimit || Boolean(url),
+  };
+}
+
+function excerpt(value: string) {
+  const normalized = value.replace(/\s+/g, ' ').trim();
+  return normalized.length <= 600
+    ? normalized
+    : `${normalized.slice(0, 600)}...`;
+}