@getmarrow/mcp 1.1.1 → 2.0.1

package/src/cli.ts

@@ -0,0 +1,235 @@
+#!/usr/bin/env node
+
+/**
+ * Marrow MCP stdio server — collective memory for Claude and MCP agents.
+ * Exposes: marrow_think, marrow_commit, marrow_status
+ */
+
+import * as readline from 'readline';
+import { marrowThink, marrowCommit, marrowStatus } from './index';
+
+const API_KEY = process.env.MARROW_API_KEY || '';
+const BASE_URL = process.env.MARROW_BASE_URL || 'https://api.getmarrow.ai';
+
+if (!API_KEY) {
+  process.stderr.write('Error: MARROW_API_KEY environment variable is required\n');
+  process.exit(1);
+}
+
+// MCP protocol types
+interface MCPRequest {
+  jsonrpc: '2.0';
+  id: string | number;
+  method: string;
+  params?: Record<string, unknown>;
+}
+
+interface MCPResponse {
+  jsonrpc: '2.0';
+  id: string | number;
+  result?: unknown;
+  error?: { code: number; message: string };
+}
+
+function send(response: MCPResponse): void {
+  process.stdout.write(JSON.stringify(response) + '\n');
+}
+
+function success(id: string | number, result: unknown): void {
+  send({ jsonrpc: '2.0', id, result });
+}
+
+function error(id: string | number, code: number, message: string): void {
+  send({ jsonrpc: '2.0', id, error: { code, message } });
+}
+
+// Tool definitions
+const TOOLS = [
+  {
+    name: 'marrow_think',
+    description:
+      'Get collective intelligence from the Marrow hive before acting. ' +
+      'Call this before every significant action. Pass previous_outcome ' +
+      'to auto-commit your last action and open a new memory session.',
+    inputSchema: {
+      type: 'object',
+      properties: {
+        action: {
+          type: 'string',
+          description: 'What the agent is about to do',
+        },
+        type: {
+          type: 'string',
+          enum: ['implementation', 'security', 'architecture', 'process', 'general'],
+          description: 'Type of action (default: general)',
+        },
+        context: {
+          type: 'object',
+          description: 'Optional metadata about the current situation',
+        },
+        previous_decision_id: {
+          type: 'string',
+          description: 'decision_id from previous think() call — auto-commits that session',
+        },
+        previous_success: {
+          type: 'boolean',
+          description: 'Did the previous action succeed?',
+        },
+        previous_outcome: {
+          type: 'string',
+          description: 'What happened in the previous action (required if previous_decision_id provided)',
+        },
+      },
+      required: ['action'],
+    },
+  },
+  {
+    name: 'marrow_commit',
+    description:
+      'Explicitly commit the result of an action to Marrow. ' +
+      'Optional — marrow_think() auto-commits if you pass previous_outcome. ' +
+      'Use when you need explicit control over commit timing.',
+    inputSchema: {
+      type: 'object',
+      properties: {
+        decision_id: {
+          type: 'string',
+          description: 'decision_id from the marrow_think call',
+        },
+        success: {
+          type: 'boolean',
+          description: 'Did the action succeed?',
+        },
+        outcome: {
+          type: 'string',
+          description: 'What happened — be specific, this trains the hive',
+        },
+        caused_by: {
+          type: 'string',
+          description: 'Optional: what caused this action',
+        },
+      },
+      required: ['decision_id', 'success', 'outcome'],
+    },
+  },
+  {
+    name: 'marrow_status',
+    description: 'Check Marrow platform health and status.',
+    inputSchema: {
+      type: 'object',
+      properties: {},
+      required: [],
+    },
+  },
+];
+
+// Request handler
+async function handleRequest(req: MCPRequest): Promise<void> {
+  const { id, method, params } = req;
+
+  try {
+    if (method === 'initialize') {
+      success(id, {
+        protocolVersion: '2024-11-05',
+        capabilities: { tools: {} },
+        serverInfo: { name: 'marrow', version: '2.0.0' },
+      });
+      return;
+    }
+
+    if (method === 'tools/list') {
+      success(id, { tools: TOOLS });
+      return;
+    }
+
+    if (method === 'tools/call') {
+      const toolName = (params as Record<string, unknown>)?.name as string;
+      const args = ((params as Record<string, unknown>)?.arguments || {}) as Record<string, unknown>;
+
+      if (toolName === 'marrow_think') {
+        const result = await marrowThink(API_KEY, BASE_URL, {
+          action: args.action as string,
+          type: args.type as string | undefined,
+          context: args.context as Record<string, unknown> | undefined,
+          previous_decision_id: args.previous_decision_id as string | undefined,
+          previous_success: args.previous_success as boolean | undefined,
+          previous_outcome: args.previous_outcome as string | undefined,
+        });
+        success(id, {
+          content: [
+            {
+              type: 'text',
+              text: JSON.stringify(result, null, 2),
+            },
+          ],
+        });
+        return;
+      }
+
+      if (toolName === 'marrow_commit') {
+        const result = await marrowCommit(API_KEY, BASE_URL, {
+          decision_id: args.decision_id as string,
+          success: args.success as boolean,
+          outcome: args.outcome as string,
+          caused_by: args.caused_by as string | undefined,
+        });
+        success(id, {
+          content: [
+            {
+              type: 'text',
+              text: JSON.stringify(result, null, 2),
+            },
+          ],
+        });
+        return;
+      }
+
+      if (toolName === 'marrow_status') {
+        const result = await marrowStatus(API_KEY, BASE_URL);
+        success(id, {
+          content: [
+            {
+              type: 'text',
+              text: JSON.stringify(result, null, 2),
+            },
+          ],
+        });
+        return;
+      }
+
+      error(id, -32601, `Unknown tool: ${toolName}`);
+      return;
+    }
+
+    // Unknown method
+    error(id, -32601, `Method not found: ${method}`);
+  } catch (err) {
+    const message = err instanceof Error ? err.message : String(err);
+    error(id, -32603, `Internal error: ${message}`);
+  }
+}
+
+// stdio server
+const rl = readline.createInterface({
+  input: process.stdin,
+  output: process.stdout,
+  terminal: false,
+});
+
+rl.on('line', (line) => {
+  const trimmed = line.trim();
+  if (!trimmed) return;
+
+  try {
+    const req = JSON.parse(trimmed) as MCPRequest;
+    handleRequest(req).catch((err) => {
+      process.stderr.write(`Unhandled error: ${err}\n`);
+    });
+  } catch {
+    process.stderr.write(`Failed to parse request: ${trimmed}\n`);
+  }
+});
+
+rl.on('close', () => {
+  process.exit(0);
+});

