agentic-flow 1.0.0

package/dist/agents/claudeAgent.js

@@ -0,0 +1,73 @@
+// Generic agent that uses .claude/agents definitions
+import { query } from "@anthropic-ai/claude-agent-sdk";
+import { logger } from "../utils/logger.js";
+import { withRetry } from "../utils/retry.js";
+import { claudeFlowSdkServer } from "../mcp/claudeFlowSdkServer.js";
+export async function claudeAgent(agent, input, onStream, modelOverride) {
+    const startTime = Date.now();
+    logger.info('Starting Claude agent', {
+        agent: agent.name,
+        input: input.substring(0, 100),
+        model: modelOverride || 'default'
+    });
+    return withRetry(async () => {
+        // Quad MCP server setup: in-SDK + claude-flow + flow-nexus + agentic-payments
+        const result = query({
+            prompt: input,
+            options: {
+                systemPrompt: agent.systemPrompt,
+                model: modelOverride, // Support custom models like OpenRouter
+                permissionMode: 'bypassPermissions', // Auto-approve all tool usage for Docker automation
+                mcpServers: {
+                    // In-SDK server: 6 basic tools (memory + swarm)
+                    'claude-flow-sdk': claudeFlowSdkServer,
+                    // Full MCP server: 101 tools via subprocess (neural, analysis, workflow, github, daa, system)
+                    'claude-flow': {
+                        command: 'npx',
+                        args: ['claude-flow@alpha', 'mcp', 'start'],
+                        env: {
+                            ...process.env,
+                            MCP_AUTO_START: 'true'
+                        }
+                    },
+                    // Flow Nexus MCP server: 96 cloud tools (sandboxes, swarms, neural, workflows)
+                    'flow-nexus': {
+                        command: 'npx',
+                        args: ['flow-nexus@latest', 'mcp', 'start'],
+                        env: {
+                            ...process.env,
+                            FLOW_NEXUS_AUTO_START: 'true'
+                        }
+                    },
+                    // Agentic Payments MCP server: Payment authorization and multi-agent consensus
+                    'agentic-payments': {
+                        command: 'npx',
+                        args: ['-y', 'agentic-payments', 'mcp'],
+                        env: {
+                            ...process.env,
+                            AGENTIC_PAYMENTS_AUTO_START: 'true'
+                        }
+                    }
+                }
+                // allowedTools: removed to enable ALL tools from all servers
+            }
+        });
+        let output = '';
+        for await (const msg of result) {
+            if (msg.type === 'assistant') {
+                const chunk = msg.message.content?.map((c) => c.type === 'text' ? c.text : '').join('') || '';
+                output += chunk;
+                if (onStream && chunk) {
+                    onStream(chunk);
+                }
+            }
+        }
+        const duration = Date.now() - startTime;
+        logger.info('Claude agent completed', {
+            agent: agent.name,
+            duration,
+            outputLength: output.length
+        });
+        return { output, agent: agent.name };
+    });
+}

package/dist/agents/claudeFlowAgent.js

