agentic-flow 1.0.0

package/dist/cli/mcp.js

@@ -0,0 +1,135 @@
+#!/usr/bin/env node
+// MCP CLI commands for agentic-flow
+import { spawn } from 'child_process';
+import { resolve, dirname } from 'path';
+import { fileURLToPath } from 'url';
+const __filename = fileURLToPath(import.meta.url);
+const __dirname = dirname(__filename);
+// Start stdio MCP server (for Claude Desktop)
+export async function startStdioServer(options = {}) {
+    console.log('🚀 Starting FastMCP stdio server...');
+    console.log('📦 Tools: memory_store, memory_retrieve, memory_search, swarm_init, agent_spawn, task_orchestrate\n');
+    const serverPath = resolve(__dirname, '../mcp/fastmcp/servers/stdio-full.js');
+    const proc = spawn('node', [serverPath], {
+        stdio: 'inherit',
+        env: {
+            ...process.env,
+            DEBUG: options.debug ? 'fastmcp:*' : undefined
+        }
+    });
+    proc.on('exit', (code) => {
+        process.exit(code || 0);
+    });
+    // Handle termination signals
+    process.on('SIGINT', () => {
+        proc.kill('SIGINT');
+    });
+    process.on('SIGTERM', () => {
+        proc.kill('SIGTERM');
+    });
+}
+// Start HTTP + SSE server (for web/remote clients)
+export async function startHttpServer(options = {}) {
+    const port = options.port || '3000';
+    console.log('🚀 Starting FastMCP HTTP + SSE server...');
+    console.log(`🌐 Port: ${port}`);
+    console.log('📡 SSE endpoint: /events');
+    console.log('🔧 MCP endpoint: /mcp');
+    console.log('❤️  Health check: /health');
+    console.log('📦 Tools: 11 (memory × 3, swarm × 3, agent × 5)\n');
+    const serverPath = resolve(__dirname, '../mcp/fastmcp/servers/http-streaming.js');
+    const proc = spawn('node', [serverPath], {
+        stdio: 'inherit',
+        env: {
+            ...process.env,
+            PORT: port,
+            DEBUG: options.debug ? 'fastmcp:*' : undefined
+        }
+    });
+    proc.on('exit', (code) => {
+        process.exit(code || 0);
+    });
+    // Handle termination signals
+    process.on('SIGINT', () => {
+        proc.kill('SIGINT');
+    });
+    process.on('SIGTERM', () => {
+        proc.kill('SIGTERM');
+    });
+}
+// List available MCP tools
+export function listTools() {
+    console.log('\n📦 Available MCP Tools (11 total)\n');
+    console.log('Memory Tools:');
+    console.log('  1. memory_store    - Store values with TTL and namespacing');
+    console.log('  2. memory_retrieve - Retrieve stored values');
+    console.log('  3. memory_search   - Search keys with pattern matching\n');
+    console.log('Swarm Coordination Tools:');
+    console.log('  4. swarm_init      - Initialize multi-agent swarms');
+    console.log('  5. agent_spawn     - Spawn specialized agents');
+    console.log('  6. task_orchestrate - Orchestrate distributed tasks\n');
+    console.log('Agent Execution Tools:');
+    console.log('  7. agent_execute   - Execute specific agent with task');
+    console.log('  8. agent_parallel  - Run 3 agents in parallel mode');
+    console.log('  9. agent_list      - List all available agents\n');
+    console.log('Custom Extension Tools:');
+    console.log('  10. agent_add      - Add new custom agent (markdown)');
+    console.log('  11. command_add    - Add new custom command (markdown)\n');
+}
+// Show server status
+export function showStatus() {
+    console.log('\n🔍 FastMCP Server Status\n');
+    console.log('Available Transports:');
+    console.log('  ✅ stdio    - JSON-RPC over stdio (for local MCP clients)');
+    console.log('  ✅ HTTP+SSE - HTTP with Server-Sent Events (for web/remote)\n');
+    console.log('Tools: 11/11 implemented');
+    console.log('  ✅ memory_store');
+    console.log('  ✅ memory_retrieve');
+    console.log('  ✅ memory_search');
+    console.log('  ✅ swarm_init');
+    console.log('  ✅ agent_spawn');
+    console.log('  ✅ task_orchestrate');
+    console.log('  ✅ agent_execute');
+    console.log('  ✅ agent_parallel');
+    console.log('  ✅ agent_list');
+    console.log('  ✅ agent_add');
+    console.log('  ✅ command_add\n');
+    console.log('Documentation:');
+    console.log('  📖 Implementation: docs/fastmcp-implementation.md');
+    console.log('  🚀 Quick Start: docs/fastmcp-quick-start.md');
+    console.log('  🏗️  Architecture: docs/ARCHITECTURE.md\n');
+}
+// CLI handler
+export function handleMCPCommand(command, options = {}) {
+    switch (command) {
+        case 'start':
+        case 'stdio':
+            return startStdioServer(options);
+        case 'http':
+        case 'sse':
+            return startHttpServer(options);
+        case 'tools':
+            return listTools();
+        case 'status':
+            return showStatus();
+        default:
+            console.error(`Unknown MCP command: ${command}`);
+            console.error('\nAvailable commands:');
+            console.error('  start, stdio - Start stdio MCP server');
+            console.error('  http, sse    - Start HTTP + SSE server');
+            console.error('  tools        - List available tools');
+            console.error('  status       - Show server status\n');
+            process.exit(1);
+    }
+}
+// If run directly
+if (import.meta.url === `file://${process.argv[1]}`) {
+    const command = process.argv[2] || 'start';
+    const options = {
+        port: process.argv.includes('--port')
+            ? process.argv[process.argv.indexOf('--port') + 1]
+            : undefined,
+        debug: process.argv.includes('--debug')
+    };
+    handleMCPCommand(command, options);
+}

