standup-mcp 0.1.0

package/dist/config.js

@@ -0,0 +1,67 @@
+/**
+ * Configuration resolved from environment variables.
+ *
+ * Design choice (same as the demo-first philosophy that makes adoption easy):
+ * the server NEVER hard-fails on missing credentials. Each source is wired up
+ * independently, and if NONE are configured (or STANDUP_DEMO_MODE=true) the
+ * server transparently runs on a synthetic multi-source dataset. So
+ * `npx standup-mcp --demo` produces a real standup in seconds with zero setup.
+ *
+ * Everything is read-only. No credential here grants write access, and the
+ * server makes no LLM calls of its own.
+ */
+function clean(value) {
+    const trimmed = value?.trim();
+    return trimmed ? trimmed : undefined;
+}
+export function loadConfig(env = process.env) {
+    const displayName = clean(env.STANDUP_NAME);
+    const forceDemo = clean(env.STANDUP_DEMO_MODE)?.toLowerCase() === "true";
+    const githubToken = clean(env.GITHUB_TOKEN) ?? clean(env.GH_TOKEN);
+    const github = githubToken
+        ? { token: githubToken }
+        : undefined;
+    const jiraBase = clean(env.JIRA_BASE_URL)?.replace(/\/+$/, "");
+    const jiraEmail = clean(env.JIRA_EMAIL);
+    const jiraToken = clean(env.JIRA_API_TOKEN);
+    const jira = jiraBase && jiraEmail && jiraToken
+        ? { baseUrl: jiraBase, email: jiraEmail, apiToken: jiraToken }
+        : undefined;
+    const linearKey = clean(env.LINEAR_API_KEY);
+    const linear = linearKey
+        ? { apiKey: linearKey }
+        : undefined;
+    const slackToken = clean(env.SLACK_TOKEN) ?? clean(env.SLACK_BOT_TOKEN);
+    const slackChannels = clean(env.SLACK_CHANNELS)
+        ?.split(",")
+        .map((c) => c.trim())
+        .filter(Boolean);
+    const slack = slackToken
+        ? { token: slackToken, channels: slackChannels }
+        : undefined;
+    const anyConfigured = Boolean(github || jira || linear || slack);
+    if (forceDemo || !anyConfigured) {
+        return { demoMode: true, displayName };
+    }
+    return { demoMode: false, displayName, github, jira, linear, slack };
+}
+/** Which sources are wired up in this config (empty in demo mode). */
+export function configuredSources(config) {
+    const out = [];
+    if (config.github)
+        out.push("github");
+    if (config.jira)
+        out.push("jira");
+    if (config.linear)
+        out.push("linear");
+    if (config.slack)
+        out.push("slack");
+    return out;
+}
+/** One-line human summary of how the server is configured, for logs. */
+export function describeConfig(config) {
+    if (config.demoMode) {
+        return "demo mode (synthetic data, no source credentials configured)";
+    }
+    return `live mode across ${configuredSources(config).join(", ")}`;
+}

package/dist/demo.js

