@nonbot/mcp 0.0.0-stage → 0.2.0

package/dist/core/layout.js

@@ -0,0 +1,193 @@
+import { IP_NODE_SIZE } from './ipShape.js';
+export const PX_PER_WEEK = 120;
+const WEEK_MS = 7 * 24 * 60 * 60 * 1000;
+const ITEM_TOP_HANDLE_X = 8;
+const LANE_GAP_X = 24;
+const ROW_GAP = 32;
+const BLOCK_GAP = 120;
+export const LEVELS = ['objective', 'key-result', 'epic', 'feature', 'story', 'enabler', 'milestone'];
+const DEFAULT_DURATION = { epic: 8, feature: 4, story: 1, enabler: 2, milestone: 0, objective: 12, 'key-result': 12 };
+const DEFAULT_WIDTH = { epic: 280, feature: 260, story: 240, enabler: 240, milestone: 120, objective: 280, 'key-result': 260 };
+const MIN_PAINT = { epic: 360, feature: 360, story: 352, enabler: 352 };
+const HEIGHT = { epic: 265, feature: 265, story: 220, enabler: 220, milestone: 54, objective: 200, 'key-result': 220 };
+const HERO_EXTRA = 150;
+export function calendarStart(now) {
+    const s = new Date(now.getFullYear(), now.getMonth() - 3, 1);
+    const d = s.getDay();
+    s.setDate(s.getDate() + (d === 0 ? -6 : 1 - d));
+    return s;
+}
+const pad = (n) => String(n).padStart(2, '0');
+export const isoDate = (d) => `${d.getFullYear()}-${pad(d.getMonth() + 1)}-${pad(d.getDate())}`;
+function parseIso(s) {
+    if (typeof s !== 'string' || !/^\d{4}-\d{2}-\d{2}$/.test(s))
+        return null;
+    const out = new Date(Number(s.slice(0, 4)), Number(s.slice(5, 7)) - 1, Number(s.slice(8, 10)));
+    return Number.isNaN(out.getTime()) ? null : out;
+}
+export function columnOf(date, now) {
+    return Math.round((date.getTime() - calendarStart(now).getTime()) / WEEK_MS);
+}
+export function dateAtColumn(col, now) {
+    const d = calendarStart(now);
+    d.setDate(d.getDate() + Math.round(col * 7));
+    return d;
+}
+export function todayColumn(now) {
+    return Math.max(0, Math.floor((now.getTime() - calendarStart(now).getTime()) / WEEK_MS));
+}
+export function sprintAtColumn(col) {
+    const c = Math.max(0, col);
+    const L = ['S1', 'S2', 'S3', 'S4', 'S5', 'IP'];
+    return { pi: `PI-${Math.floor(c / 12) + 1}`, sprint: L[Math.floor((c % 12) / 2)] ?? 'S1' };
+}
+export function scheduleFields(col, weeks, now) {
+    const s = sprintAtColumn(col);
+    const e = sprintAtColumn(col + Math.round(weeks));
+    return {
+        durationWeeks: weeks,
+        startDate: isoDate(dateAtColumn(col, now)),
+        endDate: isoDate(dateAtColumn(col + weeks, now)),
+        pi: s.pi, sprint: s.sprint, endPi: e.pi, endSprint: e.sprint,
+    };
+}
+export const levelOf = (n) => LEVELS.includes(n.data?.hierarchyLevel) ? n.data.hierarchyLevel : 'story';
+export const isItem = (n) => n.type === 'portfolio-item';
+export const isIpNode = (n) => n.type === 'rad-module' && n.data?.subtype === 'ip';
+export function layoutTimeline(nodes, opts = {}) {
+    const now = opts.now ?? new Date();
+    const heights = opts.heights ?? {};
+    const items = nodes.filter(isItem);
+    const byId = new Map(items.map(n => [n.id, n]));
+    const positions = new Map();
+    const widthOverride = new Map();
+    const geo = new Map();
+    for (const n of items) {
+        const level = levelOf(n);
+        const start = parseIso(n.data?.startDate);
+        const col = start ? columnOf(start, now) : Math.round((n.position?.x ?? 0) / PX_PER_WEEK);
+        const weeks = typeof n.data?.durationWeeks === 'number' ? n.data.durationWeeks : DEFAULT_DURATION[level];
+        const natural = weeks > 0 ? weeks * PX_PER_WEEK : DEFAULT_WIDTH[level];
+        const min = MIN_PAINT[level] ?? 0;
+        widthOverride.set(n.id, natural < min ? min : null);
+        const hero = Array.isArray(n.data?.pastedImages) && n.data.pastedImages.length > 0;
+        geo.set(n.id, { x: col * PX_PER_WEEK, width: Math.max(natural, min), height: heights[n.id] ?? HEIGHT[level] + (hero && (level === 'epic' || level === 'feature') ? HERO_EXTRA : 0) });
+    }
+    const kids = new Map();
+    for (const n of items) {
+        const p = n.data?.parentItemId;
+        if (p && geo.has(p))
+            kids.set(p, [...(kids.get(p) ?? []), n.id]);
+    }
+    const right = new Map();
+    const paintedRight = (id, depth = 0) => {
+        if (right.has(id))
+            return right.get(id);
+        const g = geo.get(id);
+        let r = g.x + g.width;
+        if (depth < 12)
+            for (const k of kids.get(id) ?? [])
+                r = Math.max(r, paintedRight(k, depth + 1) + 20);
+        right.set(id, r);
+        return r;
+    };
+    for (const [id, g] of geo)
+        g.width = paintedRight(id) - g.x;
+    const epicOf = (n) => {
+        let cur = n;
+        for (let i = 0; cur && i < 12; i++) {
+            if (levelOf(cur) === 'epic')
+                return cur.id;
+            cur = cur.data?.parentItemId ? byId.get(cur.data.parentItemId) : undefined;
+        }
+        return null;
+    };
+    const placeBand = (slots, top) => {
+        const lanes = [];
+        const laneOf = new Map();
+        for (const s of slots) {
+            const free = (i) => !lanes[i] || lanes[i].spans.every(([a, b]) => s.x + s.width + LANE_GAP_X <= a || b + LANE_GAP_X <= s.x);
+            const parentLane = s.from !== undefined ? laneOf.get(s.from) : undefined;
+            let l = 0;
+            if (parentLane !== undefined && free(parentLane))
+                l = parentLane;
+            else
+                while (!free(l))
+                    l++;
+            if (!lanes[l])
+                lanes[l] = { spans: [], height: 0 };
+            lanes[l].spans.push([s.x, s.x + s.width]);
+            lanes[l].height = Math.max(lanes[l].height, s.height);
+            laneOf.set(s.id, l);
+        }
+        const laneY = [];
+        let y = top;
+        lanes.forEach((lane, i) => { laneY[i] = y; y += lane.height + 24; });
+        for (const s of slots)
+            positions.set(s.id, { x: s.x, y: laneY[laneOf.get(s.id)] });
+        return lanes.length ? y - 24 + ROW_GAP : top;
+    };
+    const slot = (id, from) => ({ id, ...geo.get(id), ...(from ? { from } : {}) });
+    const byX = (a, b) => geo.get(a.id).x - geo.get(b.id).x || a.id.localeCompare(b.id);
+    let y = 0;
+    for (const o of items.filter(n => levelOf(n) === 'objective').sort(byX))
+        y = placeBand([slot(o.id)], y);
+    y = placeBand(items.filter(n => levelOf(n) === 'key-result').sort(byX).map(n => slot(n.id)), y);
+    const ipNodes = nodes.filter(isIpNode);
+    const ipFirstSource = new Map();
+    const ipUnplaced = [];
+    for (const n of ipNodes) {
+        const src = (n.data?.attachedItemIds ?? []).find((id) => geo.has(id));
+        if (src)
+            ipFirstSource.set(n.id, src);
+        else
+            ipUnplaced.push(n.id);
+    }
+    const epics = items.filter(n => levelOf(n) === 'epic').sort(byX);
+    const rest = items.filter(n => !['objective', 'key-result', 'epic'].includes(levelOf(n)));
+    for (const epic of [...epics.map(e => e.id), null]) {
+        const inBlock = rest.filter(n => epicOf(n) === epic);
+        const blockIds = new Set([...(epic ? [epic] : []), ...inBlock.map(n => n.id)]);
+        const ips = ipNodes.filter(n => blockIds.has(ipFirstSource.get(n.id) ?? ''));
+        if (!epic && !inBlock.length && !ips.length)
+            continue;
+        if (y > 0)
+            y += BLOCK_GAP - ROW_GAP;
+        if (epic)
+            y = placeBand([slot(epic)], y);
+        if (ips.length) {
+            const src = (id) => geo.get(ipFirstSource.get(id));
+            y = placeBand(ips.map(n => ({ id: n.id, x: src(n.id).x + ITEM_TOP_HANDLE_X - IP_NODE_SIZE.width / 2, width: IP_NODE_SIZE.width, height: IP_NODE_SIZE.height })).sort((a, b) => a.x - b.x), y) - ROW_GAP + 16;
+        }
+        const features = inBlock.filter(n => levelOf(n) === 'feature').sort(byX);
+        const leaves = inBlock.filter(n => levelOf(n) === 'story' || levelOf(n) === 'enabler').sort(byX);
+        const underFeature = (f) => leaves.filter(n => n.data?.parentItemId === f);
+        const pool = features.map(f => slot(f.id));
+        for (const f of features)
+            pool.push(...underFeature(f.id).map(n => slot(n.id, f.id)));
+        const featureIds = new Set(features.map(f => f.id));
+        pool.push(...leaves.filter(n => !featureIds.has(n.data?.parentItemId)).map(n => slot(n.id)));
+        pool.push(...inBlock.filter(n => levelOf(n) === 'milestone').sort(byX).map(n => slot(n.id)));
+        y = placeBand(pool, y);
+    }
+    ipUnplaced.forEach((id, k) => positions.set(id, { x: k * (IP_NODE_SIZE.width + LANE_GAP_X), y: y + BLOCK_GAP }));
+    return { positions, widthOverride };
+}
+export function applyLayout(nodes, res) {
+    return nodes.map(n => {
+        const p = res.positions.get(n.id);
+        if (!p)
+            return n;
+        const out = { ...n, position: { x: Math.round(p.x), y: Math.round(p.y) } };
+        if (res.widthOverride.has(n.id)) {
+            const data = { ...(n.data ?? {}) };
+            const w = res.widthOverride.get(n.id);
+            if (w)
+                data.manualWidthOverride = w;
+            else
+                delete data.manualWidthOverride;
+            out.data = data;
+        }
+        return out;
+    });
+}

