@getmarrow/mcp 2.3.3 → 2.3.5

package/dist/client.js

@@ -0,0 +1,233 @@
+"use strict";
+/**
+ * Marrow API client — thin HTTP wrapper
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.MarrowClient = void 0;
+const DEFAULT_BASE_URL = 'https://api.getmarrow.ai';
+const SESSION_START_HINT = 'Tip: log plans, decisions, and outcomes to Marrow so your agent improves over time.';
+const POST_ORIENT_NUDGE = 'You have not logged any decisions yet this session. Before acting, call marrow_think.';
+const PRE_EXIT_REMINDER = 'Before ending the session, log the outcome to Marrow so the loop closes cleanly.';
+function nowIso() {
+    return new Date().toISOString();
+}
+class MarrowClient {
+    apiKey;
+    baseUrl;
+    currentDecisionId = null;
+    loopState = {
+        orientedAt: null,
+        lastThinkAt: null,
+        lastOutcomeAt: null,
+        hasIntentLog: false,
+        hasOutcomeLog: false,
+        actionCountSinceLastThink: 0,
+        externalActionCountSinceLastThink: 0,
+        lastDecisionId: null,
+        pendingDecisionId: null,
+        recommendedNext: 'orient',
+        loopState: 'idle',
+        message: SESSION_START_HINT,
+        hints: [SESSION_START_HINT],
+    };
+    constructor() {
+        const key = process.env.MARROW_API_KEY;
+        if (!key) {
+            throw new Error('MARROW_API_KEY environment variable is required');
+        }
+        this.apiKey = key;
+        this.baseUrl = process.env.MARROW_BASE_URL || DEFAULT_BASE_URL;
+    }
+    check() {
+        if (!this.loopState.orientedAt) {
+            this.loopState.recommendedNext = 'orient';
+            this.loopState.loopState = 'idle';
+            this.loopState.message = SESSION_START_HINT;
+            this.loopState.hints = [SESSION_START_HINT];
+        }
+        else if (this.loopState.hasOutcomeLog) {
+            this.loopState.recommendedNext = 'done';
+            this.loopState.loopState = 'outcome_logged';
+            this.loopState.message = 'Loop closed. Ready for the next task.';
+            this.loopState.hints = ['Loop closed. Ready for the next task.'];
+        }
+        else if (!this.loopState.hasIntentLog) {
+            this.loopState.recommendedNext = 'think';
+            this.loopState.loopState = 'oriented';
+            this.loopState.message = POST_ORIENT_NUDGE;
+            this.loopState.hints = [SESSION_START_HINT, POST_ORIENT_NUDGE];
+        }
+        else if (!this.loopState.hasOutcomeLog && this.loopState.actionCountSinceLastThink > 0) {
+            this.loopState.recommendedNext = 'commit';
+            this.loopState.loopState = 'acting';
+            this.loopState.message = PRE_EXIT_REMINDER;
+            this.loopState.hints = [PRE_EXIT_REMINDER];
+        }
+        else if (!this.loopState.hasOutcomeLog) {
+            this.loopState.recommendedNext = 'act';
+            this.loopState.loopState = 'intent_logged';
+            this.loopState.message = 'Intent logged. Act, then log the outcome.';
+            this.loopState.hints = ['Intent logged. Act, then log the outcome.'];
+        }
+        else {
+            this.loopState.recommendedNext = 'done';
+            this.loopState.loopState = 'outcome_logged';
+            this.loopState.message = 'Loop closed. Ready for the next task.';
+            this.loopState.hints = ['Loop closed. Ready for the next task.'];
+        }
+        return {
+            ok: true,
+            recommendedNext: this.loopState.recommendedNext,
+            state: { ...this.loopState, hints: [...this.loopState.hints] },
+            warnings: [...this.loopState.hints],
+        };
+    }
+    async orient(params) {
+        const patterns = await this.get(`/v1/agent/patterns${params?.task_type ? `?type=${encodeURIComponent(params.task_type)}` : ''}`);
+        let lessons = [];
+        try {
+            const lessonRes = await this.get('/v1/agent/think/history?type=lesson&limit=5');
+            lessons = (lessonRes.data
+                || lessonRes.items
+                || lessonRes.decisions
+                || []);
+        }
+        catch {
+            lessons = [];
+        }
+        this.loopState.orientedAt = nowIso();
+        const loop = this.check();
+        const failurePatterns = (patterns.data?.failure_patterns
+            || patterns.failure_patterns
+            || []);
+        return {
+            session_start_hint: SESSION_START_HINT,
+            nudge: this.loopState.hasIntentLog ? null : POST_ORIENT_NUDGE,
+            recommended_next: loop.recommendedNext,
+            loop: loop.state,
+            warnings: failurePatterns
+                .filter((item) => Number(item.failureRate || item.failure_rate || 0) > 0.15)
+                .map((item) => ({
+                type: String(item.decisionType || item.decision_type || 'general'),
+                failure_rate: Number(item.failureRate || item.failure_rate || 0),
+                message: `${String(item.decisionType || item.decision_type || 'general')} has ${Math.round(Number(item.failureRate || item.failure_rate || 0) * 100)}% failure rate over ${Number(item.count || 0)} decisions — check lessons before proceeding`,
+            })),
+            lessons: lessons.map((lesson) => ({
+                summary: String(lesson.action || lesson.summary || ''),
+                severity: 'info',
+            })),
+            text: [SESSION_START_HINT, POST_ORIENT_NUDGE, `Recommended next step: ${loop.recommendedNext}.`].join(' '),
+        };
+    }
+    async think(params) {
+        if (params.previous_decision_id !== undefined && !params.previous_decision_id.trim()) {
+            throw new Error('decision_id must be a non-empty string');
+        }
+        const result = await this.post('/v1/agent/think', params);
+        const data = result.data || result;
+        const intelligence = data.intelligence || {};
+        const decisionId = typeof data.decision_id === 'string' && data.decision_id.trim()
+            ? data.decision_id
+            : null;
+        this.loopState.orientedAt = this.loopState.orientedAt || nowIso();
+        this.loopState.lastThinkAt = nowIso();
+        this.loopState.hasIntentLog = true;
+        this.loopState.hasOutcomeLog = false;
+        this.loopState.actionCountSinceLastThink = 0;
+        this.loopState.externalActionCountSinceLastThink = 0;
+        this.currentDecisionId = decisionId;
+        this.loopState.pendingDecisionId = decisionId;
+        this.loopState.lastDecisionId = decisionId;
+        const loop = this.check();
+        return {
+            ...result,
+            data: {
+                ...data,
+                accepted_as: 'intent',
+                warnings: loop.warnings,
+                recommended_next: loop.recommendedNext,
+                loop: loop.state,
+                summary: [
+                    'Intent logged to Marrow.',
+                    intelligence.insight ? `Pattern hint: ${String(intelligence.insight)}` : null,
+                    `Recommended next step: ${loop.recommendedNext}.`,
+                ].filter(Boolean).join(' '),
+            },
+        };
+    }
+    async commit(params) {
+        const decisionId = params.decision_id.trim();
+        if (!decisionId) {
+            throw new Error('decision_id must be a non-empty string');
+        }
+        if (!this.currentDecisionId) {
+            throw new Error('No active decision. Call marrow_think first.');
+        }
+        if (decisionId !== this.currentDecisionId) {
+            throw new Error(`decision_id mismatch: expected ${this.currentDecisionId}`);
+        }
+        const result = await this.post('/v1/agent/commit', {
+            ...params,
+            decision_id: decisionId,
+        });
+        const data = result.data || result;
+        this.loopState.lastOutcomeAt = nowIso();
+        this.loopState.hasIntentLog = false;
+        this.loopState.hasOutcomeLog = true;
+        this.loopState.actionCountSinceLastThink = 0;
+        this.loopState.externalActionCountSinceLastThink = 0;
+        this.loopState.pendingDecisionId = null;
+        this.loopState.lastDecisionId = decisionId;
+        this.currentDecisionId = null;
+        const loop = this.check();
+        return {
+            ...result,
+            data: {
+                ...data,
+                accepted_as: 'outcome',
+                recommended_next: loop.recommendedNext,
+                loop: loop.state,
+                summary: 'Outcome logged to Marrow. Loop closed.',
+            },
+        };
+    }
+    recordAction(meta) {
+        this.loopState.actionCountSinceLastThink += 1;
+        if (meta?.external)
+            this.loopState.externalActionCountSinceLastThink += 1;
+        return this.check();
+    }
+    async patterns() {
+        const res = await this.get('/v1/patterns');
+        return res?.data || [];
+    }
+    async post(path, body) {
+        const res = await fetch(`${this.baseUrl}${path}`, {
+            method: 'POST',
+            headers: {
+                'Authorization': `Bearer ${this.apiKey}`,
+                'Content-Type': 'application/json',
+            },
+            body: JSON.stringify(body),
+        });
+        if (!res.ok) {
+            const text = (await res.text()).slice(0, 200);
+            throw new Error(`Marrow API error (${res.status}): ${text}`);
+        }
+        return res.json();
+    }
+    async get(path) {
+        const res = await fetch(`${this.baseUrl}${path}`, {
+            method: 'GET',
+            headers: {
+                'Authorization': `Bearer ${this.apiKey}`,
+            },
+        });
+        if (!res.ok) {
+            const text = (await res.text()).slice(0, 200);
+            throw new Error(`Marrow API error (${res.status}): ${text}`);
+        }
+        return res.json();
+    }
+}
+exports.MarrowClient = MarrowClient;

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;
+    }[];
+}>;