@claude-flow/cli 3.10.46 → 3.11.0

package/bin/mcp-server.js

@@ -1,224 +1,224 @@
-#!/usr/bin/env node
-/**
- * @claude-flow/cli - MCP Server Entry Point
- *
- * Direct stdio MCP server for Claude Code integration.
- * This entry point handles stdin/stdout directly for MCP protocol
- * without any CLI formatting output that would corrupt the protocol.
- */
-
-import { randomUUID } from 'crypto';
-
-// Suppress the SPECIFIC cosmetic "[AgentDB Patch] Controller index not found"
-// noise. Tight match (both prefix AND "Controller index not found") so other
-// [AgentDB Patch] warnings about real issues still flow through. Also patch
-// console.log because the underlying call site uses it. See bin/cli.js for
-// the same rationale.
-const _origWarn = console.warn;
-const _origLog = console.log;
-const _isCosmeticAgentdbPatchNoise = (msg) =>
-  msg.includes('[AgentDB Patch]') && msg.includes('Controller index not found');
-console.warn = (...args) => {
-  if (_isCosmeticAgentdbPatchNoise(String(args[0] ?? ''))) return;
-  _origWarn.apply(console, args);
-};
-console.log = (...args) => {
-  if (_isCosmeticAgentdbPatchNoise(String(args[0] ?? ''))) return;
-  _origLog.apply(console, args);
-};
-
-import { listMCPTools, callMCPTool, hasTool } from '../dist/src/mcp-client.js';
-
-const VERSION = '3.0.0';
-const sessionId = `mcp-${Date.now()}-${randomUUID().slice(0, 8)}`;
-
-// Log to stderr (doesn't corrupt stdout for MCP protocol)
-console.error(
-  `[${new Date().toISOString()}] INFO [claude-flow-mcp] (${sessionId}) Starting in stdio mode`
-);
-console.error(JSON.stringify({
-  arch: process.arch,
-  mode: 'mcp-stdio',
-  nodeVersion: process.version,
-  pid: process.pid,
-  platform: process.platform,
-  protocol: 'stdio',
-  sessionId,
-  version: VERSION,
-}));
-
-// Handle stdin messages
-// Audit-flagged DoS protection (audit_1776483149979): cap stdin buffer
-// to 10MB. See bin/cli.js for the same protection on the auto-detect path.
-const MCP_MAX_BUFFER_BYTES = 10 * 1024 * 1024;
-let buffer = '';
-
-process.stdin.setEncoding('utf8');
-process.stdin.on('data', async (chunk) => {
-  buffer += chunk;
-
-  if (buffer.length > MCP_MAX_BUFFER_BYTES) {
-    console.log(JSON.stringify({
-      jsonrpc: '2.0',
-      id: null,
-      error: {
-        code: -32700,
-        message: `Buffered stdin exceeds ${MCP_MAX_BUFFER_BYTES} bytes without newline; resetting`,
-      },
-    }));
-    buffer = '';
-    return;
-  }
-
-  // Process complete JSON messages (newline-delimited)
-  let lines = buffer.split('\n');
-  buffer = lines.pop() || ''; // Keep incomplete line in buffer
-
-  for (const line of lines) {
-    if (line.trim()) {
-      try {
-        const message = JSON.parse(line);
-        const response = await handleMessage(message);
-        if (response) {
-          console.log(JSON.stringify(response));
-        }
-      } catch (error) {
-        console.error(
-          `[${new Date().toISOString()}] ERROR [claude-flow-mcp] Failed to parse:`,
-          error instanceof Error ? error.message : String(error)
-        );
-        // Send parse error response
-        console.log(JSON.stringify({
-          jsonrpc: '2.0',
-          id: null,
-          error: { code: -32700, message: 'Parse error' },
-        }));
-      }
-    }
-  }
-});
-
-process.stdin.on('end', () => {
-  console.error(
-    `[${new Date().toISOString()}] INFO [claude-flow-mcp] (${sessionId}) stdin closed, shutting down...`
-  );
-  process.exit(0);
-});
-
-// Handle process termination
-process.on('SIGINT', () => {
-  console.error(`[${new Date().toISOString()}] INFO [claude-flow-mcp] Received SIGINT`);
-  process.exit(0);
-});
-
-process.on('SIGTERM', () => {
-  console.error(`[${new Date().toISOString()}] INFO [claude-flow-mcp] Received SIGTERM`);
-  process.exit(0);
-});
-
-/**
- * Handle MCP message
- */
-async function handleMessage(message) {
-  if (!message.method) {
-    return {
-      jsonrpc: '2.0',
-      id: message.id,
-      error: { code: -32600, message: 'Invalid Request: missing method' },
-    };
-  }
-
-  const params = message.params || {};
-
-  try {
-    switch (message.method) {
-      case 'initialize':
-        return {
-          jsonrpc: '2.0',
-          id: message.id,
-          result: {
-            protocolVersion: '2024-11-05',
-            serverInfo: { name: 'ruflo', version: VERSION },
-            capabilities: {
-              tools: { listChanged: true },
-              resources: { subscribe: true, listChanged: true },
-            },
-          },
-        };
-
-      case 'tools/list': {
-        const tools = listMCPTools();
-        return {
-          jsonrpc: '2.0',
-          id: message.id,
-          result: {
-            tools: tools.map(tool => ({
-              name: tool.name,
-              description: tool.description,
-              inputSchema: tool.inputSchema,
-            })),
-          },
-        };
-      }
-
-      case 'tools/call': {
-        const toolName = params.name;
-        const toolParams = params.arguments || {};
-
-        if (!hasTool(toolName)) {
-          return {
-            jsonrpc: '2.0',
-            id: message.id,
-            error: { code: -32601, message: `Tool not found: ${toolName}` },
-          };
-        }
-
-        try {
-          const result = await callMCPTool(toolName, toolParams, { sessionId });
-          return {
-            jsonrpc: '2.0',
-            id: message.id,
-            result: { content: [{ type: 'text', text: JSON.stringify(result, null, 2) }] },
-          };
-        } catch (error) {
-          return {
-            jsonrpc: '2.0',
-            id: message.id,
-            error: {
-              code: -32603,
-              message: error instanceof Error ? error.message : 'Tool execution failed',
-            },
-          };
-        }
-      }
-
-      case 'notifications/initialized':
-        console.error(`[${new Date().toISOString()}] INFO [claude-flow-mcp] Client initialized`);
-        return null; // No response for notifications
-
-      case 'ping':
-        return {
-          jsonrpc: '2.0',
-          id: message.id,
-          result: {},
-        };
-
-      default:
-        return {
-          jsonrpc: '2.0',
-          id: message.id,
-          error: { code: -32601, message: `Method not found: ${message.method}` },
-        };
-    }
-  } catch (error) {
-    console.error(`[${new Date().toISOString()}] ERROR [claude-flow-mcp] ${message.method}:`, error);
-    return {
-      jsonrpc: '2.0',
-      id: message.id,
-      error: {
-        code: -32603,
-        message: error instanceof Error ? error.message : 'Internal error',
-      },
-    };
-  }
-}
+#!/usr/bin/env node
+/**
+ * @claude-flow/cli - MCP Server Entry Point
+ *
+ * Direct stdio MCP server for Claude Code integration.
+ * This entry point handles stdin/stdout directly for MCP protocol
+ * without any CLI formatting output that would corrupt the protocol.
+ */
+
+import { randomUUID } from 'crypto';
+
+// Suppress the SPECIFIC cosmetic "[AgentDB Patch] Controller index not found"
+// noise. Tight match (both prefix AND "Controller index not found") so other
+// [AgentDB Patch] warnings about real issues still flow through. Also patch
+// console.log because the underlying call site uses it. See bin/cli.js for
+// the same rationale.
+const _origWarn = console.warn;
+const _origLog = console.log;
+const _isCosmeticAgentdbPatchNoise = (msg) =>
+  msg.includes('[AgentDB Patch]') && msg.includes('Controller index not found');
+console.warn = (...args) => {
+  if (_isCosmeticAgentdbPatchNoise(String(args[0] ?? ''))) return;
+  _origWarn.apply(console, args);
+};
+console.log = (...args) => {
+  if (_isCosmeticAgentdbPatchNoise(String(args[0] ?? ''))) return;
+  _origLog.apply(console, args);
+};
+
+import { listMCPTools, callMCPTool, hasTool } from '../dist/src/mcp-client.js';
+
+const VERSION = '3.0.0';
+const sessionId = `mcp-${Date.now()}-${randomUUID().slice(0, 8)}`;
+
+// Log to stderr (doesn't corrupt stdout for MCP protocol)
+console.error(
+  `[${new Date().toISOString()}] INFO [claude-flow-mcp] (${sessionId}) Starting in stdio mode`
+);
+console.error(JSON.stringify({
+  arch: process.arch,
+  mode: 'mcp-stdio',
+  nodeVersion: process.version,
+  pid: process.pid,
+  platform: process.platform,
+  protocol: 'stdio',
+  sessionId,
+  version: VERSION,
+}));
+
+// Handle stdin messages
+// Audit-flagged DoS protection (audit_1776483149979): cap stdin buffer
+// to 10MB. See bin/cli.js for the same protection on the auto-detect path.
+const MCP_MAX_BUFFER_BYTES = 10 * 1024 * 1024;
+let buffer = '';
+
+process.stdin.setEncoding('utf8');
+process.stdin.on('data', async (chunk) => {
+  buffer += chunk;
+
+  if (buffer.length > MCP_MAX_BUFFER_BYTES) {
+    console.log(JSON.stringify({
+      jsonrpc: '2.0',
+      id: null,
+      error: {
+        code: -32700,
+        message: `Buffered stdin exceeds ${MCP_MAX_BUFFER_BYTES} bytes without newline; resetting`,
+      },
+    }));
+    buffer = '';
+    return;
+  }
+
+  // Process complete JSON messages (newline-delimited)
+  let lines = buffer.split('\n');
+  buffer = lines.pop() || ''; // Keep incomplete line in buffer
+
+  for (const line of lines) {
+    if (line.trim()) {
+      try {
+        const message = JSON.parse(line);
+        const response = await handleMessage(message);
+        if (response) {
+          console.log(JSON.stringify(response));
+        }
+      } catch (error) {
+        console.error(
+          `[${new Date().toISOString()}] ERROR [claude-flow-mcp] Failed to parse:`,
+          error instanceof Error ? error.message : String(error)
+        );
+        // Send parse error response
+        console.log(JSON.stringify({
+          jsonrpc: '2.0',
+          id: null,
+          error: { code: -32700, message: 'Parse error' },
+        }));
+      }
+    }
+  }
+});
+
+process.stdin.on('end', () => {
+  console.error(
+    `[${new Date().toISOString()}] INFO [claude-flow-mcp] (${sessionId}) stdin closed, shutting down...`
+  );
+  process.exit(0);
+});
+
+// Handle process termination
+process.on('SIGINT', () => {
+  console.error(`[${new Date().toISOString()}] INFO [claude-flow-mcp] Received SIGINT`);
+  process.exit(0);
+});
+
+process.on('SIGTERM', () => {
+  console.error(`[${new Date().toISOString()}] INFO [claude-flow-mcp] Received SIGTERM`);
+  process.exit(0);
+});
+
+/**
+ * Handle MCP message
+ */
+async function handleMessage(message) {
+  if (!message.method) {
+    return {
+      jsonrpc: '2.0',
+      id: message.id,
+      error: { code: -32600, message: 'Invalid Request: missing method' },
+    };
+  }
+
+  const params = message.params || {};
+
+  try {
+    switch (message.method) {
+      case 'initialize':
+        return {
+          jsonrpc: '2.0',
+          id: message.id,
+          result: {
+            protocolVersion: '2024-11-05',
+            serverInfo: { name: 'ruflo', version: VERSION },
+            capabilities: {
+              tools: { listChanged: true },
+              resources: { subscribe: true, listChanged: true },
+            },
+          },
+        };
+
+      case 'tools/list': {
+        const tools = listMCPTools();
+        return {
+          jsonrpc: '2.0',
+          id: message.id,
+          result: {
+            tools: tools.map(tool => ({
+              name: tool.name,
+              description: tool.description,
+              inputSchema: tool.inputSchema,
+            })),
+          },
+        };
+      }
+
+      case 'tools/call': {
+        const toolName = params.name;
+        const toolParams = params.arguments || {};
+
+        if (!hasTool(toolName)) {
+          return {
+            jsonrpc: '2.0',
+            id: message.id,
+            error: { code: -32601, message: `Tool not found: ${toolName}` },
+          };
+        }
+
+        try {
+          const result = await callMCPTool(toolName, toolParams, { sessionId });
+          return {
+            jsonrpc: '2.0',
+            id: message.id,
+            result: { content: [{ type: 'text', text: JSON.stringify(result, null, 2) }] },
+          };
+        } catch (error) {
+          return {
+            jsonrpc: '2.0',
+            id: message.id,
+            error: {
+              code: -32603,
+              message: error instanceof Error ? error.message : 'Tool execution failed',
+            },
+          };
+        }
+      }
+
+      case 'notifications/initialized':
+        console.error(`[${new Date().toISOString()}] INFO [claude-flow-mcp] Client initialized`);
+        return null; // No response for notifications
+
+      case 'ping':
+        return {
+          jsonrpc: '2.0',
+          id: message.id,
+          result: {},
+        };
+
+      default:
+        return {
+          jsonrpc: '2.0',
+          id: message.id,
+          error: { code: -32601, message: `Method not found: ${message.method}` },
+        };
+    }
+  } catch (error) {
+    console.error(`[${new Date().toISOString()}] ERROR [claude-flow-mcp] ${message.method}:`, error);
+    return {
+      jsonrpc: '2.0',
+      id: message.id,
+      error: {
+        code: -32603,
+        message: error instanceof Error ? error.message : 'Internal error',
+      },
+    };
+  }
+}