@@ -0,0 +1,93 @@
+/**
+ * `--demo` mode: render every tool against the synthetic dataset and print to
+ * stdout, then exit. This is what makes `npx standup-mcp --demo` show a real
+ * standup in a plain terminal instead of starting a stdio server that silently
+ * waits for an MCP client.
+ *
+ * `--check` mode: verify each configured live connection end to end.
+ */
+import { MockProvider } from "./sources/mock.js";
+import { createProvider } from "./provider.js";
+import { describeConfig, loadConfig } from "./config.js";
+import { resolveWindow, lastNDaysWindow } from "./window.js";
+import { buildStandupDraft } from "./analytics/draft.js";
+import { detectBlockers, formatBlockerReport } from "./analytics/blockers.js";
+import { buildDigest } from "./analytics/digest.js";
+import { buildWeeklySummary } from "./analytics/weekly.js";
+function divider(title) {
+    const bar = "=".repeat(66);
+    return `\n${bar}\n  ${title}\n${bar}`;
+}
+export async function runDemo() {
+    const nowMs = Date.now();
+    const now = new Date(nowMs);
+    const provider = new MockProvider(nowMs);
+    const actor = await provider.resolveActor();
+    const window = resolveWindow({}, now);
+    const events = await provider.fetchActivity();
+    const openItems = await provider.fetchOpenItems();
+    const nowIso = now.toISOString();
+    const out = [];
+    out.push("standup-mcp demo. Synthetic GitHub + Jira + Linear + Slack activity, no credentials needed.");
+    out.push("This is the output your AI assistant gets back from each tool.");
+    out.push(divider("standup_draft"));
+    out.push(buildStandupDraft({ actor, window, events, openItems, nowIso, isDemo: true }));
+    out.push(divider("blocker_scan"));
+    out.push(formatBlockerReport(detectBlockers(events, openItems, nowIso), window, true));
+    out.push(divider("activity_digest"));
+    out.push(buildDigest(events, window, true));
+    out.push(divider("weekly_summary"));
+    out.push(buildWeeklySummary(events, lastNDaysWindow(7, now), actor, true));
+    out.push("\n" + "-".repeat(66));
+    out.push("Next steps:");
+    out.push("  Connect your tools: set GITHUB_TOKEN, JIRA_BASE_URL/JIRA_EMAIL/JIRA_API_TOKEN, LINEAR_API_KEY, SLACK_TOKEN.");
+    out.push("  Use it in Claude Desktop, Cursor, Cline, and other MCP clients.");
+    out.push("  Docs: https://github.com/sathvic-kollu/standup-mcp");
+    console.log(out.join("\n"));
+}
+export async function runCheck() {
+    const config = loadConfig();
+    if (config.demoMode) {
+        console.log("No source credentials configured, so there is nothing to check.");
+        console.log("Set GITHUB_TOKEN, JIRA_BASE_URL/JIRA_EMAIL/JIRA_API_TOKEN, LINEAR_API_KEY, or SLACK_TOKEN, then run --check again.");
+        console.log("To see sample output on demo data instead, run: standup-mcp --demo");
+        return;
+    }
+    console.log(`Checking ${describeConfig(config)} ...`);
+    const provider = createProvider(config);
+    const statuses = await provider.checkConnections();
+    let anyFail = false;
+    for (const s of statuses) {
+        const mark = s.ok ? "ok " : "FAIL";
+        console.log(`  [${mark}] ${s.source}: ${s.detail}`);
+        if (!s.ok)
+            anyFail = true;
+    }
+    if (anyFail) {
+        console.error("\nOne or more sources failed. Fix the token or URL and run --check again.");
+        process.exitCode = 1;
+    }
+    else {
+        console.log("\nAll configured sources connected. standup-mcp is ready to use.");
+    }
+}
+export function printHelp() {
+    console.log([
+        "standup-mcp. Generate your daily standup from real activity across",
+        "GitHub, Jira, Linear, and Slack.",
+        "",
+        "Usage:",
+        "  standup-mcp            Start the MCP server on stdio (for an MCP client).",
+        "  standup-mcp --demo     Print a sample standup from synthetic data, then exit.",
+        "  standup-mcp --check    Verify your configured live connections.",
+        "  standup-mcp --help     Show this help.",
+        "",
+        "Configure any subset of sources (read-only tokens):",
+        "  GITHUB_TOKEN",
+        "  JIRA_BASE_URL, JIRA_EMAIL, JIRA_API_TOKEN",
+        "  LINEAR_API_KEY",
+        "  SLACK_TOKEN",
+        "With none set, the server runs on built-in demo data.",
+        "Docs: https://github.com/sathvic-kollu/standup-mcp",
+    ].join("\n"));
+}

package/dist/format.js