package/dist/core/prompts.d.ts

@@ -0,0 +1,3 @@
+import type { McpServer } from '@modelcontextprotocol/sdk/server/mcp.js';
+import type { ApiContext } from './config.js';
+export declare function registerPrompts(server: McpServer, _ctx: ApiContext): void;

package/dist/core/prompts.js

@@ -0,0 +1,45 @@
+import { z } from 'zod';
+export function registerPrompts(server, _ctx) {
+    server.registerPrompt('wsjf_prioritize', {
+        title: 'WSJF-prioritize a portfolio',
+        description: 'Rank a portfolio’s items by Weighted Shortest Job First.',
+        argsSchema: { portfolioId: z.string().describe('Portfolio id (from portfolio_list).') },
+    }, ({ portfolioId }) => ({
+        messages: [
+            {
+                role: 'user',
+                content: {
+                    type: 'text',
+                    text: [
+                        `Load portfolio "${portfolioId}" with the portfolio_get tool.`,
+                        'For each epic and feature, estimate the four WSJF inputs on a relative 1–10 scale:',
+                        'User/Business Value, Time Criticality, Risk Reduction & Opportunity Enablement, and Job Size.',
+                        'Compute WSJF = (Value + Time Criticality + Risk/Opportunity) / Job Size.',
+                        'Return a table ranked by WSJF (highest first) showing each input and the score,',
+                        'then recommend the top 5 to pull next, one line of justification each.',
+                    ].join(' '),
+                },
+            },
+        ],
+    }));
+    server.registerPrompt('decision_check', {
+        title: 'Check a plan against WhyGraph rules',
+        description: 'Evaluate a plan or decision against the team’s committed decisions and LAWs.',
+        argsSchema: { plan: z.string().describe('The plan, change, or decision to check.') },
+    }, ({ plan }) => ({
+        messages: [
+            {
+                role: 'user',
+                content: {
+                    type: 'text',
+                    text: [
+                        `Call whygraph_context with task="${plan}" to load the LAWs and prior decisions that apply.`,
+                        'Evaluate the plan against each. Treat a conflict with a LAW (locked decision) as a blocker;',
+                        'treat tension with a lower-weight decision as a caution. Cite the decision id for every point.',
+                        'If nothing conflicts, say so explicitly and name the decisions you checked against.',
+                    ].join(' '),
+                },
+            },
+        ],
+    }));
+}