@@ -0,0 +1,115 @@
+// Agent with Claude Flow memory and coordination capabilities
+import { query } from '@anthropic-ai/claude-agent-sdk';
+import { logger } from '../utils/logger.js';
+import { withRetry } from '../utils/retry.js';
+import { toolConfig } from '../config/tools.js';
+import { getMemoryConfig, getSwarmConfig } from '../config/claudeFlow.js';
+/**
+ * Execute agent with Claude Flow memory and coordination
+ */
+export async function claudeFlowAgent(agentName, systemPrompt, input, options = {}) {
+    const { enableMemory = true, enableCoordination = false, memoryNamespace, swarmTopology = 'mesh', onStream } = options;
+    const startTime = Date.now();
+    logger.info('Starting Claude Flow agent', {
+        agentName,
+        input: input.substring(0, 100),
+        enableMemory,
+        enableCoordination
+    });
+    // Prepare memory context if enabled
+    let memoryContext = '';
+    if (enableMemory) {
+        const memoryConfig = getMemoryConfig(memoryNamespace || agentName);
+        memoryContext = `
+
+You have access to persistent memory via claude-flow tools:
+- Store: mcp__claude-flow__memory_usage with action="store", namespace="${memoryConfig.namespace}"
+- Retrieve: mcp__claude-flow__memory_usage with action="retrieve", namespace="${memoryConfig.namespace}"
+- Search: mcp__claude-flow__memory_search with pattern="search query"
+
+Use memory to persist important information across conversations.`;
+    }
+    // Prepare coordination context if enabled
+    let coordinationContext = '';
+    if (enableCoordination) {
+        const swarmConfig = getSwarmConfig(swarmTopology);
+        coordinationContext = `
+
+You have access to swarm coordination via claude-flow tools:
+- Init swarm: mcp__claude-flow__swarm_init with topology="${swarmConfig.topology}"
+- Spawn agent: mcp__claude-flow__agent_spawn with type="researcher|coder|analyst"
+- Orchestrate: mcp__claude-flow__task_orchestrate with task="description"
+- Check status: mcp__claude-flow__swarm_status
+
+Use coordination for complex multi-agent tasks.`;
+    }
+    const enhancedSystemPrompt = `${systemPrompt}${memoryContext}${coordinationContext}`;
+    return withRetry(async () => {
+        const result = query({
+            prompt: input,
+            options: {
+                systemPrompt: enhancedSystemPrompt,
+                ...toolConfig
+            }
+        });
+        let output = '';
+        for await (const msg of result) {
+            if (msg.type === 'assistant') {
+                const chunk = msg.message.content
+                    ?.map((c) => (c.type === 'text' ? c.text : ''))
+                    .join('') || '';
+                output += chunk;
+                if (onStream && chunk) {
+                    onStream(chunk);
+                }
+            }
+        }
+        const duration = Date.now() - startTime;
+        logger.info('Claude Flow agent completed', {
+            agentName,
+            duration,
+            outputLength: output.length,
+            memoryUsed: enableMemory,
+            coordinationUsed: enableCoordination
+        });
+        return { output };
+    });
+}
+/**
+ * Example: Memory-enabled research agent
+ */
+export async function memoryResearchAgent(topic, onStream) {
+    return claudeFlowAgent('memory-researcher', `You are a research agent with persistent memory.
+
+Research the given topic thoroughly and store key findings in memory for future reference.
+Use memory_usage tool to store important facts, insights, and references.`, `Research topic: ${topic}`, {
+        enableMemory: true,
+        enableCoordination: false,
+        onStream
+    });
+}
+/**
+ * Example: Coordination-enabled orchestrator agent
+ */
+export async function orchestratorAgent(task, onStream) {
+    return claudeFlowAgent('orchestrator', `You are an orchestration agent that coordinates multiple specialized agents.
+
+Break down complex tasks and delegate to specialized agents using swarm coordination.
+Use swarm_init, agent_spawn, and task_orchestrate tools to manage the workflow.`, `Orchestrate task: ${task}`, {
+        enableMemory: true,
+        enableCoordination: true,
+        swarmTopology: 'hierarchical',
+        onStream
+    });
+}
+/**
+ * Example: Full-featured agent with memory and coordination
+ */
+export async function hybridAgent(task, agentName = 'hybrid', systemPrompt = 'You are a versatile agent with memory and coordination capabilities.', onStream) {
+    return claudeFlowAgent(agentName, systemPrompt, task, {
+        enableMemory: true,
+        enableCoordination: true,
+        swarmTopology: 'mesh',
+        onStream
+    });
+}

package/dist/agents/codeReviewAgent.js

@@ -0,0 +1,34 @@
+// src/agents/codeReviewAgent.ts
+import { query } from "@anthropic-ai/claude-agent-sdk";
+import { logger } from "../utils/logger.js";
+import { withRetry } from "../utils/retry.js";
+import { toolConfig } from "../config/tools.js";
+export async function codeReviewAgent(input, onStream) {
+    const startTime = Date.now();
+    logger.info('Starting code review agent', { input: input.substring(0, 100) });
+    return withRetry(async () => {
+        const result = query({
+            prompt: input,
+            options: {
+                systemPrompt: `You review diffs and point out risks, complexity, and tests to add.`,
+                ...toolConfig
+            }
+        });
+        let output = '';
+        for await (const msg of result) {
+            if (msg.type === 'assistant') {
+                const chunk = msg.message.content?.map((c) => c.type === 'text' ? c.text : '').join('') || '';
+                output += chunk;
+                if (onStream && chunk) {
+                    onStream(chunk);
+                }
+            }
+        }
+        const duration = Date.now() - startTime;
+        logger.info('Code review agent completed', {
+            duration,
+            outputLength: output.length
+        });
+        return { output };
+    });
+}

