bellwether 0.0.1

package/src/github/fetch.ts

@@ -0,0 +1,233 @@
+import { join } from "node:path";
+import { tmpdir } from "node:os";
+import { mkdtempSync } from "node:fs";
+import { readFile, rm } from "node:fs/promises";
+import { spawnSync } from "node:child_process";
+import { createRequire } from "node:module";
+
+const require = createRequire(import.meta.url);
+const USER_AGENT = "bellwether";
+
+// ---------------------------------------------------------------------------
+// Types
+// ---------------------------------------------------------------------------
+
+export type ProxyFetch = (url: string, options?: ProxyFetchOptions) => Promise<ProxyFetchResponse>;
+
+export interface ProxyFetchOptions {
+  method?: string;
+  headers?: Record<string, string>;
+  body?: string;
+}
+
+interface HeaderMap {
+  get(name: string): string | null;
+}
+
+export interface ProxyFetchResponse {
+  ok: boolean;
+  status: number;
+  headers: HeaderMap;
+  text(): Promise<string>;
+  // eslint-disable-next-line typescript/no-explicit-any -- GitHub API responses are untyped; callers cast at call sites
+  json(): Promise<any>;
+}
+
+// ---------------------------------------------------------------------------
+// Header parsing (for curl responses & proxied headers)
+// ---------------------------------------------------------------------------
+
+function parseHeaderMap(rawHeaders: string): HeaderMap {
+  const lines = rawHeaders.split(/\r?\n/).filter(Boolean);
+  const map = new Map<string, string>();
+  for (const line of lines) {
+    const idx = line.indexOf(":");
+    if (idx === -1) {
+      continue;
+    }
+    const key = line.slice(0, idx).trim().toLowerCase();
+    const value = line.slice(idx + 1).trim();
+    map.set(key, value);
+  }
+  return {
+    get(name: string) {
+      return map.get(String(name).toLowerCase()) ?? null;
+    },
+  };
+}
+
+function parseLastHeaderBlock(headerContent: string): string {
+  const blocks = headerContent
+    .split(/\r?\n\r?\n/)
+    .map((b) => b.trim())
+    .filter(Boolean);
+  for (let i = blocks.length - 1; i >= 0; i -= 1) {
+    const block = blocks[i];
+    if (block?.startsWith("HTTP/")) {
+      return block;
+    }
+  }
+  return "";
+}
+
+// ---------------------------------------------------------------------------
+// Curl-based fetch (fallback when undici is unavailable behind a proxy)
+// ---------------------------------------------------------------------------
+
+function createCurlFetch(): ProxyFetch {
+  return async (url: string, options: ProxyFetchOptions = {}) => {
+    const tempDir = mkdtempSync(join(tmpdir(), "bellwether-"));
+    const headersFile = join(tempDir, "headers.txt");
+    const bodyFile = join(tempDir, "body.txt");
+
+    const args = [
+      "--silent",
+      "--show-error",
+      "--location",
+      "--connect-timeout",
+      "10",
+      "--max-time",
+      "60",
+      "--dump-header",
+      headersFile,
+      "--output",
+      bodyFile,
+      "--request",
+      options.method ?? "GET",
+      "--write-out",
+      "%{http_code}",
+    ];
+
+    if (options.headers) {
+      for (const [key, value] of Object.entries(options.headers)) {
+        args.push("--header", `${key}: ${value}`);
+      }
+    }
+    if (options.body) {
+      args.push("--data", options.body);
+    }
+
+    args.push(String(url));
+
+    try {
+      const result = spawnSync("curl", args, {
+        encoding: "utf-8",
+        timeout: 65_000,
+      });
+      if (result.error) {
+        throw new Error(`curl failed to start: ${result.error.message}`);
+      }
+      if (result.status !== 0) {
+        const stderr = String(result.stderr).trim();
+        throw new Error(
+          `curl exited with status ${String(result.status)}${stderr ? `: ${stderr}` : ""}`,
+        );
+      }
+      const statusCodeRaw = String(result.stdout).trim();
+      const status = Number.parseInt(statusCodeRaw, 10);
+      if (!statusCodeRaw || Number.isNaN(status)) {
+        throw new Error("curl did not return a valid HTTP status code");
+      }
+      const body = await readFile(bodyFile, "utf-8");
+      const headersRaw = await readFile(headersFile, "utf-8");
+      const lastHeaderBlock = parseLastHeaderBlock(headersRaw);
+
+      return {
+        ok: status >= 200 && status < 300,
+        status,
+        headers: parseHeaderMap(lastHeaderBlock),
+        async text() {
+          return body;
+        },
+        async json() {
+          return JSON.parse(body || "null");
+        },
+      };
+    } finally {
+      await rm(tempDir, { recursive: true, force: true });
+    }
+  };
+}
+
+// ---------------------------------------------------------------------------
+// Proxy-aware fetch factory
+// ---------------------------------------------------------------------------
+
+export function getProxyFetch(): ProxyFetch {
+  const proxyUrl = process.env.HTTPS_PROXY ?? process.env.https_proxy;
+  if (proxyUrl) {
+    try {
+      const { ProxyAgent, fetch: undiciFetch } = require("undici");
+      const agent = new ProxyAgent(proxyUrl);
+      return ((url: string, options: ProxyFetchOptions = {}) =>
+        undiciFetch(url, { ...options, dispatcher: agent })) as ProxyFetch;
+    } catch {
+      return createCurlFetch();
+    }
+  }
+
+  return async (url: string, options: ProxyFetchOptions = {}) => {
+    const response = await fetch(url, options);
+    return {
+      ok: response.ok,
+      status: response.status,
+      headers: { get: (name: string) => response.headers.get(name) },
+      text: () => response.text(),
+      json: () => response.json(),
+    };
+  };
+}
+
+// ---------------------------------------------------------------------------
+// Authenticated GitHub fetch + pagination
+// ---------------------------------------------------------------------------
+
+function authHeaders(token: string): Record<string, string> {
+  return {
+    Authorization: `Bearer ${token}`,
+    Accept: "application/vnd.github.v3+json",
+    "User-Agent": USER_AGENT,
+  };
+}
+
+export async function ghFetch(
+  url: string,
+  token: string,
+  proxyFetch: ProxyFetch,
+  options: ProxyFetchOptions = {},
+): Promise<ProxyFetchResponse> {
+  return proxyFetch(url, {
+    ...options,
+    headers: { ...authHeaders(token), ...options.headers },
+  });
+}
+
+export async function fetchAllPages<T>(
+  url: string,
+  token: string,
+  proxyFetch: ProxyFetch,
+): Promise<T[]> {
+  const results: T[] = [];
+  let nextUrl: string | null = url;
+
+  while (nextUrl) {
+    const response = await ghFetch(nextUrl, token, proxyFetch);
+    if (!response.ok) {
+      throw new Error(`API request failed: ${response.status}`);
+    }
+
+    const data = (await response.json()) as T[];
+    results.push(...data);
+
+    const linkHeader = response.headers.get("link");
+    nextUrl = null;
+    if (linkHeader) {
+      const nextMatch = linkHeader.match(/<([^>]+)>;\s*rel="next"/);
+      if (nextMatch?.[1]) {
+        nextUrl = nextMatch[1];
+      }
+    }
+  }
+
+  return results;
+}

