@nonbot/mcp 0.2.3 → 0.3.0

package/dist/core/releases.js

@@ -0,0 +1,280 @@
+export const RELEASE_SUBTYPE = 'release';
+export const RELEASE_KEY = 'releaseId';
+export const DONE_AT_KEY = 'doneAt';
+export const RELEASE_SIZE = { width: 300, height: 184 };
+const dataOf = (n) => (n?.data ?? {});
+export const releaseIdOf = (n) => {
+    const v = dataOf(n)[RELEASE_KEY];
+    return typeof v === 'string' && v ? v : null;
+};
+export function releasesById(modules) {
+    const m = new Map();
+    for (const r of modules)
+        if (r.subtype === RELEASE_SUBTYPE)
+            m.set(r.id, r);
+    return m;
+}
+export const releaseIsOpen = (r) => r.data?.open === true;
+export function isHiddenByRelease(n, releases) {
+    const rid = releaseIdOf(n);
+    if (!rid)
+        return false;
+    const r = releases.get(rid);
+    return !!r && !releaseIsOpen(r);
+}
+export function isFiled(n, releases) {
+    const rid = releaseIdOf(n);
+    return !!rid && releases.has(rid);
+}
+export function membersOf(releaseId, nodes) {
+    return nodes.filter(n => releaseIdOf(n) === releaseId);
+}
+export function subtreeOf(rootIds, nodes, edges = []) {
+    const byParent = new Map();
+    const byId = new Map();
+    for (const n of nodes) {
+        byId.set(n.id, n);
+        const p = dataOf(n).parentItemId;
+        if (typeof p === 'string' && p)
+            (byParent.get(p) ?? byParent.set(p, []).get(p)).push(n.id);
+    }
+    const okr = new Map();
+    for (const e of edges)
+        if ((e.dependencyType ?? e.type) === 'okr-link')
+            (okr.get(e.source) ?? okr.set(e.source, []).get(e.source)).push(e.target);
+    const out = new Set();
+    const stack = [...rootIds];
+    while (stack.length) {
+        const id = stack.pop();
+        if (out.has(id) || !byId.has(id))
+            continue;
+        out.add(id);
+        for (const c of byParent.get(id) ?? [])
+            stack.push(c);
+        const linked = dataOf(byId.get(id)).linkedEpicIds;
+        if (Array.isArray(linked))
+            for (const x of linked)
+                if (typeof x === 'string')
+                    stack.push(x);
+        for (const t of okr.get(id) ?? [])
+            stack.push(t);
+    }
+    return out;
+}
+export const isDone = (n) => dataOf(n).state === 'done';
+export function unfinishedIn(ids, nodes) {
+    const byId = new Map(nodes.map(n => [n.id, n]));
+    const out = [];
+    for (const id of ids) {
+        const n = byId.get(id);
+        if (n && !isDone(n))
+            out.push(id);
+    }
+    return out;
+}
+export function doneAtOf(n, now = Date.now()) {
+    const d = dataOf(n);
+    for (const v of [d.doneAt, d.stateChangedAt, d.updatedAt])
+        if (typeof v === 'number' && Number.isFinite(v) && v > 0)
+            return v;
+    return now;
+}
+export function fileSet(ids, releaseId, nodes, opts = {}) {
+    const byId = new Map(nodes.map(n => [n.id, n]));
+    const out = [];
+    for (const id of ids) {
+        const n = byId.get(id);
+        if (!n)
+            continue;
+        if (opts.onlyDone !== false && !isDone(n))
+            continue;
+        if (releaseIdOf(n) === releaseId)
+            continue;
+        out.push({ id, patch: { releaseId, doneAt: doneAtOf(n, opts.now) } });
+    }
+    return out;
+}
+export function unfileSet(ids, nodes) {
+    const byId = new Map(nodes.map(n => [n.id, n]));
+    const out = [];
+    for (const id of ids)
+        if (releaseIdOf(byId.get(id) ?? { id, data: {} }))
+            out.push({ id, patch: { releaseId: null } });
+    return out;
+}
+export function memberCounts(releaseId, nodes) {
+    const out = {};
+    for (const n of membersOf(releaseId, nodes)) {
+        const lvl = String(dataOf(n).hierarchyLevel ?? 'item');
+        out[lvl] = (out[lvl] ?? 0) + 1;
+    }
+    return out;
+}
+export function previousRelease(from, releases, exceptId) {
+    let best = null;
+    for (const r of releases) {
+        if (r.subtype !== RELEASE_SUBTYPE || r.id === exceptId)
+            continue;
+        const to = String(r.data?.to ?? '');
+        if (!to || to >= from)
+            continue;
+        if (!best || to > String(best.data.to ?? ''))
+            best = r;
+    }
+    return best;
+}
+const iso = (x) => `${x.getFullYear()}-${String(x.getMonth() + 1).padStart(2, '0')}-${String(x.getDate()).padStart(2, '0')}`;
+export function weekWindow(d = new Date()) {
+    const day = (d.getDay() + 6) % 7;
+    const mon = new Date(d);
+    mon.setDate(d.getDate() - day);
+    const sun = new Date(mon);
+    sun.setDate(mon.getDate() + 6);
+    return { from: iso(mon), to: iso(sun) };
+}
+export function releaseOf(n, releases) {
+    const rid = releaseIdOf(n);
+    return (rid && releases.get(rid)) || null;
+}
+export function filedItemIds(nodes, releases) {
+    const out = new Set();
+    if (releases.size === 0)
+        return out;
+    for (const n of nodes)
+        if (isFiled(n, releases))
+            out.add(n.id);
+    return out;
+}
+export function releaseModulesFromGraphNodes(nodes) {
+    const out = new Map();
+    for (const raw of nodes) {
+        const n = raw;
+        if (!n || n.type !== 'rad-module' || typeof n.id !== 'string' || n.data?.subtype !== RELEASE_SUBTYPE)
+            continue;
+        const md = n.data.moduleData;
+        out.set(n.id, { id: n.id, subtype: RELEASE_SUBTYPE, data: md && typeof md === 'object' ? md : {} });
+    }
+    return out;
+}
+export function outTargetsOf(inst) {
+    const list = Array.isArray(inst.outConnectedNodeIds) ? inst.outConnectedNodeIds.filter(Boolean) : [];
+    const single = inst.outConnectedNodeId;
+    const ids = single && !list.includes(single) ? [single, ...list] : [...list];
+    return Array.from(new Set(ids));
+}
+const str = (v) => (typeof v === 'string' ? v : '');
+export function chainWrites(id, all) {
+    const releases = all.filter(r => r.subtype === RELEASE_SUBTYPE);
+    const self = releases.find(r => r.id === id);
+    if (!self)
+        return [];
+    const isRelease = (x) => !!x && releases.some(r => r.id === x);
+    const out = new Map();
+    for (const r of releases) {
+        const t = outTargetsOf(r)[0];
+        out.set(r.id, isRelease(t) ? t : null);
+    }
+    const original = new Map(out);
+    const mine = out.get(id) ?? null;
+    for (const r of releases)
+        if (r.id !== id && out.get(r.id) === id)
+            out.set(r.id, mine === r.id ? null : mine);
+    out.set(id, null);
+    const from = str(self.data.from);
+    const prev = from ? previousRelease(from, releases, id) : null;
+    if (prev) {
+        const next = out.get(prev.id) ?? null;
+        out.set(prev.id, id);
+        out.set(id, next && next !== id ? next : null);
+    }
+    else {
+        const to = str(self.data.to) || from;
+        let next = null;
+        for (const r of releases) {
+            if (r.id === id)
+                continue;
+            const f = str(r.data.from);
+            if (!f || !to || f <= to)
+                continue;
+            if (!next || f < str(next.data.from))
+                next = r;
+        }
+        const fed = next && [...out.entries()].some(([k, v]) => k !== id && v === next.id);
+        if (next && !fed)
+            out.set(id, next.id);
+    }
+    const writes = [];
+    for (const [k, v] of out)
+        if ((original.get(k) ?? null) !== v)
+            writes.push({ id: k, out: v });
+    return writes;
+}
+export function chainReleasesFromGraphNodes(nodes) {
+    const out = [];
+    for (const n of nodes) {
+        if (n.type !== 'rad-module' || n.data?.subtype !== RELEASE_SUBTYPE)
+            continue;
+        const md = n.data.moduleData;
+        out.push({
+            id: n.id, subtype: RELEASE_SUBTYPE, data: md && typeof md === 'object' ? md : {},
+            ...(typeof n.data.outConnectedNodeId === 'string' ? { outConnectedNodeId: n.data.outConnectedNodeId } : {}),
+            ...(Array.isArray(n.data.outConnectedNodeIds) ? { outConnectedNodeIds: n.data.outConnectedNodeIds } : {}),
+        });
+    }
+    return out;
+}
+export function applyChainWrites(nodes, writes) {
+    if (!writes.length)
+        return [...nodes];
+    const w = new Map(writes.map(x => [x.id, x.out]));
+    return nodes.map(n => {
+        if (!w.has(n.id))
+            return n;
+        const { outConnectedNodeId: _o, outConnectedNodeIds: _l, ...rest } = n.data ?? {};
+        const out = w.get(n.id);
+        return { ...n, data: { ...rest, ...(out ? { outConnectedNodeId: out } : {}) } };
+    });
+}
+export function applyItemPatches(nodes, patches) {
+    if (!patches.length)
+        return [...nodes];
+    const p = new Map(patches.map(x => [x.id, x.patch]));
+    return nodes.map(n => (p.has(n.id) ? { ...n, data: { ...(n.data ?? {}), ...p.get(n.id) } } : n));
+}
+export function patchReleaseData(nodes, releaseId, patch) {
+    return nodes.map(n => (n.id === releaseId && n.type === 'rad-module' ? { ...n, data: { ...(n.data ?? {}), moduleData: { ...(n.data?.moduleData ?? {}), ...patch } } } : n));
+}
+export function newReleaseId(now = Date.now()) {
+    return `radmod-${RELEASE_SUBTYPE}-${now}-${Math.random().toString(36).slice(2, 8)}`;
+}
+const overlaps = (a, b) => Math.abs(a.x - b.x) < RELEASE_SIZE.width + 20 && Math.abs(a.y - b.y) < RELEASE_SIZE.height + 20;
+export function placeRelease(nodes, from, prevId, xOfDate) {
+    const cards = nodes.filter(n => n.type === 'portfolio-item');
+    const rels = nodes.filter(n => n.type === 'rad-module' && n.data?.subtype === RELEASE_SUBTYPE);
+    const GAP = 80;
+    const topY = cards.length ? Math.min(...cards.map(n => n.position?.y ?? 0)) : 0;
+    const pos = { x: xOfDate(from), y: topY - RELEASE_SIZE.height - GAP };
+    while (rels.some(r => r.position && overlaps(r.position, pos)))
+        pos.y -= RELEASE_SIZE.height + 24;
+    const freeOf = (n) => n.freePosition ?? n.position ?? { x: 0, y: 0 };
+    const prev = prevId ? rels.find(r => r.id === prevId) : undefined;
+    let free;
+    if (prev)
+        free = { x: freeOf(prev).x + RELEASE_SIZE.width + 60, y: freeOf(prev).y };
+    else {
+        const minX = cards.length ? Math.min(...cards.map(n => freeOf(n).x)) : 0;
+        const minY = cards.length ? Math.min(...cards.map(n => freeOf(n).y)) : 0;
+        free = { x: minX, y: minY - RELEASE_SIZE.height - 120 };
+    }
+    while (rels.some(r => overlaps(freeOf(r), free)))
+        free.x += RELEASE_SIZE.width + 60;
+    return { position: pos, freePosition: free };
+}
+export function releaseNode(id, md, place) {
+    return {
+        id, type: 'rad-module',
+        position: { ...place.position },
+        freePosition: { ...place.freePosition },
+        data: { subtype: RELEASE_SUBTYPE, moduleData: { ...md }, width: RELEASE_SIZE.width, height: RELEASE_SIZE.height },
+    };
+}