package/dist/core/resources.d.ts

@@ -0,0 +1,3 @@
+import { type McpServer } from '@modelcontextprotocol/sdk/server/mcp.js';
+import type { ApiContext } from './config.js';
+export declare function registerResources(server: McpServer, ctx: ApiContext): void;

package/dist/core/resources.js

@@ -0,0 +1,23 @@
+import { ResourceTemplate } from '@modelcontextprotocol/sdk/server/mcp.js';
+import { api, expectJson } from './http.js';
+export function registerResources(server, ctx) {
+    server.registerResource('portfolio', new ResourceTemplate('portfolio://{id}', { list: undefined }), {
+        title: 'Portfolio graph',
+        description: 'The full node/edge graph for one portfolio as JSON. Read portfolio://<id> (id from portfolio_list) to load it directly as context — no tool call needed.',
+        mimeType: 'application/json',
+    }, async (uri, variables) => {
+        const id = String(variables.id);
+        const res = await api(ctx, `/api/portfolio/graph?id=${encodeURIComponent(id)}`);
+        const data = await expectJson(res, 'portfolio resource');
+        return { contents: [{ uri: uri.href, mimeType: 'application/json', text: JSON.stringify(data, null, 2) }] };
+    });
+    server.registerResource('whygraph-decisions', 'whygraph://decisions', {
+        title: 'WhyGraph decisions',
+        description: 'Every PM decision plus the RELATED_TO relationships between them, as JSON.',
+        mimeType: 'application/json',
+    }, async (uri) => {
+        const res = await api(ctx, '/api/whygraph/decisions');
+        const data = await expectJson(res, 'whygraph resource');
+        return { contents: [{ uri: uri.href, mimeType: 'application/json', text: JSON.stringify(data, null, 2) }] };
+    });
+}

