standup-mr 0.1.2 → 0.2.0

package/dist/chunk-MIQ7FQS6.js

@@ -0,0 +1,1108 @@
+#!/usr/bin/env node
+
+// src/buckets/buckets.constants.ts
+var STALE_DAYS = 14;
+
+// src/dates/dates.constants.ts
+var DAYS = {
+  en: ["Sunday", "Monday", "Tuesday", "Wednesday", "Thursday", "Friday", "Saturday"],
+  tr: ["Pazar", "Pazartesi", "Sal\u0131", "\xC7ar\u015Famba", "Per\u015Fembe", "Cuma", "Cumartesi"]
+};
+var MONTHS = {
+  en: [
+    "January",
+    "February",
+    "March",
+    "April",
+    "May",
+    "June",
+    "July",
+    "August",
+    "September",
+    "October",
+    "November",
+    "December"
+  ],
+  tr: [
+    "Ocak",
+    "\u015Eubat",
+    "Mart",
+    "Nisan",
+    "May\u0131s",
+    "Haziran",
+    "Temmuz",
+    "A\u011Fustos",
+    "Eyl\xFCl",
+    "Ekim",
+    "Kas\u0131m",
+    "Aral\u0131k"
+  ]
+};
+var MS_PER_DAY = 864e5;
+
+// src/dates/dates.ts
+function isoDay(day) {
+  const year = day.getFullYear();
+  const month = String(day.getMonth() + 1).padStart(2, "0");
+  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()];
+  const month = MONTHS[key][day.getMonth()];
+  const date = day.getDate();
+  return key === "tr" ? `${date} ${month} ${weekday}` : `${weekday}, ${date} ${month}`;
+}
+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((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";
+  const age = Math.round(
+    (Date.parse(`${isoDay(today)}T00:00:00Z`) - Date.parse(`${mr.updated}T00:00:00Z`)) / MS_PER_DAY
+  );
+  return age >= staleDays ? "stale" : "ready";
+}
+function markMissingPipelines(mrs) {
+  const withCi = new Set(mrs.filter((mr) => mr.pipeline).map((mr) => mr.project));
+  for (const mr of mrs) {
+    mr.pipelineMissing = mr.pipeline === null && withCi.has(mr.project);
+  }
+}
+
+// src/config/config.ts
+import { execFileSync } from "child_process";
+
+// src/config/config.constants.ts
+var CLI_TIMEOUT_MS = 15e3;
+
+// src/config/config.ts
+var ConfigError = class extends Error {
+  constructor(message) {
+    super(message);
+    this.name = "ConfigError";
+  }
+};
+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 = hostList ?? [];
+  if (hosts.length === 1) return hosts[0];
+  if (hosts.length === 0) {
+    throw new ConfigError(
+      `No ${labels.name} host configured. Pass --host, set ${labels.envHost}, or log in with \`${labels.cli} auth login\`.`
+    );
+  }
+  throw new ConfigError(
+    `Multiple ${labels.name} hosts found (${[...hosts].sort().join(", ")}). Pick one with --host or ${labels.envHost}.`
+  );
+}
+function resolveToken(host, cliToken, envToken, lookup, labels = GITLAB_LABELS) {
+  if (cliToken) return cliToken;
+  if (envToken) return envToken;
+  if (lookup) {
+    const token = lookup(host);
+    if (token) return token;
+  }
+  throw new ConfigError(
+    `No token for ${host}. Pass --token, set ${labels.envToken}, or run \`${labels.login(host)}\`.`
+  );
+}
+function cliCapture(cli, args) {
+  try {
+    return execFileSync(cli, args, {
+      encoding: "utf8",
+      timeout: CLI_TIMEOUT_MS,
+      stdio: ["ignore", "pipe", "ignore"]
+    }).trim();
+  } catch {
+    return "";
+  }
+}
+function cliStatus(cli) {
+  try {
+    return execFileSync(cli, ["auth", "status"], {
+      encoding: "utf8",
+      timeout: CLI_TIMEOUT_MS,
+      stdio: ["ignore", "pipe", "pipe"]
+    });
+  } catch (error) {
+    const result = error;
+    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();
+}
+var parseGlabHosts = parseLoggedInHosts;
+function glabHosts() {
+  return parseLoggedInHosts(cliStatus("glab"));
+}
+function glabToken(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/notify/notify.constants.ts
+var PAYLOAD_FIELD = { slack: "text", discord: "content" };
+
+// src/notify/notify.ts
+async function postWebhook(url, text, kind = "slack", fetchImpl = fetch) {
+  const field = PAYLOAD_FIELD[kind];
+  if (!field) {
+    throw new Error(
+      `Unknown webhook kind "${kind}". Use one of: ${Object.keys(PAYLOAD_FIELD).join(", ")}.`
+    );
+  }
+  const response = await fetchImpl(url, {
+    method: "POST",
+    headers: { "Content-Type": "application/json" },
+    body: JSON.stringify({ [field]: text })
+  });
+  if (!response.ok) {
+    throw new Error(`Webhook rejected the message: HTTP ${response.status}.`);
+  }
+}
+
+// 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/trace/trace.constants.ts
+var ANSI = /\x1b\[[0-9;]*[a-zA-Z]/g;
+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 = /^##\[(group|endgroup)\]/;
+
+// src/trace/trace.ts
+function extractErrors(rawTrace, limit = 8) {
+  if (!rawTrace) return [];
+  const cleaned = rawTrace.replace(ANSI, "").replace(SECTION, "");
+  const seen = /* @__PURE__ */ new Set();
+  const hits = [];
+  for (const rawLine of cleaned.split("\n")) {
+    const stamped = rawLine.trim().replace(TIMESTAMP, "");
+    if (GROUP.test(stamped)) 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);
+    hits.push(clipped);
+  }
+  return hits.slice(-limit);
+}
+
+// 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/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.fetchImpl = fetchImpl;
+  }
+  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);
+    }
+  }
+  async getJson(path, params) {
+    const response = await this.send(buildUrl(this.api, path, params));
+    assertUsable(response, this.host);
+    if (!response.ok) return null;
+    try {
+      return await response.json();
+    } catch (cause) {
+      throw unreachable(this.host, cause);
+    }
+  }
+  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 {
+      response = await this.fetchImpl(url, {
+        headers: { "PRIVATE-TOKEN": this.token }
+      });
+    } 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_SIZE2,
+        page
+      });
+      if (!chunk || chunk.length === 0) break;
+      rows.push(...chunk);
+      if (chunk.length < PAGE_SIZE2) break;
+    }
+    return rows;
+  }
+  async getIdentity() {
+    const me = await this.getJson("user");
+    if (!me) {
+      throw new Error(
+        `Could not reach ${this.host}. Check the host, the token, and network access.`
+      );
+    }
+    return { id: me.id, username: me.username };
+  }
+  async projectPath(projectId) {
+    const project = await this.getJson(
+      `projects/${projectId}`
+    );
+    return project?.path_with_namespace ?? String(projectId);
+  }
+  async getEvents(since) {
+    const raw = await this.getPaged("events", {
+      after: isoDay(since)
+    });
+    const ids = [...new Set(raw.map((e) => e.project_id).filter(Boolean))];
+    const paths = new Map(
+      await Promise.all(
+        ids.map(async (id) => [id, await this.projectPath(id)])
+      )
+    );
+    return raw.map((event) => {
+      const push = event.push_data ?? {};
+      return {
+        at: String(event.created_at).slice(0, 16),
+        action: event.action_name,
+        project: paths.get(event.project_id) ?? "",
+        targetType: event.target_type ?? "",
+        title: event.target_title ?? "",
+        branch: push.ref ?? "",
+        commits: push.commit_count ?? 0,
+        commitTitle: push.commit_title ?? ""
+      };
+    }).sort((a, b) => a.at.localeCompare(b.at));
+  }
+  async countUnresolved(projectId, iid) {
+    const discussions = await this.getJson(
+      `projects/${projectId}/merge_requests/${iid}/discussions`,
+      { per_page: PAGE_SIZE2 }
+    );
+    if (!discussions) return 0;
+    return discussions.filter((discussion) => {
+      const notes = (discussion.notes ?? []).filter((n) => !n.system);
+      return notes.length > 0 && notes.some((n) => n.resolvable && !n.resolved);
+    }).length;
+  }
+  async shapeMr(mr) {
+    const projectId = mr.project_id;
+    const iid = mr.iid;
+    const [pipelines, unresolved] = await Promise.all([
+      this.getJson(
+        `projects/${projectId}/merge_requests/${iid}/pipelines`,
+        { per_page: 1 }
+      ),
+      this.countUnresolved(projectId, iid)
+    ]);
+    const latest = pipelines?.[0];
+    return {
+      provider: "gitlab",
+      project: String(mr.references.full).split("!")[0],
+      projectId,
+      iid,
+      title: mr.title,
+      draft: mr.draft,
+      branch: mr.source_branch,
+      target: mr.target_branch,
+      updated: String(mr.updated_at).slice(0, 10),
+      url: mr.web_url,
+      mergeStatus: mr.detailed_merge_status ?? null,
+      pipeline: latest?.status ?? null,
+      pipelineId: latest?.id ?? null,
+      unresolved,
+      pipelineMissing: false,
+      bucket: "ready"
+    };
+  }
+  async getMyMrs(today) {
+    const raw = await this.getPaged("merge_requests", {
+      scope: "created_by_me",
+      state: "opened"
+    });
+    const rows = await Promise.all(raw.map((mr) => this.shapeMr(mr)));
+    markMissingPipelines(rows);
+    for (const row of rows) {
+      row.bucket = classify(row, today);
+    }
+    return rows;
+  }
+  async approvedByMe(projectId, iid, uid) {
+    const approvals = await this.getJson(`projects/${projectId}/merge_requests/${iid}/approvals`);
+    if (!approvals) return false;
+    return (approvals.approved_by ?? []).some((entry) => entry.user?.id === uid);
+  }
+  async getReviews(identity, today) {
+    const raw = await this.getPaged("merge_requests", {
+      scope: "all",
+      state: "opened",
+      reviewer_id: identity.id
+    });
+    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,
+        author: mr.author.name,
+        updated: String(mr.updated_at).slice(0, 10),
+        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, identity.id)
+      }))
+    );
+    return rows.sort((a, b) => b.updated.localeCompare(a.updated));
+  }
+  async getBlockers(mrs) {
+    const red = mrs.filter((mr) => mr.pipeline === "failed");
+    const diagnosed = await Promise.all(
+      red.map(async (mr) => {
+        const jobs = await this.getJson(
+          `projects/${mr.projectId}/pipelines/${mr.pipelineId}/jobs`,
+          { per_page: PAGE_SIZE2 }
+        ) ?? [];
+        const job = jobs.find((j) => j.status === "failed");
+        if (!job) return null;
+        const trace = await this.getText(
+          `projects/${mr.projectId}/jobs/${job.id}/trace`
+        );
+        return {
+          provider: "gitlab",
+          project: mr.project,
+          mr: mr.iid,
+          title: mr.title,
+          job: job.name,
+          stage: job.stage,
+          url: mr.url,
+          errors: extractErrors(trace)
+        };
+      })
+    );
+    return diagnosed.filter((row) => row !== null);
+  }
+};
+
+// 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/render/render.constants.ts
+var STRINGS = {
+  en: {
+    digest: "Structured digest \u2014 not a written note.",
+    previous: "Previous working day",
+    today: "Today",
+    ready: "Ready to merge",
+    blocked: "Blocked",
+    draft: "Drafts",
+    stale: "Stale",
+    reviews: "Reviews",
+    pending: "pending",
+    blockers: "Blockers",
+    noPipeline: "no pipeline ran",
+    unresolved: "unresolved comment(s)",
+    nothing: "No activity recorded."
+  },
+  tr: {
+    digest: "Yap\u0131land\u0131r\u0131lm\u0131\u015F d\xF6k\xFCm \u2014 yaz\u0131lm\u0131\u015F not de\u011Fil.",
+    previous: "\xD6nceki i\u015F g\xFCn\xFC",
+    today: "Bug\xFCn",
+    ready: "Merge'e haz\u0131r",
+    blocked: "Engelli",
+    draft: "Draftlar",
+    stale: "Bayat",
+    reviews: "Review",
+    pending: "bekliyor",
+    blockers: "Blocker",
+    noPipeline: "pipeline hi\xE7 \xE7al\u0131\u015Fmam\u0131\u015F",
+    unresolved: "\xE7\xF6z\xFClmemi\u015F yorum",
+    nothing: "Kay\u0131tl\u0131 aktivite yok."
+  }
+};
+var BUCKET_ORDER = ["ready", "blocked", "draft", "stale"];
+var REF_PREFIX = {
+  gitlab: "!",
+  github: "#"
+};
+var PROVIDER_STRINGS = {
+  gitlab: {},
+  github: {
+    en: { unresolved: "change request(s)" },
+    tr: { unresolved: "de\u011Fi\u015Fiklik iste\u011Fi" }
+  }
+};
+
+// src/render/render.ts
+function eventLine(event) {
+  const detail = event.commits ? `${event.commitTitle || event.branch} (${event.commits} commit)` : event.title || event.action;
+  return `- \`${event.project}\` ${event.action} \u2014 ${detail}`;
+}
+function toMarkdown(report, lang = "en") {
+  const base = STRINGS[lang] ?? STRINGS.en;
+  const t = { ...base, ...PROVIDER_STRINGS[report.provider][lang] ?? {} };
+  const ref = REF_PREFIX[report.provider];
+  const out = [];
+  out.push(`# ${report.today.label} \u2014 ${report.user}`, "", `_${t.digest}_`, "");
+  if (report.previousDays.length === 0) {
+    out.push(`## ${t.previous}`, "", `_${t.nothing}_`, "");
+  }
+  for (const day of report.previousDays) {
+    out.push(`## ${t.previous}: ${day.label}`, "");
+    out.push(...day.events.map(eventLine));
+    out.push("");
+  }
+  if (report.todayEvents.length > 0) {
+    out.push(`## ${t.today}`, "", ...report.todayEvents.map(eventLine), "");
+  }
+  for (const bucket of BUCKET_ORDER) {
+    const rows = report.myMrs.filter((mr) => mr.bucket === bucket);
+    if (rows.length === 0) continue;
+    out.push(`## ${t[bucket]} (${rows.length})`, "");
+    for (const mr of rows) {
+      const notes = [];
+      if (mr.pipelineMissing) notes.push(t.noPipeline);
+      if (mr.unresolved) notes.push(`${mr.unresolved} ${t.unresolved}`);
+      const suffix = notes.length > 0 ? ` \u2014 **${notes.join(", ")}**` : "";
+      out.push(`- \`${mr.project}\` ${ref}${mr.iid} ${mr.title}${suffix}`);
+    }
+    out.push("");
+  }
+  const pending = report.reviews.filter((r) => !r.approvedByMe);
+  if (pending.length > 0) {
+    out.push(`## ${t.reviews} (${report.reviewPendingCount} ${t.pending})`, "");
+    for (const review of pending) {
+      out.push(
+        `- \`${review.project}\` ${ref}${review.iid} ${review.title} \u2014 ${review.author}`
+      );
+    }
+    out.push("");
+  }
+  if (report.blockers.length > 0) {
+    out.push(`## ${t.blockers}`, "");
+    for (const blocker of report.blockers) {
+      out.push(`- \`${blocker.project}\` ${ref}${blocker.mr} \u2014 job \`${blocker.job}\``);
+      out.push(...blocker.errors.map((line) => `  - \`${line}\``));
+    }
+    out.push("");
+  }
+  return `${out.join("\n").trimEnd()}
+`;
+}
+
+// src/report/report.constants.ts
+var LOOKBACK_DAYS = 21;
+
+// src/report/report.ts
+async function buildReport(provider, today, lang = "en", lookbackDays = LOOKBACK_DAYS) {
+  const identity = await provider.getIdentity();
+  const since = new Date(today.getTime() - lookbackDays * MS_PER_DAY);
+  const events = await provider.getEvents(since);
+  const days = previousActiveDays(
+    new Set(events.map((e) => e.at.slice(0, 10))),
+    today
+  );
+  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, today),
+    provider.getBlockers(myMrs)
+  ]);
+  return {
+    provider: provider.kind,
+    user: identity.username,
+    today: { date: isoDay(today), label: label(today, lang) },
+    previousDays,
+    todayEvents,
+    myMrs,
+    reviews,
+    reviewPendingCount: reviews.filter((r) => !r.approvedByMe).length,
+    blockers
+  };
+}
+
+export {
+  STALE_DAYS,
+  isoDay,
+  localAt,
+  label,
+  previousActiveDays,
+  classify,
+  markMissingPipelines,
+  ConfigError,
+  GITLAB_LABELS,
+  GITHUB_LABELS,
+  resolveHost,
+  resolveToken,
+  parseLoggedInHosts,
+  parseGlabHosts,
+  glabHosts,
+  glabToken,
+  ghHosts,
+  ghToken,
+  postWebhook,
+  buildUrl,
+  ApiError,
+  assertUsable,
+  unreachable,
+  extractErrors,
+  repoFromUrl,
+  mapEvent,
+  normalizeChecks,
+  latestStateByReviewer,
+  countChangesRequested,
+  approvedBy,
+  GitHubProvider,
+  GitLabProvider,
+  chooseKind,
+  connect,
+  toMarkdown,
+  buildReport
+};