package/dist/core/server.d.ts

@@ -1,7 +1,7 @@
 import { McpServer } from '@modelcontextprotocol/sdk/server/mcp.js';
 import type { ApiContext } from './config.js';
 export declare const SERVER_NAME = "nonbot-mcp";
-export declare const SERVER_VERSION = "0.2.3";
+export declare const SERVER_VERSION = "0.3.0";
 export declare const INSTRUCTIONS: string;
 export declare function registerAll(server: McpServer, ctx: ApiContext): void;
 export declare function createNonbotMcpServer(ctx: ApiContext): McpServer;

package/dist/core/server.js

@@ -2,6 +2,7 @@ import { McpServer } from '@modelcontextprotocol/sdk/server/mcp.js';
 import { registerPortfolioTools } from './toolsets/portfolio.js';
 import { registerIpTools } from './toolsets/ip.js';
 import { registerBuildTools } from './toolsets/build.js';
+import { registerReleaseTools } from './toolsets/release.js';
 import { registerWhygraphTools } from './toolsets/whygraph.js';
 import { registerRunTools } from './toolsets/run.js';
 import { registerMonitorTools } from './toolsets/monitor.js';
@@ -9,7 +10,7 @@ import { registerRadbugsTools } from './toolsets/radbugs.js';
 import { registerResources } from './resources.js';
 import { registerPrompts } from './prompts.js';
 export const SERVER_NAME = 'nonbot-mcp';
