agentic-flow 1.0.0

package/dist/mcp/fastmcp/tools/agent/execute.js

@@ -0,0 +1,56 @@
+import { z } from 'zod';
+import { execSync } from 'child_process';
+const executeAgentSchema = z.object({
+    agent: z.string().describe('Agent name to execute (e.g., coder, researcher, reviewer)'),
+    task: z.string().describe('Task description for the agent'),
+    stream: z.boolean().optional().default(false).describe('Enable real-time streaming output')
+});
+export const executeAgentTool = {
+    name: 'agent_execute',
+    description: 'Execute a specific agent with a task (equivalent to --agent CLI command)',
+    parameters: executeAgentSchema,
+    async execute({ agent, task, stream }, { onProgress }) {
+        try {
+            onProgress?.({ progress: 0.1, message: `Starting agent: ${agent}` });
+            // Build command
+            const streamFlag = stream ? '--stream' : '';
+            const cmd = `npx agentic-flow --agent "${agent}" --task "${task}" ${streamFlag}`.trim();
+            onProgress?.({ progress: 0.3, message: 'Executing agent...' });
+            // Execute with timeout and capture output
+            const result = execSync(cmd, {
+                encoding: 'utf8',
+                maxBuffer: 10 * 1024 * 1024, // 10MB buffer
+                timeout: 300000, // 5 minute timeout
+                env: { ...process.env }
+            });
+            onProgress?.({ progress: 1.0, message: 'Agent execution completed' });
+            return {
+                content: [{
+                        type: 'text',
+                        text: JSON.stringify({
+                            success: true,
+                            agent,
+                            task: task.substring(0, 100),
+                            output: result,
+                            timestamp: new Date().toISOString()
+                        }, null, 2)
+                    }]
+            };
+        }
+        catch (error) {
+            return {
+                content: [{
+                        type: 'text',
+                        text: JSON.stringify({
+                            success: false,
+                            agent,
+                            error: error.message,
+                            stderr: error.stderr?.toString(),
+                            timestamp: new Date().toISOString()
+                        }, null, 2)
+                    }],
+                isError: true
+            };
+        }
+    }
+};

package/dist/mcp/fastmcp/tools/agent/list.js

@@ -0,0 +1,82 @@
+import { z } from 'zod';
+import { execSync } from 'child_process';
+const listAgentsSchema = z.object({
+    format: z.enum(['summary', 'detailed', 'json']).optional().default('summary')
+        .describe('Output format for agent list')
+});
+export const listAgentsTool = {
+    name: 'agent_list',
+    description: 'List all available agents (equivalent to --list CLI command)',
+    parameters: listAgentsSchema,
+    async execute({ format }, { onProgress }) {
+        try {
+            onProgress?.({ progress: 0.3, message: 'Loading available agents...' });
+            // Execute list command
+            const result = execSync('npx agentic-flow --list', {
+                encoding: 'utf8',
+                maxBuffer: 5 * 1024 * 1024,
+                timeout: 30000
+            });
+            onProgress?.({ progress: 0.8, message: 'Processing agent list...' });
+            // Parse the output to extract agent info
+            const agents = [];
+            const lines = result.split('\n');
+            let currentCategory = '';
+            for (const line of lines) {
+                if (line.includes(':') && line.trim().endsWith(':')) {
+                    currentCategory = line.replace(':', '').trim();
+                }
+                else if (line.trim().startsWith('•') || /^\s{2,}\w/.test(line)) {
+                    const match = line.match(/^\s*[•\s]*(\S+)\s+(.+)$/);
+                    if (match) {
+                        agents.push({
+                            name: match[1],
+                            description: match[2].trim(),
+                            category: currentCategory
+                        });
+                    }
+                }
+            }
+            onProgress?.({ progress: 1.0, message: `Found ${agents.length} agents` });
+            let output;
+            if (format === 'json') {
+                output = JSON.stringify({ agents, count: agents.length }, null, 2);
+            }
+            else if (format === 'detailed') {
+                output = result;
+            }
+            else {
+                output = JSON.stringify({
+                    success: true,
+                    count: agents.length,
+                    agents: agents.map(a => ({
+                        name: a.name,
+                        category: a.category,
+                        description: a.description.substring(0, 100) + (a.description.length > 100 ? '...' : '')
+                    })),
+                    timestamp: new Date().toISOString()
+                }, null, 2);
+            }
+            return {
+                content: [{
+                        type: 'text',
+                        text: output
+                    }]
+            };
+        }
+        catch (error) {
+            return {
+                content: [{
+                        type: 'text',
+                        text: JSON.stringify({
+                            success: false,
+                            error: error.message,
+                            stderr: error.stderr?.toString(),
+                            timestamp: new Date().toISOString()
+                        }, null, 2)
+                    }],
+                isError: true
+            };
+        }
+    }
+};