package/dist/core/server.d.ts

@@ -0,0 +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.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

@@ -0,0 +1,46 @@
+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 { registerWhygraphTools } from './toolsets/whygraph.js';
+import { registerRunTools } from './toolsets/run.js';
+import { registerMonitorTools } from './toolsets/monitor.js';
+import { registerResources } from './resources.js';
+import { registerPrompts } from './prompts.js';
+export const SERVER_NAME = 'nonbot-mcp';
+export const SERVER_VERSION = '0.2.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',
+    'WHYGRAPH (the PM decision graph — the rules and decisions the team has committed to).',
+    'Read before you write: call the *_list / *_get / *_search tools first.',
+    'BUILDING: portfolio_create makes an empty portfolio; portfolio_add_items adds items of any level',
+    '(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.',
+    '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',
+    'decisions that apply. WhyGraph is read/reasoning-only over this transport.',
+    'MONITORING: run_feed / run_daemon_status / run_machines / run_prompts_list answer',
+    '"what are my runs and daemon doing?"; run_snapshot_request + run_snapshot_get read a',
+    'live run’s terminal output; run_prompt_answer unblocks a waiting run (supervisor',
+    '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.',
+].join(' ');
+export function registerAll(server, ctx) {
+    registerPortfolioTools(server, ctx);
+    registerBuildTools(server, ctx);
+    registerIpTools(server, ctx);
+    registerWhygraphTools(server, ctx);
+    registerRunTools(server, ctx);
+    registerMonitorTools(server, ctx);
+    registerResources(server, ctx);
+    registerPrompts(server, ctx);
+}
+export function createNonbotMcpServer(ctx) {
+    const server = new McpServer({ name: SERVER_NAME, version: SERVER_VERSION }, { instructions: INSTRUCTIONS });
+    registerAll(server, ctx);
+    return server;
+}

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