@@ -0,0 +1,66 @@
+/**
+ * Small markdown helpers so every tool returns output you can paste straight
+ * into Slack, Geekbot, a standup doc, or a ticket comment.
+ */
+const MONTHS = [
+    "Jan", "Feb", "Mar", "Apr", "May", "Jun",
+    "Jul", "Aug", "Sep", "Oct", "Nov", "Dec",
+];
+const DAYS = ["Sun", "Mon", "Tue", "Wed", "Thu", "Fri", "Sat"];
+/** "Jun 16". UTC, to match window math. */
+export function fmtDate(iso) {
+    if (!iso)
+        return "n/a";
+    const d = new Date(iso);
+    if (Number.isNaN(d.getTime()))
+        return "n/a";
+    return `${MONTHS[d.getUTCMonth()]} ${d.getUTCDate()}`;
+}
+/** "Mon Jun 16". */
+export function fmtDayDate(iso) {
+    if (!iso)
+        return "n/a";
+    const d = new Date(iso);
+    if (Number.isNaN(d.getTime()))
+        return "n/a";
+    return `${DAYS[d.getUTCDay()]} ${MONTHS[d.getUTCMonth()]} ${d.getUTCDate()}`;
+}
+/** "9:30am". UTC. */
+export function fmtTime(iso) {
+    if (!iso)
+        return "";
+    const d = new Date(iso);
+    if (Number.isNaN(d.getTime()))
+        return "";
+    let h = d.getUTCHours();
+    const m = d.getUTCMinutes().toString().padStart(2, "0");
+    const ap = h < 12 ? "am" : "pm";
+    h = h % 12 || 12;
+    return `${h}:${m}${ap}`;
+}
+export function plural(n, one, many = `${one}s`) {
+    return `${n} ${n === 1 ? one : many}`;
+}
+/** Whole days between two ISO timestamps (b - a), never negative. */
+export function daysBetween(aIso, bIso) {
+    const a = Date.parse(aIso);
+    const b = Date.parse(bIso);
+    if (Number.isNaN(a) || Number.isNaN(b))
+        return 0;
+    return Math.max(0, Math.floor((b - a) / 86_400_000));
+}
+export function bullets(items) {
+    return items.length ? items.map((i) => `- ${i}`).join("\n") : "_none_";
+}
+export function heading(level, text) {
+    return `${"#".repeat(level)} ${text}`;
+}
+const SOURCE_LABEL = {
+    github: "GitHub",
+    jira: "Jira",
+    linear: "Linear",
+    slack: "Slack",
+};
+export function sourceLabel(s) {
+    return SOURCE_LABEL[s];
+}

package/dist/index.js