package/src/index.ts

@@ -0,0 +1,103 @@
+export interface MarrowIntelligence {
+  similar: Array<{ outcome: string; confidence: number }>;
+  patterns: Array<{ pattern: string; frequency: number }>;
+  templates: Array<{ steps: unknown[]; success_rate: number }>;
+  shared: Array<{ outcome: string }>;
+  causal_chain: unknown | null;
+  success_rate: number;
+  priority_score: number;
+}
+
+export interface ThinkResult {
+  decision_id: string;
+  intelligence: MarrowIntelligence;
+  stream_url: string;
+  previous_committed?: boolean;
+}
+
+export interface CommitResult {
+  committed: boolean;
+  success_rate: number;
+  insight: string | null;
+}
+
+export interface StatusResult {
+  status: string;
+  version: string;
+  tiers: number;
+  uptime_ms: number;
+}
+
+export async 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> {
+  const body: Record<string, unknown> = {
+    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() as { data: ThinkResult; error?: string };
+  if (json.error) throw new Error(json.error);
+  return json.data;
+}
+
+export async function marrowCommit(
+  apiKey: string,
+  baseUrl: string,
+  params: {
+    decision_id: string;
+    success: boolean;
+    outcome: string;
+    caused_by?: string;
+  }
+): Promise<CommitResult> {
+  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() as { data: CommitResult; error?: string };
+  if (json.error) throw new Error(json.error);
+  return json.data;
+}
+
+export async function marrowStatus(
+  apiKey: string,
+  baseUrl: string
+): Promise<StatusResult> {
+  const res = await fetch(`${baseUrl}/v1/health`, {
+    headers: { 'Authorization': `Bearer ${apiKey}` },
+  });
+
+  const json = await res.json() as { data: StatusResult; error?: string };
+  if (json.error) throw new Error(json.error);
+  return json.data;
+}

package/tsconfig.json

@@ -0,0 +1,18 @@
+{
+  "compilerOptions": {
+    "target": "ES2020",
+    "module": "commonjs",
+    "lib": ["ES2020"],
+    "declaration": true,
+    "declarationMap": true,
+    "sourceMap": true,
+    "outDir": "./dist",
+    "rootDir": "./src",
+    "strict": true,
+    "esModuleInterop": true,
+    "skipLibCheck": true,
+    "forceConsistentCasingInFileNames": true
+  },
+  "include": ["src/**/*"],
+  "exclude": ["node_modules", "dist"]
+}