@@ -0,0 +1,105 @@
+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 & {
+    id: string;
+    type?: string;
+    data?: Record<string, any>;
+};
+type Edge = {
+    id: string;
+    source: string;
+    target: string;
+    [k: string]: unknown;
+};
+interface Graph {
+    name: string;
+    description: string;
+    nodes: Node[];
+    edges: Edge[];
+    viewport: unknown;
+    version?: number;
+}
+export declare const toHtml: (s: string) => string;
+export declare function newItemId(now?: number): string;
+declare const itemSpec: z.ZodObject<{
+    key: z.ZodOptional<z.ZodString>;
+    level: z.ZodEnum<["objective", "key-result", "epic", "feature", "story", "enabler", "milestone"]>;
+    title: z.ZodString;
+    description: z.ZodOptional<z.ZodString>;
+    bluf: z.ZodOptional<z.ZodString>;
+    acceptance_criteria: z.ZodOptional<z.ZodString>;
+    hypothesis: z.ZodOptional<z.ZodString>;
+    state: z.ZodOptional<z.ZodEnum<["funnel", "reviewing", "analyzing", "ready", "implementing", "done"]>>;
+    parent: z.ZodOptional<z.ZodString>;
+    okr: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
+    depends_on: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
+    start_week: z.ZodOptional<z.ZodNumber>;
+    start_date: z.ZodOptional<z.ZodString>;
+    duration_weeks: z.ZodOptional<z.ZodNumber>;
+    tags: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
+    wsjf: z.ZodOptional<z.ZodTuple<[z.ZodNumber, z.ZodNumber, z.ZodNumber, z.ZodNumber], null>>;
+    owner: z.ZodOptional<z.ZodString>;
+    kr_target: z.ZodOptional<z.ZodString>;
+    kr_current: z.ZodOptional<z.ZodString>;
+    okr_status: z.ZodOptional<z.ZodEnum<["on-track", "at-risk", "behind"]>>;
+    images: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
+    fields: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+}, "strip", z.ZodTypeAny, {
+    title: string;
+    level: "epic" | "objective" | "key-result" | "feature" | "story" | "enabler" | "milestone";
+    parent?: string | undefined;
+    description?: string | undefined;
+    acceptance_criteria?: string | undefined;
+    hypothesis?: string | undefined;
+    owner?: string | undefined;
+    key?: string | undefined;
+    bluf?: string | undefined;
+    state?: "done" | "funnel" | "reviewing" | "analyzing" | "ready" | "implementing" | undefined;
+    okr?: string[] | undefined;
+    depends_on?: string[] | undefined;
+    start_week?: number | undefined;
+    start_date?: string | undefined;
+    duration_weeks?: number | undefined;
+    tags?: string[] | undefined;
+    wsjf?: [number, number, number, number] | undefined;
+    kr_target?: string | undefined;
+    kr_current?: string | undefined;
+    okr_status?: "on-track" | "at-risk" | "behind" | undefined;
+    images?: string[] | undefined;
+    fields?: Record<string, unknown> | undefined;
+}, {
+    title: string;
+    level: "epic" | "objective" | "key-result" | "feature" | "story" | "enabler" | "milestone";
+    parent?: string | undefined;
+    description?: string | undefined;
+    acceptance_criteria?: string | undefined;
+    hypothesis?: string | undefined;
+    owner?: string | undefined;
+    key?: string | undefined;
+    bluf?: string | undefined;
+    state?: "done" | "funnel" | "reviewing" | "analyzing" | "ready" | "implementing" | undefined;
+    okr?: string[] | undefined;
+    depends_on?: string[] | undefined;
+    start_week?: number | undefined;
+    start_date?: string | undefined;
+    duration_weeks?: number | undefined;
+    tags?: string[] | undefined;
+    wsjf?: [number, number, number, number] | undefined;
+    kr_target?: string | undefined;
+    kr_current?: string | undefined;
+    okr_status?: "on-track" | "at-risk" | "behind" | undefined;
+    images?: string[] | undefined;
+    fields?: Record<string, unknown> | undefined;
+}>;
+type ItemSpec = z.infer<typeof itemSpec>;
+export declare function buildItems(g: Graph, specs: ItemSpec[], now?: Date): {
+    nodes: Node[];
+    edges: Edge[];
+    ids: Record<string, string>;
+    errors: string[];
+    patched: Map<string, Record<string, any>>;
+};
+export declare function registerBuildTools(server: McpServer, ctx: ApiContext): void;
+export {};