standup-mcp 0.1.0

package/dist/sources/jira.js

@@ -0,0 +1,192 @@
+/**
+ * Live Jira Cloud source. Implements ActivitySource against the REST Platform
+ * API v3 with basic auth (email + API token). Read-only.
+ *
+ * Activity comes from per-issue changelogs filtered to status transitions the
+ * authenticated user made; open items come from the user's in-progress issues.
+ * Search uses the enhanced JQL endpoint (POST /rest/api/3/search/jql), not the
+ * deprecated GET /rest/api/3/search.
+ */
+import { truncate } from "../normalize.js";
+const REQUEST_TIMEOUT_MS = 30_000;
+const TWO_DAYS_MS = 2 * 24 * 60 * 60 * 1000;
+const CHANGELOG_ISSUE_CAP = 20;
+export class JiraSource {
+    creds;
+    id = "jira";
+    isDemo = false;
+    authHeader;
+    constructor(creds) {
+        this.creds = creds;
+        const token = Buffer.from(`${creds.email}:${creds.apiToken}`).toString("base64");
+        this.authHeader = `Basic ${token}`;
+    }
+    // --- HTTP plumbing -------------------------------------------------------
+    async request(path, init) {
+        const url = path.startsWith("http") ? path : `${this.creds.baseUrl}${path}`;
+        const controller = new AbortController();
+        const timer = setTimeout(() => controller.abort(), REQUEST_TIMEOUT_MS);
+        try {
+            const headers = {
+                Authorization: this.authHeader,
+                Accept: "application/json",
+            };
+            if (init?.body !== undefined)
+                headers["Content-Type"] = "application/json";
+            const res = await fetch(url, {
+                method: init?.method ?? "GET",
+                headers,
+                body: init?.body !== undefined ? JSON.stringify(init.body) : undefined,
+                signal: controller.signal,
+            });
+            if (!res.ok) {
+                const body = await res.text().catch(() => "");
+                throw new Error(`Jira API ${res.status} ${res.statusText} for ${path}` +
+                    (body ? `: ${body.slice(0, 300)}` : ""));
+            }
+            return (await res.json());
+        }
+        catch (err) {
+            if (err instanceof Error && err.name === "AbortError") {
+                throw new Error(`Jira API request timed out after 30s: ${path}`);
+            }
+            throw err;
+        }
+        finally {
+            clearTimeout(timer);
+        }
+    }
+    // --- ActivitySource surface ----------------------------------------------
+    async resolveIdentity() {
+        const me = await this.request("/rest/api/3/myself");
+        return me.accountId;
+    }
+    async checkConnection() {
+        try {
+            const me = await this.request("/rest/api/3/myself");
+            const name = me.displayName ?? "unknown";
+            return {
+                source: "jira",
+                ok: true,
+                identity: name,
+                detail: `authenticated as ${name}`,
+            };
+        }
+        catch (err) {
+            const message = err instanceof Error ? err.message : String(err);
+            return { source: "jira", ok: false, detail: message };
+        }
+    }
+    async fetchActivity(window, _actor) {
+        const events = [];
+        let myAccountId;
+        try {
+            myAccountId = await this.resolveIdentity();
+        }
+        catch {
+            return events;
+        }
+        if (!myAccountId)
+            return events;
+        const dateOnly = window.since.slice(0, 10);
+        const jql = `updated >= "${dateOnly}" ` +
+            "AND (assignee = currentUser() OR reporter = currentUser()) " +
+            "ORDER BY updated DESC";
+        let issues;
+        try {
+            const data = await this.request("/rest/api/3/search/jql", {
+                method: "POST",
+                body: { jql, fields: ["summary", "status"], maxResults: 50 },
+            });
+            issues = data.issues ?? [];
+        }
+        catch {
+            return events;
+        }
+        const sinceMs = Date.parse(window.since);
+        // Cap changelog fetches to bound the number of calls.
+        for (const issue of issues.slice(0, CHANGELOG_ISSUE_CAP)) {
+            let entries;
+            try {
+                const cl = await this.request(`/rest/api/3/issue/${issue.key}/changelog?maxResults=100`);
+                entries = cl.values ?? [];
+            }
+            catch {
+                continue; // skip this issue on failure, keep what we have
+            }
+            for (const entry of entries) {
+                if (entry.author?.accountId !== myAccountId)
+                    continue;
+                if (Date.parse(entry.created) < sinceMs)
+                    continue;
+                const author = entry.author.displayName ?? "unknown";
+                for (const item of entry.items ?? []) {
+                    if (item.field !== "status")
+                        continue;
+                    const fromStatus = item.fromString ?? undefined;
+                    const toStatus = item.toString ?? undefined;
+                    const summary = issue.fields.summary ?? issue.key;
+                    events.push({
+                        source: "jira",
+                        kind: "issue_moved",
+                        timestamp: entry.created,
+                        actor: author,
+                        title: `${issue.key} moved ${fromStatus ?? "?"} to ` +
+                            `${toStatus ?? "?"}`,
+                        workItem: issue.key,
+                        workItemTitle: truncate(summary),
+                        fromStatus,
+                        toStatus,
+                        signals: [],
+                    });
+                }
+            }
+        }
+        return events;
+    }
+    async fetchOpenItems(actor) {
+        const events = [];
+        let issues;
+        try {
+            const data = await this.request("/rest/api/3/search/jql", {
+                method: "POST",
+                body: {
+                    jql: 'assignee = currentUser() AND statusCategory = "In Progress" ' +
+                        "ORDER BY updated DESC",
+                    fields: ["summary", "status", "updated", "labels"],
+                    maxResults: 30,
+                },
+            });
+            issues = data.issues ?? [];
+        }
+        catch {
+            return events;
+        }
+        for (const issue of issues) {
+            const fields = issue.fields;
+            const summary = fields.summary ?? issue.key;
+            const status = fields.status?.name ?? "In Progress";
+            const updated = fields.updated ?? new Date().toISOString();
+            const signals = [];
+            const labels = fields.labels ?? [];
+            if (labels.some((label) => /block|impediment/i.test(label))) {
+                signals.push("blocked");
+            }
+            else if (Date.now() - Date.parse(updated) >= TWO_DAYS_MS) {
+                signals.push("stale");
+            }
+            events.push({
+                source: "jira",
+                kind: "issue_moved",
+                timestamp: updated,
+                actor: actor.displayName,
+                title: `${issue.key} ${truncate(summary)} (${status})`,
+                workItem: issue.key,
+                workItemTitle: truncate(summary),
+                toStatus: status,
+                signals,
+            });
+        }
+        return events;
+    }
+}

