agentic-flow 1.0.0

package/dist/index.js

@@ -0,0 +1,167 @@
+import "dotenv/config";
+import { webResearchAgent } from "./agents/webResearchAgent.js";
+import { codeReviewAgent } from "./agents/codeReviewAgent.js";
+import { dataAgent } from "./agents/dataAgent.js";
+import { claudeAgent } from "./agents/claudeAgent.js";
+import { logger } from "./utils/logger.js";
+import { startHealthServer } from "./health.js";
+import { parseArgs, printHelp, validateOptions } from "./utils/cli.js";
+import { getAgent, listAgents } from "./utils/agentLoader.js";
+import { handleMCPCommand } from "./utils/mcpCommands.js";
+async function runParallelMode() {
+    const topic = process.env.TOPIC ?? "migrate payments service";
+    const codeDiff = process.env.DIFF ?? "feat: add payments router and mandate checks";
+    const datasetHint = process.env.DATASET ?? "monthly tx volume, refunds, chargebacks";
+    logger.info('Starting parallel agent execution', {
+        topic,
+        diff: codeDiff.substring(0, 50),
+        dataset: datasetHint
+    });
+    // Stream handler for real-time output
+    const streamHandler = (agent) => (chunk) => {
+        if (process.env.ENABLE_STREAMING === 'true') {
+            process.stdout.write(`[${agent}] ${chunk}`);
+        }
+    };
+    // Each agent runs with its own context. Fan out in parallel.
+    const startTime = Date.now();
+    const [researchOut, reviewOut, dataOut] = await Promise.all([
+        webResearchAgent(`Give me context and risks about: ${topic}`, streamHandler('RESEARCH')),
+        codeReviewAgent(`Review this diff at a high level and propose tests:\n${codeDiff}`, streamHandler('CODE_REVIEW')),
+        dataAgent(`Analyze ${datasetHint} and report key stats.`, streamHandler('DATA'))
+    ]);
+    const totalDuration = Date.now() - startTime;
+    logger.info('All agents completed', {
+        totalDuration,
+        agentCount: 3,
+        avgDuration: Math.round(totalDuration / 3)
+    });
+    // Basic reconcile step
+    const summary = [
+        "=== RESEARCH ===",
+        researchOut.output?.trim() ?? "",
+        "=== CODE REVIEW ===",
+        reviewOut.output?.trim() ?? "",
+        "=== DATA ===",
+        dataOut.output?.trim() ?? ""
+    ].join("\n");
+    console.log(summary);
+}
+async function runAgentMode(agentName, task, stream, modelOverride) {
+    logger.info('Running agent mode', { agent: agentName, task: task.substring(0, 100), model: modelOverride || 'default' });
+    // Load the specified agent
+    const agent = getAgent(agentName);
+    if (!agent) {
+        const availableAgents = listAgents();
+        logger.error('Agent not found', { agent: agentName });
+        console.error(`\n❌ Agent '${agentName}' not found.\n`);
+        console.error('Available agents:');
+        availableAgents.slice(0, 20).forEach(a => {
+            console.error(`  • ${a.name}: ${a.description.substring(0, 80)}...`);
+        });
+        if (availableAgents.length > 20) {
+            console.error(`  ... and ${availableAgents.length - 20} more (use --list to see all)`);
+        }
+        process.exit(1);
+    }
+    console.log(`\n🤖 Agent: ${agent.name}`);
+    console.log(`📝 Description: ${agent.description}\n`);
+    console.log(`🎯 Task: ${task}\n`);
+    if (modelOverride) {
+        console.log(`🔧 Model: ${modelOverride}\n`);
+    }
+    console.log('⏳ Running...\n');
+    const streamHandler = stream ? (chunk) => process.stdout.write(chunk) : undefined;
+    // Use Claude Agent SDK with in-SDK MCP server and optional model override
+    logger.info('Using Claude Agent SDK with in-SDK MCP server', { modelOverride });
+    const result = await claudeAgent(agent, task, streamHandler, modelOverride);
+    if (!stream) {
+        console.log('\n✅ Completed!\n');
+        console.log('═══════════════════════════════════════\n');
+        console.log(result.output);
+        console.log('\n═══════════════════════════════════════\n');
+    }
+    logger.info('Agent mode completed', { agent: agentName, outputLength: result.output.length, model: modelOverride || 'default' });
+}
+function runListMode() {
+    const agents = listAgents();
+    console.log(`\n📦 Available Agents (${agents.length} total)\n`);
+    // Group by category (based on directory structure)
+    const grouped = new Map();
+    agents.forEach(agent => {
+        const parts = agent.filePath.split('/');
+        const category = parts[parts.length - 2] || 'other';
+        if (!grouped.has(category)) {
+            grouped.set(category, []);
+        }
+        grouped.get(category).push(agent);
+    });
+    // Print grouped
+    Array.from(grouped.entries())
+        .sort(([a], [b]) => a.localeCompare(b))
+        .forEach(([category, categoryAgents]) => {
+        console.log(`\n${category.toUpperCase()}:`);
+        categoryAgents.forEach(agent => {
+            console.log(`  ${agent.name.padEnd(30)} ${agent.description.substring(0, 80)}`);
+        });
+    });
+    console.log(`\nTo use an agent:`);
+    console.log(`  docker run --env-file .env claude-agents --agent <name> --task "Your task"\n`);
+}
+async function main() {
+    logger.setContext({ service: 'claude-agents', version: '1.0.0' });
+    // Parse CLI arguments
+    const options = parseArgs();
+    // Handle help
+    if (options.help) {
+        printHelp();
+        process.exit(0);
+    }
+    // Handle list mode
+    if (options.mode === 'list') {
+        runListMode();
+        process.exit(0);
+    }
+    // Handle MCP mode
+    if (options.mode === 'mcp') {
+        await handleMCPCommand(options.mcpCommand || 'start', options.mcpServer || 'all');
+        process.exit(0);
+    }
+    // Validate options
+    const validationError = validateOptions(options);
+    if (validationError) {
+        console.error(`\n❌ ${validationError}\n`);
+        printHelp();
+        process.exit(1);
+    }
+    logger.info('Starting Claude Agent SDK', { mode: options.mode });
+    // Start health check server
+    const healthPort = parseInt(process.env.HEALTH_PORT || '8080');
+    const healthServer = startHealthServer(healthPort);
+    try {
+        if (options.mode === 'agent') {
+            const task = options.task || process.env.TASK || '';
+            const agent = options.agent || process.env.AGENT || '';
+            const model = options.model || process.env.MODEL;
+            await runAgentMode(agent, task, options.stream || false, model);
+        }
+        else {
+            await runParallelMode();
+        }
+        logger.info('Execution completed successfully');
+    }
+    catch (err) {
+        logger.error('Execution failed', { error: err });
+        throw err;
+    }
+    finally {
+        // Keep health server running for container health checks
+        if (process.env.KEEP_ALIVE !== 'true') {
+            healthServer.close();
+        }
+    }
+}
+main().catch(err => {
+    console.error(err);
+    process.exit(1);
+});