package/dist/mcp/fastmcp/tools/agent/parallel.js

@@ -0,0 +1,63 @@
+import { z } from 'zod';
+import { execSync } from 'child_process';
+const parallelModeSchema = z.object({
+    topic: z.string().optional().describe('Research topic for parallel mode'),
+    diff: z.string().optional().describe('Code diff for review'),
+    dataset: z.string().optional().describe('Dataset hint for analysis'),
+    streaming: z.boolean().optional().default(false).describe('Enable streaming output')
+});
+export const parallelModeTool = {
+    name: 'agent_parallel',
+    description: 'Run parallel mode with 3 agents (research, code review, data analysis)',
+    parameters: parallelModeSchema,
+    async execute({ topic, diff, dataset, streaming }, { onProgress }) {
+        try {
+            onProgress?.({ progress: 0.1, message: 'Starting parallel agent execution' });
+            // Set environment variables
+            const env = {
+                ...process.env,
+                ...(topic && { TOPIC: topic }),
+                ...(diff && { DIFF: diff }),
+                ...(dataset && { DATASET: dataset }),
+                ...(streaming && { ENABLE_STREAMING: 'true' })
+            };
+            onProgress?.({ progress: 0.3, message: 'Executing 3 agents in parallel...' });
+            // Execute parallel mode
+            const result = execSync('npx agentic-flow', {
+                encoding: 'utf8',
+                maxBuffer: 10 * 1024 * 1024,
+                timeout: 300000,
+                env
+            });
+            onProgress?.({ progress: 1.0, message: 'Parallel execution completed' });
+            return {
+                content: [{
+                        type: 'text',
+                        text: JSON.stringify({
+                            success: true,
+                            mode: 'parallel',
+                            agents: ['research', 'code_review', 'data'],
+                            config: { topic, diff, dataset, streaming },
+                            output: result,
+                            timestamp: new Date().toISOString()
+                        }, null, 2)
+                    }]
+            };
+        }
+        catch (error) {
+            return {
+                content: [{
+                        type: 'text',
+                        text: JSON.stringify({
+                            success: false,
+                            mode: 'parallel',
+                            error: error.message,
+                            stderr: error.stderr?.toString(),
+                            timestamp: new Date().toISOString()
+                        }, null, 2)
+                    }],
+                isError: true
+            };
+        }
+    }
+};

package/dist/mcp/fastmcp/tools/memory/retrieve.js

@@ -0,0 +1,38 @@
+// Memory retrieve tool implementation using FastMCP
+import { z } from 'zod';
+import { execSync } from 'child_process';
+export const memoryRetrieveTool = {
+    name: 'memory_retrieve',
+    description: 'Retrieve a value from persistent memory',
+    parameters: z.object({
+        key: z.string()
+            .min(1)
+            .describe('Memory key'),
+        namespace: z.string()
+            .optional()
+            .default('default')
+            .describe('Memory namespace')
+    }),
+    execute: async ({ key, namespace }, { onProgress, auth }) => {
+        try {
+            onProgress?.({ progress: 0.3, message: 'Retrieving value...' });
+            const cmd = `npx claude-flow@alpha memory retrieve "${key}" --namespace "${namespace}"`;
+            const result = execSync(cmd, {
+                encoding: 'utf-8',
+                maxBuffer: 10 * 1024 * 1024
+            });
+            onProgress?.({ progress: 1.0, message: 'Retrieved successfully' });
+            return {
+                success: true,
+                key,
+                namespace,
+                value: result.trim(),
+                userId: auth?.userId,
+                timestamp: new Date().toISOString()
+            };
+        }
+        catch (error) {
+            throw new Error(`Failed to retrieve memory: ${error.message}`);
+        }
+    }
+};

