standup-mr 0.1.0

package/dist/mcp/server.js

@@ -0,0 +1,468 @@
+#!/usr/bin/env node
+
+// mcp/server.ts
+import { pathToFileURL } from "url";
+
+// 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/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/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((entry2) => entry2.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/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
+  };
+}
+
+// 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");
+}
+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" });
+  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.",
+    {},
+    async () => {
+      const report = await collect();
+      return { content: [{ type: "text", text: JSON.stringify(report) }] };
+    }
+  );
+  await server.connect(new StdioServerTransport());
+}
+var entry = process.argv[1];
+if (entry && import.meta.url === pathToFileURL(entry).href) {
+  main().catch((error) => {
+    if (error instanceof Error && error.code === "ERR_MODULE_NOT_FOUND") {
+      process.stderr.write(
+        "standup-mr MCP server requires the optional dependency @modelcontextprotocol/sdk. Install it with: npm install @modelcontextprotocol/sdk\n"
+      );
+      process.exitCode = 1;
+      return;
+    }
+    throw error;
+  });
+}
+export {
+  collect,
+  main
+};

package/mcp/README.md

@@ -0,0 +1,33 @@
+# MCP server
+
+Exposes one tool, `get_standup_data`, returning the same JSON as `standup fetch`.
+
+## Install
+
+```bash
+npm install standup-mr @modelcontextprotocol/sdk
+```
+
+## Configure
+
+```json
+{
+  "mcpServers": {
+    "standup": {
+      "command": "node",
+      "args": ["/absolute/path/to/standup-mr/dist/mcp/server.js"],
+      "env": {
+        "GITLAB_HOST": "gitlab.example.com",
+        "GITLAB_TOKEN": "glpat-..."
+      }
+    }
+  }
+}
+```
+
+`GITLAB_HOST` and `GITLAB_TOKEN` are the supported configuration for MCP use. If
+`glab` happens to be installed and authenticated it is used as a fallback, but do
+not rely on that inside a container.
+
+The tool returns data only. Ask your client to write the note, or use the Claude
+Code skill in `skill/`, which carries the note-writing rules.

package/package.json

@@ -0,0 +1,54 @@
+{
+    "name": "standup-mr",
+    "version": "0.1.0",
+    "description": "Standup notes from merge request state, not commit logs.",
+    "keywords": ["standup", "gitlab", "merge-request", "cli", "mcp"],
+    "license": "MIT",
+    "author": {
+        "name": "İlker Balcılar",
+        "email": "ilkerbalcilartr@gmail.com"
+    },
+    "repository": {
+        "type": "git",
+        "url": "https://github.com/Jubstaaa/standup-mr.git"
+    },
+    "bugs": {
+        "url": "https://github.com/Jubstaaa/standup-mr/issues"
+    },
+    "homepage": "https://github.com/Jubstaaa/standup-mr#readme",
+    "funding": [
+        {
+            "type": "github",
+            "url": "https://github.com/sponsors/Jubstaaa"
+        },
+        {
+            "type": "buy_me_a_coffee",
+            "url": "https://buymeacoffee.com/jubstaa"
+        }
+    ],
+    "type": "module",
+    "engines": { "node": ">=20" },
+    "bin": { "standup": "./dist/cli.js" },
+    "main": "./dist/index.js",
+    "types": "./dist/index.d.ts",
+    "files": ["dist", "skill", "mcp/README.md", "README.md", "LICENSE"],
+    "scripts": {
+        "build": "tsup",
+        "test": "bun test",
+        "typecheck": "tsc --noEmit",
+        "prepublishOnly": "tsup"
+    },
+    "devDependencies": {
+        "@modelcontextprotocol/sdk": "^1.0.0",
+        "@types/bun": "^1.0.0",
+        "@types/node": "^22.0.0",
+        "tsup": "^8.0.0",
+        "typescript": "^5.5.0"
+    },
+    "peerDependencies": {
+        "@modelcontextprotocol/sdk": "^1.0.0"
+    },
+    "peerDependenciesMeta": {
+        "@modelcontextprotocol/sdk": { "optional": true }
+    }
+}

package/skill/SKILL.md