package/dist/mcp/claudeFlowSdkServer.js

@@ -0,0 +1,202 @@
+// In-SDK MCP server for claude-flow tools (no subprocess required)
+import { createSdkMcpServer, tool } from '@anthropic-ai/claude-agent-sdk';
+import { z } from 'zod';
+import { execSync } from 'child_process';
+import { logger } from '../utils/logger.js';
+/**
+ * Create an in-SDK MCP server that provides claude-flow memory and coordination tools
+ * This runs in-process without spawning Claude Code CLI subprocess
+ */
+export const claudeFlowSdkServer = createSdkMcpServer({
+    name: 'claude-flow-sdk',
+    version: '1.0.0',
+    tools: [
+        // Memory storage tool
+        tool('memory_store', 'Store a value in persistent memory with optional namespace and TTL', {
+            key: z.string().describe('Memory key'),
+            value: z.string().describe('Value to store'),
+            namespace: z.string().optional().default('default').describe('Memory namespace'),
+            ttl: z.number().optional().describe('Time-to-live in seconds')
+        }, async ({ key, value, namespace, ttl }) => {
+            try {
+                logger.info('Storing memory', { key, namespace });
+                const cmd = `npx claude-flow@alpha memory store "${key}" "${value}" --namespace "${namespace}"${ttl ? ` --ttl ${ttl}` : ''}`;
+                const result = execSync(cmd, { encoding: 'utf-8', maxBuffer: 10 * 1024 * 1024 });
+                logger.info('Memory stored successfully', { key });
+                return {
+                    content: [{
+                            type: 'text',
+                            text: `✅ Stored successfully\n📝 Key: ${key}\n📦 Namespace: ${namespace}\n💾 Size: ${value.length} bytes`
+                        }]
+                };
+            }
+            catch (error) {
+                logger.error('Failed to store memory', { error: error.message });
+                return {
+                    content: [{
+                            type: 'text',
+                            text: `❌ Failed to store: ${error.message}`
+                        }],
+                    isError: true
+                };
+            }
+        }),
+        // Memory retrieval tool
+        tool('memory_retrieve', 'Retrieve a value from persistent memory', {
+            key: z.string().describe('Memory key'),
+            namespace: z.string().optional().default('default').describe('Memory namespace')
+        }, async ({ key, namespace }) => {
+            try {
+                const cmd = `npx claude-flow@alpha memory retrieve "${key}" --namespace "${namespace}"`;
+                const result = execSync(cmd, { encoding: 'utf-8' });
+                return {
+                    content: [{
+                            type: 'text',
+                            text: `✅ Retrieved:\n${result}`
+                        }]
+                };
+            }
+            catch (error) {
+                return {
+                    content: [{
+                            type: 'text',
+                            text: `❌ Failed to retrieve: ${error.message}`
+                        }],
+                    isError: true
+                };
+            }
+        }),
+        // Memory search tool
+        tool('memory_search', 'Search for keys matching a pattern in memory', {
+            pattern: z.string().describe('Search pattern (supports wildcards)'),
+            namespace: z.string().optional().describe('Memory namespace to search in'),
+            limit: z.number().optional().default(10).describe('Maximum results to return')
+        }, async ({ pattern, namespace, limit }) => {
+            try {
+                const cmd = `npx claude-flow@alpha memory search "${pattern}"${namespace ? ` --namespace "${namespace}"` : ''} --limit ${limit}`;
+                const result = execSync(cmd, { encoding: 'utf-8' });
+                return {
+                    content: [{
+                            type: 'text',
+                            text: `🔍 Search results:\n${result}`
+                        }]
+                };
+            }
+            catch (error) {
+                return {
+                    content: [{
+                            type: 'text',
+                            text: `❌ Search failed: ${error.message}`
+                        }],
+                    isError: true
+                };
+            }
+        }),
+        // Swarm initialization tool
+        tool('swarm_init', 'Initialize a multi-agent swarm with specified topology', {
+            topology: z.enum(['mesh', 'hierarchical', 'ring', 'star']).describe('Swarm topology'),
+            maxAgents: z.number().optional().default(8).describe('Maximum number of agents'),
+            strategy: z.enum(['balanced', 'specialized', 'adaptive']).optional().default('balanced').describe('Agent distribution strategy')
+        }, async ({ topology, maxAgents, strategy }) => {
+            try {
+                const cmd = `npx claude-flow@alpha swarm init --topology ${topology} --max-agents ${maxAgents} --strategy ${strategy}`;
+                const result = execSync(cmd, { encoding: 'utf-8' });
+                return {
+                    content: [{
+                            type: 'text',
+                            text: `🚀 Swarm initialized:\n${result}`
+                        }]
+                };
+            }
+            catch (error) {
+                return {
+                    content: [{
+                            type: 'text',
+                            text: `❌ Swarm init failed: ${error.message}`
+                        }],
+                    isError: true
+                };
+            }
+        }),
+        // Agent spawn tool
+        tool('agent_spawn', 'Spawn a new agent in the swarm', {
+            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')
+        }, async ({ type, capabilities, name }) => {
+            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' });
+                return {
+                    content: [{
+                            type: 'text',
+                            text: `🤖 Agent spawned:\n${result}`
+                        }]
+                };
+            }
+            catch (error) {
+                return {
+                    content: [{
+                            type: 'text',
+                            text: `❌ Agent spawn failed: ${error.message}`
+                        }],
+                    isError: true
+                };
+            }
+        }),
+        // Task orchestration tool
+        tool('task_orchestrate', 'Orchestrate a complex task across the swarm', {
+            task: z.string().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().optional().describe('Maximum agents to use for this task')
+        }, async ({ task, strategy, priority, maxAgents }) => {
+            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' });
+                return {
+                    content: [{
+                            type: 'text',
+                            text: `⚡ Task orchestrated:\n${result}`
+                        }]
+                };
+            }
+            catch (error) {
+                return {
+                    content: [{
+                            type: 'text',
+                            text: `❌ Task orchestration failed: ${error.message}`
+                        }],
+                    isError: true
+                };
+            }
+        }),
+        // Swarm status tool
+        tool('swarm_status', 'Get current swarm status and metrics', {
+            verbose: z.boolean().optional().default(false).describe('Include detailed metrics')
+        }, async ({ verbose }) => {
+            try {
+                const cmd = `npx claude-flow@alpha swarm status${verbose ? ' --verbose' : ''}`;
+                const result = execSync(cmd, { encoding: 'utf-8' });
+                return {
+                    content: [{
+                            type: 'text',
+                            text: `📊 Swarm status:\n${result}`
+                        }]
+                };
+            }
+            catch (error) {
+                return {
+                    content: [{
+                            type: 'text',
+                            text: `❌ Status check failed: ${error.message}`
+                        }],
+                    isError: true
+                };
+            }
+        })
+    ]
+});