package/dist/agents/dataAgent.js

@@ -0,0 +1,34 @@
+// src/agents/dataAgent.ts
+import { query } from "@anthropic-ai/claude-agent-sdk";
+import { logger } from "../utils/logger.js";
+import { withRetry } from "../utils/retry.js";
+import { toolConfig } from "../config/tools.js";
+export async function dataAgent(input, onStream) {
+    const startTime = Date.now();
+    logger.info('Starting data agent', { input: input.substring(0, 100) });
+    return withRetry(async () => {
+        const result = query({
+            prompt: input,
+            options: {
+                systemPrompt: `You analyze tabular data and produce a short brief with 3 key stats and 1 risk.`,
+                ...toolConfig
+            }
+        });
+        let output = '';
+        for await (const msg of result) {
+            if (msg.type === 'assistant') {
+                const chunk = msg.message.content?.map((c) => c.type === 'text' ? c.text : '').join('') || '';
+                output += chunk;
+                if (onStream && chunk) {
+                    onStream(chunk);
+                }
+            }
+        }
+        const duration = Date.now() - startTime;
+        logger.info('Data agent completed', {
+            duration,
+            outputLength: output.length
+        });
+        return { output };
+    });
+}

package/dist/agents/directApiAgent.js

@@ -0,0 +1,260 @@
+// Direct Anthropic API agent with in-process tool execution (no subprocess)
+import Anthropic from '@anthropic-ai/sdk';
+import { logger } from '../utils/logger.js';
+import { withRetry } from '../utils/retry.js';
+import { execSync } from 'child_process';
+const anthropic = new Anthropic({
+    apiKey: process.env.ANTHROPIC_API_KEY
+});
+// Define claude-flow tools as native Anthropic tool definitions
+const claudeFlowTools = [
+    {
+        name: 'memory_store',
+        description: 'Store a value in persistent memory with optional namespace and TTL',
+        input_schema: {
+            type: 'object',
+            properties: {
+                key: { type: 'string', description: 'Memory key' },
+                value: { type: 'string', description: 'Value to store' },
+                namespace: { type: 'string', description: 'Memory namespace', default: 'default' },
+                ttl: { type: 'number', description: 'Time-to-live in seconds' }
+            },
+            required: ['key', 'value']
+        }
+    },
+    {
+        name: 'memory_retrieve',
+        description: 'Retrieve a value from persistent memory',
+        input_schema: {
+            type: 'object',
+            properties: {
+                key: { type: 'string', description: 'Memory key' },
+                namespace: { type: 'string', description: 'Memory namespace', default: 'default' }
+            },
+            required: ['key']
+        }
+    },
+    {
+        name: 'memory_search',
+        description: 'Search for keys matching a pattern in memory',
+        input_schema: {
+            type: 'object',
+            properties: {
+                pattern: { type: 'string', description: 'Search pattern (supports wildcards)' },
+                namespace: { type: 'string', description: 'Memory namespace to search in' },
+                limit: { type: 'number', description: 'Maximum results to return', default: 10 }
+            },
+            required: ['pattern']
+        }
+    },
+    {
+        name: 'swarm_init',
+        description: 'Initialize a multi-agent swarm with specified topology',
+        input_schema: {
+            type: 'object',
+            properties: {
+                topology: { type: 'string', enum: ['mesh', 'hierarchical', 'ring', 'star'], description: 'Swarm topology' },
+                maxAgents: { type: 'number', description: 'Maximum number of agents', default: 8 },
+                strategy: { type: 'string', enum: ['balanced', 'specialized', 'adaptive'], description: 'Agent distribution strategy', default: 'balanced' }
+            },
+            required: ['topology']
+        }
+    },
+    {
+        name: 'agent_spawn',
+        description: 'Spawn a new agent in the swarm',
+        input_schema: {
+            type: 'object',
+            properties: {
+                type: { type: 'string', enum: ['researcher', 'coder', 'analyst', 'optimizer', 'coordinator'], description: 'Agent type' },
+                capabilities: { type: 'array', items: { type: 'string' }, description: 'Agent capabilities' },
+                name: { type: 'string', description: 'Custom agent name' }
+            },
+            required: ['type']
+        }
+    },
+    {
+        name: 'task_orchestrate',
+        description: 'Orchestrate a complex task across the swarm',
+        input_schema: {
+            type: 'object',
+            properties: {
+                task: { type: 'string', description: 'Task description or instructions' },
+                strategy: { type: 'string', enum: ['parallel', 'sequential', 'adaptive'], description: 'Execution strategy', default: 'adaptive' },
+                priority: { type: 'string', enum: ['low', 'medium', 'high', 'critical'], description: 'Task priority', default: 'medium' },
+                maxAgents: { type: 'number', description: 'Maximum agents to use for this task' }
+            },
+            required: ['task']
+        }
+    },
+    {
+        name: 'swarm_status',
+        description: 'Get current swarm status and metrics',
+        input_schema: {
+            type: 'object',
+            properties: {
+                verbose: { type: 'boolean', description: 'Include detailed metrics', default: false }
+            }
+        }
+    }
+];
+// Execute tool calls using claude-flow CLI
+async function executeToolCall(toolName, toolInput) {
+    try {
+        logger.info('Executing tool', { toolName, input: toolInput });
+        switch (toolName) {
+            case 'memory_store': {
+                const { key, value, namespace = 'default', ttl } = toolInput;
+                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', { key, namespace });
+                return `✅ Stored successfully\n📝 Key: ${key}\n📦 Namespace: ${namespace}\n💾 Size: ${value.length} bytes`;
+            }
+            case 'memory_retrieve': {
+                const { key, namespace = 'default' } = toolInput;
+                const cmd = `npx claude-flow@alpha memory retrieve "${key}" --namespace "${namespace}"`;
+                const result = execSync(cmd, { encoding: 'utf-8' });
+                logger.info('Memory retrieved', { key });
+                return `✅ Retrieved:\n${result}`;
+            }
+            case 'memory_search': {
+                const { pattern, namespace, limit = 10 } = toolInput;
+                const cmd = `npx claude-flow@alpha memory search "${pattern}"${namespace ? ` --namespace "${namespace}"` : ''} --limit ${limit}`;
+                const result = execSync(cmd, { encoding: 'utf-8' });
+                return `🔍 Search results:\n${result}`;
+            }
+            case 'swarm_init': {
+                const { topology, maxAgents = 8, strategy = 'balanced' } = toolInput;
+                const cmd = `npx claude-flow@alpha swarm init --topology ${topology} --max-agents ${maxAgents} --strategy ${strategy}`;
+                const result = execSync(cmd, { encoding: 'utf-8' });
+                return `🚀 Swarm initialized:\n${result}`;
+            }
+            case 'agent_spawn': {
+                const { type, capabilities, name } = toolInput;
+                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 `🤖 Agent spawned:\n${result}`;
+            }
+            case 'task_orchestrate': {
+                const { task, strategy = 'adaptive', priority = 'medium', maxAgents } = toolInput;
+                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 `⚡ Task orchestrated:\n${result}`;
+            }
+            case 'swarm_status': {
+                const { verbose = false } = toolInput;
+                const cmd = `npx claude-flow@alpha swarm status${verbose ? ' --verbose' : ''}`;
+                const result = execSync(cmd, { encoding: 'utf-8' });
+                return `📊 Swarm status:\n${result}`;
+            }
+            default:
+                throw new Error(`Unknown tool: ${toolName}`);
+        }
+    }
+    catch (error) {
+        logger.error('Tool execution failed', { toolName, error: error.message });
+        return `❌ Tool execution failed: ${error.message}`;
+    }
+}
+/**
+ * Direct API agent using Anthropic SDK with native tool calling
+ * Bypasses Claude Agent SDK subprocess issues entirely
+ */
+export async function directApiAgent(agent, input, onStream) {
+    const startTime = Date.now();
+    logger.info('Starting direct API agent', {
+        agent: agent.name,
+        input: input.substring(0, 100)
+    });
+    return withRetry(async () => {
+        const messages = [
+            { role: 'user', content: input }
+        ];
+        let finalOutput = '';
+        let toolUseCount = 0;
+        const maxToolUses = 10; // Prevent infinite loops
+        // Agentic loop: keep calling API until no more tool uses
+        while (toolUseCount < maxToolUses) {
+            logger.debug('API call iteration', { toolUseCount, messagesLength: messages.length });
+            const response = await anthropic.messages.create({
+                model: 'claude-sonnet-4-5-20250929',
+                max_tokens: 8192,
+                system: agent.systemPrompt || 'You are a helpful AI assistant.',
+                messages,
+                tools: claudeFlowTools
+            });
+            logger.debug('API response', {
+                stopReason: response.stop_reason,
+                contentBlocks: response.content.length
+            });
+            // Process response content
+            const toolResults = [];
+            for (const block of response.content) {
+                if (block.type === 'text') {
+                    finalOutput += block.text;
+                    if (onStream) {
+                        onStream(block.text);
+                    }
+                }
+                else if (block.type === 'tool_use') {
+                    toolUseCount++;
+                    logger.info('Tool use requested', {
+                        toolName: block.name,
+                        toolUseId: block.id
+                    });
+                    // Execute the tool
+                    const toolResult = await executeToolCall(block.name, block.input);
+                    // Collect tool result
+                    toolResults.push({
+                        type: 'tool_result',
+                        tool_use_id: block.id,
+                        content: toolResult
+                    });
+                    logger.debug('Tool result collected', {
+                        toolUseId: block.id,
+                        resultLength: toolResult.length
+                    });
+                }
+            }
+            // If there were tool uses, add assistant message and all tool results
+            if (toolResults.length > 0) {
+                // Add assistant message with tool uses
+                messages.push({
+                    role: 'assistant',
+                    content: response.content
+                });
+                // Add all tool results in one user message
+                messages.push({
+                    role: 'user',
+                    content: toolResults
+                });
+                logger.debug('Tool results added to conversation', {
+                    count: toolResults.length
+                });
+            }
+            // Stop if no tool use or end_turn
+            if (response.stop_reason === 'end_turn' || response.content.every(b => b.type === 'text')) {
+                // Add final assistant message if it has text
+                const textContent = response.content.filter(b => b.type === 'text');
+                if (textContent.length > 0 && messages[messages.length - 1].role !== 'assistant') {
+                    messages.push({
+                        role: 'assistant',
+                        content: response.content
+                    });
+                }
+                break;
+            }
+        }
+        const duration = Date.now() - startTime;
+        logger.info('Direct API agent completed', {
+            agent: agent.name,
+            duration,
+            toolUseCount,
+            outputLength: finalOutput.length
+        });
+        return { output: finalOutput, agent: agent.name };
+    });
+}

package/dist/agents/webResearchAgent.js

@@ -0,0 +1,35 @@
+// src/agents/webResearchAgent.ts
+import { query } from "@anthropic-ai/claude-agent-sdk";
+import { logger } from "../utils/logger.js";
+import { withRetry } from "../utils/retry.js";
+import { toolConfig } from "../config/tools.js";
+export async function webResearchAgent(input, onStream) {
+    const startTime = Date.now();
+    logger.info('Starting web research agent', { input: input.substring(0, 100) });
+    return withRetry(async () => {
+        const result = query({
+            prompt: input,
+            options: {
+                systemPrompt: `You perform fast web-style reconnaissance and return a concise bullet list of findings.`,
+                ...toolConfig
+            }
+        });
+        let output = '';
+        for await (const msg of result) {
+            if (msg.type === 'assistant') {
+                const chunk = msg.message.content?.map((c) => c.type === 'text' ? c.text : '').join('') || '';
+                output += chunk;
+                // Stream chunks in real-time
+                if (onStream && chunk) {
+                    onStream(chunk);
+                }
+            }
+        }
+        const duration = Date.now() - startTime;
+        logger.info('Web research agent completed', {
+            duration,
+            outputLength: output.length
+        });
+        return { output };
+    });
+}