@nonbot/mcp 0.2.3 → 0.3.0

package/dist/core/toolsets/release.js

@@ -0,0 +1,329 @@
+import { z } from 'zod';
+import { checkRepoPath } from '../config.js';
+import { api, expectJson } from '../http.js';
+import { loadGraph, saveGraph, toHtml } from './build.js';
+import { fetchRadbugs } from './radbugs.js';
+import { columnOf, PX_PER_WEEK } from '../layout.js';
+import { RELEASE_SUBTYPE, applyChainWrites, applyItemPatches, chainReleasesFromGraphNodes, chainWrites, fileSet, memberCounts, membersOf, newReleaseId, outTargetsOf, patchReleaseData, placeRelease, previousRelease, releaseIdOf, releaseNode, subtreeOf, unfileSet, unfinishedIn, } from '../releases.js';
+import { clocklessDone, completedWork, matchEvidence, proposeReleases, toMs, windowMs } from '../completedWork.js';
+const DATE = z.string().regex(/^\d{4}-\d{2}-\d{2}$/, 'YYYY-MM-DD');
+const MAX_PROPOSALS = 120;
+const text = (obj) => ({ type: 'text', text: JSON.stringify(obj, null, 2) });
+const fail = (msg) => ({ content: [{ type: 'text', text: msg }], isError: true });
+const ok = (structured) => ({ content: [text(structured)], structuredContent: structured });
+const items = (g) => g.nodes.filter(n => n.type === 'portfolio-item');
+const localDay = (s) => new Date(Number(s.slice(0, 4)), Number(s.slice(5, 7)) - 1, Number(s.slice(8, 10)));
+const xOfDate = (now) => (iso) => columnOf(localDay(iso), now) * PX_PER_WEEK;
+const findRelease = (g, id) => g.nodes.find(n => n.id === id && n.type === 'rad-module' && n.data?.subtype === RELEASE_SUBTYPE);
+const titleOf = (n) => String(n?.data?.title ?? '');
+function addRelease(nodes, md, now) {
+    const id = newReleaseId(now.getTime());
+    const prev = previousRelease(md.from, chainReleasesFromGraphNodes(nodes));
+    const node = releaseNode(id, md, placeRelease(nodes, md.from, prev?.id ?? null, xOfDate(now)));
+    const withNode = [...nodes, node];
+    return { nodes: applyChainWrites(withNode, chainWrites(id, chainReleasesFromGraphNodes(withNode))), id, prev: prev?.id ?? null };
+}
+function nextOf(nodes, id) {
+    const n = nodes.find(x => x.id === id);
+    return n ? (outTargetsOf(n.data ?? {})[0] ?? null) : null;
+}
+const versionOf = (r) => (r.version !== undefined ? { version: r.version } : {});
+export function registerReleaseTools(server, ctx) {
+    server.registerTool('portfolio_completed_work', {
+        title: 'What got done',
+        description: 'The done items of a portfolio in a date window, computed from the graph: each row names its done date and the clock it came from (doneAt — stamped when filed, stateChangedAt — the state clock, updatedAt — only the last edit, a proxy; none = unknown), rolled up objective → key result → epic → feature → story. Parents that are NOT done but hold done work are flagged partially_done and never counted. Cards already filed in a release are left out unless include_filed. Window ends are inclusive local days; with a window, done cards with no clock at all are listed as undated.',
+        inputSchema: {
+            portfolio_id: z.string(),
+            from: DATE.optional(),
+            to: DATE.optional(),
+            include_filed: z.boolean().optional().describe('Default false: cards filed in a release are already accounted for.'),
+        },
+        annotations: { readOnlyHint: true, openWorldHint: true },
+    }, async (a) => {
+        if (a.from && a.to && a.to < a.from)
+            return fail('to is before from.');
+        const g = await loadGraph(ctx, a.portfolio_id);
+        const r = completedWork(g.nodes, g.edges, { from: a.from, to: a.to, includeFiled: a.include_filed });
+        return ok({ window: { from: a.from ?? null, to: a.to ?? null }, ...r });
+    });
+    server.registerTool('portfolio_rebuild_done_work', {
+        title: 'Find when forgotten work finished',
+        description: 'For every done card with no finish clock (no doneAt, no stateChangedAt), gather POINTERS — not verdicts — to when it finished: commits in the local git repo at repo_path (since `since`) that cite the card id or a radBUGS id tied to the card; closed radBUGS tied to it (owner-only — needs radbug_list access); the card\'s own comments. Each card gets a proposal: the latest commit / closed-radBUG date, else the latest comment, else unknown. Writes nothing; to keep a proposal, set the card\'s doneAt with portfolio_patch_item (set: { doneAt: <epoch ms> }), then portfolio_propose_releases.',
+        inputSchema: {
+            portfolio_id: z.string(),
+            since: DATE.describe('Look at commits, radBUGS and comments from this day on.'),
+            repo_path: z.string().max(1024).optional().describe('Absolute path of a local git checkout (stdio only). portfolio_repo_path tells you the saved one.'),
+            radbugs: z.boolean().optional().describe('Default true: read closed radBUGS (owner-only; skipped with a note otherwise).'),
+            comments: z.boolean().optional().describe('Default true: read each card\'s comments (one request per card).'),
+            max_cards: z.number().int().min(1).max(300).optional().describe('Default 100: cards examined, most recently edited first.'),
+        },
+        annotations: { readOnlyHint: true, openWorldHint: true },
+    }, async (a) => {
+        if (a.repo_path !== undefined) {
+            const bad = checkRepoPath(a.repo_path);
+            if (bad)
+                return fail(bad);
+        }
+        const g = await loadGraph(ctx, a.portfolio_id);
+        const all = clocklessDone(g.nodes);
+        const upd = (n) => (typeof n.data?.updatedAt === 'number' ? n.data.updatedAt : 0);
+        const cards = [...all].sort((x, y) => upd(y) - upd(x) || x.id.localeCompare(y.id)).slice(0, a.max_cards ?? 100);
+        const { lo } = windowMs(a.since);
+        const sources = {};
+        let commits = [];
+        if (!a.repo_path)
+            sources.git = 'not requested — pass repo_path';
+        else if (!ctx.gitLog)
+            sources.git = 'unavailable — this server has no local disk (use the stdio server)';
+        else {
+            try {
+                commits = await ctx.gitLog(a.repo_path, a.since);
+                sources.git = `${commits.length} commit(s) since ${a.since}`;
+            }
+            catch (e) {
+                sources.git = `failed — ${e instanceof Error ? e.message.slice(0, 200) : 'git error'}`;
+            }
+        }
+        let radbugs = [];
+        if (a.radbugs === false)
+            sources.radbugs = 'not requested';
+        else {
+            const r = await fetchRadbugs(ctx, { status: 'done' });
+            if (r.forbidden)
+                sources.radbugs = `skipped — ${r.reason}`;
+            else {
+                radbugs = r.notes.filter(b => (b.updatedAt ?? b.createdAt ?? 0) >= lo);
+                sources.radbugs = `${radbugs.length} closed radBUG(s) since ${a.since}`;
+            }
+        }
+        const comments = new Map();
+        if (a.comments === false)
+            sources.comments = 'not requested';
+        else {
+            let failed = 0;
+            const queue = [...cards];
+            const worker = async () => {
+                for (let c = queue.shift(); c; c = queue.shift()) {
+                    try {
+                        const res = await api(ctx, `/api/portfolio/comments?portfolioId=${encodeURIComponent(a.portfolio_id)}&itemId=${encodeURIComponent(c.id)}`);
+                        const body = await expectJson(res, 'comments');
+                        comments.set(c.id, (Array.isArray(body.comments) ? body.comments : []).filter(x => (toMs(x.createdAt) ?? 0) >= lo));
+                    }
+                    catch {
+                        failed++;
+                    }
+                }
+            };
+            await Promise.all(Array.from({ length: Math.min(4, cards.length) }, worker));
+            sources.comments = `read for ${cards.length - failed} card(s)${failed ? `, ${failed} failed` : ''}`;
+        }
+        const out = cards.map(c => {
+            const m = matchEvidence(c, { commits, radbugs, comments: comments.get(c.id) ?? [] });
+            return { id: c.id, title: titleOf(c), level: String(c.data?.hierarchyLevel ?? ''), proposal: m.proposal, evidence: m.evidence };
+        });
+        const known = out.filter(c => c.proposal.basis !== 'unknown').length;
+        return ok({ clockless_done: all.length, examined: cards.length, with_evidence: known, unknown: cards.length - known, sources, cards: out });
+    });
+    server.registerTool('portfolio_release_list', {
+        title: 'List releases',
+        description: 'The releases of a portfolio, oldest first: id, name, from–to window, draft / approvedAt / open, the chain (previous / next release by the OUT wire), member counts by level, and for a draft the cards it proposes. include_members lists each release\'s filed cards (id, title, level, doneAt).',
+        inputSchema: { portfolio_id: z.string(), include_members: z.boolean().optional() },
+        annotations: { readOnlyHint: true, openWorldHint: true },
+    }, async (a) => {
+        const g = await loadGraph(ctx, a.portfolio_id);
+        const cards = items(g);
+        const nodes = g.nodes;
+        const rels = g.nodes.filter(n => n.type === 'rad-module' && n.data?.subtype === RELEASE_SUBTYPE);
+        const prevOf = new Map();
+        for (const r of rels) {
+            const t = outTargetsOf(r.data ?? {})[0];
+            if (t)
+                prevOf.set(t, r.id);
+        }
+        const list = rels.map(r => {
+            const md = (r.data?.moduleData ?? {});
+            const proposed = Array.isArray(md.proposed) ? md.proposed.filter((x) => typeof x === 'string') : [];
+            return {
+                id: r.id, name: String(md.name ?? ''), from: String(md.from ?? ''), to: String(md.to ?? ''),
+                draft: md.draft === true, ...(typeof md.approvedAt === 'number' ? { approvedAt: md.approvedAt } : {}), open: md.open === true,
+                summary: String(md.summary ?? '').slice(0, 2000), ...(Array.isArray(md.highlights) ? { highlights: md.highlights } : {}),
+                previous: prevOf.get(r.id) ?? null, next: nextOf(nodes, r.id),
+                counts: memberCounts(r.id, cards),
+                ...(md.draft === true ? { proposed } : {}),
+                ...(a.include_members ? { members: membersOf(r.id, cards).map(n => ({ id: n.id, title: titleOf(n), level: String(n.data?.hierarchyLevel ?? ''), doneAt: n.data?.doneAt ?? null })) } : {}),
+            };
+        }).sort((x, y) => x.from.localeCompare(y.from) || x.to.localeCompare(y.to));
+        return ok({ releases: list, ...(g.version !== undefined ? { version: g.version } : {}) });
+    });
+    if (ctx.readonly)
+        return;
+    server.registerTool('portfolio_propose_releases', {
+        title: 'Propose releases',
+        description: 'Write DRAFT releases for done work that is not filed yet: one per calendar week (Mon–Sun, by each card\'s done date) and — unless objective_releases is false — one per finished objective, holding it and its done subtree. Each draft lists the cards it proposes (moduleData.proposed); NOTHING is filed and no card is touched until the draft is approved (portfolio_release_approve, or Accept in the app). Drafts are chained by date like any release. Cards already proposed by another draft and cards with no done clock are skipped and listed. One versioned write.',
+        inputSchema: {
+            portfolio_id: z.string(),
+            from: DATE.optional().describe('Only work done on or after this day.'),
+            to: DATE.optional().describe('Only work done on or before this day.'),
+            objective_releases: z.boolean().optional().describe('Default true: a finished objective gets its own release.'),
+            expected_version: z.number().int().optional(),
+        },
+        annotations: { readOnlyHint: false, destructiveHint: false, idempotentHint: false, openWorldHint: true },
+    }, async (a) => {
+        if (a.from && a.to && a.to < a.from)
+            return fail('to is before from.');
+        const g = await loadGraph(ctx, a.portfolio_id);
+        const p = proposeReleases(g.nodes, g.edges, { from: a.from, to: a.to, objectiveReleases: a.objective_releases });
+        const report = { undated: p.undated, already_proposed: p.already_proposed, filed_skipped: p.filed_skipped };
+        if (!p.drafts.length)
+            return ok({ ok: true, created: [], ...report });
+        if (p.drafts.length > MAX_PROPOSALS)
+            return fail(`That would be ${p.drafts.length} drafts (limit ${MAX_PROPOSALS}) — narrow the window with from / to.`);
+        const now = new Date();
+        let nodes = g.nodes;
+        const created = [];
+        for (const d of p.drafts) {
+            const r = addRelease(nodes, { name: d.name, from: d.from, to: d.to, summary: '', draft: true, open: false, proposed: d.proposed }, now);
+            nodes = r.nodes;
+            created.push({ id: r.id, kind: d.kind, name: d.name, from: d.from, to: d.to, proposed: d.proposed.length, ...(d.objective_id ? { objective_id: d.objective_id } : {}) });
+        }
+        const s = await saveGraph(ctx, a.portfolio_id, g, { ...g, nodes: nodes }, a.expected_version);
+        if (!s.ok)
+            return fail(s.message);
+        return ok({ ok: true, created, ...report, ...versionOf(s) });
+    });
+    server.registerTool('portfolio_release_create', {
+        title: 'Create a release',
+        description: 'Add one release (a Release node) covering from–to, chained after the release whose window ends latest before it starts (and before the one that starts next), placed above the cards on the Timeline at its date and beside the release it follows on the Map. Its summary is for a business reader (plain text or HTML; outcomes before features). File cards into it with portfolio_release_file. One versioned write.',
+        inputSchema: {
+            portfolio_id: z.string(),
+            name: z.string().min(1).max(200),
+            from: DATE,
+            to: DATE,
+            summary: z.string().max(20000).optional(),
+            highlights: z.array(z.string().max(300)).max(20).optional(),
+            expected_version: z.number().int().optional(),
+        },
+        outputSchema: { id: z.string(), previous: z.string().nullable(), next: z.string().nullable(), version: z.number().optional() },
+        annotations: { readOnlyHint: false, destructiveHint: false, idempotentHint: false, openWorldHint: true },
+    }, async (a) => {
+        if (a.to < a.from)
+            return fail('to is before from.');
+        const g = await loadGraph(ctx, a.portfolio_id);
+        const md = { name: a.name, from: a.from, to: a.to, summary: a.summary ? toHtml(a.summary) : '', draft: false, open: false, ...(a.highlights?.length ? { highlights: a.highlights } : {}) };
+        const r = addRelease(g.nodes, md, new Date());
+        const s = await saveGraph(ctx, a.portfolio_id, g, { ...g, nodes: r.nodes }, a.expected_version);
+        if (!s.ok)
+            return fail(s.message);
+        return ok({ id: r.id, previous: r.prev, next: nextOf(r.nodes, r.id), ...versionOf(s) });
+    });
+    server.registerTool('portfolio_release_file', {
+        title: 'File cards into a release',
+        description: 'File cards into a release, each WITH its subtree (children by parent; from an objective, its key results\' linked epics). Only done cards are filed unless only_done is false (open ones are listed as left_open). A card in another release moves; a card already in this one is skipped. Filing never moves a card or touches its parent, edges or position: it sets releaseId and stamps doneAt once (doneAt ?? stateChangedAt ?? updatedAt). Refuses a DRAFT release (approve it first). One versioned write.',
+        inputSchema: {
+            portfolio_id: z.string(),
+            release_id: z.string(),
+            item_ids: z.array(z.string()).min(1).max(500),
+            only_done: z.boolean().optional().describe('Default true — "file the done parts only".'),
+            expected_version: z.number().int().optional(),
+        },
+        annotations: { readOnlyHint: false, destructiveHint: false, idempotentHint: true, openWorldHint: true },
+    }, async (a) => {
+        const g = await loadGraph(ctx, a.portfolio_id);
+        const rel = findRelease(g, a.release_id);
+        if (!rel)
+            return fail(`${a.release_id} is not a release in this portfolio.`);
+        if (rel.data?.moduleData?.draft === true)
+            return fail('That release is a draft — approve it first (portfolio_release_approve); a draft files nothing.');
+        const cards = items(g);
+        const known = new Set(cards.map(n => n.id));
+        const missing = a.item_ids.filter(id => !known.has(id));
+        if (missing.length)
+            return fail(`Not cards in this portfolio: ${missing.join(', ')}`);
+        const ids = [...subtreeOf(a.item_ids, cards, g.edges)];
+        const patches = fileSet(ids, a.release_id, cards, { onlyDone: a.only_done });
+        const leftOpen = a.only_done === false ? [] : unfinishedIn(ids, cards);
+        const moved = patches.filter(p => releaseIdOf(cards.find(n => n.id === p.id)) !== null).map(p => p.id);
+        const already = ids.filter(id => releaseIdOf(cards.find(n => n.id === id)) === a.release_id);
+        const report = { filed: patches.length, filed_ids: patches.map(p => p.id), moved_from_other_release: moved, already_in_release: already, left_open: leftOpen };
+        if (!patches.length)
+            return ok({ ok: true, ...report });
+        const s = await saveGraph(ctx, a.portfolio_id, g, { ...g, nodes: applyItemPatches(g.nodes, patches) }, a.expected_version);
+        if (!s.ok)
+            return fail(s.message);
+        return ok({ ok: true, ...report, ...versionOf(s) });
+    });
+    server.registerTool('portfolio_release_unfile', {
+        title: 'Un-file cards',
+        description: 'Take cards out of their release: item_ids (exactly those cards — no subtree), or release_id for every member of one release. Clears releaseId and KEEPS doneAt (a fact about the card, not the release); nothing else changes. One versioned write.',
+        inputSchema: {
+            portfolio_id: z.string(),
+            item_ids: z.array(z.string()).min(1).max(500).optional(),
+            release_id: z.string().optional().describe('Un-file every member of this release.'),
+            expected_version: z.number().int().optional(),
+        },
+        annotations: { readOnlyHint: false, destructiveHint: false, idempotentHint: true, openWorldHint: true },
+    }, async (a) => {
+        if (!a.item_ids === !a.release_id)
+            return fail('Pass item_ids or release_id (one of them).');
+        const g = await loadGraph(ctx, a.portfolio_id);
+        const cards = items(g);
+        let ids;
+        if (a.release_id) {
+            if (!findRelease(g, a.release_id))
+                return fail(`${a.release_id} is not a release in this portfolio.`);
+            ids = membersOf(a.release_id, cards).map(n => n.id);
+        }
+        else {
+            const known = new Set(cards.map(n => n.id));
+            const missing = a.item_ids.filter(id => !known.has(id));
+            if (missing.length)
+                return fail(`Not cards in this portfolio: ${missing.join(', ')}`);
+            ids = a.item_ids;
+        }
+        const patches = unfileSet(ids, cards);
+        if (!patches.length)
+            return ok({ ok: true, unfiled: 0, unfiled_ids: [] });
+        const s = await saveGraph(ctx, a.portfolio_id, g, { ...g, nodes: applyItemPatches(g.nodes, patches) }, a.expected_version);
+        if (!s.ok)
+            return fail(s.message);
+        return ok({ ok: true, unfiled: patches.length, unfiled_ids: patches.map(p => p.id), ...versionOf(s) });
+    });
+    server.registerTool('portfolio_release_approve', {
+        title: 'Approve a draft release',
+        description: 'Turn a DRAFT release into a release: files exactly the cards it proposes (still-done ones; each keeps its parent, edges and position, gets releaseId and doneAt once) and sets draft false, approvedAt now and proposed empty — all in one versioned write. Optionally set its name, summary (for a business reader; plain text or HTML) and highlights in the same write. Proposed cards no longer done or no longer present are listed as not_filed.',
+        inputSchema: {
+            portfolio_id: z.string(),
+            release_id: z.string(),
+            name: z.string().min(1).max(200).optional(),
+            summary: z.string().max(20000).optional(),
+            highlights: z.array(z.string().max(300)).max(20).optional(),
+            expected_version: z.number().int().optional(),
+        },
+        annotations: { readOnlyHint: false, destructiveHint: false, idempotentHint: false, openWorldHint: true },
+    }, async (a) => {
+        const g = await loadGraph(ctx, a.portfolio_id);
+        const rel = findRelease(g, a.release_id);
+        if (!rel)
+            return fail(`${a.release_id} is not a release in this portfolio.`);
+        const md = (rel.data?.moduleData ?? {});
+        if (md.draft !== true)
+            return fail('That release is not a draft — nothing to approve.');
+        const proposed = Array.isArray(md.proposed) ? md.proposed.filter((x) => typeof x === 'string') : [];
+        const cards = items(g);
+        const patches = fileSet(proposed, a.release_id, cards);
+        const filed = new Set(patches.map(p => p.id));
+        const notFiled = proposed.filter(id => !filed.has(id) && releaseIdOf(cards.find(n => n.id === id) ?? { id }) !== a.release_id);
+        const modPatch = { draft: false, approvedAt: Date.now(), proposed: [] };
+        if (a.name !== undefined)
+            modPatch.name = a.name;
+        if (a.summary !== undefined)
+            modPatch.summary = toHtml(a.summary);
+        if (a.highlights !== undefined)
+            modPatch.highlights = a.highlights;
+        const nodes = patchReleaseData(applyItemPatches(g.nodes, patches), a.release_id, modPatch);
+        const s = await saveGraph(ctx, a.portfolio_id, g, { ...g, nodes }, a.expected_version);
+        if (!s.ok)
+            return fail(s.message);
+        return ok({ ok: true, release_id: a.release_id, filed: patches.length, filed_ids: patches.map(p => p.id), not_filed: notFiled, ...versionOf(s) });
+    });
+}