package/dist/cli-proxy.js

@@ -0,0 +1,246 @@
+#!/usr/bin/env node
+/**
+ * Agentic Flow - Standalone CLI with integrated OpenRouter proxy
+ * Usage: npx agentic-flow-proxy --agent coder --task "Create code" --openrouter
+ */
+import "dotenv/config";
+import { AnthropicToOpenRouterProxy } from "./proxy/anthropic-to-openrouter.js";
+import { logger } from "./utils/logger.js";
+import { parseArgs } from "./utils/cli.js";
+import { getAgent, listAgents } from "./utils/agentLoader.js";
+import { claudeAgent } from "./agents/claudeAgent.js";
+import { handleMCPCommand } from "./utils/mcpCommands.js";
+class AgenticFlowCLI {
+    proxyServer = null;
+    proxyPort = 3000;
+    async start() {
+        const options = parseArgs();
+        if (options.help) {
+            this.printHelp();
+            process.exit(0);
+        }
+        if (options.mode === 'list') {
+            this.listAgents();
+            process.exit(0);
+        }
+        if (options.mode === 'mcp') {
+            await handleMCPCommand(options.mcpCommand || 'start', options.mcpServer || 'all');
+            process.exit(0);
+        }
+        // Determine if we should use OpenRouter
+        const useOpenRouter = this.shouldUseOpenRouter(options);
+        try {
+            // Start proxy if needed
+            if (useOpenRouter) {
+                await this.startProxy();
+            }
+            // Run agent
+            await this.runAgent(options, useOpenRouter);
+            logger.info('Execution completed successfully');
+            process.exit(0);
+        }
+        catch (err) {
+            logger.error('Execution failed', { error: err });
+            console.error(err);
+            process.exit(1);
+        }
+    }
+    shouldUseOpenRouter(options) {
+        // Don't use OpenRouter if ONNX is explicitly requested
+        if (options.provider === 'onnx' || process.env.USE_ONNX === 'true' || process.env.PROVIDER === 'onnx') {
+            return false;
+        }
+        // Use OpenRouter if:
+        // 1. Provider is explicitly set to openrouter
+        // 2. Model parameter contains "/" (e.g., "meta-llama/llama-3.1-8b-instruct")
+        // 3. USE_OPENROUTER env var is set
+        // 4. OPENROUTER_API_KEY is set and ANTHROPIC_API_KEY is not
+        if (options.provider === 'openrouter' || process.env.PROVIDER === 'openrouter') {
+            return true;
+        }
+        if (options.model?.includes('/')) {
+            return true;
+        }
+        if (process.env.USE_OPENROUTER === 'true') {
+            return true;
+        }
+        if (process.env.OPENROUTER_API_KEY && !process.env.ANTHROPIC_API_KEY) {
+            return true;
+        }
+        return false;
+    }
+    async startProxy() {
+        const openrouterKey = process.env.OPENROUTER_API_KEY;
+        if (!openrouterKey) {
+            console.error('❌ Error: OPENROUTER_API_KEY required for OpenRouter models');
+            console.error('Set it in .env or export OPENROUTER_API_KEY=sk-or-v1-xxxxx');
+            process.exit(1);
+        }
+        logger.info('Starting integrated OpenRouter proxy');
+        const defaultModel = process.env.COMPLETION_MODEL ||
+            process.env.REASONING_MODEL ||
+            'meta-llama/llama-3.1-8b-instruct';
+        const proxy = new AnthropicToOpenRouterProxy({
+            openrouterApiKey: openrouterKey,
+            openrouterBaseUrl: process.env.ANTHROPIC_PROXY_BASE_URL,
+            defaultModel
+        });
+        // Start proxy in background
+        proxy.start(this.proxyPort);
+        this.proxyServer = proxy;
+        // Set ANTHROPIC_BASE_URL to proxy
+        process.env.ANTHROPIC_BASE_URL = `http://localhost:${this.proxyPort}`;
+        console.log(`🔗 Proxy Mode: OpenRouter`);
+        console.log(`🔧 Proxy URL: http://localhost:${this.proxyPort}`);
+        console.log(`🤖 Default Model: ${defaultModel}\n`);
+        // Wait for proxy to be ready
+        await new Promise(resolve => setTimeout(resolve, 1500));
+    }
+    async runAgent(options, useOpenRouter) {
+        const agentName = options.agent || process.env.AGENT || '';
+        const task = options.task || process.env.TASK || '';
+        if (!agentName) {
+            console.error('❌ Error: --agent required');
+            this.printHelp();
+            process.exit(1);
+        }
+        if (!task) {
+            console.error('❌ Error: --task required');
+            this.printHelp();
+            process.exit(1);
+        }
+        const agent = getAgent(agentName);
+        if (!agent) {
+            const available = listAgents();
+            console.error(`\n❌ Agent '${agentName}' not found.\n`);
+            console.error('Available agents:');
+            available.slice(0, 20).forEach(a => {
+                console.error(`  • ${a.name}: ${a.description.substring(0, 80)}...`);
+            });
+            if (available.length > 20) {
+                console.error(`  ... and ${available.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 (useOpenRouter) {
+            const model = options.model || process.env.COMPLETION_MODEL || 'meta-llama/llama-3.1-8b-instruct';
+            console.log(`🔧 Provider: OpenRouter (via proxy)`);
+            console.log(`🔧 Model: ${model}\n`);
+        }
+        else if (options.provider === 'onnx' || process.env.USE_ONNX === 'true' || process.env.PROVIDER === 'onnx') {
+            console.log(`🔧 Provider: ONNX Local (Phi-4-mini)`);
+            console.log(`💾 Free local inference - no API costs`);
+            if (process.env.ONNX_OPTIMIZED === 'true') {
+                console.log(`⚡ Optimizations: Context pruning, prompt optimization`);
+            }
+            console.log('');
+        }
+        console.log('⏳ Running...\n');
+        const streamHandler = options.stream ? (chunk) => process.stdout.write(chunk) : undefined;
+        const modelOverride = useOpenRouter ? (options.model || process.env.COMPLETION_MODEL) : undefined;
+        const result = await claudeAgent(agent, task, streamHandler, modelOverride);
+        if (!options.stream) {
+            console.log('\n✅ Completed!\n');
+            console.log('═══════════════════════════════════════\n');
+            console.log(result.output);
+            console.log('\n═══════════════════════════════════════\n');
+        }
+        logger.info('Agent completed', {
+            agent: agentName,
+            outputLength: result.output.length,
+            provider: useOpenRouter ? 'openrouter' : 'anthropic'
+        });
+    }
+    listAgents() {
+        const agents = listAgents();
+        console.log(`\n📦 Available Agents (${agents.length} total)\n`);
+        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);
+        });
+        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(`\nUsage:`);
+        console.log(`  npx agentic-flow --agent <name> --task "Your task"\n`);
+    }
+    printHelp() {
+        console.log(`
+🤖 Agentic Flow - AI Agent Orchestration with OpenRouter Support
+
+USAGE:
+  npx agentic-flow [COMMAND] [OPTIONS]
+
+COMMANDS:
+  mcp <command> [server]  Manage MCP servers (start, stop, status, list)
+  --list, -l              List all available agents
+  --agent, -a <name>      Run specific agent mode
+
+MCP COMMANDS:
+  npx agentic-flow mcp start [server]    Start MCP server(s)
+  npx agentic-flow mcp stop [server]     Stop MCP server(s)
+  npx agentic-flow mcp status [server]   Check MCP server status
+  npx agentic-flow mcp list              List all available MCP tools
+
+  Available servers: claude-flow, flow-nexus, agentic-payments, all (default)
+
+OPTIONS:
+  --task, -t <task>       Task description for agent mode
+  --model, -m <model>     Model to use (triggers OpenRouter if contains "/")
+  --provider, -p <name>   Provider to use (anthropic, openrouter, onnx)
+  --stream, -s            Enable real-time streaming output
+  --help, -h              Show this help message
+
+EXAMPLES:
+  # MCP Server Management
+  npx agentic-flow mcp start              # Start all MCP servers
+  npx agentic-flow mcp start claude-flow  # Start specific server
+  npx agentic-flow mcp list               # List all 203+ MCP tools
+  npx agentic-flow mcp status             # Check server status
+
+  # Agent Execution
+  npx agentic-flow --list                 # List all 150+ agents
+  npx agentic-flow --agent coder --task "Create Python hello world"
+  npx agentic-flow --agent coder --task "Create REST API" --model "meta-llama/llama-3.1-8b-instruct"
+  npx agentic-flow --agent coder --task "Create code" --provider onnx
+
+ENVIRONMENT VARIABLES:
+  ANTHROPIC_API_KEY       Anthropic API key (for Claude models)
+  OPENROUTER_API_KEY      OpenRouter API key (for alternative models)
+  USE_OPENROUTER          Set to 'true' to force OpenRouter usage
+  COMPLETION_MODEL        Default model for OpenRouter
+  AGENTS_DIR              Path to agents directory
+  PROXY_PORT              Proxy server port (default: 3000)
+
+OPENROUTER MODELS:
+  - meta-llama/llama-3.1-8b-instruct (99% cost savings)
+  - deepseek/deepseek-chat-v3.1 (excellent for code)
+  - google/gemini-2.5-flash-preview (fastest)
+  - See https://openrouter.ai/models for full list
+
+MCP TOOLS (203+ available):
+  • claude-flow-sdk: 6 in-process tools (memory, swarm coordination)
+  • claude-flow: 101 tools (neural networks, GitHub, workflows, DAA)
+  • flow-nexus: 96 cloud tools (sandboxes, distributed swarms, templates)
+  • agentic-payments: Payment authorization and multi-agent consensus
+
+For more information: https://github.com/ruvnet/agentic-flow
+    `);
+    }
+}
+// Run CLI
+const cli = new AgenticFlowCLI();
+cli.start();

package/dist/cli.js

@@ -0,0 +1,158 @@
+#!/usr/bin/env node
+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";
+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) {
+    logger.info('Running agent mode', { agent: agentName, task: task.substring(0, 100) });
+    // 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`);
+    console.log('⏳ Running...\n');
+    const streamHandler = stream ? (chunk) => process.stdout.write(chunk) : undefined;
+    // Use Claude Agent SDK with in-SDK MCP server
+    logger.info('Using Claude Agent SDK with in-SDK MCP server');
+    const result = await claudeAgent(agent, task, streamHandler);
+    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 });
+}
+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);
+    }
+    // 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 || '';
+            await runAgentMode(agent, task, options.stream || false);
+        }
+        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/config/claudeFlow.js