package/src/github/index.ts

@@ -0,0 +1,35 @@
+export {
+  type ProxyFetch,
+  type ProxyFetchOptions,
+  type ProxyFetchResponse,
+  getProxyFetch,
+  ghFetch,
+  fetchAllPages,
+} from "./fetch.js";
+
+export { getGitHubToken } from "./auth.js";
+
+export {
+  type RepoInfo,
+  type PR,
+  type PRMergeState,
+  getRepoRoot,
+  getRepoInfo,
+  getCurrentBranch,
+  findPRForBranch,
+  listOpenPRs,
+  fetchPRMergeState,
+} from "./repo.js";
+
+export {
+  type ProcessedComment,
+  type Reply,
+  type FilterOptions,
+  fetchPRComments,
+  processComments,
+  filterComments,
+  replyToComment,
+  resolveThread,
+} from "./comments.js";
+
+export { type FailingCheck, type CIStatus, fetchCIStatus } from "./checks.js";

package/src/github/repo.ts

@@ -0,0 +1,146 @@
+import { spawnSync } from "node:child_process";
+import { ghFetch, type ProxyFetch } from "./fetch.js";
+
+function spawnText(cmd: string[]): string | null {
+  const [command, ...args] = cmd;
+  if (!command) {
+    return null;
+  }
+  const result = spawnSync(command, args, { encoding: "utf-8" });
+  if (result.status !== 0) {
+    return null;
+  }
+  return result.stdout.trim();
+}
+
+// ---------------------------------------------------------------------------
+// Local git state
+// ---------------------------------------------------------------------------
+
+export function getRepoRoot(): string | null {
+  return spawnText(["git", "rev-parse", "--show-toplevel"]);
+}
+
+export interface RepoInfo {
+  owner: string;
+  repo: string;
+}
+
+export function getRepoInfo(): RepoInfo | null {
+  const envRepo = process.env.GH_REPO;
+  if (envRepo) {
+    const match = envRepo.match(/^([^/]+)\/([^/]+)$/);
+    if (match?.[1] && match[2]) {
+      return { owner: match[1], repo: match[2] };
+    }
+  }
+
+  const remoteUrl = spawnText(["git", "remote", "get-url", "origin"]);
+  if (!remoteUrl) {
+    return null;
+  }
+
+  // SSH, HTTPS, and proxy URL formats
+  const sshMatch = remoteUrl.match(/git@github\.com:([^/]+)\/(.+?)(?:\.git)?$/);
+  const httpsMatch = remoteUrl.match(/github\.com\/([^/]+)\/(.+?)(?:\.git)?$/);
+  const proxyMatch = remoteUrl.match(/\/git\/([^/]+)\/([^/]+)$/);
+
+  const match = sshMatch ?? httpsMatch ?? proxyMatch;
+  if (match?.[1] && match[2]) {
+    return { owner: match[1], repo: match[2].replace(/\.git$/, "") };
+  }
+
+  return null;
+}
+
+export function getCurrentBranch(): string | null {
+  return spawnText(["git", "rev-parse", "--abbrev-ref", "HEAD"]);
+}
+
+// ---------------------------------------------------------------------------
+// PR helpers
+// ---------------------------------------------------------------------------
+
+export interface PR {
+  number: number;
+  title: string;
+  html_url: string;
+  head: { ref: string; sha: string };
+  state: string;
+}
+
+export async function findPRForBranch(
+  owner: string,
+  repo: string,
+  branch: string,
+  token: string,
+  proxyFetch: ProxyFetch,
+): Promise<PR | null> {
+  const response = await ghFetch(
+    `https://api.github.com/repos/${owner}/${repo}/pulls?head=${owner}:${branch}&state=open`,
+    token,
+    proxyFetch,
+  );
+  if (!response.ok) {
+    throw new Error(`Failed to find PR: ${response.status}`);
+  }
+  const prs = (await response.json()) as PR[];
+  return prs[0] ?? null;
+}
+
+export async function listOpenPRs(
+  owner: string,
+  repo: string,
+  token: string,
+  proxyFetch: ProxyFetch,
+): Promise<PR[]> {
+  const response = await ghFetch(
+    `https://api.github.com/repos/${owner}/${repo}/pulls?state=open&per_page=30`,
+    token,
+    proxyFetch,
+  );
+  if (!response.ok) {
+    throw new Error(`Failed to list PRs: ${response.status}`);
+  }
+  return (await response.json()) as PR[];
+}
+
+// ---------------------------------------------------------------------------
+// PR merge state
+// ---------------------------------------------------------------------------
+
+export interface PRMergeState {
+  state: "open" | "closed" | "merged";
+  mergeable: boolean | null;
+  mergeableState: string;
+}
+
+interface RawPRMergeData {
+  state: string;
+  merged: boolean;
+  mergeable: boolean | null;
+  mergeable_state?: string;
+}
+
+export async function fetchPRMergeState(
+  owner: string,
+  repo: string,
+  prNumber: number,
+  token: string,
+  proxyFetch: ProxyFetch,
+): Promise<PRMergeState> {
+  const response = await ghFetch(
+    `https://api.github.com/repos/${owner}/${repo}/pulls/${prNumber}`,
+    token,
+    proxyFetch,
+  );
+  if (!response.ok) {
+    throw new Error(`Failed to fetch PR merge state: ${response.status}`);
+  }
+  const pr = (await response.json()) as RawPRMergeData;
+  return {
+    state: pr.merged ? "merged" : (pr.state as "open" | "closed"),
+    mergeable: pr.mergeable,
+    mergeableState: pr.mergeable_state ?? "unknown",
+  };
+}