standup-mr 0.1.2 → 0.2.1

package/dist/mcp/server.js

@@ -8,7 +8,7 @@ import { pathToFileURL } from "url";
 import { execFileSync } from "child_process";
 
 // src/config/config.constants.ts
-var GLAB_TIMEOUT_MS = 15e3;
+var CLI_TIMEOUT_MS = 15e3;
 
 // src/config/config.ts
 var ConfigError = class extends Error {
@@ -17,51 +17,61 @@ var ConfigError = class extends Error {
     this.name = "ConfigError";
   }
 };
-function resolveHost(cliHost, envHost, glabHostList) {
+var GITLAB_LABELS = {
+  name: "GitLab",
+  cli: "glab",
+  envHost: "GITLAB_HOST",
+  envToken: "GITLAB_TOKEN",
+  login: (host) => `glab auth login --hostname ${host}`
+};
+var GITHUB_LABELS = {
+  name: "GitHub",
+  cli: "gh",
+  envHost: "GITHUB_HOST",
+  envToken: "GITHUB_TOKEN",
+  login: (host) => `gh auth login --hostname ${host}`
+};
+function resolveHost(cliHost, envHost, hostList, labels = GITLAB_LABELS) {
   if (cliHost) return cliHost;
   if (envHost) return envHost;
-  const hosts = glabHostList ?? [];
+  const hosts = hostList ?? [];
   if (hosts.length === 1) return hosts[0];
   if (hosts.length === 0) {
     throw new ConfigError(
-      "No GitLab host configured. Pass --host, set GITLAB_HOST, or log in with `glab auth login`."
+      `No ${labels.name} host configured. Pass --host, set ${labels.envHost}, or log in with \`${labels.cli} auth login\`.`
     );
   }
   throw new ConfigError(
-    `Multiple GitLab hosts found (${[...hosts].sort().join(", ")}). Pick one with --host or GITLAB_HOST.`
+    `Multiple ${labels.name} hosts found (${[...hosts].sort().join(", ")}). Pick one with --host or ${labels.envHost}.`
   );
 }
-function resolveToken(host, cliToken, envToken, glabLookup) {
+function resolveToken(host, cliToken, envToken, lookup, labels = GITLAB_LABELS) {
   if (cliToken) return cliToken;
   if (envToken) return envToken;
-  if (glabLookup) {
-    const token = glabLookup(host);
+  if (lookup) {
+    const token = lookup(host);
     if (token) return token;
   }
   throw new ConfigError(
-    `No token for ${host}. Pass --token, set GITLAB_TOKEN, or run \`glab auth login --hostname ${host}\`.`
+    `No token for ${host}. Pass --token, set ${labels.envToken}, or run \`${labels.login(host)}\`.`
   );
 }
-function glab(args) {
+function cliCapture(cli, args) {
   try {
-    return execFileSync("glab", args, {
+    return execFileSync(cli, args, {
       encoding: "utf8",
-      timeout: GLAB_TIMEOUT_MS,
+      timeout: CLI_TIMEOUT_MS,
       stdio: ["ignore", "pipe", "ignore"]
     }).trim();
   } catch {
     return "";
   }
 }
-function parseGlabHosts(statusOutput) {
-  const hosts = [...statusOutput.matchAll(/Logged in to (\S+)/g)].map((match) => match[1]);
-  return [...new Set(hosts)].sort();
-}
-function glabStatus() {
+function cliStatus(cli) {
   try {
-    return execFileSync("glab", ["auth", "status"], {
+    return execFileSync(cli, ["auth", "status"], {
       encoding: "utf8",
-      timeout: GLAB_TIMEOUT_MS,
+      timeout: CLI_TIMEOUT_MS,
       stdio: ["ignore", "pipe", "pipe"]
     });
   } catch (error) {
@@ -69,11 +79,21 @@ function glabStatus() {
     return `${result.stdout ?? ""}${result.stderr ?? ""}`;
   }
 }
+function parseLoggedInHosts(statusOutput) {
+  const hosts = [...statusOutput.matchAll(/Logged in to (\S+)/g)].map((match) => match[1]);
+  return [...new Set(hosts)].sort();
+}
 function glabHosts() {
-  return parseGlabHosts(glabStatus());
+  return parseLoggedInHosts(cliStatus("glab"));
 }
 function glabToken(host) {
-  return glab(["config", "get", "token", "--host", host]);
+  return cliCapture("glab", ["config", "get", "token", "--host", host]);
+}
+function ghHosts() {
+  return parseLoggedInHosts(cliStatus("gh"));
+}
+function ghToken(host) {
+  return cliCapture("gh", ["auth", "token", "--hostname", host]);
 }
 
 // src/buckets/buckets.constants.ts
@@ -123,6 +143,12 @@ function isoDay(day) {
   const date = String(day.getDate()).padStart(2, "0");
   return `${year}-${month}-${date}`;
 }
+function localAt(iso) {
+  const at = new Date(iso);
+  const hours = String(at.getHours()).padStart(2, "0");
+  const minutes = String(at.getMinutes()).padStart(2, "0");
+  return `${isoDay(at)}T${hours}:${minutes}`;
+}
 function label(day, lang = "en") {
   const key = DAYS[lang] ? lang : "en";
   const weekday = DAYS[key][day.getDay()];
@@ -130,21 +156,27 @@ function label(day, lang = "en") {
   const date = day.getDate();
   return key === "tr" ? `${date} ${month} ${weekday}` : `${weekday}, ${date} ${month}`;
 }
-function previousActiveDay(eventDates, today) {
+function isWeekday(day) {
+  const weekday = (/* @__PURE__ */ new Date(`${day}T00:00:00`)).getDay();
+  return weekday >= 1 && weekday <= 5;
+}
+function previousActiveDays(eventDates, today) {
   const cutoff = isoDay(today);
-  const past = [...eventDates].filter((d) => d < cutoff).sort();
-  const latest = past[past.length - 1];
-  if (!latest) return { date: null, gapDays: null };
-  const gapDays = Math.round(
-    (Date.parse(`${cutoff}T00:00:00Z`) - Date.parse(`${latest}T00:00:00Z`)) / MS_PER_DAY
-  );
-  return { date: latest, gapDays };
+  const past = [...eventDates].filter((day) => day < cutoff).sort();
+  if (past.length === 0) return [];
+  const anchor = past.filter(isWeekday).pop() ?? past[0];
+  return past.filter((day) => day >= anchor).map((day) => ({
+    date: day,
+    gapDays: Math.round(
+      (Date.parse(`${cutoff}T00:00:00Z`) - Date.parse(`${day}T00:00:00Z`)) / MS_PER_DAY
+    )
+  }));
 }
 
 // src/buckets/buckets.ts
 function classify(mr, today, staleDays = STALE_DAYS) {
   if (mr.draft) return "draft";
-  if (mr.pipeline === "failed" || mr.unresolved > 0) return "blocked";
+  if (mr.pipeline === "failed" || mr.pipeline === "canceled" || mr.unresolved > 0) return "blocked";
   const age = Math.round(
     (Date.parse(`${isoDay(today)}T00:00:00Z`) - Date.parse(`${mr.updated}T00:00:00Z`)) / MS_PER_DAY
   );
@@ -163,6 +195,11 @@ var SECTION = /section_(start|end):\d+:\S*/g;
 var SIGNAL = /(\berror\b|Error:|fatal:|npm ERR!|\bfailed\b)/i;
 var NOISE = /^(Cleaning up|Job failed: exit status|ERROR: Job failed|Uploading artifacts|Job succeeded)/i;
 var MAX_LINE = 200;
+var TIMESTAMP = /^\d{4}-\d{2}-\d{2}T[\d:.]+Z\s+/;
+var ERROR_MARKER = /^##\[error\]\s*/;
+var GROUP_START = /^##\[group\]/;
+var GROUP_END = /^##\[endgroup\]/;
+var RUN_GROUP = /^##\[group\]Run\s/;
 
 // src/trace/trace.ts
 function extractErrors(rawTrace, limit = 8) {
@@ -170,9 +207,21 @@ function extractErrors(rawTrace, limit = 8) {
   const cleaned = rawTrace.replace(ANSI, "").replace(SECTION, "");
   const seen = /* @__PURE__ */ new Set();
   const hits = [];
+  let suppressing = false;
   for (const rawLine of cleaned.split("\n")) {
-    const line = rawLine.trim();
-    if (!line || NOISE.test(line) || !SIGNAL.test(line)) continue;
+    const stamped = rawLine.trim().replace(TIMESTAMP, "");
+    if (GROUP_START.test(stamped)) {
+      suppressing = RUN_GROUP.test(stamped);
+      continue;
+    }
+    if (GROUP_END.test(stamped)) {
+      suppressing = false;
+      continue;
+    }
+    if (suppressing) continue;
+    if (!stamped || NOISE.test(stamped) || !SIGNAL.test(stamped)) continue;
+    const line = stamped.replace(ERROR_MARKER, "").trim();
+    if (!line) continue;
     const clipped = line.slice(0, MAX_LINE);
     if (seen.has(clipped)) continue;
     seen.add(clipped);
@@ -181,64 +230,465 @@ function extractErrors(rawTrace, limit = 8) {
   return hits.slice(-limit);
 }
 
-// src/providers/gitlab/gitlab.constants.ts
+// src/providers/base/http.ts
+function buildUrl(api, path, params) {
+  const base = `${api}/${path}`;
+  if (!params || Object.keys(params).length === 0) return base;
+  const query = new URLSearchParams();
+  for (const [key, value] of Object.entries(params)) {
+    query.set(key, String(value));
+  }
+  return `${base}?${query.toString()}`;
+}
+var ApiError = class extends Error {
+  constructor(message) {
+    super(message);
+    this.name = "ApiError";
+  }
+};
+function remaining(response) {
+  return response.headers.get("x-ratelimit-remaining") ?? response.headers.get("ratelimit-remaining");
+}
+function resetAt(response) {
+  const reset = response.headers.get("x-ratelimit-reset") ?? response.headers.get("ratelimit-reset");
+  if (!reset) return "";
+  const seconds = Number(reset);
+  if (!Number.isFinite(seconds) || seconds <= 0) return "";
+  return `; resets at ${new Date(seconds * 1e3).toISOString()}`;
+}
+function retryAfter(response) {
+  const value = response.headers.get("retry-after");
+  if (!value) return "";
+  const seconds = Number(value);
+  if (!Number.isFinite(seconds) || seconds <= 0) return `; retry after ${value}`;
+  return `; retry after ${seconds}s`;
+}
+function assertUsable(response, host) {
+  if (response.ok || response.status === 404) return;
+  if (response.status === 403 || response.status === 429) {
+    if (remaining(response) === "0") {
+      throw new ApiError(`${host} rate limit reached${resetAt(response)}.`);
+    }
+    const retry = retryAfter(response);
+    if (retry) throw new ApiError(`${host} rate limit reached${retry}.`);
+  }
+  if (response.status === 401) {
+    throw new ApiError(
+      `${host} rejected the token (401). Check the token and its scopes.`
+    );
+  }
+  if (response.status === 403) {
+    throw new ApiError(
+      `${host} refused the request (403). The token has no access to that resource.`
+    );
+  }
+  throw new ApiError(`${host} returned ${response.status}.`);
+}
+function unreachable(host, cause) {
+  const detail = cause instanceof Error ? cause.message : String(cause);
+  return new ApiError(`Could not reach ${host}: ${detail}`);
+}
+
+// src/providers/github/github.constants.ts
 var PAGE_SIZE = 100;
 var FRESH_REVIEW_DAYS = 7;
+var API_VERSION = "2022-11-28";
+var DOT_COM = "github.com";
+var SEARCH_CAP = 3;
+var EVENT_FEED_CAP = 300;
+var EVENTS_PAGE_CAP = EVENT_FEED_CAP / PAGE_SIZE;
+var FAILED_CONCLUSIONS = /* @__PURE__ */ new Set([
+  "failure",
+  "timed_out",
+  "startup_failure",
+  "action_required"
+]);
+var EVENT_ACTIONS = {
+  PushEvent: "pushed to",
+  PullRequestReviewEvent: "reviewed",
+  PullRequestReviewCommentEvent: "commented on",
+  IssueCommentEvent: "commented on",
+  CreateEvent: "created",
+  DeleteEvent: "deleted"
+};
+var EVENT_TARGET_TYPES = {
+  PullRequestEvent: "MergeRequest",
+  PullRequestReviewEvent: "MergeRequest",
+  PullRequestReviewCommentEvent: "MergeRequest",
+  IssueCommentEvent: "Note"
+};
 
-// src/providers/gitlab/gitlab.ts
-var GitLabProvider = class {
+// src/providers/github/github.map.ts
+function repoFromUrl(repositoryUrl) {
+  const match = /\/repos\/([^/]+\/[^/]+)/.exec(repositoryUrl);
+  return match ? match[1] : "";
+}
+function mapEvent(raw) {
+  const payload = raw.payload ?? {};
+  const type = raw.type ?? "";
+  const commits = payload.commits ?? [];
+  const last = commits[commits.length - 1];
+  return {
+    at: localAt(raw.created_at),
+    action: type === "PullRequestEvent" ? String(payload.action ?? "updated") : EVENT_ACTIONS[type] ?? type.replace(/Event$/, "").toLowerCase(),
+    project: raw.repo?.name ?? "",
+    targetType: EVENT_TARGET_TYPES[type] ?? "",
+    title: payload.pull_request?.title ?? payload.issue?.title ?? "",
+    branch: String(payload.ref ?? "").replace(/^refs\/heads\//, ""),
+    commits: Number(payload.size ?? 0),
+    commitTitle: last ? String(last.message ?? "").split("\n")[0] : ""
+  };
+}
+
+// src/providers/github/github.state.ts
+function normalizeChecks(runs) {
+  if (runs.length === 0) return { pipeline: null, pipelineId: null };
+  const failed = runs.find(
+    (run) => run.conclusion !== null && FAILED_CONCLUSIONS.has(run.conclusion)
+  );
+  if (failed) return { pipeline: "failed", pipelineId: failed.id };
+  if (runs.some((run) => run.status !== "completed")) {
+    return { pipeline: "running", pipelineId: null };
+  }
+  if (runs.some((run) => run.conclusion === "cancelled")) {
+    return { pipeline: "canceled", pipelineId: null };
+  }
+  return { pipeline: "success", pipelineId: null };
+}
+function latestStateByReviewer(reviews) {
+  const latest = /* @__PURE__ */ new Map();
+  for (const review of reviews) {
+    const login = review.user?.login;
+    if (!login) continue;
+    if (review.state === "COMMENTED" || review.state === "PENDING") continue;
+    latest.set(login, review.state);
+  }
+  return latest;
+}
+function countChangesRequested(reviews) {
+  return [...latestStateByReviewer(reviews).values()].filter(
+    (state) => state === "CHANGES_REQUESTED"
+  ).length;
+}
+function approvedBy(reviews, login) {
+  return latestStateByReviewer(reviews).get(login) === "APPROVED";
+}
+
+// src/providers/github/github.ts
+var GitHubProvider = class {
+  kind = "github";
   host;
   api;
   token;
   fetchImpl;
+  identity = null;
   constructor(host, token, fetchImpl = fetch) {
     this.host = host;
+    this.api = host === DOT_COM ? "https://api.github.com" : `https://${host}/api/v3`;
     this.token = token;
-    this.api = `https://${host}/api/v4`;
     this.fetchImpl = fetchImpl;
   }
-  url(path, params) {
-    const base = `${this.api}/${path}`;
-    if (!params || Object.keys(params).length === 0) return base;
-    const query = new URLSearchParams();
-    for (const [key, value] of Object.entries(params)) {
-      query.set(key, String(value));
+  headers() {
+    return {
+      authorization: `Bearer ${this.token}`,
+      accept: "application/vnd.github+json",
+      "x-github-api-version": API_VERSION
+    };
+  }
+  async send(url, init) {
+    try {
+      return await this.fetchImpl(url, { headers: this.headers(), ...init });
+    } catch (cause) {
+      throw unreachable(this.host, cause);
     }
-    return `${base}?${query.toString()}`;
   }
   async getJson(path, params) {
+    const response = await this.send(buildUrl(this.api, path, params));
+    assertUsable(response, this.host);
+    if (!response.ok) return null;
     try {
-      const response = await this.fetchImpl(this.url(path, params), {
-        headers: { "PRIVATE-TOKEN": this.token }
-      });
-      if (!response.ok) return null;
       return await response.json();
-    } catch {
-      return null;
+    } catch (cause) {
+      throw unreachable(this.host, cause);
     }
   }
-  async getText(path) {
+  async getPaged(path, params = {}, cap = 5) {
+    const rows = [];
+    for (let page = 1; page <= cap; page += 1) {
+      const chunk = await this.getJson(path, {
+        ...params,
+        per_page: PAGE_SIZE,
+        page
+      });
+      if (!chunk || chunk.length === 0) break;
+      rows.push(...chunk);
+      if (chunk.length < PAGE_SIZE) break;
+    }
+    return rows;
+  }
+  async getSearch(query, cap = 3) {
+    const rows = [];
+    for (let page = 1; page <= cap; page += 1) {
+      const chunk = await this.getJson("search/issues", {
+        q: query,
+        per_page: PAGE_SIZE,
+        page
+      });
+      const items = chunk?.items ?? [];
+      if (items.length === 0) break;
+      rows.push(...items);
+      if (items.length < PAGE_SIZE) break;
+    }
+    return rows;
+  }
+  async getLogText(path) {
+    const first = await this.send(buildUrl(this.api, path), { redirect: "manual" });
+    if (first.status === 404) return "";
+    const location = first.headers.get("location");
+    if (!location) {
+      if (first.status === 0 || first.status >= 300 && first.status < 400) return "";
+      assertUsable(first, this.host);
+      return first.ok ? await first.text() : "";
+    }
+    let blob;
+    try {
+      blob = await this.fetchImpl(location);
+    } catch (cause) {
+      throw unreachable(this.host, cause);
+    }
+    if (!blob.ok) return "";
+    return await blob.text();
+  }
+  async getIdentity() {
+    if (this.identity) return this.identity;
+    const me = await this.getJson("user");
+    if (!me) {
+      throw new ApiError(
+        `Could not read the ${this.host} user. Check the host, the token, and network access.`
+      );
+    }
+    this.identity = { id: me.id, username: me.login };
+    return this.identity;
+  }
+  async getEvents(since) {
+    const login = (await this.getIdentity()).username;
+    const raw = await this.getPaged(
+      `users/${encodeURIComponent(login)}/events`,
+      {},
+      EVENTS_PAGE_CAP
+    );
+    if (raw.length === 0) {
+      process.stderr.write(
+        `Warning: the ${this.host} events feed returned nothing. Private activity is only visible to a token that belongs to the same account.
+`
+      );
+    }
+    const floor = isoDay(since);
+    return raw.map(mapEvent).filter((event) => event.at.slice(0, 10) >= floor).sort((a, b) => a.at.localeCompare(b.at));
+  }
+  async shapePr(item) {
+    const project = repoFromUrl(item.repository_url);
+    const iid = item.number;
+    const pull = await this.getJson(`repos/${project}/pulls/${iid}`);
+    if (!pull) return null;
+    const sha = pull.head?.sha ?? "";
+    const [checks, reviews] = await Promise.all([
+      sha ? this.getJson(
+        `repos/${project}/commits/${sha}/check-runs`,
+        { per_page: PAGE_SIZE }
+      ) : Promise.resolve(null),
+      this.getPaged(`repos/${project}/pulls/${iid}/reviews`, {}, 2)
+    ]);
+    const { pipeline, pipelineId } = normalizeChecks(checks?.check_runs ?? []);
+    return {
+      provider: "github",
+      project,
+      projectId: pull.base?.repo?.id ?? 0,
+      iid,
+      title: pull.title,
+      draft: pull.draft,
+      branch: pull.head?.ref ?? "",
+      target: pull.base?.ref ?? "",
+      updated: localAt(pull.updated_at).slice(0, 10),
+      url: pull.html_url,
+      mergeStatus: pull.mergeable_state ?? null,
+      pipeline,
+      pipelineId,
+      unresolved: countChangesRequested(reviews),
+      pipelineMissing: false,
+      bucket: "ready"
+    };
+  }
+  async getMyMrs(today) {
+    const login = (await this.getIdentity()).username;
+    const items = await this.getSearch(
+      `is:pr is:open author:${login} archived:false`,
+      SEARCH_CAP
+    );
+    const shaped = await Promise.all(items.map((item) => this.shapePr(item)));
+    const rows = shaped.filter((row) => row !== null);
+    markMissingPipelines(rows);
+    for (const row of rows) {
+      row.bucket = classify(row, today);
+    }
+    return rows;
+  }
+  async getReviews(identity, today) {
+    const items = await this.getSearch(
+      `is:pr is:open review-requested:${identity.username}`,
+      SEARCH_CAP
+    );
+    const cutoff = isoDay(new Date(today.getTime() - FRESH_REVIEW_DAYS * MS_PER_DAY));
+    const rows = await Promise.all(
+      items.map(async (item) => {
+        const project = repoFromUrl(item.repository_url);
+        const reviews = await this.getPaged(
+          `repos/${project}/pulls/${item.number}/reviews`,
+          {},
+          2
+        );
+        const updated = localAt(item.updated_at).slice(0, 10);
+        return {
+          provider: "github",
+          project,
+          iid: item.number,
+          title: item.title,
+          author: item.user?.login ?? "",
+          updated,
+          draft: item.draft ?? false,
+          url: item.html_url,
+          fresh: updated >= cutoff,
+          approvedByMe: approvedBy(reviews, identity.username)
+        };
+      })
+    );
+    return rows.sort((a, b) => b.updated.localeCompare(a.updated));
+  }
+  async actionsBlocker(mr, sha) {
+    const runs = await this.getJson(
+      `repos/${mr.project}/actions/runs`,
+      { head_sha: sha, per_page: 10 }
+    );
+    const run = (runs?.workflow_runs ?? []).find(
+      (row) => row.conclusion !== null && FAILED_CONCLUSIONS.has(row.conclusion)
+    );
+    if (!run) return null;
+    const jobs = await this.getJson(
+      `repos/${mr.project}/actions/runs/${run.id}/jobs`,
+      { per_page: PAGE_SIZE }
+    );
+    const job = (jobs?.jobs ?? []).find(
+      (row) => row.conclusion !== null && FAILED_CONCLUSIONS.has(row.conclusion)
+    );
+    if (!job) return null;
+    const log = await this.getLogText(
+      `repos/${mr.project}/actions/jobs/${job.id}/logs`
+    );
+    return {
+      provider: "github",
+      project: mr.project,
+      mr: mr.iid,
+      title: mr.title,
+      job: job.name,
+      stage: run.name ?? "",
+      url: mr.url,
+      errors: extractErrors(log)
+    };
+  }
+  async checkRunBlocker(mr, sha) {
+    const checks = await this.getJson(
+      `repos/${mr.project}/commits/${sha}/check-runs`,
+      { per_page: PAGE_SIZE }
+    );
+    const failed = (checks?.check_runs ?? []).find(
+      (run) => run.conclusion !== null && FAILED_CONCLUSIONS.has(run.conclusion)
+    );
+    if (!failed) return null;
+    const summary = [failed.output?.summary ?? "", failed.output?.text ?? ""].filter(Boolean).join("\n");
+    const errors = extractErrors(summary);
+    if (errors.length === 0) return null;
+    return {
+      provider: "github",
+      project: mr.project,
+      mr: mr.iid,
+      title: mr.title,
+      job: failed.name,
+      stage: failed.app?.slug ?? "check",
+      url: mr.url,
+      errors
+    };
+  }
+  async diagnose(mr) {
+    const pull = await this.getJson(
+      `repos/${mr.project}/pulls/${mr.iid}`
+    );
+    const sha = pull?.head?.sha;
+    if (!sha) return null;
+    const actions = await this.actionsBlocker(mr, sha);
+    if (actions?.errors.length) return actions;
+    return await this.checkRunBlocker(mr, sha) ?? actions;
+  }
+  async getBlockers(mrs) {
+    const red = mrs.filter((mr) => mr.pipeline === "failed");
+    const diagnosed = await Promise.all(red.map((mr) => this.diagnose(mr)));
+    return diagnosed.filter((row) => row !== null);
+  }
+};
+
+// src/providers/gitlab/gitlab.constants.ts
+var PAGE_SIZE2 = 100;
+var FRESH_REVIEW_DAYS2 = 7;
+
+// src/providers/gitlab/gitlab.ts
+var GitLabProvider = class {
+  kind = "gitlab";
+  host;
+  api;
+  token;
+  fetchImpl;
+  constructor(host, token, fetchImpl = fetch) {
+    this.host = host;
+    this.token = token;
+    this.api = `https://${host}/api/v4`;
+    this.fetchImpl = fetchImpl;
+  }
+  async send(url) {
+    let response;
     try {
-      const response = await this.fetchImpl(this.url(path), {
+      response = await this.fetchImpl(url, {
         headers: { "PRIVATE-TOKEN": this.token }
       });
-      if (!response.ok) return "";
-      return await response.text();
-    } catch {
-      return "";
+    } catch (cause) {
+      throw unreachable(this.host, cause);
     }
+    assertUsable(response, this.host);
+    return response;
+  }
+  async getJson(path, params) {
+    const response = await this.send(buildUrl(this.api, path, params));
+    if (!response.ok) return null;
+    try {
+      return await response.json();
+    } catch (cause) {
+      throw unreachable(this.host, cause);
+    }
+  }
+  async getText(path) {
+    const response = await this.send(buildUrl(this.api, path));
+    if (!response.ok) return "";
+    return await response.text();
   }
   async getPaged(path, params = {}, cap = 5) {
     const rows = [];
     for (let page = 1; page <= cap; page += 1) {
       const chunk = await this.getJson(path, {
         ...params,
-        per_page: PAGE_SIZE,
+        per_page: PAGE_SIZE2,
         page
       });
       if (!chunk || chunk.length === 0) break;
       rows.push(...chunk);
-      if (chunk.length < PAGE_SIZE) break;
+      if (chunk.length < PAGE_SIZE2) break;
     }
     return rows;
   }
@@ -284,7 +734,7 @@ var GitLabProvider = class {
   async countUnresolved(projectId, iid) {
     const discussions = await this.getJson(
       `projects/${projectId}/merge_requests/${iid}/discussions`,
-      { per_page: PAGE_SIZE }
+      { per_page: PAGE_SIZE2 }
     );
     if (!discussions) return 0;
     return discussions.filter((discussion) => {
@@ -304,6 +754,7 @@ var GitLabProvider = class {
     ]);
     const latest = pipelines?.[0];
     return {
+      provider: "gitlab",
       project: String(mr.references.full).split("!")[0],
       projectId,
       iid,
@@ -338,15 +789,16 @@ var GitLabProvider = class {
     if (!approvals) return false;
     return (approvals.approved_by ?? []).some((entry2) => entry2.user?.id === uid);
   }
-  async getReviews(uid, today) {
+  async getReviews(identity, today) {
     const raw = await this.getPaged("merge_requests", {
       scope: "all",
       state: "opened",
-      reviewer_id: uid
+      reviewer_id: identity.id
     });
-    const cutoff = isoDay(new Date(today.getTime() - FRESH_REVIEW_DAYS * MS_PER_DAY));
+    const cutoff = isoDay(new Date(today.getTime() - FRESH_REVIEW_DAYS2 * MS_PER_DAY));
     const rows = await Promise.all(
       raw.map(async (mr) => ({
+        provider: "gitlab",
         project: String(mr.references.full).split("!")[0],
         iid: mr.iid,
         title: mr.title,
@@ -355,7 +807,7 @@ var GitLabProvider = class {
         draft: mr.draft,
         url: mr.web_url,
         fresh: String(mr.updated_at).slice(0, 10) >= cutoff,
-        approvedByMe: await this.approvedByMe(mr.project_id, mr.iid, uid)
+        approvedByMe: await this.approvedByMe(mr.project_id, mr.iid, identity.id)
       }))
     );
     return rows.sort((a, b) => b.updated.localeCompare(a.updated));
@@ -366,7 +818,7 @@ var GitLabProvider = class {
       red.map(async (mr) => {
         const jobs = await this.getJson(
           `projects/${mr.projectId}/pipelines/${mr.pipelineId}/jobs`,
-          { per_page: PAGE_SIZE }
+          { per_page: PAGE_SIZE2 }
         ) ?? [];
         const job = jobs.find((j) => j.status === "failed");
         if (!job) return null;
@@ -374,6 +826,7 @@ var GitLabProvider = class {
           `projects/${mr.projectId}/jobs/${job.id}/trace`
         );
         return {
+          provider: "gitlab",
           project: mr.project,
           mr: mr.iid,
           title: mr.title,
@@ -388,6 +841,86 @@ var GitLabProvider = class {
   }
 };
 
+// src/providers/select.ts
+var DEFAULT_PROBE = { gitlab: glabHosts, github: ghHosts };
+function hostFrom(cliHost, envHost, probe, fallback, labels) {
+  if (cliHost) return cliHost;
+  if (envHost) return envHost;
+  const found = probe();
+  return resolveHost(void 0, void 0, found.length > 0 ? found : fallback, labels);
+}
+function chooseKind(options = {}) {
+  const env = options.env ?? process.env;
+  const probe = options.probe ?? DEFAULT_PROBE;
+  if (options.provider) {
+    if (options.provider === "github" || options.provider === "gitlab") {
+      return options.provider;
+    }
+    throw new ConfigError(
+      `Unknown provider "${options.provider}" for --provider. Use github or gitlab.`
+    );
+  }
+  if (options.host) {
+    const host = options.host.toLowerCase();
+    if (host === DOT_COM || host.includes("github")) return "github";
+    if (host === "gitlab.com" || host.includes("gitlab")) return "gitlab";
+  }
+  if (env.STANDUP_PROVIDER) {
+    if (env.STANDUP_PROVIDER === "github" || env.STANDUP_PROVIDER === "gitlab") {
+      return env.STANDUP_PROVIDER;
+    }
+    throw new ConfigError(
+      `Unknown provider "${env.STANDUP_PROVIDER}" for STANDUP_PROVIDER. Use github or gitlab.`
+    );
+  }
+  const hasGitHubEnv = Boolean(env.GITHUB_HOST || env.GITHUB_TOKEN);
+  const hasGitLabEnv = Boolean(env.GITLAB_HOST || env.GITLAB_TOKEN);
+  if (hasGitHubEnv !== hasGitLabEnv) return hasGitHubEnv ? "github" : "gitlab";
+  if (hasGitHubEnv && hasGitLabEnv) {
+    const ghHost = Boolean(env.GITHUB_HOST);
+    const glabHost = Boolean(env.GITLAB_HOST);
+    if (ghHost !== glabHost) return ghHost ? "github" : "gitlab";
+    throw new ConfigError(
+      "Both GITHUB_* and GITLAB_* are configured. Pass --provider github or --provider gitlab."
+    );
+  }
+  const ghLoggedIn = probe.github().length > 0;
+  const glabLoggedIn = probe.gitlab().length > 0;
+  if (ghLoggedIn !== glabLoggedIn) return ghLoggedIn ? "github" : "gitlab";
+  if (ghLoggedIn && glabLoggedIn) {
+    throw new ConfigError(
+      "Both gh and glab are authenticated. Pass --provider github or --provider gitlab."
+    );
+  }
+  throw new ConfigError(
+    "No provider configured. Pass --provider with --host and --token, set GITHUB_* or GITLAB_* environment variables, or log in with gh or glab."
+  );
+}
+function connect(options = {}) {
+  const env = options.env ?? process.env;
+  const probe = options.probe ?? DEFAULT_PROBE;
+  if (chooseKind(options) === "github") {
+    const host2 = hostFrom(options.host, env.GITHUB_HOST, probe.github, [DOT_COM], GITHUB_LABELS);
+    const token2 = resolveToken(
+      host2,
+      options.token,
+      env.GITHUB_TOKEN,
+      ghToken,
+      GITHUB_LABELS
+    );
+    return new GitHubProvider(host2, token2);
+  }
+  const host = hostFrom(options.host, env.GITLAB_HOST, probe.gitlab, [], GITLAB_LABELS);
+  const token = resolveToken(
+    host,
+    options.token,
+    env.GITLAB_TOKEN,
+    glabToken,
+    GITLAB_LABELS
+  );
+  return new GitLabProvider(host, token);
+}
+
 // src/report/report.constants.ts
 var LOOKBACK_DAYS = 21;
 
@@ -396,27 +929,27 @@ async function buildReport(provider, today, lang = "en", lookbackDays = LOOKBACK
   const identity = await provider.getIdentity();
   const since = new Date(today.getTime() - lookbackDays * MS_PER_DAY);
   const events = await provider.getEvents(since);
-  const { date: previousDate, gapDays } = previousActiveDay(
+  const days = previousActiveDays(
     new Set(events.map((e) => e.at.slice(0, 10))),
     today
   );
-  const previousEvents = previousDate ? events.filter((e) => e.at.slice(0, 10) === previousDate) : [];
+  const previousDays = days.map(({ date, gapDays }) => ({
+    date,
+    label: label(/* @__PURE__ */ new Date(`${date}T00:00:00`), lang),
+    gapDays,
+    events: events.filter((e) => e.at.slice(0, 10) === date)
+  }));
   const todayEvents = events.filter((e) => e.at.slice(0, 10) === isoDay(today));
   const myMrs = await provider.getMyMrs(today);
   const [reviews, blockers] = await Promise.all([
-    provider.getReviews(identity.id, today),
+    provider.getReviews(identity, today),
     provider.getBlockers(myMrs)
   ]);
   return {
+    provider: provider.kind,
     user: identity.username,
     today: { date: isoDay(today), label: label(today, lang) },
-    previous: {
-      date: previousDate,
-      label: previousDate ? label(/* @__PURE__ */ new Date(`${previousDate}T00:00:00`), lang) : null,
-      gapDays,
-      eventCount: previousEvents.length
-    },
-    previousEvents,
+    previousDays,
     todayEvents,
     myMrs,
     reviews,
@@ -426,22 +959,17 @@ async function buildReport(provider, today, lang = "en", lookbackDays = LOOKBACK
 }
 
 // mcp/server.ts
-function resolveProvider(options) {
-  if (options.provider) return options.provider;
-  const host = resolveHost(options.host, process.env.GITLAB_HOST, glabHosts());
-  const token = resolveToken(host, options.token, process.env.GITLAB_TOKEN, glabToken);
-  return new GitLabProvider(host, token);
-}
 async function collect(options = {}) {
-  return buildReport(resolveProvider(options), /* @__PURE__ */ new Date(), options.lang ?? "en");
+  const provider = options.providerImpl ?? connect({ provider: options.provider, host: options.host, token: options.token });
+  return buildReport(provider, /* @__PURE__ */ new Date(), options.lang ?? "en");
 }
 async function main() {
   const { McpServer } = await import("@modelcontextprotocol/sdk/server/mcp.js");
   const { StdioServerTransport } = await import("@modelcontextprotocol/sdk/server/stdio.js");
-  const server = new McpServer({ name: "standup-mr", version: "0.1.0" });
+  const server = new McpServer({ name: "standup-mr", version: "0.2.1" });
   server.tool(
     "get_standup_data",
-    "Collect merge-request-based standup data from GitLab. Returns the previous working day activity, open merge requests bucketed by state (ready / blocked / draft / stale), pending reviews, and the error lines from any failed CI pipeline.",
+    "Collect merge-request-based standup data from GitLab or GitHub. Returns the previous working day activity, open merge requests or pull requests bucketed by state (ready / blocked / draft / stale), pending reviews, and the error lines from any failed pipeline or check.",
     {},
     async () => {
       const report = await collect();