bellwether 0.0.1

package/src/github/checks.ts

@@ -0,0 +1,187 @@
+import { ghFetch, type ProxyFetch } from "./fetch.js";
+
+// ---------------------------------------------------------------------------
+// Types
+// ---------------------------------------------------------------------------
+
+export interface FailingCheck {
+  name: string;
+  conclusion: string;
+  html_url: string;
+  log: string;
+}
+
+interface RawCheckRun {
+  id: number;
+  name: string;
+  status: string;
+  conclusion: string | null;
+  html_url: string;
+}
+
+export interface CIStatus {
+  sha: string;
+  total: number;
+  passing: number;
+  failing: number;
+  pending: number;
+  passed: string[];
+  in_progress: string[];
+  failures: FailingCheck[];
+}
+
+// ---------------------------------------------------------------------------
+// Job log fetching + RTK-style filtering
+// ---------------------------------------------------------------------------
+
+const MAX_LINES = 60;
+// eslint-disable-next-line no-control-regex
+const ANSI_RE = /\u001b\[[0-9;]*[a-zA-Z]/g;
+const TIMESTAMP_RE = /^\d{4}-\d{2}-\d{2}T\d{2}:\d{2}:\d{2}\.\d+Z\s?/;
+const GROUP_MARKERS = /^##\[(group|endgroup|command|section)\]/;
+const NOISE_RE =
+  /^(##\[debug\]|##\[notice\]|##\[save-state\]|##\[add-matcher\]|##\[remove-matcher\]|##\[set-output\]|##\[set-env\]|##\[add-path\]|##\[warning\]Couldn't find any|Downloading |Download action repository|Complete job name:|shell: \/|error: script ".*" exited with code|\$ )/;
+// RTK "failure focus": strip passing test/check lines, keep only failures
+const PASSING_LINE_RE = /^( *✓ | *✔ | *PASS | *√ | *ok \d| *\. |\s*\d+ passing)/;
+
+function parseJobId(htmlUrl: string): string | null {
+  const m = htmlUrl.match(/\/job\/(\d+)/);
+  return m?.[1] ?? null;
+}
+
+function filterLog(raw: string): string {
+  const lines = raw.split("\n");
+
+  // Find the failed step: look for ##[error]Process completed with exit code
+  // and walk backwards to find its ##[group] start
+  let failStart = -1;
+  let failEnd = -1;
+  for (let i = lines.length - 1; i >= 0; i--) {
+    const line = lines[i]!;
+    if (failEnd === -1 && line.includes("##[error]Process completed with exit code")) {
+      failEnd = i;
+    }
+    if (failEnd !== -1 && line.includes("##[group]")) {
+      failStart = i;
+      break;
+    }
+  }
+
+  // If we found a failed step, extract just that; otherwise use entire log
+  const stepLines = failStart !== -1 && failEnd !== -1 ? lines.slice(failStart, failEnd) : lines;
+
+  const cleaned = stepLines
+    .map((l) => l.replace(ANSI_RE, "")) // strip ANSI
+    .map((l) => l.replace(TIMESTAMP_RE, "")) // strip timestamps
+    .filter((l) => !GROUP_MARKERS.test(l)) // strip ##[group] markers
+    .filter((l) => !NOISE_RE.test(l)) // strip debug/notice noise
+    .filter((l) => !PASSING_LINE_RE.test(l)) // strip passing test lines (failure focus)
+    .map((l) => l.replace(/^##\[error\]/, "")) // strip ##[error] prefix, keep content
+    .map((l) => l.replace(/^##\[warning\]/, "")) // strip ##[warning] prefix, keep content
+    .filter((l) => l.trim() !== "") // strip blank lines
+    .map((l) => (l.length > 200 ? l.slice(0, 200) + "…" : l)); // truncate long lines
+
+  // Tail: keep last N lines (error summaries are at the end)
+  const tail = cleaned.length > MAX_LINES ? cleaned.slice(-MAX_LINES) : cleaned;
+
+  return tail.join("\n");
+}
+
+async function fetchJobLog(
+  owner: string,
+  repo: string,
+  jobId: string,
+  token: string,
+  proxyFetch: ProxyFetch,
+): Promise<string> {
+  try {
+    const res = await ghFetch(
+      `https://api.github.com/repos/${owner}/${repo}/actions/jobs/${jobId}/logs`,
+      token,
+      proxyFetch,
+    );
+    if (!res.ok) {
+      return `[failed to fetch logs: ${res.status}]`;
+    }
+    return filterLog(await res.text());
+  } catch {
+    return "[failed to fetch logs]";
+  }
+}
+
+// ---------------------------------------------------------------------------
+// Fetch CI status
+// ---------------------------------------------------------------------------
+
+export async function fetchCIStatus(
+  owner: string,
+  repo: string,
+  prNumber: number,
+  token: string,
+  proxyFetch: ProxyFetch,
+  headSha?: string,
+): Promise<CIStatus> {
+  let sha = headSha;
+  if (!sha) {
+    const prResponse = await ghFetch(
+      `https://api.github.com/repos/${owner}/${repo}/pulls/${prNumber}`,
+      token,
+      proxyFetch,
+    );
+    if (!prResponse.ok) {
+      throw new Error(`Failed to fetch PR: ${prResponse.status}`);
+    }
+    const pr = (await prResponse.json()) as { head: { sha: string } };
+    sha = pr.head.sha;
+  }
+
+  // Fetch check runs for that SHA
+  const checksResponse = await ghFetch(
+    `https://api.github.com/repos/${owner}/${repo}/commits/${sha}/check-runs?per_page=100`,
+    token,
+    proxyFetch,
+  );
+  if (!checksResponse.ok) {
+    throw new Error(`Failed to fetch checks: ${checksResponse.status}`);
+  }
+  const checksData = (await checksResponse.json()) as { check_runs: RawCheckRun[] };
+  const rawChecks = checksData.check_runs;
+
+  const isPassing = (c: RawCheckRun) =>
+    c.conclusion === "success" || c.conclusion === "skipped" || c.conclusion === "neutral";
+  const isFailing = (c: RawCheckRun) =>
+    c.conclusion === "failure" ||
+    c.conclusion === "timed_out" ||
+    c.conclusion === "action_required";
+
+  const passed = rawChecks.filter(isPassing).map((c) => c.name);
+  const in_progress = rawChecks.filter((c) => c.status !== "completed").map((c) => c.name);
+  const failingChecks = rawChecks.filter(isFailing);
+
+  // Fetch job logs for failing checks in parallel
+  const failures: FailingCheck[] = await Promise.all(
+    failingChecks.map(async (c) => {
+      const jobId = parseJobId(c.html_url);
+      const log = jobId
+        ? await fetchJobLog(owner, repo, jobId, token, proxyFetch)
+        : "[could not parse job ID from URL]";
+      return {
+        name: c.name,
+        conclusion: c.conclusion ?? "unknown",
+        html_url: c.html_url,
+        log,
+      };
+    }),
+  );
+
+  return {
+    sha,
+    total: rawChecks.length,
+    passing: passed.length,
+    failing: failingChecks.length,
+    pending: in_progress.length,
+    passed,
+    in_progress,
+    failures,
+  };
+}

package/src/github/comments.ts

@@ -0,0 +1,522 @@
+import { fetchAllPages, ghFetch, type ProxyFetch } from "./fetch.js";
+
+// ---------------------------------------------------------------------------
+// Types
+// ---------------------------------------------------------------------------
+
+export interface ProcessedComment {
+  id: number;
+  type: "review_comment" | "issue_comment" | "review";
+  user: string;
+  isBot: boolean;
+  path: string | null;
+  line: number | null;
+  diffHunk: string | null;
+  body: string;
+  state?: string;
+  createdAt: string;
+  updatedAt: string;
+  url: string;
+  replies: Reply[];
+  hasHumanReply: boolean;
+  hasAnyReply: boolean;
+  isResolved: boolean;
+}
+
+export interface Reply {
+  id: number;
+  user: string;
+  body: string;
+  createdAt: string;
+  isBot: boolean;
+}
+
+export interface FilterOptions {
+  botsOnly?: boolean;
+  humansOnly?: boolean;
+  filter?: "unresolved" | "unanswered" | null;
+}
+
+// ---------------------------------------------------------------------------
+// Meta-comment filters
+// ---------------------------------------------------------------------------
+
+type MetaFilter = (user: string, body: string) => boolean;
+
+const DEFAULT_META_FILTERS: MetaFilter[] = [
+  (_user, body) => body.startsWith("> Re: comment "),
+  (user, body) => (user === "vercel[bot]" || user === "vercel") && body.startsWith("[vc]:"),
+  (user, body) => (user === "supabase[bot]" || user === "supabase") && body.startsWith("[supa]:"),
+  (user, body) =>
+    (user === "cursor[bot]" || user === "cursor") &&
+    body.startsWith("Cursor Bugbot has reviewed your changes"),
+  (user, body) =>
+    (user === "copilot-pull-request-reviewer[bot]" || user === "copilot-pull-request-reviewer") &&
+    body.includes("Pull request overview"),
+  (user, body) =>
+    (user === "coderabbitai[bot]" || user === "coderabbitai") &&
+    body.includes("<!-- This is an auto-generated comment: summarize by coderabbit.ai -->"),
+  (user, body) =>
+    (user === "sourcery-ai[bot]" || user === "sourcery-ai") &&
+    body.includes("<!-- Generated by sourcery-ai[bot]:"),
+  (user, body) =>
+    (user === "codacy-production[bot]" || user === "codacy-production") &&
+    (body.includes("Codacy's Analysis Summary") || body.includes("Coverage summary from Codacy")),
+  (user, body) =>
+    (user === "sonarcloud[bot]" ||
+      user === "sonarcloud" ||
+      user === "sonarqubecloud[bot]" ||
+      user === "sonarqubecloud" ||
+      user === "sonarqube-cloud-us[bot]" ||
+      user === "sonarqube-cloud-us") &&
+    body.includes("Quality Gate"),
+];
+
+function isMetaComment(user: string, body: string): boolean {
+  if (!body) {
+    return false;
+  }
+  return DEFAULT_META_FILTERS.some((filter) => filter(user, body));
+}
+
+// ---------------------------------------------------------------------------
+// Bot detection
+// ---------------------------------------------------------------------------
+
+const KNOWN_BOT_LOGINS = new Set([
+  "cursor",
+  "vercel",
+  "supabase",
+  "chatgpt-codex-connector",
+  "github-actions",
+  "Copilot",
+  "copilot-pull-request-reviewer",
+  "coderabbitai",
+  "sourcery-ai",
+  "codacy-production",
+  "sonarcloud",
+  "sonarqubecloud",
+  "sonarqube-cloud-us",
+]);
+
+function isBot(username: string | undefined): boolean {
+  if (!username) {
+    return false;
+  }
+  return username.endsWith("[bot]") || KNOWN_BOT_LOGINS.has(username) || username.includes("bot");
+}
+
+// ---------------------------------------------------------------------------
+// Body cleanup
+// ---------------------------------------------------------------------------
+
+function cleanBody(body: string | null | undefined): string {
+  if (!body) {
+    return "";
+  }
+  let cleaned = body;
+  // Remove HTML comments (single and multi-line)
+  cleaned = cleaned.replaceAll(/<!--[\s\S]*?-->/g, "");
+  // Remove <details> blocks containing "Additional Locations"
+  cleaned = cleaned.replaceAll(
+    /<details>\s*<summary>\s*Additional Locations[\s\S]*?<\/details>/gi,
+    "",
+  );
+  // Remove <p> blocks containing cursor.com links
+  cleaned = cleaned.replaceAll(/<p>\s*<a [^>]*cursor\.com[\s\S]*?<\/p>/gi, "");
+  // Collapse runs of 3+ newlines into 2
+  cleaned = cleaned.replaceAll(/\n{3,}/g, "\n\n");
+  return cleaned.trim();
+}
+
+// ---------------------------------------------------------------------------
+// Fetch & process
+// ---------------------------------------------------------------------------
+
+interface RawGitHubUser {
+  login: string;
+}
+
+interface RawReviewComment {
+  id: number;
+  user?: RawGitHubUser;
+  body: string;
+  path: string;
+  line: number | null;
+  original_line: number | null;
+  diff_hunk: string | null;
+  created_at: string;
+  updated_at: string;
+  html_url: string;
+  in_reply_to_id?: number;
+}
+
+interface RawIssueComment {
+  id: number;
+  user?: RawGitHubUser;
+  body: string;
+  created_at: string;
+  updated_at: string;
+  html_url: string;
+}
+
+interface RawReview {
+  id: number;
+  user?: RawGitHubUser;
+  body: string | null;
+  state: string;
+  submitted_at: string;
+  html_url: string;
+}
+
+export interface RawCommentData {
+  reviewComments: RawReviewComment[];
+  issueComments: RawIssueComment[];
+  reviews: RawReview[];
+}
+
+export async function fetchPRComments(
+  owner: string,
+  repo: string,
+  prNumber: number,
+  token: string,
+  proxyFetch: ProxyFetch,
+): Promise<RawCommentData> {
+  const baseUrl = `https://api.github.com/repos/${owner}/${repo}`;
+
+  const [reviewComments, issueComments, reviews] = await Promise.all([
+    fetchAllPages<RawReviewComment>(
+      `${baseUrl}/pulls/${prNumber}/comments?per_page=100`,
+      token,
+      proxyFetch,
+    ),
+    fetchAllPages<RawIssueComment>(
+      `${baseUrl}/issues/${prNumber}/comments?per_page=100`,
+      token,
+      proxyFetch,
+    ),
+    fetchAllPages<RawReview>(
+      `${baseUrl}/pulls/${prNumber}/reviews?per_page=100`,
+      token,
+      proxyFetch,
+    ),
+  ]);
+
+  return { reviewComments, issueComments, reviews };
+}
+
+export function processComments(data: RawCommentData): ProcessedComment[] {
+  const { reviewComments, issueComments, reviews } = data;
+
+  // Build reply map
+  const repliesMap = new Map<number, Reply[]>();
+  for (const comment of reviewComments) {
+    if (comment.in_reply_to_id) {
+      if (!repliesMap.has(comment.in_reply_to_id)) {
+        repliesMap.set(comment.in_reply_to_id, []);
+      }
+      repliesMap.get(comment.in_reply_to_id)!.push({
+        id: comment.id,
+        user: comment.user?.login ?? "unknown",
+        body: cleanBody(comment.body),
+        createdAt: comment.created_at,
+        isBot: isBot(comment.user?.login),
+      });
+    }
+  }
+
+  const processed: ProcessedComment[] = [];
+
+  // Review comments (inline code comments)
+  for (const comment of reviewComments) {
+    if (comment.in_reply_to_id) {
+      continue;
+    }
+    if (isMetaComment(comment.user?.login ?? "", comment.body)) {
+      continue;
+    }
+
+    const replies = repliesMap.get(comment.id) ?? [];
+    const hasHumanReply = replies.some((r) => !r.isBot);
+    const hasAnyReply = replies.length > 0;
+
+    processed.push({
+      id: comment.id,
+      type: "review_comment",
+      user: comment.user?.login ?? "unknown",
+      isBot: isBot(comment.user?.login),
+      path: comment.path,
+      // oxlint-disable-next-line typescript/prefer-nullish-coalescing -- 0 is "no line", intentional falsy check
+      line: comment.line || comment.original_line,
+      diffHunk: comment.diff_hunk ?? null,
+      body: cleanBody(comment.body),
+      createdAt: comment.created_at,
+      updatedAt: comment.updated_at,
+      url: comment.html_url,
+      replies,
+      hasHumanReply,
+      hasAnyReply,
+      isResolved: false,
+    });
+  }
+
+  // Issue comments (general PR comments)
+  for (const comment of issueComments) {
+    if (isMetaComment(comment.user?.login ?? "", comment.body)) {
+      continue;
+    }
+
+    processed.push({
+      id: comment.id,
+      type: "issue_comment",
+      user: comment.user?.login ?? "unknown",
+      isBot: isBot(comment.user?.login),
+      path: null,
+      line: null,
+      diffHunk: null,
+      body: cleanBody(comment.body),
+      createdAt: comment.created_at,
+      updatedAt: comment.updated_at,
+      url: comment.html_url,
+      replies: [],
+      hasHumanReply: false,
+      hasAnyReply: false,
+      isResolved: false,
+    });
+  }
+
+  // Reviews (only human, with body)
+  for (const review of reviews) {
+    if (isBot(review.user?.login)) {
+      continue;
+    }
+    if (isMetaComment(review.user?.login ?? "", review.body ?? "")) {
+      continue;
+    }
+    if (!review.body?.trim()) {
+      continue;
+    }
+
+    processed.push({
+      id: review.id,
+      type: "review",
+      user: review.user?.login ?? "unknown",
+      isBot: false,
+      path: null,
+      line: null,
+      diffHunk: null,
+      body: cleanBody(review.body),
+      state: review.state,
+      createdAt: review.submitted_at,
+      updatedAt: review.submitted_at,
+      url: review.html_url,
+      replies: [],
+      hasHumanReply: false,
+      hasAnyReply: false,
+      isResolved: review.state === "APPROVED" || review.state === "DISMISSED",
+    });
+  }
+
+  processed.sort((a, b) => new Date(b.createdAt).getTime() - new Date(a.createdAt).getTime());
+
+  return processed;
+}
+
+export function filterComments(
+  comments: ProcessedComment[],
+  options: FilterOptions,
+): ProcessedComment[] {
+  let filtered = comments;
+
+  if (options.botsOnly) {
+    filtered = filtered.filter((c) => c.isBot);
+  } else if (options.humansOnly) {
+    filtered = filtered.filter((c) => !c.isBot);
+  }
+
+  if (options.filter === "unresolved") {
+    filtered = filtered.filter((c) => !(c.isResolved || c.hasHumanReply));
+  } else if (options.filter === "unanswered") {
+    filtered = filtered.filter((c) => !c.hasAnyReply);
+  }
+
+  return filtered;
+}
+
+// ---------------------------------------------------------------------------
+// Reply & resolve
+// ---------------------------------------------------------------------------
+
+export async function replyToComment(
+  owner: string,
+  repo: string,
+  prNumber: number,
+  commentId: number,
+  message: string,
+  token: string,
+  proxyFetch: ProxyFetch,
+): Promise<{ html_url: string }> {
+  // Try review comment reply endpoint first
+  const response = await ghFetch(
+    `https://api.github.com/repos/${owner}/${repo}/pulls/${prNumber}/comments/${commentId}/replies`,
+    token,
+    proxyFetch,
+    {
+      method: "POST",
+      headers: { "Content-Type": "application/json" },
+      body: JSON.stringify({ body: message }),
+    },
+  );
+
+  if (!response.ok) {
+    // Fallback to issue comment endpoint
+    const issueResponse = await ghFetch(
+      `https://api.github.com/repos/${owner}/${repo}/issues/${prNumber}/comments`,
+      token,
+      proxyFetch,
+      {
+        method: "POST",
+        headers: { "Content-Type": "application/json" },
+        body: JSON.stringify({
+          body: `> Re: comment ${commentId}\n\n${message}`,
+        }),
+      },
+    );
+
+    if (!issueResponse.ok) {
+      const error = await issueResponse.text();
+      throw new Error(`Failed to reply: ${issueResponse.status} - ${error}`);
+    }
+
+    return issueResponse.json() as Promise<{ html_url: string }>;
+  }
+
+  return response.json() as Promise<{ html_url: string }>;
+}
+
+export async function resolveThread(
+  owner: string,
+  repo: string,
+  prNumber: number,
+  commentId: number,
+  token: string,
+  proxyFetch: ProxyFetch,
+): Promise<
+  | { resolved: true; threadId: string }
+  | { alreadyResolved: true; threadId: string }
+  | { skipped: true; reason: string }
+> {
+  const query = `
+    query($owner: String!, $repo: String!, $pr: Int!, $cursor: String) {
+      repository(owner: $owner, name: $repo) {
+        pullRequest(number: $pr) {
+          reviewThreads(first: 100, after: $cursor) {
+            pageInfo { hasNextPage endCursor }
+            nodes {
+              id
+              isResolved
+              comments(first: 1) {
+                nodes { databaseId }
+              }
+            }
+          }
+        }
+      }
+    }
+  `;
+
+  interface ReviewThreadNode {
+    id: string;
+    isResolved: boolean;
+    comments: { nodes: { databaseId: number }[] };
+  }
+
+  let cursor: string | null = null;
+  let thread: ReviewThreadNode | null = null;
+
+  while (!thread) {
+    const response = await ghFetch("https://api.github.com/graphql", token, proxyFetch, {
+      method: "POST",
+      headers: { "Content-Type": "application/json" },
+      body: JSON.stringify({
+        query,
+        variables: { owner, repo, pr: prNumber, cursor },
+      }),
+    });
+
+    if (!response.ok) {
+      throw new Error(`GraphQL query failed: ${response.status}`);
+    }
+
+    const data = (await response.json()) as {
+      errors?: { message: string }[];
+      data?: {
+        repository?: {
+          pullRequest?: {
+            reviewThreads?: {
+              pageInfo: { hasNextPage: boolean; endCursor: string | null };
+              nodes: ReviewThreadNode[];
+            };
+          };
+        };
+      };
+    };
+    if (data.errors?.[0]) {
+      throw new Error(`GraphQL error: ${data.errors[0].message}`);
+    }
+
+    const reviewThreads = data.data?.repository?.pullRequest?.reviewThreads;
+    if (!reviewThreads) {
+      break;
+    }
+
+    thread =
+      reviewThreads.nodes.find((t: ReviewThreadNode) =>
+        t.comments.nodes.some((c: { databaseId: number }) => c.databaseId === commentId),
+      ) ?? null;
+
+    if (!thread && reviewThreads.pageInfo.hasNextPage) {
+      cursor = reviewThreads.pageInfo.endCursor;
+    } else {
+      break;
+    }
+  }
+
+  if (!thread) {
+    return { skipped: true, reason: "not a review comment thread" };
+  }
+
+  if (thread.isResolved) {
+    return { alreadyResolved: true, threadId: thread.id };
+  }
+
+  const mutation = `
+    mutation($threadId: ID!) {
+      resolveReviewThread(input: { threadId: $threadId }) {
+        thread { id isResolved }
+      }
+    }
+  `;
+
+  const resolveResponse = await ghFetch("https://api.github.com/graphql", token, proxyFetch, {
+    method: "POST",
+    headers: { "Content-Type": "application/json" },
+    body: JSON.stringify({
+      query: mutation,
+      variables: { threadId: thread.id },
+    }),
+  });
+
+  if (!resolveResponse.ok) {
+    throw new Error(`Failed to resolve thread: ${resolveResponse.status}`);
+  }
+
+  const resolveData = (await resolveResponse.json()) as {
+    errors?: { message: string }[];
+  };
+  if (resolveData.errors?.[0]) {
+    throw new Error(`GraphQL error: ${resolveData.errors[0].message}`);
+  }
+
+  return { resolved: true, threadId: thread.id };
+}