package/dist/mcp/fastmcp/tools/memory/search.js

@@ -0,0 +1,41 @@
+// Memory search tool implementation using FastMCP
+import { z } from 'zod';
+import { execSync } from 'child_process';
+export const memorySearchTool = {
+    name: 'memory_search',
+    description: 'Search for keys matching a pattern in memory',
+    parameters: z.object({
+        pattern: z.string()
+            .min(1)
+            .describe('Search pattern (supports wildcards)'),
+        namespace: z.string()
+            .optional()
+            .describe('Memory namespace to search in'),
+        limit: z.number()
+            .positive()
+            .optional()
+            .default(10)
+            .describe('Maximum results to return')
+    }),
+    execute: async ({ pattern, namespace, limit }, { onProgress, auth }) => {
+        try {
+            const cmd = `npx claude-flow@alpha memory search "${pattern}"${namespace ? ` --namespace "${namespace}"` : ''} --limit ${limit}`;
+            const result = execSync(cmd, {
+                encoding: 'utf-8',
+                maxBuffer: 10 * 1024 * 1024
+            });
+            return {
+                success: true,
+                pattern,
+                namespace: namespace || 'all',
+                results: result.trim(),
+                limit,
+                userId: auth?.userId,
+                timestamp: new Date().toISOString()
+            };
+        }
+        catch (error) {
+            throw new Error(`Failed to search memory: ${error.message}`);
+        }
+    }
+};

package/dist/mcp/fastmcp/tools/memory/store.js

@@ -0,0 +1,56 @@
+// Memory store tool implementation using FastMCP
+import { z } from 'zod';
+import { execSync } from 'child_process';
+export const memoryStoreTool = {
+    name: 'memory_store',
+    description: 'Store a value in persistent memory with optional namespace and TTL',
+    parameters: z.object({
+        key: z.string()
+            .min(1)
+            .describe('Memory key'),
+        value: z.string()
+            .describe('Value to store'),
+        namespace: z.string()
+            .optional()
+            .default('default')
+            .describe('Memory namespace'),
+        ttl: z.number()
+            .positive()
+            .optional()
+            .describe('Time-to-live in seconds')
+    }),
+    execute: async ({ key, value, namespace, ttl }, { onProgress, auth }) => {
+        try {
+            // Progress reporting
+            onProgress?.({ progress: 0.2, message: 'Validating input...' });
+            // Build command
+            const cmd = [
+                'npx claude-flow@alpha memory store',
+                `"${key}"`,
+                `"${value}"`,
+                `--namespace "${namespace}"`,
+                ttl ? `--ttl ${ttl}` : ''
+            ].filter(Boolean).join(' ');
+            onProgress?.({ progress: 0.5, message: 'Storing value...' });
+            // Execute
+            const result = execSync(cmd, {
+                encoding: 'utf-8',
+                maxBuffer: 10 * 1024 * 1024
+            });
+            onProgress?.({ progress: 1.0, message: 'Stored successfully' });
+            // Return formatted result
+            return {
+                success: true,
+                key,
+                namespace,
+                size: value.length,
+                ttl,
+                userId: auth?.userId,
+                timestamp: new Date().toISOString()
+            };
+        }
+        catch (error) {
+            throw new Error(`Failed to store memory: ${error.message}`);
+        }
+    }
+};

package/dist/mcp/fastmcp/tools/swarm/init.js