@@ -0,0 +1,63 @@
+#!/usr/bin/env node
+/**
+ * standup-mcp entry point.
+ *
+ * A Model Context Protocol server that generates your daily standup from real
+ * activity across GitHub, Jira, Linear, and Slack, over stdio. Runs in demo
+ * mode automatically when no source credentials are configured.
+ *
+ * Local and read-only: the server makes no LLM calls and needs no AI API key.
+ * The host AI client supplies the model; the only credentials are read-only
+ * source tokens, and nothing leaves the machine except calls to those APIs.
+ */
+import { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
+import { StdioServerTransport } from "@modelcontextprotocol/sdk/server/stdio.js";
+import { describeConfig, loadConfig } from "./config.js";
+import { createProvider } from "./provider.js";
+import { registerAllTools } from "./tools/registry.js";
+import { printHelp, runCheck, runDemo } from "./demo.js";
+export const SERVER_NAME = "standup-mcp";
+export const SERVER_VERSION = "0.1.0";
+export function buildServer(deps) {
+    const server = new McpServer({
+        name: SERVER_NAME,
+        version: SERVER_VERSION,
+    });
+    registerAllTools(server, deps);
+    return server;
+}
+async function main() {
+    const args = process.argv.slice(2);
+    if (args.includes("--help") || args.includes("-h")) {
+        printHelp();
+        return;
+    }
+    if (args.includes("--demo") || args.includes("demo")) {
+        await runDemo();
+        return;
+    }
+    if (args.includes("--check") || args.includes("check")) {
+        await runCheck();
+        return;
+    }
+    const config = loadConfig();
+    const provider = createProvider(config);
+    const server = buildServer({ provider, config });
+    const transport = new StdioServerTransport();
+    await server.connect(transport);
+    // Logs must go to stderr; stdout is the MCP protocol channel.
+    console.error(`${SERVER_NAME} v${SERVER_VERSION} running in ${describeConfig(config)}`);
+    // If a person ran this directly in a terminal (stdin is a TTY, so no MCP
+    // client is driving it), tell them what to do instead of appearing to hang.
+    if (process.stdin.isTTY) {
+        console.error("\nThis is an MCP server. It is now waiting for a client on stdin.\n" +
+            "To see a sample standup instead, run:  npx standup-mcp --demo\n" +
+            "To use it, add it to an MCP client (Claude Desktop, Cursor, Cline):\n" +
+            "  https://github.com/sathvic-kollu/standup-mcp\n" +
+            "Press Ctrl+C to exit.");
+    }
+}
+main().catch((err) => {
+    console.error("Fatal error starting standup-mcp:", err);
+    process.exit(1);
+});

package/dist/normalize.js

@@ -0,0 +1,101 @@
+/**
+ * Shared, pure normalization helpers used by every source client and by the
+ * demo provider. The risky, heuristic parsing lives here in one place so it can
+ * be unit tested in isolation (test/normalize.test.ts).
+ */
+// --- Work-item key extraction --------------------------------------------
+//
+// The whole point of grouping "by work item, not by tool" is tying a GitHub
+// branch/PR/commit back to its Jira or Linear ticket. Keys look like PROJ-412
+// or ENG-45: an uppercase project prefix, a dash, and a number.
+const KEY_RE = /\b([A-Z][A-Z0-9]{1,9})-(\d{1,6})\b/g;
+// Common non-ticket tokens that match the key shape (UTF-8, SHA-256, ...).
+// Excluding these removes the bulk of false positives in commit messages.
+const KEY_DENYLIST = new Set([
+    "UTF",
+    "SHA",
+    "MD",
+    "AES",
+    "RSA",
+    "ISO",
+    "RFC",
+    "IPV",
+    "IP",
+    "HTTP",
+    "HTTPS",
+    "TLS",
+    "SSL",
+    "EC",
+    "ES",
+    "CVE",
+    "PR",
+    "CI",
+    "CD",
+    "API",
+    "URL",
+    "UUID",
+    "BASE",
+    "X",
+]);
+/**
+ * Return the first plausible work-item key in a string (branch name, PR title,
+ * commit message), or undefined. Keys are uppercased and the prefix is checked
+ * against a denylist of look-alike tokens.
+ */
+export function extractWorkItemKey(text) {
+    if (!text)
+        return undefined;
+    KEY_RE.lastIndex = 0;
+    let m;
+    while ((m = KEY_RE.exec(text)) !== null) {
+        const prefix = m[1].toUpperCase();
+        if (KEY_DENYLIST.has(prefix))
+            continue;
+        return `${prefix}-${m[2]}`;
+    }
+    return undefined;
+}
+// --- Language signals -----------------------------------------------------
+const BLOCKED_RE = /\b(blocked|blocker|waiting on|waiting for|stuck|can'?t (?:repro|reproduce|get|access)|depends? on|dependency on|need(?:s|ed)? (?:access|creds|credentials|approval)|on hold)\b/i;
+const HELP_RE = /\b(can someone|anyone (?:know|have)|need help|any ideas|help needed|pls help|please help|how do i|not sure how)\b/i;
+/** Signals implied by free text (commit body, comment, Slack message). */
+export function detectTextSignals(text) {
+    if (!text)
+        return [];
+    const out = [];
+    if (BLOCKED_RE.test(text))
+        out.push("blocked");
+    if (HELP_RE.test(text))
+        out.push("help_requested");
+    return out;
+}
+// --- Noise suppression ----------------------------------------------------
+const MERGE_COMMIT_RE = /^(merge (branch|pull request|remote-tracking)|merge ")/i;
+const TRIVIAL_COMMIT_RE = /^(bump version|update (package-lock|yarn\.lock|pnpm-lock|changelog)|wip\b|fixup!|squash!|amend\b)/i;
+/** True for merge commits and trivial churn that should not appear in a standup. */
+export function isNoiseCommit(message) {
+    if (!message)
+        return false;
+    const first = firstLine(message).trim();
+    return MERGE_COMMIT_RE.test(first) || TRIVIAL_COMMIT_RE.test(first);
+}
+const BOT_RE = /\[bot\]$|^(dependabot|renovate|github-actions|snyk-bot)\b/i;
+/** True for automation accounts whose activity is not the user's work. */
+export function isBotActor(login) {
+    if (!login)
+        return false;
+    return BOT_RE.test(login);
+}
+// --- Small text utilities -------------------------------------------------
+export function firstLine(text) {
+    const idx = text.indexOf("\n");
+    return idx === -1 ? text : text.slice(0, idx);
+}
+export function truncate(text, max = 140) {
+    const clean = text.replace(/\s+/g, " ").trim();
+    return clean.length <= max ? clean : clean.slice(0, max - 1).trimEnd() + "…";
+}
+/** Title-case a bare verb phrase for a clean leading word, e.g. "merged" -> "Merged". */
+export function cap(text) {
+    return text.length ? text[0].toUpperCase() + text.slice(1) : text;
+}

package/dist/provider.js

@@ -0,0 +1,76 @@
+/**
+ * Builds the activity provider from config and fans every request out to the
+ * configured sources. Tools never construct sources themselves; they take an
+ * ActivityProvider, which keeps them identical across live and demo modes.
+ *
+ * Resilience matters here: one source being misconfigured or rate-limited must
+ * not sink the whole standup. Each source's failures are swallowed per call so
+ * the user still gets a draft from whatever did respond. Use --check to see
+ * which connections are actually healthy.
+ */
+import { MockProvider } from "./sources/mock.js";
+import { GithubSource } from "./sources/github.js";
+import { JiraSource } from "./sources/jira.js";
+import { LinearSource } from "./sources/linear.js";
+import { SlackSource } from "./sources/slack.js";
+export function createProvider(config) {
+    if (config.demoMode)
+        return new MockProvider();
+    const clients = [];
+    if (config.github)
+        clients.push(new GithubSource(config.github));
+    if (config.jira)
+        clients.push(new JiraSource(config.jira));
+    if (config.linear)
+        clients.push(new LinearSource(config.linear));
+    if (config.slack)
+        clients.push(new SlackSource(config.slack));
+    return new LiveProvider(clients, config);
+}
+class LiveProvider {
+    clients;
+    config;
+    isDemo = false;
+    sources;
+    constructor(clients, config) {
+        this.clients = clients;
+        this.config = config;
+        this.sources = clients.map((c) => c.id);
+    }
+    async resolveActor() {
+        const actor = { displayName: this.config.displayName ?? "you" };
+        await Promise.all(this.clients.map(async (c) => {
+            try {
+                const id = await c.resolveIdentity();
+                if (id)
+                    actor[c.id] = id;
+            }
+            catch {
+                // Leave this source's identity unset; it just won't match events.
+            }
+        }));
+        // Without an explicit name, fall back to the GitHub handle (the one
+        // human-readable identity we resolve) rather than a bare "you".
+        if (!this.config.displayName && actor.github) {
+            actor.displayName = actor.github;
+        }
+        return actor;
+    }
+    async fetchActivity(window, actor) {
+        const batches = await Promise.all(this.clients.map((c) => c.fetchActivity(window, actor).catch(() => [])));
+        return batches
+            .flat()
+            .sort((a, b) => Date.parse(a.timestamp) - Date.parse(b.timestamp));
+    }
+    async fetchOpenItems(actor) {
+        const batches = await Promise.all(this.clients.map((c) => c.fetchOpenItems(actor).catch(() => [])));
+        return batches.flat();
+    }
+    async checkConnections() {
+        return Promise.all(this.clients.map((c) => c.checkConnection().catch((e) => ({
+            source: c.id,
+            ok: false,
+            detail: e instanceof Error ? e.message : String(e),
+        }))));
+    }
+}

package/dist/sources/github.js

@@ -0,0 +1,192 @@
+/**
+ * Live GitHub source. Implements ActivitySource against the GitHub REST API
+ * (https://api.github.com) with a personal-access-token bearer credential.
+ *
+ * Read-only: every call is a GET against /user or the search endpoints. We use
+ * search (issues for PRs, commits for commits) rather than per-repo listing so
+ * one query spans every repo the token can see, which is what a standup needs.
+ * Each search slice is wrapped so a single failing query degrades gracefully
+ * instead of sinking the whole fetch.
+ */
+import { extractWorkItemKey, firstLine, isNoiseCommit } from "../normalize.js";
+const API_BASE = "https://api.github.com";
+const REQUEST_TIMEOUT_MS = 30_000;
+export class GithubSource {
+    creds;
+    id = "github";
+    isDemo = false;
+    constructor(creds) {
+        this.creds = creds;
+    }
+    // --- HTTP plumbing -------------------------------------------------------
+    async request(path) {
+        const url = path.startsWith("http") ? path : `${API_BASE}${path}`;
+        const controller = new AbortController();
+        const timer = setTimeout(() => controller.abort(), REQUEST_TIMEOUT_MS);
+        try {
+            const res = await fetch(url, {
+                method: "GET",
+                headers: {
+                    Authorization: `Bearer ${this.creds.token}`,
+                    Accept: "application/vnd.github+json",
+                    "X-GitHub-Api-Version": "2022-11-28",
+                    "User-Agent": "standup-mcp",
+                },
+                signal: controller.signal,
+            });
+            if (!res.ok) {
+                const body = await res.text().catch(() => "");
+                throw new Error(`GitHub 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(`GitHub API request timed out after 30s: ${path}`);
+            }
+            throw err;
+        }
+        finally {
+            clearTimeout(timer);
+        }
+    }
+    /** Build a /search/{kind} path with a safely-encoded query string. */
+    searchPath(kind, q, perPage) {
+        const params = new URLSearchParams({
+            q,
+            per_page: String(perPage),
+        });
+        return `/search/${kind}?${params.toString()}`;
+    }
+    /**
+     * Run one PR (issues) search and map each hit to an event. The five PR
+     * searches differ only in query, kind, title verb, timestamp, and signals,
+     * so the request + map + per-slice skip-on-failure lives here once.
+     */
+    async searchIssueEvents(q, perPage, toEvent) {
+        try {
+            const res = await this.request(this.searchPath("issues", q, perPage));
+            return res.items.map(toEvent);
+        }
+        catch {
+            return []; // One failing query must not sink the whole fetch.
+        }
+    }
+    // --- Identity ------------------------------------------------------------
+    async resolveIdentity() {
+        const user = await this.request("/user");
+        return user.login;
+    }
+    async checkConnection() {
+        try {
+            const login = await this.resolveIdentity();
+            return {
+                source: "github",
+                ok: true,
+                identity: login,
+                detail: `authenticated as ${login}`,
+            };
+        }
+        catch (err) {
+            return {
+                source: "github",
+                ok: false,
+                detail: err instanceof Error ? err.message : String(err),
+            };
+        }
+    }
+    // --- Activity ------------------------------------------------------------
+    async fetchActivity(window, actor) {
+        const login = actor.github ?? (await this.resolveIdentity());
+        const sinceDate = window.since.slice(0, 10); // YYYY-MM-DD
+        const sinceMs = Date.parse(window.since);
+        const events = [];
+        // Opened PRs.
+        events.push(...(await this.searchIssueEvents(`type:pr author:${login} created:>=${sinceDate}`, 50, (item) => ({
+            source: "github",
+            kind: "pr_opened",
+            timestamp: item.created_at,
+            actor: login,
+            title: `Opened PR #${item.number}: ${item.title}`,
+            workItem: extractWorkItemKey(item.title),
+            url: item.html_url,
+            signals: [],
+        }))));
+        // Merged PRs.
+        events.push(...(await this.searchIssueEvents(`type:pr author:${login} is:merged merged:>=${sinceDate}`, 50, (item) => ({
+            source: "github",
+            kind: "pr_merged",
+            timestamp: item.closed_at ?? item.updated_at,
+            actor: login,
+            title: `Merged PR #${item.number}: ${item.title}`,
+            workItem: extractWorkItemKey(item.title),
+            url: item.html_url,
+            signals: [],
+        }))));
+        // Reviewed PRs (someone else's, where you left a review).
+        events.push(...(await this.searchIssueEvents(`type:pr reviewed-by:${login} -author:${login} updated:>=${sinceDate}`, 50, (item) => ({
+            source: "github",
+            kind: "pr_reviewed",
+            timestamp: item.updated_at,
+            actor: login,
+            title: `Reviewed PR #${item.number}: ${item.title}`,
+            workItem: extractWorkItemKey(item.title),
+            url: item.html_url,
+            signals: [],
+        }))));
+        // Commits. Different response shape: no number, message under .commit.
+        try {
+            const res = await this.request(this.searchPath("commits", `author:${login} author-date:>=${sinceDate}`, 50));
+            for (const item of res.items) {
+                const message = item.commit.message;
+                if (isNoiseCommit(message))
+                    continue;
+                events.push({
+                    source: "github",
+                    kind: "commit",
+                    timestamp: item.commit.author.date,
+                    actor: login,
+                    title: firstLine(message),
+                    workItem: extractWorkItemKey(message),
+                    url: item.html_url,
+                    signals: [],
+                });
+            }
+        }
+        catch {
+            // Skip this slice.
+        }
+        // The date-granular qualifiers admit events from earlier on sinceDate;
+        // keep only those at or after the precise window start. Since-only by spec.
+        return events.filter((e) => Date.parse(e.timestamp) >= sinceMs);
+    }
+    // --- Open items ----------------------------------------------------------
+    async fetchOpenItems(actor) {
+        const login = actor.github ?? (await this.resolveIdentity());
+        const events = [];
+        // Your open PRs. A non-draft open PR is awaiting review.
+        events.push(...(await this.searchIssueEvents(`type:pr author:${login} state:open`, 30, (item) => ({
+            source: "github",
+            kind: "pr_opened",
+            timestamp: item.updated_at,
+            actor: login,
+            title: `Opened PR #${item.number}: ${item.title}`,
+            workItem: extractWorkItemKey(item.title),
+            url: item.html_url,
+            signals: item.draft ? [] : ["review_pending"],
+        }))));
+        // Reviews requested of you.
+        events.push(...(await this.searchIssueEvents(`type:pr review-requested:${login} state:open`, 30, (item) => ({
+            source: "github",
+            kind: "pr_review_requested",
+            timestamp: item.updated_at,
+            actor: login,
+            title: `Review PR #${item.number}: ${item.title}`,
+            workItem: extractWorkItemKey(item.title),
+            url: item.html_url,
+            signals: [],
+        }))));
+        return events;
+    }
+}