package/dist/sources/linear.js

@@ -0,0 +1,176 @@
+/**
+ * Live Linear client. Implements ActivitySource against the Linear GraphQL API
+ * with a personal API key. Read-only: every call is a query, never a mutation.
+ *
+ * Auth note: Linear personal API keys go in the Authorization header RAW, with
+ * no "Bearer " prefix. Errors arrive either as a non-2xx HTTP status or as a
+ * populated `errors` array on a 200 body, so both paths throw.
+ */
+import { detectTextSignals, truncate } from "../normalize.js";
+const ENDPOINT = "https://api.linear.app/graphql";
+const REQUEST_TIMEOUT_MS = 30_000;
+const STALE_AFTER_MS = 2 * 24 * 60 * 60 * 1000; // 2 days
+const VIEWER_QUERY = `{ viewer { id name email } }`;
+const ACTIVITY_QUERY = `query($since: DateTimeOrDuration!) { issues(filter: { assignee: { isMe: { eq: true } }, updatedAt: { gte: $since } }, first: 50) { nodes { identifier title updatedAt state { name } history(first: 20) { nodes { createdAt fromState { name } toState { name } } } comments(first: 10) { nodes { createdAt body user { isMe } } } } } }`;
+const OPEN_ITEMS_QUERY = `{ issues(filter: { assignee: { isMe: { eq: true } }, state: { type: { eq: "started" } } }, first: 50) { nodes { identifier title updatedAt state { name } labels { nodes { name } } } } }`;
+export class LinearSource {
+    creds;
+    id = "linear";
+    isDemo = false;
+    constructor(creds) {
+        this.creds = creds;
+    }
+    // --- HTTP plumbing -------------------------------------------------------
+    async query(query, variables) {
+        const controller = new AbortController();
+        const timer = setTimeout(() => controller.abort(), REQUEST_TIMEOUT_MS);
+        try {
+            const res = await fetch(ENDPOINT, {
+                method: "POST",
+                headers: {
+                    // Personal API keys are sent raw, NOT as "Bearer ...".
+                    Authorization: this.creds.apiKey,
+                    "Content-Type": "application/json",
+                },
+                body: JSON.stringify({ query, variables }),
+                signal: controller.signal,
+            });
+            if (!res.ok) {
+                const body = await res.text().catch(() => "");
+                throw new Error(`Linear API ${res.status} ${res.statusText}` +
+                    (body ? `: ${body.slice(0, 300)}` : ""));
+            }
+            const json = (await res.json());
+            if (json.errors?.length) {
+                throw new Error(`Linear API error: ${json.errors.map((e) => e.message).join("; ")}`);
+            }
+            return json.data;
+        }
+        catch (err) {
+            if (err instanceof Error && err.name === "AbortError") {
+                throw new Error("Linear API request timed out after 30s");
+            }
+            throw err;
+        }
+        finally {
+            clearTimeout(timer);
+        }
+    }
+    // --- Activity source surface ---------------------------------------------
+    async resolveIdentity() {
+        try {
+            const data = await this.query(VIEWER_QUERY);
+            return data.viewer.id;
+        }
+        catch {
+            // Identity resolution is best-effort; a failure should not abort actor
+            // matching across the other sources.
+            return undefined;
+        }
+    }
+    async checkConnection() {
+        try {
+            const data = await this.query(VIEWER_QUERY);
+            const name = data.viewer.name;
+            return {
+                source: "linear",
+                ok: true,
+                identity: name,
+                detail: `authenticated as ${name}`,
+            };
+        }
+        catch (err) {
+            return {
+                source: "linear",
+                ok: false,
+                detail: err instanceof Error ? err.message : String(err),
+            };
+        }
+    }
+    async fetchActivity(window, actor) {
+        try {
+            const data = await this.query(ACTIVITY_QUERY, { since: window.since });
+            const sinceMs = Date.parse(window.since);
+            const events = [];
+            for (const issue of data.issues.nodes) {
+                // State transitions within the window. The first history entry of an
+                // issue has no fromState, so guard the title on it.
+                for (const h of issue.history.nodes) {
+                    if (Date.parse(h.createdAt) < sinceMs || !h.toState)
+                        continue;
+                    const from = h.fromState?.name;
+                    const to = h.toState.name;
+                    events.push({
+                        source: "linear",
+                        kind: "issue_moved",
+                        timestamp: h.createdAt,
+                        actor: actor.displayName,
+                        title: from
+                            ? `${issue.identifier} moved ${from} → ${to}`
+                            : `${issue.identifier} moved to ${to}`,
+                        workItem: issue.identifier,
+                        workItemTitle: issue.title,
+                        fromStatus: from,
+                        toStatus: to,
+                        signals: [],
+                    });
+                }
+                // Comments the user authored within the window.
+                for (const c of issue.comments.nodes) {
+                    // The spec compares Date.parse(createdAt) to the raw ISO string,
+                    // which is always false (number vs string). Resolved toward the
+                    // history rule above: parse both sides.
+                    if (c.user?.isMe !== true || Date.parse(c.createdAt) < sinceMs) {
+                        continue;
+                    }
+                    events.push({
+                        source: "linear",
+                        kind: "issue_commented",
+                        timestamp: c.createdAt,
+                        actor: actor.displayName,
+                        title: `${issue.identifier} comment`,
+                        body: truncate(c.body, 200),
+                        workItem: issue.identifier,
+                        workItemTitle: issue.title,
+                        signals: detectTextSignals(c.body),
+                    });
+                }
+            }
+            return events;
+        }
+        catch {
+            // A GraphQL/transport failure for one source must not sink the standup;
+            // the aggregate provider tolerates an empty slice.
+            return [];
+        }
+    }
+    async fetchOpenItems(actor) {
+        try {
+            const data = await this.query(OPEN_ITEMS_QUERY);
+            const now = Date.now();
+            return data.issues.nodes.map((issue) => {
+                const stateName = issue.state?.name;
+                const blocked = issue.labels.nodes.some((l) => /block/i.test(l.name));
+                const signals = blocked
+                    ? ["blocked"]
+                    : now - Date.parse(issue.updatedAt) >= STALE_AFTER_MS
+                        ? ["stale"]
+                        : [];
+                return {
+                    source: "linear",
+                    kind: "issue_moved",
+                    timestamp: issue.updatedAt,
+                    actor: actor.displayName,
+                    title: `${issue.identifier} ${issue.title} (${stateName ?? "In Progress"})`,
+                    workItem: issue.identifier,
+                    workItemTitle: issue.title,
+                    toStatus: stateName,
+                    signals,
+                };
+            });
+        }
+        catch {
+            return [];
+        }
+    }
+}