@@ -0,0 +1,41 @@
+// Swarm init tool implementation using FastMCP
+import { z } from 'zod';
+import { execSync } from 'child_process';
+export const swarmInitTool = {
+    name: 'swarm_init',
+    description: 'Initialize a multi-agent swarm with specified topology',
+    parameters: z.object({
+        topology: z.enum(['mesh', 'hierarchical', 'ring', 'star'])
+            .describe('Swarm topology'),
+        maxAgents: z.number()
+            .positive()
+            .optional()
+            .default(8)
+            .describe('Maximum number of agents'),
+        strategy: z.enum(['balanced', 'specialized', 'adaptive'])
+            .optional()
+            .default('balanced')
+            .describe('Agent distribution strategy')
+    }),
+    execute: async ({ topology, maxAgents, strategy }, { onProgress, auth }) => {
+        try {
+            const cmd = `npx claude-flow@alpha swarm init --topology ${topology} --max-agents ${maxAgents} --strategy ${strategy}`;
+            const result = execSync(cmd, {
+                encoding: 'utf-8',
+                maxBuffer: 10 * 1024 * 1024
+            });
+            return {
+                success: true,
+                topology,
+                maxAgents,
+                strategy,
+                result: result.trim(),
+                userId: auth?.userId,
+                timestamp: new Date().toISOString()
+            };
+        }
+        catch (error) {
+            throw new Error(`Failed to initialize swarm: ${error.message}`);
+        }
+    }
+};

package/dist/mcp/fastmcp/tools/swarm/orchestrate.js

@@ -0,0 +1,47 @@
+// Task orchestration tool implementation using FastMCP
+import { z } from 'zod';
+import { execSync } from 'child_process';
+export const taskOrchestrateTool = {
+    name: 'task_orchestrate',
+    description: 'Orchestrate a complex task across the swarm',
+    parameters: z.object({
+        task: z.string()
+            .min(1)
+            .describe('Task description or instructions'),
+        strategy: z.enum(['parallel', 'sequential', 'adaptive'])
+            .optional()
+            .default('adaptive')
+            .describe('Execution strategy'),
+        priority: z.enum(['low', 'medium', 'high', 'critical'])
+            .optional()
+            .default('medium')
+            .describe('Task priority'),
+        maxAgents: z.number()
+            .positive()
+            .optional()
+            .describe('Maximum agents to use for this task')
+    }),
+    execute: async ({ task, strategy, priority, maxAgents }, { onProgress, auth }) => {
+        try {
+            const maxStr = maxAgents ? ` --max-agents ${maxAgents}` : '';
+            const cmd = `npx claude-flow@alpha task orchestrate "${task}" --strategy ${strategy} --priority ${priority}${maxStr}`;
+            const result = execSync(cmd, {
+                encoding: 'utf-8',
+                maxBuffer: 10 * 1024 * 1024
+            });
+            return {
+                success: true,
+                task,
+                strategy,
+                priority,
+                maxAgents,
+                result: result.trim(),
+                userId: auth?.userId,
+                timestamp: new Date().toISOString()
+            };
+        }
+        catch (error) {
+            throw new Error(`Failed to orchestrate task: ${error.message}`);
+        }
+    }
+};

package/dist/mcp/fastmcp/tools/swarm/spawn.js

@@ -0,0 +1,40 @@
+// Agent spawn tool implementation using FastMCP
+import { z } from 'zod';
+import { execSync } from 'child_process';
+export const agentSpawnTool = {
+    name: 'agent_spawn',
+    description: 'Spawn a new agent in the swarm',
+    parameters: z.object({
+        type: z.enum(['researcher', 'coder', 'analyst', 'optimizer', 'coordinator'])
+            .describe('Agent type'),
+        capabilities: z.array(z.string())
+            .optional()
+            .describe('Agent capabilities'),
+        name: z.string()
+            .optional()
+            .describe('Custom agent name')
+    }),
+    execute: async ({ type, capabilities, name }, { onProgress, auth }) => {
+        try {
+            const capStr = capabilities ? ` --capabilities "${capabilities.join(',')}"` : '';
+            const nameStr = name ? ` --name "${name}"` : '';
+            const cmd = `npx claude-flow@alpha agent spawn --type ${type}${capStr}${nameStr}`;
+            const result = execSync(cmd, {
+                encoding: 'utf-8',
+                maxBuffer: 10 * 1024 * 1024
+            });
+            return {
+                success: true,
+                type,
+                capabilities,
+                name,
+                result: result.trim(),
+                userId: auth?.userId,
+                timestamp: new Date().toISOString()
+            };
+        }
+        catch (error) {
+            throw new Error(`Failed to spawn agent: ${error.message}`);
+        }
+    }
+};

package/dist/mcp/fastmcp/types/index.js

@@ -0,0 +1,2 @@
+// Type definitions for FastMCP implementation
+export {};