package/dist/mcp/fastmcp/servers/claude-flow-sdk.js

@@ -0,0 +1,198 @@
+#!/usr/bin/env node
+// FastMCP implementation of claude-flow-sdk server (in-process, 6 tools)
+// Phase 1: Migration from claudeFlowSdkServer.ts to fastmcp
+import { FastMCP } from 'fastmcp';
+import { z } from 'zod';
+import { execSync } from 'child_process';
+import { logger } from '../../../utils/logger.js';
+console.error('🚀 Starting FastMCP claude-flow-sdk Server...');
+// Create server
+const server = new FastMCP({
+    name: 'claude-flow-sdk',
+    version: '1.0.0'
+});
+// Tool 1: Memory Store
+server.addTool({
+    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 }) => {
+        try {
+            logger.info('Storing memory', { key, namespace });
+            const cmd = [
+                'npx claude-flow@alpha memory store',
+                `"${key}"`,
+                `"${value}"`,
+                `--namespace "${namespace}"`,
+                ttl ? `--ttl ${ttl}` : ''
+            ].filter(Boolean).join(' ');
+            const result = execSync(cmd, { encoding: 'utf-8', maxBuffer: 10 * 1024 * 1024 });
+            logger.info('Memory stored successfully', { key });
+            return JSON.stringify({
+                success: true,
+                key,
+                namespace,
+                size: value.length,
+                ttl,
+                timestamp: new Date().toISOString(),
+                message: 'Memory stored successfully'
+            }, null, 2);
+        }
+        catch (error) {
+            logger.error('Failed to store memory', { error: error.message });
+            throw new Error(`Failed to store memory: ${error.message}`);
+        }
+    }
+});
+// Tool 2: Memory Retrieve
+server.addTool({
+    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 }) => {
+        try {
+            const cmd = `npx claude-flow@alpha memory retrieve "${key}" --namespace "${namespace}"`;
+            const result = execSync(cmd, { encoding: 'utf-8', maxBuffer: 10 * 1024 * 1024 });
+            return JSON.stringify({
+                success: true,
+                key,
+                namespace,
+                value: result.trim(),
+                timestamp: new Date().toISOString()
+            }, null, 2);
+        }
+        catch (error) {
+            throw new Error(`Failed to retrieve memory: ${error.message}`);
+        }
+    }
+});
+// Tool 3: Memory Search
+server.addTool({
+    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 }) => {
+        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 JSON.stringify({
+                success: true,
+                pattern,
+                namespace: namespace || 'all',
+                results: result.trim(),
+                limit,
+                timestamp: new Date().toISOString()
+            }, null, 2);
+        }
+        catch (error) {
+            throw new Error(`Failed to search memory: ${error.message}`);
+        }
+    }
+});
+// Tool 4: Swarm Init
+server.addTool({
+    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 }) => {
+        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 JSON.stringify({
+                success: true,
+                topology,
+                maxAgents,
+                strategy,
+                result: result.trim(),
+                timestamp: new Date().toISOString()
+            }, null, 2);
+        }
+        catch (error) {
+            throw new Error(`Failed to initialize swarm: ${error.message}`);
+        }
+    }
+});
+// Tool 5: Agent Spawn
+server.addTool({
+    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 }) => {
+        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 JSON.stringify({
+                success: true,
+                type,
+                capabilities,
+                name,
+                result: result.trim(),
+                timestamp: new Date().toISOString()
+            }, null, 2);
+        }
+        catch (error) {
+            throw new Error(`Failed to spawn agent: ${error.message}`);
+        }
+    }
+});
+// Tool 6: Task Orchestrate
+server.addTool({
+    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 }) => {
+        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 JSON.stringify({
+                success: true,
+                task,
+                strategy,
+                priority,
+                maxAgents,
+                result: result.trim(),
+                timestamp: new Date().toISOString()
+            }, null, 2);
+        }
+        catch (error) {
+            throw new Error(`Failed to orchestrate task: ${error.message}`);
+        }
+    }
+});
+console.error('📦 Registered 6 tools: memory_store, memory_retrieve, memory_search, swarm_init, agent_spawn, task_orchestrate');
+console.error('🔌 Starting stdio transport...');
+// Start with stdio transport
+server.start({ transportType: 'stdio' }).then(() => {
+    console.error('✅ FastMCP claude-flow-sdk server running on stdio');
+}).catch((error) => {
+    console.error('❌ Failed to start server:', error);
+    process.exit(1);
+});