package/dist/gitLog.d.ts

@@ -0,0 +1,3 @@
+import { type GitCommit } from './core/config.js';
+export declare function gitLog(repoPath: string, since: string): Promise<GitCommit[]>;
+export declare function parseGitLog(out: string): GitCommit[];

package/dist/gitLog.js

@@ -0,0 +1,46 @@
+import { execFile } from 'node:child_process';
+import { stat } from 'node:fs/promises';
+import { resolve } from 'node:path';
+import { checkRepoPath } from './core/config.js';
+const MAX_COMMITS = 5000;
+const BODY_MAX = 2000;
+const FS = '\x1f';
+const RS = '\x1e';
+export async function gitLog(repoPath, since) {
+    const bad = checkRepoPath(repoPath);
+    if (bad)
+        throw new Error(bad);
+    if (!/^\d{4}-\d{2}-\d{2}$/.test(since))
+        throw new Error('since must be YYYY-MM-DD');
+    const dir = resolve(repoPath);
+    const st = await stat(dir).catch(() => null);
+    if (!st || !st.isDirectory())
+        throw new Error('repo_path is not a directory');
+    const args = [
+        '-c', 'core.fsmonitor=false', '-c', 'log.showSignature=false',
+        '-C', dir, 'log', `--since=${since}`, `--max-count=${MAX_COMMITS}`, '--no-color',
+        `--format=%H${FS}%cI${FS}%s${FS}%b${RS}`,
+    ];
+    const out = await new Promise((ok, fail) => {
+        execFile('git', args, { timeout: 20_000, maxBuffer: 32 * 1024 * 1024, env: { ...process.env, GIT_TERMINAL_PROMPT: '0' }, windowsHide: true }, (err, stdout) => {
+            if (err)
+                fail(new Error('git log failed — is repo_path a git repository?'));
+            else
+                ok(stdout);
+        });
+    });
+    return parseGitLog(out);
+}
+export function parseGitLog(out) {
+    const commits = [];
+    for (const rec of out.split(RS)) {
+        const r = rec.replace(/^\s+/, '');
+        if (!r)
+            continue;
+        const [hash = '', date = '', subject = '', body = ''] = r.split(FS);
+        if (!/^[0-9a-f]{7,64}$/.test(hash))
+            continue;
+        commits.push({ hash, date, subject, body: body.trim().slice(0, BODY_MAX) });
+    }
+    return commits;
+}

package/dist/stdio.js

@@ -5,6 +5,7 @@ import { dirname, join, resolve } from 'node:path';
 import { StdioServerTransport } from '@modelcontextprotocol/sdk/server/stdio.js';
 import { resolveApiBase } from './core/config.js';
 import { createNonbotMcpServer } from './core/server.js';
+import { gitLog } from './gitLog.js';
 const BACKUP_DIR = join(homedir(), '.non.bot', 'backups');
 async function tokenFromCliAuth() {
     try {
@@ -61,6 +62,7 @@ async function main() {
         readonly: process.env.NON_BOT_MCP_READONLY === '1',
         backup: fileBackup,
         readLocalImage,
+        gitLog,
     };
     const server = createNonbotMcpServer(ctx);
     const transport = new StdioServerTransport();

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@nonbot/mcp",
-  "version": "0.2.3",
+  "version": "0.3.0",
   "type": "module",
   "description": "The non.bot MCP server — one server for your portfolios, decision graph, and Runs. Runs over stdio (Claude Code, Cursor, VS Code) with a pat_ token. Built on MCP protocol 2025-11-25.",
   "keywords": [