package/dist/sources/mock.js

@@ -0,0 +1,257 @@
+/**
+ * Demo provider: a synthetic but realistic day of one developer's activity
+ * across all four sources. This is what makes `npx standup-mcp --demo` produce
+ * a believable standup with zero setup, and it is the share-worthy demo.
+ *
+ * The story: Jordan Lee, a fintech engineer. Yesterday they pushed a biometric
+ * re-auth feature (PROJ-412), shipped a card-dispute fix (PROJ-407), advanced a
+ * Linear rate-limit task (ENG-88), reviewed a teammate's PR, and said in Slack
+ * they are blocked on vendor sandbox creds. The engine should surface that
+ * blocker on its own, group GitHub + Jira + Linear + Slack by work item, and
+ * propose a sensible "Today".
+ */
+import { ALL_SOURCES } from "../types.js";
+const ACTOR = {
+    displayName: "Jordan Lee",
+    github: "jordanlee",
+    jira: "jordan@acmebank.dev",
+    linear: "jordan",
+    slack: "U07JORDAN",
+};
+export class MockProvider {
+    isDemo = true;
+    sources = ALL_SOURCES;
+    now;
+    constructor(now = Date.now()) {
+        this.now = now;
+    }
+    /** ISO timestamp `hours` ago. */
+    t(hours) {
+        return new Date(this.now - hours * 3_600_000).toISOString();
+    }
+    async resolveActor() {
+        return ACTOR;
+    }
+    async fetchActivity() {
+        return this.events();
+    }
+    async fetchOpenItems() {
+        return this.openItems();
+    }
+    async checkConnections() {
+        return ALL_SOURCES.map((source) => ({
+            source,
+            ok: true,
+            identity: ACTOR[source] ?? "demo",
+            detail: "demo data (no real connection)",
+        }));
+    }
+    events() {
+        const PROJ412 = "Biometric re-auth";
+        const PROJ407 = "Card dispute webhook";
+        const ENG88 = "Rate-limit the export endpoint";
+        return [
+            // --- PROJ-412: GitHub commits + PR, Jira move, Slack blocker ---------
+            {
+                source: "github",
+                kind: "commit",
+                timestamp: this.t(28),
+                actor: ACTOR.github,
+                title: "scaffold biometric prompt component",
+                workItem: "PROJ-412",
+                workItemTitle: PROJ412,
+                signals: [],
+            },
+            {
+                source: "github",
+                kind: "commit",
+                timestamp: this.t(26),
+                actor: ACTOR.github,
+                title: "wire WebAuthn challenge endpoint",
+                workItem: "PROJ-412",
+                workItemTitle: PROJ412,
+                signals: [],
+            },
+            {
+                source: "github",
+                kind: "commit",
+                timestamp: this.t(24),
+                actor: ACTOR.github,
+                title: "handle expired challenge edge case",
+                workItem: "PROJ-412",
+                workItemTitle: PROJ412,
+                signals: [],
+            },
+            {
+                source: "github",
+                kind: "pr_opened",
+                timestamp: this.t(23),
+                actor: ACTOR.github,
+                title: "Opened PR #128: Add biometric re-auth",
+                workItem: "PROJ-412",
+                workItemTitle: PROJ412,
+                url: "https://github.com/acmebank/app/pull/128",
+                signals: [],
+            },
+            {
+                source: "jira",
+                kind: "issue_moved",
+                timestamp: this.t(27),
+                actor: ACTOR.displayName,
+                title: "PROJ-412 moved To Do → In Progress",
+                workItem: "PROJ-412",
+                workItemTitle: PROJ412,
+                fromStatus: "To Do",
+                toStatus: "In Progress",
+                signals: [],
+            },
+            {
+                source: "slack",
+                kind: "message",
+                timestamp: this.t(17),
+                actor: ACTOR.displayName,
+                title: "#payments: blocked on vendor sandbox creds for PROJ-412",
+                body: "Blocked on the vendor sandbox creds for PROJ-412. Waiting on infra to provision them before I can test the re-auth flow end to end.",
+                workItem: "PROJ-412",
+                signals: ["blocked"],
+            },
+            // --- PROJ-407: merged PR + Jira move to In Review --------------------
+            {
+                source: "github",
+                kind: "pr_merged",
+                timestamp: this.t(30),
+                actor: ACTOR.github,
+                title: "Merged PR #125: Card dispute webhook retry/backoff",
+                workItem: "PROJ-407",
+                workItemTitle: PROJ407,
+                url: "https://github.com/acmebank/app/pull/125",
+                signals: [],
+            },
+            {
+                source: "jira",
+                kind: "issue_moved",
+                timestamp: this.t(29),
+                actor: ACTOR.displayName,
+                title: "PROJ-407 moved In Progress → In Review",
+                workItem: "PROJ-407",
+                workItemTitle: PROJ407,
+                fromStatus: "In Progress",
+                toStatus: "In Review",
+                signals: [],
+            },
+            // --- ENG-88 (Linear): state change, commits, comment -----------------
+            {
+                source: "linear",
+                kind: "issue_moved",
+                timestamp: this.t(26),
+                actor: ACTOR.displayName,
+                title: "ENG-88 moved Backlog → In Progress",
+                workItem: "ENG-88",
+                workItemTitle: ENG88,
+                fromStatus: "Backlog",
+                toStatus: "In Progress",
+                signals: [],
+            },
+            {
+                source: "github",
+                kind: "commit",
+                timestamp: this.t(22),
+                actor: ACTOR.github,
+                title: "add token-bucket limiter for /export",
+                workItem: "ENG-88",
+                workItemTitle: ENG88,
+                signals: [],
+            },
+            {
+                source: "github",
+                kind: "commit",
+                timestamp: this.t(21),
+                actor: ACTOR.github,
+                title: "tests for limiter window",
+                workItem: "ENG-88",
+                workItemTitle: ENG88,
+                signals: [],
+            },
+            {
+                source: "linear",
+                kind: "issue_commented",
+                timestamp: this.t(20),
+                actor: ACTOR.displayName,
+                title: "ENG-88 comment: documented the 429 retry-after header",
+                body: "Documented the 429 retry-after header behaviour in the spec.",
+                workItem: "ENG-88",
+                workItemTitle: ENG88,
+                signals: [],
+            },
+            {
+                source: "slack",
+                kind: "message",
+                timestamp: this.t(18),
+                actor: ACTOR.displayName,
+                title: "#eng: shared the limiter approach, ENG-88 ready for QA tomorrow",
+                body: "Shared the limiter approach in #eng. ENG-88 should be ready for QA tomorrow.",
+                workItem: "ENG-88",
+                signals: [],
+            },
+            // --- Loose review (no ticket) -> Other activity ----------------------
+            {
+                source: "github",
+                kind: "pr_reviewed",
+                timestamp: this.t(25),
+                actor: ACTOR.github,
+                title: "Reviewed PR #129: Tidy currency formatting helpers",
+                url: "https://github.com/acmebank/app/pull/129",
+                signals: [],
+            },
+        ];
+    }
+    openItems() {
+        return [
+            // In-progress tickets -> "Continue ..."
+            {
+                source: "jira",
+                kind: "issue_moved",
+                timestamp: this.t(27),
+                actor: ACTOR.displayName,
+                title: "PROJ-412 Biometric re-auth (In Progress)",
+                workItem: "PROJ-412",
+                workItemTitle: "Biometric re-auth",
+                toStatus: "In Progress",
+                signals: [],
+            },
+            {
+                source: "linear",
+                kind: "issue_moved",
+                timestamp: this.t(26),
+                actor: ACTOR.displayName,
+                title: "ENG-88 Rate-limit the export endpoint (In Progress)",
+                workItem: "ENG-88",
+                workItemTitle: "Rate-limit the export endpoint",
+                toStatus: "In Progress",
+                signals: [],
+            },
+            // Your open PR awaiting review -> "Land ..." + a review-pending signal.
+            {
+                source: "github",
+                kind: "pr_opened",
+                timestamp: this.t(23),
+                actor: ACTOR.github,
+                title: "Opened PR #128: Add biometric re-auth",
+                workItem: "PROJ-412",
+                workItemTitle: "Biometric re-auth",
+                url: "https://github.com/acmebank/app/pull/128",
+                signals: ["review_pending"],
+            },
+            // A review requested of you -> "Review ..."
+            {
+                source: "github",
+                kind: "pr_review_requested",
+                timestamp: this.t(20),
+                actor: ACTOR.github,
+                title: "Review PR #130: Refactor request logging",
+                url: "https://github.com/acmebank/app/pull/130",
+                signals: [],
+            },
+        ];
+    }
+}