claude-flow 3.5.24 → 3.5.26

package/v3/@claude-flow/cli/dist/src/mcp-tools/swarm-tools.js

@@ -1,82 +1,212 @@
 /**
  * Swarm MCP Tools for CLI
  *
- * Tool definitions for swarm coordination.
+ * Tool definitions for swarm coordination with file-based state persistence.
+ * Replaces previous stub implementations with real state tracking.
  */
+import { existsSync, mkdirSync, readFileSync, writeFileSync } from 'node:fs';
+import { join } from 'node:path';
+// Swarm state persistence
+const SWARM_DIR = '.claude-flow/swarm';
+const SWARM_STATE_FILE = 'swarm-state.json';
+function getSwarmDir() {
+    return join(process.cwd(), SWARM_DIR);
+}
+function getSwarmStatePath() {
+    return join(getSwarmDir(), SWARM_STATE_FILE);
+}
+function ensureSwarmDir() {
+    const dir = getSwarmDir();
+    if (!existsSync(dir)) {
+        mkdirSync(dir, { recursive: true, mode: 0o700 });
+    }
+}
+function loadSwarmStore() {
+    try {
+        const path = getSwarmStatePath();
+        if (existsSync(path)) {
+            return JSON.parse(readFileSync(path, 'utf-8'));
+        }
+    }
+    catch { /* return default */ }
+    return { swarms: {}, version: '3.0.0' };
+}
+function saveSwarmStore(store) {
+    ensureSwarmDir();
+    writeFileSync(getSwarmStatePath(), JSON.stringify(store, null, 2), 'utf-8');
+}
+// Input validation
+const VALID_TOPOLOGIES = new Set([
+    'hierarchical', 'mesh', 'hierarchical-mesh', 'ring', 'star', 'hybrid', 'adaptive',
+]);
 export const swarmTools = [
     {
         name: 'swarm_init',
-        description: 'Initialize a swarm',
+        description: 'Initialize a swarm with persistent state tracking',
         category: 'swarm',
         inputSchema: {
             type: 'object',
             properties: {
-                topology: { type: 'string', description: 'Swarm topology type' },
-                maxAgents: { type: 'number', description: 'Maximum number of agents' },
-                config: { type: 'object', description: 'Swarm configuration' },
+                topology: { type: 'string', description: 'Swarm topology type (hierarchical, mesh, hierarchical-mesh, ring, star, hybrid, adaptive)' },
+                maxAgents: { type: 'number', description: 'Maximum number of agents (1-50)' },
+                strategy: { type: 'string', description: 'Agent strategy (specialized, balanced, adaptive)' },
+                config: { type: 'object', description: 'Additional swarm configuration' },
             },
         },
         handler: async (input) => {
             const topology = input.topology || 'hierarchical-mesh';
-            const maxAgents = input.maxAgents || 15;
+            const maxAgents = Math.min(Math.max(input.maxAgents || 15, 1), 50);
+            const strategy = input.strategy || 'specialized';
             const config = (input.config || {});
-            return {
-                success: true,
-                swarmId: `swarm-${Date.now()}`,
+            if (!VALID_TOPOLOGIES.has(topology)) {
+                return {
+                    success: false,
+                    error: `Invalid topology: ${topology}. Valid: ${[...VALID_TOPOLOGIES].join(', ')}`,
+                };
+            }
+            const swarmId = `swarm-${Date.now()}-${Math.random().toString(36).slice(2, 8)}`;
+            const now = new Date().toISOString();
+            const swarmState = {
+                swarmId,
                 topology,
-                initializedAt: new Date().toISOString(),
+                maxAgents,
+                status: 'running',
+                agents: [],
+                tasks: [],
                 config: {
                     topology,
                     maxAgents,
-                    currentAgents: 0,
+                    strategy,
                     communicationProtocol: config.communicationProtocol || 'message-bus',
                     autoScaling: config.autoScaling ?? true,
                     consensusMechanism: config.consensusMechanism || 'majority',
                 },
+                createdAt: now,
+                updatedAt: now,
+            };
+            const store = loadSwarmStore();
+            store.swarms[swarmId] = swarmState;
+            saveSwarmStore(store);
+            return {
+                success: true,
+                swarmId,
+                topology,
+                strategy,
+                maxAgents,
+                initializedAt: now,
+                config: swarmState.config,
+                persisted: true,
             };
         },
     },
     {
         name: 'swarm_status',
-        description: 'Get swarm status',
+        description: 'Get swarm status from persistent state',
         category: 'swarm',
         inputSchema: {
             type: 'object',
             properties: {
-                swarmId: { type: 'string', description: 'Swarm ID' },
+                swarmId: { type: 'string', description: 'Swarm ID (omit for most recent)' },
             },
         },
         handler: async (input) => {
+            const store = loadSwarmStore();
+            const swarmId = input.swarmId;
+            if (swarmId && store.swarms[swarmId]) {
+                const swarm = store.swarms[swarmId];
+                return {
+                    swarmId: swarm.swarmId,
+                    status: swarm.status,
+                    topology: swarm.topology,
+                    maxAgents: swarm.maxAgents,
+                    agentCount: swarm.agents.length,
+                    taskCount: swarm.tasks.length,
+                    config: swarm.config,
+                    createdAt: swarm.createdAt,
+                    updatedAt: swarm.updatedAt,
+                };
+            }
+            // Return most recent swarm if no ID specified
+            const swarmIds = Object.keys(store.swarms);
+            if (swarmIds.length === 0) {
+                return {
+                    status: 'no_swarm',
+                    message: 'No active swarms. Use swarm_init to create one.',
+                    totalSwarms: 0,
+                };
+            }
+            const latest = swarmIds
+                .map(id => store.swarms[id])
+                .sort((a, b) => new Date(b.updatedAt).getTime() - new Date(a.updatedAt).getTime())[0];
             return {
-                swarmId: input.swarmId,
-                status: 'running',
-                agentCount: 0,
-                taskCount: 0,
+                swarmId: latest.swarmId,
+                status: latest.status,
+                topology: latest.topology,
+                maxAgents: latest.maxAgents,
+                agentCount: latest.agents.length,
+                taskCount: latest.tasks.length,
+                config: latest.config,
+                createdAt: latest.createdAt,
+                updatedAt: latest.updatedAt,
+                totalSwarms: swarmIds.length,
             };
         },
     },
     {
         name: 'swarm_shutdown',
-        description: 'Shutdown a swarm',
+        description: 'Shutdown a swarm and update persistent state',
         category: 'swarm',
         inputSchema: {
             type: 'object',
             properties: {
-                swarmId: { type: 'string', description: 'Swarm ID' },
-                graceful: { type: 'boolean', description: 'Graceful shutdown' },
+                swarmId: { type: 'string', description: 'Swarm ID to shutdown' },
+                graceful: { type: 'boolean', description: 'Graceful shutdown (default: true)' },
             },
         },
         handler: async (input) => {
+            const store = loadSwarmStore();
+            const swarmId = input.swarmId;
+            // Find the swarm
+            let target;
+            if (swarmId && store.swarms[swarmId]) {
+                target = store.swarms[swarmId];
+            }
+            else {
+                // Shutdown most recent running swarm
+                const running = Object.values(store.swarms)
+                    .filter(s => s.status === 'running')
+                    .sort((a, b) => new Date(b.updatedAt).getTime() - new Date(a.updatedAt).getTime());
+                target = running[0];
+            }
+            if (!target) {
+                return {
+                    success: false,
+                    error: swarmId ? `Swarm ${swarmId} not found` : 'No running swarms to shutdown',
+                };
+            }
+            if (target.status === 'terminated') {
+                return {
+                    success: false,
+                    swarmId: target.swarmId,
+                    error: 'Swarm already terminated',
+                };
+            }
+            target.status = 'terminated';
+            target.updatedAt = new Date().toISOString();
+            saveSwarmStore(store);
             return {
                 success: true,
-                swarmId: input.swarmId,
+                swarmId: target.swarmId,
                 terminated: true,
+                graceful: input.graceful ?? true,
+                agentsTerminated: target.agents.length,
+                terminatedAt: target.updatedAt,
             };
         },
     },
     {
         name: 'swarm_health',
-        description: 'Check swarm health status',
+        description: 'Check swarm health status with real state inspection',
         category: 'swarm',
         inputSchema: {
             type: 'object',
@@ -85,15 +215,71 @@ export const swarmTools = [
             },
         },
         handler: async (input) => {
+            const store = loadSwarmStore();
+            const swarmId = input.swarmId;
+            // Find the swarm
+            let target;
+            if (swarmId) {
+                target = store.swarms[swarmId];
+                if (!target) {
+                    return {
+                        status: 'not_found',
+                        healthy: false,
+                        checks: [
+                            { name: 'swarm_exists', status: 'fail', message: `Swarm ${swarmId} not found` },
+                        ],
+                        checkedAt: new Date().toISOString(),
+                    };
+                }
+            }
+            else {
+                const running = Object.values(store.swarms)
+                    .filter(s => s.status === 'running')
+                    .sort((a, b) => new Date(b.updatedAt).getTime() - new Date(a.updatedAt).getTime());
+                target = running[0];
+            }
+            if (!target) {
+                return {
+                    status: 'no_swarm',
+                    healthy: false,
+                    checks: [
+                        { name: 'swarm_exists', status: 'fail', message: 'No active swarm found' },
+                    ],
+                    checkedAt: new Date().toISOString(),
+                };
+            }
+            const isRunning = target.status === 'running';
+            const stateFileExists = existsSync(getSwarmStatePath());
+            const checks = [
+                {
+                    name: 'coordinator',
+                    status: isRunning ? 'ok' : 'warn',
+                    message: isRunning ? 'Coordinator active' : `Swarm status: ${target.status}`,
+                },
+                {
+                    name: 'agents',
+                    status: target.agents.length > 0 ? 'ok' : 'info',
+                    message: `${target.agents.length} agents registered (max: ${target.maxAgents})`,
+                },
+                {
+                    name: 'persistence',
+                    status: stateFileExists ? 'ok' : 'warn',
+                    message: stateFileExists ? 'State file persisted' : 'State file missing',
+                },
+                {
+                    name: 'topology',
+                    status: 'ok',
+                    message: `Topology: ${target.topology}`,
+                },
+            ];
+            const healthy = isRunning && stateFileExists;
             return {
-                status: 'healthy',
-                swarmId: input.swarmId || 'default',
-                checks: [
-                    { name: 'coordinator', status: 'ok', message: 'Coordinator responding' },
-                    { name: 'agents', status: 'ok', message: 'Agent pool healthy' },
-                    { name: 'memory', status: 'ok', message: 'Memory backend connected' },
-                    { name: 'messaging', status: 'ok', message: 'Message bus active' },
-                ],
+                status: healthy ? 'healthy' : 'degraded',
+                healthy,
+                swarmId: target.swarmId,
+                topology: target.topology,
+                agentCount: target.agents.length,
+                checks,
                 checkedAt: new Date().toISOString(),
             };
         },

package/v3/@claude-flow/cli/dist/src/mcp-tools/wasm-agent-tools.d.ts

@@ -0,0 +1,9 @@
+/**
+ * WASM Agent MCP Tools
+ *
+ * Exposes @ruvector/rvagent-wasm operations via MCP protocol.
+ * All tools gracefully degrade when the WASM package is not installed.
+ */
+import type { MCPTool } from './types.js';
+export declare const wasmAgentTools: MCPTool[];
+//# sourceMappingURL=wasm-agent-tools.d.ts.map

package/v3/@claude-flow/cli/dist/src/mcp-tools/wasm-agent-tools.js

@@ -0,0 +1,230 @@
+/**
+ * WASM Agent MCP Tools
+ *
+ * Exposes @ruvector/rvagent-wasm operations via MCP protocol.
+ * All tools gracefully degrade when the WASM package is not installed.
+ */
+async function loadAgentWasm() {
+    const mod = await import('../ruvector/agent-wasm.js');
+    return mod;
+}
+export const wasmAgentTools = [
+    {
+        name: 'wasm_agent_create',
+        description: 'Create a sandboxed WASM agent with virtual filesystem (no OS access). Optionally use a gallery template.',
+        inputSchema: {
+            type: 'object',
+            properties: {
+                template: { type: 'string', description: 'Gallery template name (coder, researcher, tester, reviewer, security, swarm)' },
+                model: { type: 'string', description: 'Model identifier (default: anthropic:claude-sonnet-4-20250514)' },
+                instructions: { type: 'string', description: 'System instructions for the agent' },
+                maxTurns: { type: 'number', description: 'Max conversation turns (default: 50)' },
+            },
+        },
+        handler: async (args) => {
+            try {
+                const wasm = await loadAgentWasm();
+                if (args.template) {
+                    const info = await wasm.createAgentFromTemplate(args.template);
+                    return { content: [{ type: 'text', text: JSON.stringify({ success: true, agent: info, source: 'gallery' }, null, 2) }] };
+                }
+                const info = await wasm.createWasmAgent({
+                    model: args.model,
+                    instructions: args.instructions,
+                    maxTurns: args.maxTurns,
+                });
+                return { content: [{ type: 'text', text: JSON.stringify({ success: true, agent: info }, null, 2) }] };
+            }
+            catch (err) {
+                return { content: [{ type: 'text', text: JSON.stringify({ error: String(err) }) }], isError: true };
+            }
+        },
+    },
+    {
+        name: 'wasm_agent_prompt',
+        description: 'Send a prompt to a WASM agent and get a response.',
+        inputSchema: {
+            type: 'object',
+            properties: {
+                agentId: { type: 'string', description: 'WASM agent ID' },
+                input: { type: 'string', description: 'User prompt to send' },
+            },
+            required: ['agentId', 'input'],
+        },
+        handler: async (args) => {
+            try {
+                const wasm = await loadAgentWasm();
+                const result = await wasm.promptWasmAgent(args.agentId, args.input);
+                return { content: [{ type: 'text', text: result }] };
+            }
+            catch (err) {
+                return { content: [{ type: 'text', text: JSON.stringify({ error: String(err) }) }], isError: true };
+            }
+        },
+    },
+    {
+        name: 'wasm_agent_tool',
+        description: 'Execute a tool on a WASM agent sandbox. Tools: read_file, write_file, edit_file, write_todos, list_files. Use flat format: {tool, path, content, ...}.',
+        inputSchema: {
+            type: 'object',
+            properties: {
+                agentId: { type: 'string', description: 'WASM agent ID' },
+                toolName: { type: 'string', description: 'Tool name (read_file, write_file, edit_file, write_todos, list_files)' },
+                toolInput: { type: 'object', description: 'Tool parameters (flat: {path, content, old_string, new_string, todos})' },
+            },
+            required: ['agentId', 'toolName'],
+        },
+        handler: async (args) => {
+            try {
+                const wasm = await loadAgentWasm();
+                // Flat format: {tool: 'write_file', path: '...', content: '...'}
+                const toolCall = {
+                    tool: args.toolName,
+                    ...(args.toolInput ?? {}),
+                };
+                const result = await wasm.executeWasmTool(args.agentId, toolCall);
+                return { content: [{ type: 'text', text: JSON.stringify(result) }] };
+            }
+            catch (err) {
+                return { content: [{ type: 'text', text: JSON.stringify({ error: String(err) }) }], isError: true };
+            }
+        },
+    },
+    {
+        name: 'wasm_agent_list',
+        description: 'List all active WASM agents.',
+        inputSchema: { type: 'object', properties: {} },
+        handler: async () => {
+            try {
+                const wasm = await loadAgentWasm();
+                const agents = wasm.listWasmAgents();
+                return { content: [{ type: 'text', text: JSON.stringify({ agents, count: agents.length }, null, 2) }] };
+            }
+            catch (err) {
+                return { content: [{ type: 'text', text: JSON.stringify({ error: String(err) }) }], isError: true };
+            }
+        },
+    },
+    {
+        name: 'wasm_agent_terminate',
+        description: 'Terminate a WASM agent and free resources.',
+        inputSchema: {
+            type: 'object',
+            properties: {
+                agentId: { type: 'string', description: 'WASM agent ID' },
+            },
+            required: ['agentId'],
+        },
+        handler: async (args) => {
+            try {
+                const wasm = await loadAgentWasm();
+                const ok = wasm.terminateWasmAgent(args.agentId);
+                return { content: [{ type: 'text', text: JSON.stringify({ success: ok }) }] };
+            }
+            catch (err) {
+                return { content: [{ type: 'text', text: JSON.stringify({ error: String(err) }) }], isError: true };
+            }
+        },
+    },
+    {
+        name: 'wasm_agent_files',
+        description: 'Get a WASM agent\'s available tools and info.',
+        inputSchema: {
+            type: 'object',
+            properties: {
+                agentId: { type: 'string', description: 'WASM agent ID' },
+            },
+            required: ['agentId'],
+        },
+        handler: async (args) => {
+            try {
+                const wasm = await loadAgentWasm();
+                const tools = wasm.getWasmAgentTools(args.agentId);
+                const info = wasm.getWasmAgent(args.agentId);
+                return { content: [{ type: 'text', text: JSON.stringify({ tools, fileCount: info?.fileCount ?? 0, turnCount: info?.turnCount ?? 0 }, null, 2) }] };
+            }
+            catch (err) {
+                return { content: [{ type: 'text', text: JSON.stringify({ error: String(err) }) }], isError: true };
+            }
+        },
+    },
+    {
+        name: 'wasm_agent_export',
+        description: 'Export a WASM agent\'s full state (config, filesystem, conversation) as JSON.',
+        inputSchema: {
+            type: 'object',
+            properties: {
+                agentId: { type: 'string', description: 'WASM agent ID' },
+            },
+            required: ['agentId'],
+        },
+        handler: async (args) => {
+            try {
+                const wasm = await loadAgentWasm();
+                const state = wasm.exportWasmState(args.agentId);
+                return { content: [{ type: 'text', text: state }] };
+            }
+            catch (err) {
+                return { content: [{ type: 'text', text: JSON.stringify({ error: String(err) }) }], isError: true };
+            }
+        },
+    },
+    {
+        name: 'wasm_gallery_list',
+        description: 'List all available WASM agent gallery templates (Coder, Researcher, Tester, Reviewer, Security, Swarm).',
+        inputSchema: { type: 'object', properties: {} },
+        handler: async () => {
+            try {
+                const wasm = await loadAgentWasm();
+                const templates = await wasm.listGalleryTemplates();
+                return { content: [{ type: 'text', text: JSON.stringify({ templates, count: templates.length }, null, 2) }] };
+            }
+            catch (err) {
+                return { content: [{ type: 'text', text: JSON.stringify({ error: String(err) }) }], isError: true };
+            }
+        },
+    },
+    {
+        name: 'wasm_gallery_search',
+        description: 'Search WASM agent gallery templates by query.',
+        inputSchema: {
+            type: 'object',
+            properties: {
+                query: { type: 'string', description: 'Search query' },
+            },
+            required: ['query'],
+        },
+        handler: async (args) => {
+            try {
+                const wasm = await loadAgentWasm();
+                const results = await wasm.searchGalleryTemplates(args.query);
+                return { content: [{ type: 'text', text: JSON.stringify({ results, count: results.length }, null, 2) }] };
+            }
+            catch (err) {
+                return { content: [{ type: 'text', text: JSON.stringify({ error: String(err) }) }], isError: true };
+            }
+        },
+    },
+    {
+        name: 'wasm_gallery_create',
+        description: 'Create a WASM agent from a gallery template.',
+        inputSchema: {
+            type: 'object',
+            properties: {
+                template: { type: 'string', description: 'Template name (coder, researcher, tester, reviewer, security, swarm)' },
+            },
+            required: ['template'],
+        },
+        handler: async (args) => {
+            try {
+                const wasm = await loadAgentWasm();
+                const info = await wasm.createAgentFromTemplate(args.template);
+                return { content: [{ type: 'text', text: JSON.stringify({ success: true, agent: info, template: args.template }, null, 2) }] };
+            }
+            catch (err) {
+                return { content: [{ type: 'text', text: JSON.stringify({ error: String(err) }) }], isError: true };
+            }
+        },
+    },
+];
+//# sourceMappingURL=wasm-agent-tools.js.map

package/v3/@claude-flow/cli/dist/src/memory/memory-initializer.js

@@ -1315,6 +1315,60 @@ export async function loadEmbeddingModel(options) {
                 loadTime: Date.now() - startTime
             };
         }
+        // Fallback: Check for ruvector ONNX embedder (bundled MiniLM-L6-v2 since v0.2.15)
+        // v0.2.16: LoRA B=0 fix makes AdaptiveEmbedder safe (identity when untrained)
+        const ruvector = await import('ruvector').catch(() => null);
+        if (ruvector?.initOnnxEmbedder) {
+            try {
+                await ruvector.initOnnxEmbedder();
+                // Prefer AdaptiveEmbedder (LoRA adaptation capability, identity when untrained)
+                if (ruvector.AdaptiveEmbedder) {
+                    try {
+                        const adaptive = new ruvector.AdaptiveEmbedder({ useEpisodic: false });
+                        if (adaptive?.embed && adaptive.isReady?.()) {
+                            if (verbose) {
+                                console.log('Loading ruvector AdaptiveEmbedder (all-MiniLM-L6-v2 + LoRA)...');
+                            }
+                            embeddingModelState = {
+                                loaded: true,
+                                model: (text) => adaptive.embed(text),
+                                tokenizer: null,
+                                dimensions: adaptive.getDimension?.() || 384
+                            };
+                            return {
+                                success: true,
+                                dimensions: adaptive.getDimension?.() || 384,
+                                modelName: 'ruvector/adaptive',
+                                loadTime: Date.now() - startTime
+                            };
+                        }
+                    }
+                    catch { /* fall through to OptimizedOnnxEmbedder */ }
+                }
+                // Fallback: OptimizedOnnxEmbedder (raw ONNX without LoRA)
+                const onnxEmb = ruvector.getOptimizedOnnxEmbedder?.();
+                if (onnxEmb?.embed && onnxEmb.isReady?.()) {
+                    if (verbose) {
+                        console.log('Loading ruvector ONNX embedder (all-MiniLM-L6-v2)...');
+                    }
+                    embeddingModelState = {
+                        loaded: true,
+                        model: (text) => onnxEmb.embed(text),
+                        tokenizer: null,
+                        dimensions: onnxEmb.getDimension?.() || 384
+                    };
+                    return {
+                        success: true,
+                        dimensions: onnxEmb.getDimension?.() || 384,
+                        modelName: 'ruvector/onnx',
+                        loadTime: Date.now() - startTime
+                    };
+                }
+            }
+            catch {
+                // ruvector ONNX init failed, continue to next fallback
+            }
+        }
         // Legacy fallback: Check for agentic-flow core embeddings
         const agenticFlow = await import('agentic-flow').catch(() => null);
         if (agenticFlow && agenticFlow.embeddings) {
@@ -1378,12 +1432,17 @@ export async function generateEmbedding(text) {
     if (state.model && typeof state.model === 'function') {
         try {
             const output = await state.model(text, { pooling: 'mean', normalize: true });
-            const embedding = Array.from(output.data);
-            return {
-                embedding,
-                dimensions: embedding.length,
-                model: 'onnx'
-            };
+            // Handle both @xenova/transformers (output.data) and ruvector (plain array) formats
+            const embedding = output?.data
+                ? Array.from(output.data)
+                : Array.isArray(output) ? output : null;
+            if (embedding) {
+                return {
+                    embedding,
+                    dimensions: embedding.length,
+                    model: 'onnx'
+                };
+            }
         }
         catch {
             // Fall through to fallback