@@ -0,0 +1,67 @@
+// Claude Flow integration configuration
+import { logger } from '../utils/logger.js';
+export const defaultClaudeFlowConfig = {
+    enableMemory: true,
+    enableCoordination: true,
+    enableSwarm: true,
+    memoryNamespace: 'claude-agents',
+    coordinationTopology: 'mesh'
+};
+/**
+ * Initialize claude-flow MCP tools for agent use
+ */
+export function getClaudeFlowTools(config = defaultClaudeFlowConfig) {
+    const tools = [];
+    if (config.enableMemory) {
+        tools.push('mcp__claude-flow__memory_usage', 'mcp__claude-flow__memory_search', 'mcp__claude-flow__memory_persist', 'mcp__claude-flow__memory_namespace');
+        logger.info('Claude Flow memory tools enabled', { namespace: config.memoryNamespace });
+    }
+    if (config.enableCoordination) {
+        tools.push('mcp__claude-flow__swarm_init', 'mcp__claude-flow__agent_spawn', 'mcp__claude-flow__task_orchestrate', 'mcp__claude-flow__swarm_status', 'mcp__claude-flow__coordination_sync');
+        logger.info('Claude Flow coordination tools enabled', { topology: config.coordinationTopology });
+    }
+    if (config.enableSwarm) {
+        tools.push('mcp__claude-flow__swarm_scale', 'mcp__claude-flow__load_balance', 'mcp__claude-flow__agent_metrics', 'mcp__claude-flow__swarm_monitor');
+        logger.info('Claude Flow swarm tools enabled');
+    }
+    return tools;
+}
+/**
+ * Check if claude-flow MCP is available
+ */
+export async function isClaudeFlowAvailable() {
+    try {
+        // Check if claude-flow is installed
+        const { execSync } = await import('child_process');
+        execSync('npx claude-flow@alpha --version', { stdio: 'ignore' });
+        logger.info('Claude Flow detected and available');
+        return true;
+    }
+    catch (error) {
+        logger.warn('Claude Flow not available', { error });
+        return false;
+    }
+}
+/**
+ * Initialize memory namespace for agent session
+ */
+export function getMemoryConfig(agentName) {
+    const namespace = agentName
+        ? `claude-agents:${agentName}`
+        : 'claude-agents:default';
+    return {
+        namespace,
+        ttl: 3600, // 1 hour default TTL
+        action: 'store'
+    };
+}
+/**
+ * Initialize swarm coordination for multi-agent tasks
+ */
+export function getSwarmConfig(topology = 'mesh') {
+    return {
+        topology,
+        maxAgents: 8,
+        strategy: 'balanced'
+    };
+}

package/dist/config/tools.js

@@ -0,0 +1,33 @@
+// Tool configuration for Claude Agent SDK
+import { getClaudeFlowTools, defaultClaudeFlowConfig } from './claudeFlow.js';
+export const enabledTools = [
+    'Read',
+    'Write',
+    'Edit',
+    'Bash',
+    'Glob',
+    'Grep',
+    'WebFetch',
+    'WebSearch'
+];
+// Get claude-flow tools dynamically
+const claudeFlowTools = getClaudeFlowTools(defaultClaudeFlowConfig);
+export const toolConfig = {
+    // Enable all standard tools for full capability
+    enableAllTools: true,
+    // MCP servers configuration
+    mcpServers: {
+        'claude-flow': {
+            command: 'npx',
+            args: ['claude-flow@alpha', 'mcp', 'start'],
+            env: {
+                CLAUDE_FLOW_MEMORY_ENABLED: 'true',
+                CLAUDE_FLOW_COORDINATION_ENABLED: 'true'
+            }
+        }
+    },
+    // Permission mode
+    permissionMode: 'default',
+    // Additional enabled tools from claude-flow
+    additionalTools: claudeFlowTools
+};