@@ -0,0 +1,102 @@
+---
+name: standup
+description: >-
+  Generates a daily standup note from GitLab merge request state. Groups the
+  previous working day's activity into themes, reports which merge requests are
+  ready to merge or blocked, and diagnoses failed pipelines from their job logs.
+  Use for "/standup", "standup note", "what did I do yesterday", "what's on my
+  plate today", "daily note".
+---
+
+# Standup Note
+
+Goal: put the things worth *saying* in front of the user before their standup.
+Not a commit log — what finished, what is waiting, what is stuck.
+
+## 1. Collect
+
+```bash
+npx standup-mr fetch
+```
+
+Prints one JSON document. Add `--lang tr` for Turkish date labels. Nothing else
+needs running: the command resolves the host and token, works out which day to
+report on, and reads failed job logs itself.
+
+If the command exits non-zero, relay its stderr verbatim — do not invent a
+cause. The usual fix is `glab auth login`, or setting `GITLAB_HOST` and
+`GITLAB_TOKEN`.
+
+## 2. Shape of the JSON
+
+| Field | Contents |
+|---|---|
+| `previous` | Last active day: `date`, `label`, `gapDays`, `eventCount` |
+| `previousEvents` | That day's events — `action`, `project`, `branch`, `commits`, `commitTitle` |
+| `todayEvents` | Anything already done today (usually empty) |
+| `myMrs` | Open merge requests with `bucket`: `ready` / `blocked` / `draft` / `stale`, plus `pipelineMissing` |
+| `reviews` | Review requests, with `fresh` and `approvedByMe` |
+| `reviewPendingCount` | Reviews genuinely awaiting action |
+| `blockers` | Failed pipelines with real error lines from the job trace |
+
+## 3. Write the note
+
+Three sections: **Previous day · Today · Blockers**. Short, in the language the
+user is speaking, phrased the way they would say it out loud.
+
+### Previous day
+
+Use `previous.label`. Never say "yesterday" — after a weekend or a day off it is
+wrong, and the label already carries the right day.
+
+**Group by theme; never list events one by one.** A 60-event day should collapse
+to four to six bullets. Group on project + branch + subject:
+
+> **Virtual keyboard — two fixes, two releases** (`acme/ui` → main)
+> - keeps scaling on large screens, no longer widens modals → **0.5.13**
+> - mirrors the settled field value, not the in-flight one → **0.5.14**
+
+`commitTitle` values are conventional commits; use the scope as the grouping
+hint. Fold merges, branch deletions and tags into the sentence rather than
+giving them their own bullets.
+
+When one subject spans several projects in a day — dependency alignment, a CI
+rollout — make it **one bullet** and say how many projects it touched.
+
+### Today
+
+- **`ready`** → count them, give project + `!iid`.
+  - If `pipelineMissing` is true, say **"no pipeline ever ran"** explicitly. Do
+    not let it pass as green.
+- **`blocked`** → say which: red pipeline, or unresolved comments, or both.
+- **`draft`** → what needs finishing. Collapse drafts that share a branch prefix
+  or scope into one line, and flag it when they must merge in order.
+- **`stale`** → a count and the oldest date. No long list.
+
+For reviews, use `reviewPendingCount`, not the raw length of `reviews` — GitLab
+keeps you on the reviewer list after you approve, so the raw number overstates
+the work. List the pending ones with author and `!iid`. If the user has both
+their own merge request and a review in the same project, note the conflict risk.
+
+### Blockers
+
+If `blockers` is empty, **omit the section entirely.** Never write "no blockers".
+
+Otherwise the useful content is the lines in `errors`, not the job name. Collapse
+several merge requests sharing one root cause into a single blocker.
+
+> The CI token cannot pull the private packages — `npm ci` gets a 404. Two
+> pipelines are red for the same reason; the third passes because it has no such
+> dependency.
+
+A private package registry returning **404 instead of 403** usually means the
+token's scope is wrong, not that the package is missing. Say so when the pattern
+fits.
+
+## Rules
+
+- Speak from the data the command returned. If unsure about a merge request,
+  verify it rather than guessing.
+- If `todayEvents` is non-empty, do not say "nothing done today" — call out the
+  work already started.
+- The note gets read aloud: one breath per bullet, no three-line paragraphs.