@getmarrow/mcp 2.3.3 → 2.3.4

package/dist/index.d.ts

@@ -1,109 +1,2 @@
-export interface ActionableInsight {
-    type: 'frequency' | 'failure_pattern' | 'workflow_gap' | 'hive_trend';
-    summary: string;
-    action: string;
-    severity: 'info' | 'warning' | 'critical';
-    count: number;
-}
-export interface MarrowIntelligence {
-    similar: Array<{
-        outcome: string;
-        confidence: number;
-    }>;
-    similar_count: number;
-    patterns: Array<{
-        pattern_id: string;
-        decision_type: string;
-        frequency: number;
-        confidence: number;
-    }>;
-    patterns_count: number;
-    templates: Array<{
-        steps: unknown[];
-        success_rate: number;
-    }>;
-    shared: Array<{
-        outcome: string;
-    }>;
-    causal_chain: unknown | null;
-    success_rate: number;
-    priority_score: number;
-    insight: string | null;
-    insights: ActionableInsight[];
-    cluster_id: string | null;
-}
-export interface ThinkResult {
-    decision_id: string;
-    intelligence: MarrowIntelligence;
-    stream_url: string;
-    previous_committed?: boolean;
-    sanitized?: boolean;
-    upgrade_hint?: {
-        message: string;
-        tier: string;
-        url: string;
-    };
-}
-export interface CommitResult {
-    committed: boolean;
-    success_rate: number;
-    insight: string | null;
-}
-export interface StatusResult {
-    status: string;
-    version: string;
-    tiers: number;
-    uptime_ms: number;
-}
-export declare function marrowThink(apiKey: string, baseUrl: string, params: {
-    action: string;
-    type?: string;
-    context?: Record<string, unknown>;
-    previous_decision_id?: string;
-    previous_success?: boolean;
-    previous_outcome?: string;
-}): Promise<ThinkResult>;
-export declare function marrowCommit(apiKey: string, baseUrl: string, params: {
-    decision_id: string;
-    success: boolean;
-    outcome: string;
-    caused_by?: string;
-}): Promise<CommitResult>;
-export interface AgentPatternsResult {
-    failure_patterns: Array<{
-        decision_type: string;
-        failure_rate: number;
-        count: number;
-        last_seen: string;
-    }>;
-    recurring_decisions: Array<{
-        decision_type: string;
-        frequency: number;
-        avg_confidence: number;
-        trend: string;
-    }>;
-    behavioral_drift: {
-        success_rate_7d: number;
-        success_rate_30d: number;
-        drift: string;
-        direction: string;
-    };
-    top_failure_types: string[];
-    generated_at: string;
-}
-export declare function marrowAgentPatterns(apiKey: string, baseUrl: string, params?: {
-    type?: string;
-    limit?: number;
-}): Promise<AgentPatternsResult>;
-export declare function marrowOrient(apiKey: string, baseUrl: string, params?: {
-    taskType?: string;
-}): Promise<{
-    warnings: Array<{
-        type: string;
-        failureRate: number;
-        message: string;
-    }>;
-    shouldPause: boolean;
-}>;
-export declare function marrowStatus(apiKey: string, baseUrl: string): Promise<StatusResult>;
-//# sourceMappingURL=index.d.ts.map
+#!/usr/bin/env node
+export {};

package/dist/index.js