-export const SERVER_VERSION = '0.2.3';
+export const SERVER_VERSION = '0.3.0';
 export const INSTRUCTIONS = [
     'non.bot MCP — work against the caller’s real product-management data, not a copy.',
     'Two domains: PORTFOLIOS (the SAFe portfolio canvas — epics → features → stories) and',
@@ -19,6 +20,9 @@ export const INSTRUCTIONS = [
     '(parents / OKR links / dependencies by id or by a key from the same call) and lays the Timeline out;',
     'portfolio_patch_item changes one item; portfolio_layout re-lays everything; portfolio_set_meta sets',
     'context text and palette; portfolio_asset_upload stores an image; ip_create adds an IP node over its sources.',
+    'OWNERS: give every feature, story, enabler and milestone an owner so the human can see what is theirs —',
+    'the human’s name for work only a person can do (review or approve a plan, decide, buy, sign in, hand over a key,',
+    'test on a real device), owner "AI" for work an agent delivers (code, tests, migrations, docs, research).',
     'Whole-graph rewrites (restructures, deletes): portfolio_get for the graph + version, then portfolio_update',
     '(pass expectedVersion for safe concurrent editing).',
     'Before a non-trivial decision, call whygraph_context to surface the LAWs and prior',
@@ -29,11 +33,17 @@ export const INSTRUCTIONS = [
     'tokens with the explicit runs:respond scope only).',
     'IP NODES: ip_list / ip_get read a patent or trademark disclosure; ip_update edits it (op list + expected_version);',
     'ip_evidence_add adds evidence the SERVER hashes, timestamps and numbers — never send a hash or a time.',
-    'RADBUGS: radbug_file files a bug into the non.bot radBUGS inbox (needs the radbugs:write scope).',
+    'RELEASES: portfolio_completed_work says what got done in a window (rolled up, each date naming its clock);',
+    'portfolio_rebuild_done_work finds pointers (commits, closed radBUGS, comments) for done cards with no clock;',
+    'portfolio_propose_releases writes DRAFT releases (files nothing) and portfolio_release_approve files a draft\u2019s cards;',
+    'portfolio_release_create / _file / _unfile / _list manage releases directly. Filing never moves a card.',
+    'RADBUGS: radbug_file files a bug into the non.bot radBUGS inbox (needs the radbugs:write scope); radbug_list reads',
+    'them (site owner only).',
 ].join(' ');
 export function registerAll(server, ctx) {
     registerPortfolioTools(server, ctx);
     registerBuildTools(server, ctx);
+    registerReleaseTools(server, ctx);
     registerIpTools(server, ctx);
     registerWhygraphTools(server, ctx);
     registerRunTools(server, ctx);

package/dist/core/style.d.ts

@@ -0,0 +1,31 @@
+import { type Level, type LayoutNode } from './layout.js';
+export declare const CARD_STYLES: readonly ["plain", "poster", "split", "image-top", "cover", "grid-2", "grid-4"];
+export declare const TITLE_SIZES: readonly ["sm", "md", "lg"];
+export declare const ACCENTS: readonly ["tint", "bar", "plain"];
+export declare const SHOW_KEYS: readonly ["bluf", "description", "acceptanceCriteria", "tags", "dates", "wsjf"];
+export declare const STATES: readonly ["funnel", "reviewing", "analyzing", "ready", "implementing", "done"];
+export interface StyleRule {
+    levels?: Level[];
+    states?: string[];
+    ids?: string[];
+    hasImage?: boolean;
+    artifacts?: boolean;
+    display?: {
+        cardStyle?: (typeof CARD_STYLES)[number];
+        titleSize?: (typeof TITLE_SIZES)[number];
+        accent?: (typeof ACCENTS)[number];
+        show?: Partial<Record<(typeof SHOW_KEYS)[number], boolean>>;
+    };
+    size?: {
+        width: number;
+        height: number;
+    } | 'auto';
+    satellites?: 'close';
+}
+export interface StyleResult<T> {
+    nodes: T[];
+    matched: number;
+    changed: number;
+    perRule: number[];
+}
+export declare function applyStyleRules<T extends LayoutNode>(nodes: T[], rules: StyleRule[]): StyleResult<T>;

package/dist/core/style.js

@@ -0,0 +1,64 @@
+import { LEVELS } from './layout.js';
+export const CARD_STYLES = ['plain', 'poster', 'split', 'image-top', 'cover', 'grid-2', 'grid-4'];
+export const TITLE_SIZES = ['sm', 'md', 'lg'];
+export const ACCENTS = ['tint', 'bar', 'plain'];
+export const SHOW_KEYS = ['bluf', 'description', 'acceptanceCriteria', 'tags', 'dates', 'wsjf'];
+export const STATES = ['funnel', 'reviewing', 'analyzing', 'ready', 'implementing', 'done'];
+const hasImage = (n) => Array.isArray(n.data?.pastedImages) && n.data.pastedImages.length > 0;
+function matches(rule, n) {
+    if (n.type !== 'portfolio-item')
+        return false;
+    if (n.data?.childCardType && !rule.artifacts)
+        return false;
+    const level = LEVELS.includes(n.data?.hierarchyLevel) ? n.data.hierarchyLevel : 'story';
+    if (rule.levels && !rule.levels.includes(level))
+        return false;
+    if (rule.states && !rule.states.includes(String(n.data?.state ?? 'funnel')))
+        return false;
+    if (rule.ids && !rule.ids.includes(n.id))
+        return false;
+    if (rule.hasImage !== undefined && hasImage(n) !== rule.hasImage)
+        return false;
+    return true;
+}
+export function applyStyleRules(nodes, rules) {
+    const perRule = rules.map(() => 0);
+    const touched = new Set();
+    let changed = 0;
+    const out = nodes.map(n => {
+        let data = null;
+        rules.forEach((rule, i) => {
+            if (!matches(rule, n))
+                return;
+            perRule[i]++;
+            touched.add(n.id);
+            data ??= { ...(n.data ?? {}) };
+            if (rule.display) {
+                const prev = (data.nodeDisplay && typeof data.nodeDisplay === 'object') ? data.nodeDisplay : {};
+                const next = { ...prev };
+                if (rule.display.cardStyle)
+                    next.cardStyle = rule.display.cardStyle;
+                if (rule.display.titleSize)
+                    next.titleSize = rule.display.titleSize;
+                if (rule.display.accent)
+                    next.accent = rule.display.accent;
+                if (rule.display.show)
+                    next.show = { ...(prev.show ?? {}), ...rule.display.show };
+                data.nodeDisplay = next;
+            }
+            if (rule.size === 'auto')
+                delete data.canvasSize;
+            else if (rule.size)
+                data.canvasSize = { width: Math.round(rule.size.width), height: Math.round(rule.size.height) };
+            if (rule.satellites === 'close')
+                data.innerLoopExpanded = false;
+        });
+        if (!data)
+            return n;
+        if (JSON.stringify(data) === JSON.stringify(n.data ?? {}))
+            return n;
+        changed++;
+        return { ...n, data };
+    });
+    return { nodes: out, matched: touched.size, changed, perRule };
+}

package/dist/core/toolsets/build.d.ts

@@ -2,18 +2,18 @@ import { z } from 'zod';
 import type { McpServer } from '@modelcontextprotocol/sdk/server/mcp.js';
 import type { ApiContext } from '../config.js';
 import { type LayoutNode } from '../layout.js';
-type Node = LayoutNode & {
+export type Node = LayoutNode & {
     id: string;
     type?: string;
     data?: Record<string, any>;
 };
-type Edge = {
+export type Edge = {
     id: string;
     source: string;
     target: string;
     [k: string]: unknown;
 };
-interface Graph {
+export interface Graph {
     name: string;
     description: string;
     nodes: Node[];
@@ -23,6 +23,14 @@ interface Graph {
 }
 export declare const toHtml: (s: string) => string;
 export declare function newItemId(now?: number): string;
+export declare function loadGraph(ctx: ApiContext, id: string): Promise<Graph>;
+export declare function saveGraph(ctx: ApiContext, id: string, before: Graph, after: Graph, expectedVersion?: number): Promise<{
+    ok: true;
+    version?: number;
+} | {
+    ok: false;
+    message: string;
+}>;
 declare const itemSpec: z.ZodObject<{
     key: z.ZodOptional<z.ZodString>;
     level: z.ZodEnum<{
@@ -67,6 +75,11 @@ declare const itemSpec: z.ZodObject<{
     fields: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
 }, z.core.$strip>;
 type ItemSpec = z.infer<typeof itemSpec>;
+export declare const AI_OWNER = "AI";
+export declare function ownerReport(specs: Array<Pick<ItemSpec, 'key' | 'level' | 'title' | 'owner'>>): {
+    owners: Record<string, number>;
+    unassigned: string[];
+};
 export declare function buildItems(g: Graph, specs: ItemSpec[], now?: Date): {
     nodes: Node[];
     edges: Edge[];