standup-mr 0.1.0

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 İlker Balcılar
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -0,0 +1,72 @@
+# standup-mr
+
+Standup notes from **merge request state**, not commit logs.
+
+Most standup tools read your local `git log`. That answers "what did I type",
+which is not what anyone asks in a standup. This one reads GitLab: what is ready
+to merge, what is blocked, what is waiting on you — and when a pipeline is red,
+it opens the job log and tells you **why**.
+
+## What makes it different
+
+|  | commit-log tools | standup-mr |
+|---|---|---|
+| Source | local `git log` | GitLab API |
+| Merge request state | ✗ | ready / blocked / draft / stale |
+| Review queue | ✗ | pending only, approvals filtered out |
+| Failed pipeline | ✗ | error lines pulled from the job trace |
+| Self-hosted GitLab | varies | first class |
+
+## Use
+
+```bash
+npx standup-mr fetch                 # JSON
+npx standup-mr fetch --markdown      # structured digest
+npx standup-mr fetch --lang tr       # Turkish date labels
+```
+
+Credentials resolve in this order, independently for host and token:
+
+1. `--host` / `--token`
+2. `GITLAB_HOST` / `GITLAB_TOKEN`
+3. the local [`glab`](https://gitlab.com/gitlab-org/cli) CLI config
+
+So if you already use `glab`, there is nothing to configure.
+
+### Post it to chat
+
+```bash
+npx standup-mr fetch --markdown | npx standup-mr post --slack "$SLACK_WEBHOOK_URL"
+```
+
+## The three surfaces
+
+**CLI** — the core. Emits JSON; zero runtime dependencies.
+
+**MCP server** (`mcp/`) — one tool, `get_standup_data`, for Claude Desktop,
+Cursor, or any MCP client. See [`mcp/README.md`](mcp/README.md).
+
+**Claude Code skill** (`skill/`) — the note-writing playbook. Copy it in:
+
+```bash
+cp -r skill ~/.claude/skills/standup
+```
+
+Then type `/standup`.
+
+## `--markdown` is a digest, not a written note
+
+`--markdown` organizes the raw material into readable sections. It does **not**
+group events into themes or diagnose blockers — that is the model's work, and it
+lives in the MCP client's prompt or in the Claude Code skill.
+
+- Without AI: a structured digest.
+- With AI: a note you can read out.
+
+## Requirements
+
+Node 20 or newer. No runtime dependencies.
+
+## License
+
+MIT

package/dist/chunk-SKCJT2AY.js

@@ -0,0 +1,551 @@
+#!/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 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 previousActiveDay(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 };
+}
+
+// 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 GLAB_TIMEOUT_MS = 15e3;
+
+// src/config/config.ts
+var ConfigError = class extends Error {
+  constructor(message) {
+    super(message);
+    this.name = "ConfigError";
+  }
+};
+function resolveHost(cliHost, envHost, glabHostList) {
+  if (cliHost) return cliHost;
+  if (envHost) return envHost;
+  const hosts = glabHostList ?? [];
+  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`."
+    );
+  }
+  throw new ConfigError(
+    `Multiple GitLab hosts found (${[...hosts].sort().join(", ")}). Pick one with --host or GITLAB_HOST.`
+  );
+}
+function resolveToken(host, cliToken, envToken, glabLookup) {
+  if (cliToken) return cliToken;
+  if (envToken) return envToken;
+  if (glabLookup) {
+    const token = glabLookup(host);
+    if (token) return token;
+  }
+  throw new ConfigError(
+    `No token for ${host}. Pass --token, set GITLAB_TOKEN, or run \`glab auth login --hostname ${host}\`.`
+  );
+}
+function glab(args) {
+  try {
+    return execFileSync("glab", args, {
+      encoding: "utf8",
+      timeout: GLAB_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() {
+  try {
+    return execFileSync("glab", ["auth", "status"], {
+      encoding: "utf8",
+      timeout: GLAB_TIMEOUT_MS,
+      stdio: ["ignore", "pipe", "pipe"]
+    });
+  } catch (error) {
+    const result = error;
+    return `${result.stdout ?? ""}${result.stderr ?? ""}`;
+  }
+}
+function glabHosts() {
+  return parseGlabHosts(glabStatus());
+}
+function glabToken(host) {
+  return glab(["config", "get", "token", "--host", 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/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;
+
+// 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 line = rawLine.trim();
+    if (!line || NOISE.test(line) || !SIGNAL.test(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/gitlab/gitlab.constants.ts
+var PAGE_SIZE = 100;
+var FRESH_REVIEW_DAYS = 7;
+
+// src/providers/gitlab/gitlab.ts
+var GitLabProvider = class {
+  host;
+  api;
+  token;
+  fetchImpl;
+  constructor(host, token, fetchImpl = fetch) {
+    this.host = host;
+    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));
+    }
+    return `${base}?${query.toString()}`;
+  }
+  async getJson(path, params) {
+    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;
+    }
+  }
+  async getText(path) {
+    try {
+      const response = await this.fetchImpl(this.url(path), {
+        headers: { "PRIVATE-TOKEN": this.token }
+      });
+      if (!response.ok) return "";
+      return await response.text();
+    } catch {
+      return "";
+    }
+  }
+  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 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_SIZE }
+    );
+    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 {
+      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(uid, today) {
+    const raw = await this.getPaged("merge_requests", {
+      scope: "all",
+      state: "opened",
+      reviewer_id: uid
+    });
+    const cutoff = isoDay(new Date(today.getTime() - FRESH_REVIEW_DAYS * MS_PER_DAY));
+    const rows = await Promise.all(
+      raw.map(async (mr) => ({
+        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, uid)
+      }))
+    );
+    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_SIZE }
+        ) ?? [];
+        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 {
+          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/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"];
+
+// 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 t = STRINGS[lang] ?? STRINGS.en;
+  const out = [];
+  out.push(`# ${report.today.label} \u2014 ${report.user}`, "", `_${t.digest}_`, "");
+  out.push(`## ${t.previous}: ${report.previous.label ?? "\u2014"}`, "");
+  if (report.previousEvents.length > 0) {
+    out.push(...report.previousEvents.map(eventLine));
+  } else {
+    out.push(`_${t.nothing}_`);
+  }
+  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}\` !${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}\` !${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}\` !${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 { date: previousDate, gapDays } = previousActiveDay(
+    new Set(events.map((e) => e.at.slice(0, 10))),
+    today
+  );
+  const previousEvents = previousDate ? events.filter((e) => e.at.slice(0, 10) === previousDate) : [];
+  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.getBlockers(myMrs)
+  ]);
+  return {
+    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,
+    todayEvents,
+    myMrs,
+    reviews,
+    reviewPendingCount: reviews.filter((r) => !r.approvedByMe).length,
+    blockers
+  };
+}
+
+export {
+  STALE_DAYS,
+  isoDay,
+  label,
+  previousActiveDay,
+  classify,
+  markMissingPipelines,
+  ConfigError,
+  resolveHost,
+  resolveToken,
+  glabHosts,
+  glabToken,
+  postWebhook,
+  extractErrors,
+  GitLabProvider,
+  toMarkdown,
+  buildReport
+};

package/dist/cli.d.ts

@@ -0,0 +1,3 @@
+declare function main(argv: string[]): Promise<number>;
+
+export { main };