@@ -1,87 +1,129 @@
+#!/usr/bin/env node
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.marrowStatus = exports.marrowOrient = exports.marrowAgentPatterns = exports.marrowCommit = exports.marrowThink = void 0;
-async function marrowThink(apiKey, baseUrl, params) {
-    const body = {
-        action: params.action,
-        type: params.type || 'general',
-    };
-    if (params.context)
-        body.context = params.context;
-    if (params.previous_decision_id) {
-        body.previous_decision_id = params.previous_decision_id;
-        body.previous_success = params.previous_success ?? true;
-        body.previous_outcome = params.previous_outcome ?? '';
-    }
-    const res = await fetch(`${baseUrl}/v1/agent/think`, {
-        method: 'POST',
-        headers: {
-            'Authorization': `Bearer ${apiKey}`,
-            'Content-Type': 'application/json',
-        },
-        body: JSON.stringify(body),
-    });
-    const json = await res.json();
-    if (json.error)
-        throw new Error(json.error);
-    return json.data;
+/**
+ * Marrow MCP Server — decision intelligence for AI agents
+ * Protocol: MCP 1.0 (JSON-RPC over stdio)
+ */
+const mcp_js_1 = require("@modelcontextprotocol/sdk/server/mcp.js");
+const stdio_js_1 = require("@modelcontextprotocol/sdk/server/stdio.js");
+const client_js_1 = require("./client.js");
+const think_js_1 = require("./tools/think.js");
+const commit_js_1 = require("./tools/commit.js");
+const patterns_js_1 = require("./tools/patterns.js");
+const orient_js_1 = require("./tools/orient.js");
+const check_js_1 = require("./tools/check.js");
+const zod_1 = require("zod");
+const server = new mcp_js_1.McpServer({
+    name: 'marrow',
+    version: '1.1.0',
+});
+let client;
+try {
+    client = new client_js_1.MarrowClient();
 }
-exports.marrowThink = marrowThink;
-async function marrowCommit(apiKey, baseUrl, params) {
-    const res = await fetch(`${baseUrl}/v1/agent/commit`, {
-        method: 'POST',
-        headers: {
-            'Authorization': `Bearer ${apiKey}`,
-            'Content-Type': 'application/json',
-        },
-        body: JSON.stringify(params),
-    });
-    const json = await res.json();
-    if (json.error)
-        throw new Error(json.error);
-    return json.data;
+catch (e) {
+    console.error(e instanceof Error ? e.message : 'Failed to initialize Marrow client');
+    process.exit(1);
 }
-exports.marrowCommit = marrowCommit;
-async function marrowAgentPatterns(apiKey, baseUrl, params) {
-    const qs = new URLSearchParams();
-    if (params?.type)
-        qs.set('type', params.type);
-    if (params?.limit)
-        qs.set('limit', String(params.limit));
-    const url = `${baseUrl}/v1/agent/patterns${qs.toString() ? '?' + qs.toString() : ''}`;
-    const res = await fetch(url, { headers: { 'Authorization': `Bearer ${apiKey}` } });
-    const json = await res.json();
-    if (json.error)
-        throw new Error(json.error);
-    return json.data;
-}
-exports.marrowAgentPatterns = marrowAgentPatterns;
-// Session orientation — MUST be called first at every session/task start.
-// Returns failure warnings + lessons so agent avoids known mistakes before acting.
-// This closes the write-only gap: orient() makes Marrow compound instead of just log.
-async function marrowOrient(apiKey, baseUrl, params) {
-    const patterns = await marrowAgentPatterns(apiKey, baseUrl, params?.taskType ? { type: params.taskType } : undefined);
-    const warnings = patterns.failure_patterns
-        .filter((p) => p.failure_rate > 0.15)
-        .map((p) => ({
-        type: p.decision_type,
-        failureRate: p.failure_rate,
-        message: `${p.decision_type} has ${Math.round(p.failure_rate * 100)}% failure rate over ${p.count} decisions — review lessons before acting`,
-    }));
-    return {
-        warnings,
-        shouldPause: warnings.some((w) => w.failureRate > 0.4),
-    };
-}
-exports.marrowOrient = marrowOrient;
-async function marrowStatus(apiKey, baseUrl) {
-    const res = await fetch(`${baseUrl}/v1/health`, {
-        headers: { 'Authorization': `Bearer ${apiKey}` },
-    });
-    const json = await res.json();
-    if (json.error)
-        throw new Error(json.error);
-    return json.data;
-}
-exports.marrowStatus = marrowStatus;
-//# sourceMappingURL=index.js.map
+server.tool(orient_js_1.orientTool.name, orient_js_1.orientTool.description, {
+    task_type: zod_1.z.string().optional().describe('Optional task type: implementation, security, process, architecture, deployment'),
+}, async (args) => {
+    try {
+        return await (0, orient_js_1.handleOrient)(client, args);
+    }
+    catch (e) {
+        return { isError: true, content: [{ type: 'text', text: e instanceof Error ? e.message : 'Unknown error' }] };
+    }
+});
+server.tool(orient_js_1.orientAliasTool.name, orient_js_1.orientAliasTool.description, {
+    task_type: zod_1.z.string().optional().describe('Optional task type: implementation, security, process, architecture, deployment'),
+}, async (args) => {
+    try {
+        return await (0, orient_js_1.handleOrient)(client, args);
+    }
+    catch (e) {
+        return { isError: true, content: [{ type: 'text', text: e instanceof Error ? e.message : 'Unknown error' }] };
+    }
+});
+server.tool(think_js_1.thinkTool.name, think_js_1.thinkTool.description, {
+    action: zod_1.z.string().describe('What you are about to do or just did'),
+    type: zod_1.z.string().describe('Decision type: implementation, security, process, architecture, deployment'),
+    previous_decision_id: zod_1.z.string().optional().describe('ID from previous think() call'),
+    previous_success: zod_1.z.boolean().optional().describe('Did the previous action succeed?'),
+    previous_outcome: zod_1.z.string().optional().describe('One line outcome of previous action (max 2000 chars)'),
+}, async (args) => {
+    try {
+        return await (0, think_js_1.handleThink)(client, args);
+    }
+    catch (e) {
+        return { isError: true, content: [{ type: 'text', text: e instanceof Error ? e.message : 'Unknown error' }] };
+    }
+});
+server.tool(think_js_1.thinkAliasTool.name, think_js_1.thinkAliasTool.description, {
+    action: zod_1.z.string().describe('What you are about to do or just did'),
+    type: zod_1.z.string().describe('Decision type: implementation, security, process, architecture, deployment'),
+    previous_decision_id: zod_1.z.string().optional().describe('ID from previous think() call'),
+    previous_success: zod_1.z.boolean().optional().describe('Did the previous action succeed?'),
+    previous_outcome: zod_1.z.string().optional().describe('One line outcome of previous action (max 2000 chars)'),
+}, async (args) => {
+    try {
+        return await (0, think_js_1.handleThink)(client, args);
+    }
+    catch (e) {
+        return { isError: true, content: [{ type: 'text', text: e instanceof Error ? e.message : 'Unknown error' }] };
+    }
+});
+server.tool(commit_js_1.commitTool.name, commit_js_1.commitTool.description, {
+    decision_id: zod_1.z.string().describe('ID from think() call'),
+    success: zod_1.z.boolean().describe('Did the task succeed?'),
+    outcome: zod_1.z.string().describe('One line outcome summary (max 2000 chars)'),
+}, async (args) => {
+    try {
+        return await (0, commit_js_1.handleCommit)(client, args);
+    }
+    catch (e) {
+        return { isError: true, content: [{ type: 'text', text: e instanceof Error ? e.message : 'Unknown error' }] };
+    }
+});
+server.tool(commit_js_1.commitAliasTool.name, commit_js_1.commitAliasTool.description, {
+    decision_id: zod_1.z.string().describe('ID from think() call'),
+    success: zod_1.z.boolean().describe('Did the task succeed?'),
+    outcome: zod_1.z.string().describe('One line outcome summary (max 2000 chars)'),
+}, async (args) => {
+    try {
+        return await (0, commit_js_1.handleCommit)(client, args);
+    }
+    catch (e) {
+        return { isError: true, content: [{ type: 'text', text: e instanceof Error ? e.message : 'Unknown error' }] };
+    }
+});
+server.tool(check_js_1.checkTool.name, check_js_1.checkTool.description, {}, async () => {
+    try {
+        return await (0, check_js_1.handleCheck)(client);
+    }
+    catch (e) {
+        return { isError: true, content: [{ type: 'text', text: e instanceof Error ? e.message : 'Unknown error' }] };
+    }
+});
+server.tool(check_js_1.checkAliasTool.name, check_js_1.checkAliasTool.description, {}, async () => {
+    try {
+        return await (0, check_js_1.handleCheck)(client);
+    }
+    catch (e) {
+        return { isError: true, content: [{ type: 'text', text: e instanceof Error ? e.message : 'Unknown error' }] };
+    }
+});
+server.tool(patterns_js_1.patternsTool.name, patterns_js_1.patternsTool.description, {}, async () => {
+    try {
+        return await (0, patterns_js_1.handlePatterns)(client);
+    }
+    catch (e) {
+        return { isError: true, content: [{ type: 'text', text: e instanceof Error ? e.message : 'Unknown error' }] };
+    }
+});
+const transport = new stdio_js_1.StdioServerTransport();
+server.connect(transport).catch((e) => {
+    console.error('Failed to start MCP server:', e);
+    process.exit(1);
+});

package/dist/tools/check.d.ts

@@ -0,0 +1,23 @@
+import { MarrowClient } from '../client.js';
+export declare const checkTool: {
+    name: string;
+    description: string;
+    inputSchema: {
+        type: "object";
+        properties: {};
+    };
+};
+export declare const checkAliasTool: {
+    name: string;
+    description: string;
+    inputSchema: {
+        type: "object";
+        properties: {};
+    };
+};
+export declare function handleCheck(client: MarrowClient): Promise<{
+    content: {
+        type: "text";
+        text: string;
+    }[];
+}>;

package/dist/tools/check.js

@@ -0,0 +1,26 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.checkAliasTool = exports.checkTool = void 0;
+exports.handleCheck = handleCheck;
+exports.checkTool = {
+    name: 'marrow_check',
+    description: 'Inspect Marrow loop state for this MCP session: orientation, intent log, outcome log, and recommended next step.',
+    inputSchema: {
+        type: 'object',
+        properties: {},
+    },
+};
+exports.checkAliasTool = {
+    name: 'check',
+    description: exports.checkTool.description,
+    inputSchema: exports.checkTool.inputSchema,
+};
+async function handleCheck(client) {
+    const result = client.check();
+    return {
+        content: [{
+                type: 'text',
+                text: JSON.stringify(result, null, 2),
+            }],
+    };
+}

package/dist/tools/commit.d.ts

@@ -0,0 +1,51 @@
+import { MarrowClient } from '../client.js';
+export declare const commitTool: {
+    name: string;
+    description: string;
+    inputSchema: {
+        type: "object";
+        properties: {
+            decision_id: {
+                type: string;
+                description: string;
+            };
+            success: {
+                type: string;
+                description: string;
+            };
+            outcome: {
+                type: string;
+                description: string;
+            };
+        };
+        required: string[];
+    };
+};
+export declare const commitAliasTool: {
+    name: string;
+    description: string;
+    inputSchema: {
+        type: "object";
+        properties: {
+            decision_id: {
+                type: string;
+                description: string;
+            };
+            success: {
+                type: string;
+                description: string;
+            };
+            outcome: {
+                type: string;
+                description: string;
+            };
+        };
+        required: string[];
+    };
+};
+export declare function handleCommit(client: MarrowClient, args: Record<string, unknown>): Promise<{
+    content: {
+        type: "text";
+        text: string;
+    }[];
+}>;

package/dist/tools/commit.js

@@ -0,0 +1,46 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.commitAliasTool = exports.commitTool = void 0;
+exports.handleCommit = handleCommit;
+exports.commitTool = {
+    name: 'marrow_commit',
+    description: 'Commit the outcome of a previous decision to Marrow. Call after every task completes.',
+    inputSchema: {
+        type: 'object',
+        properties: {
+            decision_id: { type: 'string', description: 'ID from think() call' },
+            success: { type: 'boolean', description: 'Did the task succeed?' },
+            outcome: { type: 'string', description: 'One line outcome summary (max 2000 chars)' },
+        },
+        required: ['decision_id', 'success', 'outcome'],
+    },
+};
+exports.commitAliasTool = {
+    name: 'commit',
+    description: exports.commitTool.description,
+    inputSchema: exports.commitTool.inputSchema,
+};
+async function handleCommit(client, args) {
+    if (typeof args.decision_id !== 'string' || !args.decision_id.trim()) {
+        throw new Error('decision_id must be a non-empty string');
+    }
+    const result = await client.commit({
+        decision_id: args.decision_id.trim(),
+        success: Boolean(args.success),
+        outcome: String(args.outcome),
+    });
+    const data = result.data || result;
+    return {
+        content: [{
+                type: 'text',
+                text: JSON.stringify({
+                    committed: true,
+                    decision_id: args.decision_id,
+                    accepted_as: data.accepted_as || 'outcome',
+                    summary: data.summary || 'Outcome logged to Marrow. Loop closed.',
+                    recommended_next: data.recommended_next || 'done',
+                    loop: data.loop || null,
+                }, null, 2),
+            }],
+    };
+}

package/dist/tools/orient.d.ts

@@ -0,0 +1,33 @@
+import { MarrowClient } from '../client.js';
+export declare const orientTool: {
+    name: string;
+    description: string;
+    inputSchema: {
+        type: "object";
+        properties: {
+            task_type: {
+                type: string;
+                description: string;
+            };
+        };
+    };
+};
+export declare const orientAliasTool: {
+    name: string;
+    description: string;
+    inputSchema: {
+        type: "object";
+        properties: {
+            task_type: {
+                type: string;
+                description: string;
+            };
+        };
+    };
+};
+export declare function handleOrient(client: MarrowClient, args: Record<string, unknown>): Promise<{
+    content: {
+        type: "text";
+        text: string;
+    }[];
+}>;

package/dist/tools/orient.js

@@ -0,0 +1,30 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.orientAliasTool = exports.orientTool = void 0;
+exports.handleOrient = handleOrient;
+exports.orientTool = {
+    name: 'marrow_orient',
+    description: 'Start the session with Marrow context, loop state, and a recommended next step before acting.',
+    inputSchema: {
+        type: 'object',
+        properties: {
+            task_type: { type: 'string', description: 'Optional task type: implementation, security, process, architecture, deployment' },
+        },
+    },
+};
+exports.orientAliasTool = {
+    name: 'orient',
+    description: exports.orientTool.description,
+    inputSchema: exports.orientTool.inputSchema,
+};
+async function handleOrient(client, args) {
+    const result = await client.orient({
+        task_type: args.task_type ? String(args.task_type) : undefined,
+    });
+    return {
+        content: [{
+                type: 'text',
+                text: JSON.stringify(result, null, 2),
+            }],
+    };
+}

package/dist/tools/patterns.d.ts

@@ -0,0 +1,15 @@
+import { MarrowClient } from '../client.js';
+export declare const patternsTool: {
+    name: string;
+    description: string;
+    inputSchema: {
+        type: "object";
+        properties: {};
+    };
+};
+export declare function handlePatterns(client: MarrowClient): Promise<{
+    content: {
+        type: "text";
+        text: string;
+    }[];
+}>;

package/dist/tools/patterns.js

@@ -0,0 +1,21 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.patternsTool = void 0;
+exports.handlePatterns = handlePatterns;
+exports.patternsTool = {
+    name: 'patterns',
+    description: 'Get your accumulated decision patterns and failure clusters from Marrow.',
+    inputSchema: {
+        type: 'object',
+        properties: {},
+    },
+};
+async function handlePatterns(client) {
+    const patterns = await client.patterns();
+    return {
+        content: [{
+                type: 'text',
+                text: JSON.stringify(patterns, null, 2),
+            }],
+    };
+}

package/dist/tools/think.d.ts

@@ -0,0 +1,67 @@
+import { MarrowClient } from '../client.js';
+export declare const thinkTool: {
+    name: string;
+    description: string;
+    inputSchema: {
+        type: "object";
+        properties: {
+            action: {
+                type: string;
+                description: string;
+            };
+            type: {
+                type: string;
+                description: string;
+            };
+            previous_decision_id: {
+                type: string;
+                description: string;
+            };
+            previous_success: {
+                type: string;
+                description: string;
+            };
+            previous_outcome: {
+                type: string;
+                description: string;
+            };
+        };
+        required: string[];
+    };
+};
+export declare const thinkAliasTool: {
+    name: string;
+    description: string;
+    inputSchema: {
+        type: "object";
+        properties: {
+            action: {
+                type: string;
+                description: string;
+            };
+            type: {
+                type: string;
+                description: string;
+            };
+            previous_decision_id: {
+                type: string;
+                description: string;
+            };
+            previous_success: {
+                type: string;
+                description: string;
+            };
+            previous_outcome: {
+                type: string;
+                description: string;
+            };
+        };
+        required: string[];
+    };
+};
+export declare function handleThink(client: MarrowClient, args: Record<string, unknown>): Promise<{
+    content: {
+        type: "text";
+        text: string;
+    }[];
+}>;