package/bin/preinstall.cjs

@@ -1,2 +1,2 @@
-#!/usr/bin/env node
-// Preinstall hook — no-op (cache repair removed in 3.1.0-alpha.53)
+#!/usr/bin/env node
+// Preinstall hook — no-op (cache repair removed in 3.1.0-alpha.53)

package/dist/src/benchmarks/capability-tasks.d.ts

@@ -0,0 +1,126 @@
+export declare const BUILTIN_CAPABILITY_TASKS: {
+    readonly version: "1.3";
+    readonly description: "Text-only agent capability benchmark — verifiable multi-step reasoning tasks scoreable without tool use. Format inspired by GAIA / SWE-bench / GSM8K. The fixture mixes EASY (regression-floor) and HARD (model-gradient) questions so the pass rate has signal across Haiku → Sonnet → Opus. Real GAIA (web browsing, attachments, HF dataset) remains future work.";
+    readonly answerFormat: "Each question requires the model to reply with the answer wrapped in <answer>...</answer> tags. The harness extracts the tag contents and checks against `expected` per `matchMode`. Per-task `maxTokens` overrides the default cap.";
+    readonly tasks: readonly [{
+        readonly id: "math-prime";
+        readonly category: "easy:reasoning";
+        readonly prompt: "What is the smallest 3-digit prime number that does not contain the digit 7?";
+        readonly expected: "101";
+        readonly matchMode: "exact";
+        readonly maxTokens: 192;
+    }, {
+        readonly id: "logic-syllogism";
+        readonly category: "easy:reasoning";
+        readonly prompt: "All routers in tier 1 cost less than $0.001 per call. The Booster router is in tier 1. The Sonnet router costs $0.003 per call. Is the Sonnet router in tier 1? Answer with just \"yes\" or \"no\".";
+        readonly expected: "no";
+        readonly matchMode: "exact";
+        readonly maxTokens: 160;
+    }, {
+        readonly id: "regex-match";
+        readonly category: "easy:code-reasoning";
+        readonly prompt: "Given the regex /^([a-z]+)-(\\d+)$/ and the input string 'pattern-1779526376', what is the value of capture group 2?";
+        readonly expected: "1779526376";
+        readonly matchMode: "exact";
+        readonly maxTokens: 192;
+    }, {
+        readonly id: "gsm8k-trip";
+        readonly category: "hard:gsm8k-style";
+        readonly prompt: "A delivery van starts a route with 240 packages. At stop A it drops off 1/4 of its current load and picks up 6 new packages. At stop B it drops off 1/3 of its current load and picks up 4 new packages. At stop C it drops off half of its current load. How many packages does the van have after stop C? Answer with the integer.";
+        readonly expected: "64";
+        readonly matchMode: "exact";
+        readonly maxTokens: 256;
+    }, {
+        readonly id: "gsm8k-discount";
+        readonly category: "hard:gsm8k-style";
+        readonly prompt: "A store sells 3 widgets and 2 sprockets for $23. It also sells 2 widgets and 4 sprockets for $26. What is the price of one widget? Answer with the integer dollar amount only.";
+        readonly expected: "5";
+        readonly matchMode: "exact";
+        readonly maxTokens: 256;
+    }, {
+        readonly id: "code-trace";
+        readonly category: "hard:code-trace";
+        readonly prompt: "Consider this JavaScript code:\n```\nconst counts = new Map();\nfor (const c of 'abracadabra') {\n  counts.set(c, (counts.get(c) ?? 0) + 1);\n}\nlet maxK = '', maxV = 0;\nfor (const [k, v] of counts) {\n  if (v > maxV || (v === maxV && k < maxK)) { maxK = k; maxV = v; }\n}\nconsole.log(`${maxK}:${maxV}`);\n```\nWhat does it print? Answer with just the printed string.";
+        readonly expected: "a:5";
+        readonly matchMode: "exact";
+        readonly maxTokens: 192;
+    }, {
+        readonly id: "hard-graph-shortest";
+        readonly category: "hard:graph-reasoning";
+        readonly prompt: "A directed graph has these weighted edges: A→B(3), A→C(7), B→C(2), B→D(5), C→D(1), C→E(4), D→E(2). What is the cost of the shortest path from A to E? Answer with the integer.";
+        readonly expected: "8";
+        readonly matchMode: "exact";
+        readonly maxTokens: 192;
+    }, {
+        readonly id: "hard-probability";
+        readonly category: "hard:probability";
+        readonly prompt: "A bag contains 5 red, 3 blue, and 2 green balls. Two balls are drawn without replacement. What is the probability that both balls are the same color? Express as a fraction in lowest terms in the form a/b (e.g. 3/10).";
+        readonly expected: "14/45";
+        readonly matchMode: "exact";
+        readonly maxTokens: 256;
+    }, {
+        readonly id: "expert-marble-inverse";
+        readonly category: "expert:inverse-arithmetic";
+        readonly prompt: "A bag of marbles is split as follows: 40% are given to Alice, then 25% of the REMAINING marbles are given to Bob, then half of the remaining marbles (after Alice and Bob) are given to Carol. Carol receives exactly 18 marbles. How many marbles were in the bag originally? Answer with the integer.";
+        readonly expected: "80";
+        readonly matchMode: "exact";
+        readonly maxTokens: 512;
+    }, {
+        readonly id: "expert-crt";
+        readonly category: "expert:number-theory";
+        readonly prompt: "Find the smallest positive integer n such that all three of these hold simultaneously: n mod 7 = 3, n mod 9 = 4, n mod 11 = 5. Answer with just the integer.";
+        readonly expected: "346";
+        readonly matchMode: "exact";
+        readonly maxTokens: 768;
+    }, {
+        readonly id: "expert-bayes";
+        readonly category: "expert:bayesian";
+        readonly prompt: "A medical test has 95% sensitivity (true positive rate) and 90% specificity (true negative rate). In the screened population, 1% of people have the disease. A patient tests positive. What is the probability the patient actually has the disease, rounded to the nearest whole percent? Answer with just the integer percentage (no '%' sign).";
+        readonly expected: "9";
+        readonly matchMode: "exact";
+        readonly maxTokens: 512;
+    }, {
+        readonly id: "expert-banana";
+        readonly category: "expert:combinatorics";
+        readonly prompt: "In how many distinct arrangements of the letters of the word BANANA do no two N's appear next to each other? Answer with the integer.";
+        readonly expected: "40";
+        readonly matchMode: "exact";
+        readonly maxTokens: 512;
+    }, {
+        readonly id: "expert-rectangle";
+        readonly category: "expert:diophantine";
+        readonly prompt: "A rectangle has positive integer side lengths. Its perimeter (in linear units) is numerically equal to its area (in square units). Two rectangles that are rotations of each other (e.g. 3x6 and 6x3) count as the same rectangle. What is the sum of the areas of all distinct such rectangles? Answer with the integer.";
+        readonly expected: "34";
+        readonly matchMode: "exact";
+        readonly maxTokens: 512;
+    }, {
+        readonly id: "expert-dice-reroll";
+        readonly category: "expert:expected-value";
+        readonly prompt: "You roll a fair 6-sided die. If the result is a 6, you reroll exactly once and take the new result. Otherwise, you keep the original result. What is the expected value of your final number? Express the answer as a fraction in lowest terms in the form a/b (no spaces, no surrounding text).";
+        readonly expected: "37/12";
+        readonly matchMode: "exact";
+        readonly maxTokens: 512;
+    }, {
+        readonly id: "sonnet-killer-knights";
+        readonly category: "sonnet-killer:logic-puzzle";
+        readonly prompt: "On an island, knights always tell the truth and knaves always lie. You meet four people named Alice, Bob, Carol, and Dan. They make the following statements: Alice says 'Bob and Carol are different types (one is a knight, the other is a knave).' Bob says 'Alice is a knave.' Carol says 'Dan is a knave.' Dan says 'Carol is a knave.' How many knaves are among the four people? Answer with just the integer.";
+        readonly expected: "2";
+        readonly matchMode: "exact";
+        readonly maxTokens: 768;
+    }, {
+        readonly id: "sonnet-killer-hofstadter";
+        readonly category: "sonnet-killer:recursive-sequence";
+        readonly prompt: "A sequence is defined on the positive integers by f(1) = 1 and, for every n > 1, f(n) = f(n - f(n-1)) + 1. Compute f(10). Answer with just the integer.";
+        readonly expected: "4";
+        readonly matchMode: "exact";
+        readonly maxTokens: 768;
+    }, {
+        readonly id: "sonnet-killer-modexp";
+        readonly category: "sonnet-killer:number-theory";
+        readonly prompt: "What are the last two digits of 7 raised to the 2026th power? Answer with exactly the two-digit number (e.g. '07' if it's seven, '49' if it's forty-nine).";
+        readonly expected: "49";
+        readonly matchMode: "exact";
+        readonly maxTokens: 512;
+    }];
+};
+//# sourceMappingURL=capability-tasks.d.ts.map

package/dist/src/benchmarks/capability-tasks.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"capability-tasks.d.ts","sourceRoot":"","sources":["../../../src/benchmarks/capability-tasks.ts"],"names":[],"mappings":"AAIA,eAAO,MAAM,wBAAwB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CA8I3B,CAAC"}