agentic-flow 1.0.0

package/dist/utils/cli.js

@@ -0,0 +1,128 @@
+// CLI argument parsing and help utilities
+export function parseArgs() {
+    const args = process.argv.slice(2);
+    const options = {
+        mode: 'parallel'
+    };
+    // Check for MCP command first
+    if (args[0] === 'mcp') {
+        options.mode = 'mcp';
+        options.mcpCommand = args[1] || 'start'; // default to start
+        options.mcpServer = args[2] || 'all'; // default to all servers
+        return options;
+    }
+    for (let i = 0; i < args.length; i++) {
+        const arg = args[i];
+        switch (arg) {
+            case '--help':
+            case '-h':
+                options.help = true;
+                break;
+            case '--agent':
+            case '-a':
+                options.mode = 'agent';
+                options.agent = args[++i];
+                break;
+            case '--task':
+            case '-t':
+                options.task = args[++i];
+                break;
+            case '--model':
+            case '-m':
+                options.model = args[++i];
+                break;
+            case '--provider':
+            case '-p':
+                options.provider = args[++i];
+                break;
+            case '--stream':
+            case '-s':
+                options.stream = true;
+                break;
+            case '--list':
+            case '-l':
+                options.mode = 'list';
+                break;
+        }
+    }
+    return options;
+}
+export function printHelp() {
+    console.log(`
+🤖 Agentic Flow - AI Agent Orchestration CLI
+
+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
+  (default)               Run parallel mode (3 agents)
+
+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 (supports OpenRouter models)
+  --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 researcher --task "Analyze AI trends"
+  npx agentic-flow --agent coder --task "Build REST API" --model "meta-llama/llama-3.1-8b-instruct"
+  npx agentic-flow --agent coder --task "Create hello world" --provider onnx
+  npx agentic-flow --agent coder --task "Build REST API" --stream
+
+  # Parallel Mode
+  npx agentic-flow  # Run 3 agents in parallel (requires TOPIC, DIFF, DATASET)
+
+ENVIRONMENT VARIABLES:
+  ANTHROPIC_API_KEY       Anthropic API key (for Claude models)
+  OPENROUTER_API_KEY      OpenRouter API key (for alternative models)
+  USE_ONNX                Set to 'true' to force ONNX local inference
+  AGENT                   Agent name for agent mode
+  TASK                    Task description for agent mode
+  MODEL                   Model override for agent mode
+  PROVIDER                Provider to use (anthropic, openrouter, onnx)
+  TOPIC                   Research topic for parallel mode
+  DIFF                    Code diff for parallel mode
+  DATASET                 Dataset hint for parallel mode
+  ENABLE_STREAMING        Enable streaming (true/false)
+  HEALTH_PORT             Health check port (default: 8080)
+
+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, visit: https://github.com/ruvnet/agentic-flow
+  `);
+}
+export function validateOptions(options) {
+    if (options.mode === 'agent') {
+        if (!options.agent && !process.env.AGENT) {
+            return 'Agent mode requires --agent <name> or AGENT env variable';
+        }
+        if (!options.task && !process.env.TASK) {
+            return 'Agent mode requires --task <description> or TASK env variable';
+        }
+    }
+    return null;
+}

package/dist/utils/logger.js

@@ -0,0 +1,41 @@
+class Logger {
+    context = {};
+    setContext(ctx) {
+        this.context = { ...this.context, ...ctx };
+    }
+    log(level, message, data) {
+        const timestamp = new Date().toISOString();
+        const logEntry = {
+            timestamp,
+            level,
+            message,
+            ...this.context,
+            ...data
+        };
+        // Structured JSON logging for production
+        if (process.env.NODE_ENV === 'production') {
+            console.log(JSON.stringify(logEntry));
+        }
+        else {
+            // Human-readable for development
+            const prefix = `[${timestamp}] ${level.toUpperCase()}`;
+            const contextStr = Object.keys({ ...this.context, ...data }).length > 0
+                ? ` ${JSON.stringify({ ...this.context, ...data })}`
+                : '';
+            console.log(`${prefix}: ${message}${contextStr}`);
+        }
+    }
+    debug(message, data) {
+        this.log('debug', message, data);
+    }
+    info(message, data) {
+        this.log('info', message, data);
+    }
+    warn(message, data) {
+        this.log('warn', message, data);
+    }
+    error(message, data) {
+        this.log('error', message, data);
+    }
+}
+export const logger = new Logger();

package/dist/utils/mcpCommands.js

@@ -0,0 +1,214 @@
+// MCP server management commands
+import { spawn, exec } from 'child_process';
+import { promisify } from 'util';
+const execAsync = promisify(exec);
+const MCP_SERVERS = {
+    'claude-flow': {
+        name: 'claude-flow',
+        command: 'npx',
+        args: ['claude-flow@alpha', 'mcp', 'start'],
+        description: '101 tools (neural networks, GitHub, workflows, DAA)',
+        toolCount: 101
+    },
+    'flow-nexus': {
+        name: 'flow-nexus',
+        command: 'npx',
+        args: ['flow-nexus@latest', 'mcp', 'start'],
+        description: '96 cloud tools (sandboxes, distributed swarms, templates)',
+        toolCount: 96
+    },
+    'agentic-payments': {
+        name: 'agentic-payments',
+        command: 'npx',
+        args: ['-y', 'agentic-payments', 'mcp'],
+        description: 'Payment authorization and multi-agent consensus',
+        toolCount: 10
+    }
+};
+export async function handleMCPCommand(command, server = 'all') {
+    switch (command) {
+        case 'start':
+            await startMCPServers(server);
+            break;
+        case 'stop':
+            await stopMCPServers(server);
+            break;
+        case 'status':
+            await checkMCPStatus(server);
+            break;
+        case 'list':
+            await listMCPTools(server);
+            break;
+        default:
+            console.error(`❌ Unknown MCP command: ${command}`);
+            console.error('Available commands: start, stop, status, list');
+            process.exit(1);
+    }
+}
+async function startMCPServers(server) {
+    console.log(`\n🚀 Starting MCP Server(s): ${server}\n`);
+    const serversToStart = server === 'all'
+        ? Object.keys(MCP_SERVERS)
+        : [server];
+    for (const serverName of serversToStart) {
+        const config = MCP_SERVERS[serverName];
+        if (!config) {
+            console.error(`❌ Unknown server: ${serverName}`);
+            continue;
+        }
+        console.log(`📦 ${config.name}`);
+        console.log(`   ${config.description}`);
+        console.log(`   Command: ${config.command} ${config.args.join(' ')}`);
+        console.log(`   Status: Starting as subprocess...\n`);
+        // Start server in background
+        const child = spawn(config.command, config.args, {
+            detached: true,
+            stdio: 'inherit',
+            env: {
+                ...process.env,
+                MCP_AUTO_START: 'true'
+            }
+        });
+        child.unref(); // Allow parent to exit independently
+    }
+    console.log(`\n✅ MCP server(s) started in background`);
+    console.log(`💡 Tip: Use 'npx agentic-flow mcp status' to check server status\n`);
+}
+async function stopMCPServers(server) {
+    console.log(`\n🛑 Stopping MCP Server(s): ${server}\n`);
+    const serversToStop = server === 'all'
+        ? Object.keys(MCP_SERVERS)
+        : [server];
+    for (const serverName of serversToStop) {
+        const config = MCP_SERVERS[serverName];
+        if (!config) {
+            console.error(`❌ Unknown server: ${serverName}`);
+            continue;
+        }
+        try {
+            // Try to kill processes by name
+            const killCommand = process.platform === 'win32'
+                ? `taskkill /F /IM node.exe /FI "WINDOWTITLE eq ${serverName}*"`
+                : `pkill -f "${serverName}"`;
+            await execAsync(killCommand);
+            console.log(`✅ Stopped ${config.name}`);
+        }
+        catch (error) {
+            if (error.code === 1) {
+                console.log(`⚠️  ${config.name} not running`);
+            }
+            else {
+                console.error(`❌ Error stopping ${config.name}:`, error.message);
+            }
+        }
+    }
+    console.log();
+}
+async function checkMCPStatus(server) {
+    console.log(`\n📊 MCP Server Status: ${server}\n`);
+    const serversToCheck = server === 'all'
+        ? Object.keys(MCP_SERVERS)
+        : [server];
+    for (const serverName of serversToCheck) {
+        const config = MCP_SERVERS[serverName];
+        if (!config) {
+            console.error(`❌ Unknown server: ${serverName}`);
+            continue;
+        }
+        console.log(`📦 ${config.name}`);
+        console.log(`   Description: ${config.description}`);
+        console.log(`   Tool Count: ${config.toolCount}`);
+        try {
+            // Check if process is running
+            const checkCommand = process.platform === 'win32'
+                ? `tasklist /FI "IMAGENAME eq node.exe" /FO CSV | findstr /C:"${serverName}"`
+                : `pgrep -f "${serverName}"`;
+            const { stdout } = await execAsync(checkCommand);
+            const isRunning = stdout.trim().length > 0;
+            console.log(`   Status: ${isRunning ? '✅ Running' : '⚠️  Not running'}`);
+        }
+        catch (error) {
+            console.log(`   Status: ⚠️  Not running`);
+        }
+        console.log();
+    }
+}
+async function listMCPTools(server) {
+    console.log(`\n📋 MCP Tools Available\n`);
+    const serversToList = server === 'all'
+        ? Object.keys(MCP_SERVERS)
+        : [server];
+    let totalTools = 0;
+    for (const serverName of serversToList) {
+        const config = MCP_SERVERS[serverName];
+        if (!config) {
+            console.error(`❌ Unknown server: ${serverName}`);
+            continue;
+        }
+        console.log(`\n📦 ${config.name.toUpperCase()} (${config.toolCount} tools)`);
+        console.log(`   ${config.description}`);
+        console.log();
+        totalTools += config.toolCount;
+        // Show example tools based on server
+        const examples = getExampleTools(serverName);
+        examples.forEach(tool => {
+            console.log(`   • ${tool}`);
+        });
+    }
+    // Add in-SDK tools
+    console.log(`\n📦 CLAUDE-FLOW-SDK (6 in-process tools)`);
+    console.log(`   Fast, zero-latency tools running in-process`);
+    console.log();
+    console.log(`   • memory_store - Store values in persistent memory`);
+    console.log(`   • memory_retrieve - Retrieve values from memory`);
+    console.log(`   • memory_list - List all memory keys`);
+    console.log(`   • swarm_init - Initialize agent swarms`);
+    console.log(`   • agent_spawn - Spawn specialized agents`);
+    console.log(`   • coordination_sync - Synchronize agent coordination`);
+    totalTools += 6;
+    console.log(`\n━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━`);
+    console.log(`📊 TOTAL: ${totalTools} MCP tools available`);
+    console.log(`━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━\n`);
+    console.log(`💡 Usage: Tools are automatically available to agents`);
+    console.log(`   npx agentic-flow --agent coder --task "Your task"\n`);
+}
+function getExampleTools(serverName) {
+    switch (serverName) {
+        case 'claude-flow':
+            return [
+                'swarm_init - Initialize multi-agent swarms',
+                'agent_spawn - Create specialized AI agents',
+                'task_orchestrate - Orchestrate complex tasks',
+                'neural_train - Train neural networks with WASM',
+                'github_repo_analyze - Analyze GitHub repositories',
+                'workflow_create - Create automated workflows',
+                'daa_agent_create - Create autonomous agents',
+                'performance_report - Generate performance metrics',
+                '... and 93 more tools'
+            ];
+        case 'flow-nexus':
+            return [
+                'sandbox_create - Create isolated E2B sandboxes',
+                'sandbox_execute - Execute code in sandboxes',
+                'swarm_init - Initialize cloud-based swarms',
+                'neural_train - Distributed neural training',
+                'workflow_create - Event-driven workflows',
+                'template_deploy - Deploy project templates',
+                'user_login - Authenticate Flow Nexus users',
+                'storage_upload - Cloud file storage',
+                '... and 88 more tools'
+            ];
+        case 'agentic-payments':
+            return [
+                'create_active_mandate - Create payment authorization',
+                'sign_mandate - Sign with Ed25519 cryptography',
+                'verify_mandate - Verify payment signatures',
+                'revoke_mandate - Revoke authorizations',
+                'verify_consensus - Multi-agent consensus',
+                'generate_agent_identity - Create agent identities',
+                '... and 4 more tools'
+            ];
+        default:
+            return [];
+    }
+}

package/dist/utils/model-downloader.js

@@ -0,0 +1,182 @@
+/**
+ * Automatic Model Downloader for ONNX Phi-4
+ *
+ * Downloads Phi-4 ONNX model from HuggingFace on first use
+ */
+import { createWriteStream, existsSync, mkdirSync } from 'fs';
+import { dirname } from 'path';
+import { createHash } from 'crypto';
+import { readFileSync } from 'fs';
+export class ModelDownloader {
+    baseUrl = 'https://huggingface.co';
+    /**
+     * Phi-4 Mini ONNX INT4 quantized model (CPU optimized)
+     * Size: ~52MB model + ~4.86GB data = ~4.9GB total
+     * Note: Requires TWO files - model.onnx and model.onnx.data
+     */
+    phi4Model = {
+        repo: 'microsoft/Phi-4-mini-instruct-onnx',
+        filename: 'cpu_and_mobile/cpu-int4-rtn-block-32-acc-level-4/model.onnx',
+        localPath: './models/phi-4-mini/cpu_and_mobile/cpu-int4-rtn-block-32-acc-level-4/model.onnx'
+    };
+    phi4ModelData = {
+        repo: 'microsoft/Phi-4-mini-instruct-onnx',
+        filename: 'cpu_and_mobile/cpu-int4-rtn-block-32-acc-level-4/model.onnx.data',
+        localPath: './models/phi-4-mini/cpu_and_mobile/cpu-int4-rtn-block-32-acc-level-4/model.onnx.data'
+    };
+    /**
+     * Check if model exists locally
+     */
+    isModelDownloaded(modelPath) {
+        const path = modelPath || this.phi4Model.localPath;
+        return existsSync(path);
+    }
+    /**
+     * Get model download URL
+     */
+    getDownloadUrl(model) {
+        return `${this.baseUrl}/${model.repo}/resolve/main/${model.filename}`;
+    }
+    /**
+     * Download model with progress tracking
+     */
+    async downloadModel(modelInfo, onProgress) {
+        const model = modelInfo || this.phi4Model;
+        // Check if already downloaded
+        if (this.isModelDownloaded(model.localPath)) {
+            console.log(`✅ Model already exists at ${model.localPath}`);
+            return model.localPath;
+        }
+        // Create directory
+        const dir = dirname(model.localPath);
+        if (!existsSync(dir)) {
+            mkdirSync(dir, { recursive: true });
+        }
+        const url = this.getDownloadUrl(model);
+        console.log(`📦 Downloading Phi-4 ONNX model from HuggingFace...`);
+        console.log(`   URL: ${url}`);
+        console.log(`   Destination: ${model.localPath}`);
+        try {
+            const response = await fetch(url);
+            if (!response.ok) {
+                throw new Error(`Download failed: ${response.statusText}`);
+            }
+            const totalSize = parseInt(response.headers.get('content-length') || '0', 10);
+            let downloadedSize = 0;
+            if (!response.body) {
+                throw new Error('Response body is null');
+            }
+            const fileStream = createWriteStream(model.localPath);
+            // Track progress
+            const reader = response.body.getReader();
+            const chunks = [];
+            while (true) {
+                const { done, value } = await reader.read();
+                if (done)
+                    break;
+                if (value) {
+                    chunks.push(value);
+                    downloadedSize += value.length;
+                    if (onProgress && totalSize > 0) {
+                        onProgress({
+                            downloaded: downloadedSize,
+                            total: totalSize,
+                            percentage: (downloadedSize / totalSize) * 100
+                        });
+                    }
+                    // Write chunk
+                    fileStream.write(value);
+                }
+            }
+            fileStream.end();
+            // Wait for file stream to finish
+            await new Promise((resolve, reject) => {
+                fileStream.on('finish', () => resolve());
+                fileStream.on('error', reject);
+            });
+            console.log(`✅ Model downloaded successfully`);
+            console.log(`   Size: ${(downloadedSize / (1024 * 1024)).toFixed(2)} MB`);
+            console.log(`   Path: ${model.localPath}`);
+            return model.localPath;
+        }
+        catch (error) {
+            console.error(`❌ Model download failed:`, error);
+            throw new Error(`Failed to download model: ${error}`);
+        }
+    }
+    /**
+     * Download Phi-4 ONNX model if needed (downloads BOTH .onnx and .onnx.data files)
+     */
+    async ensurePhi4Model(onProgress) {
+        const mainFileExists = this.isModelDownloaded(this.phi4Model.localPath);
+        const dataFileExists = this.isModelDownloaded(this.phi4ModelData.localPath);
+        if (mainFileExists && dataFileExists) {
+            return this.phi4Model.localPath;
+        }
+        console.log(`🔍 Phi-4-mini ONNX model not found locally`);
+        console.log(`📥 Starting automatic download...`);
+        console.log(`   This is a one-time download (~4.9GB total)`);
+        console.log(`   Model: microsoft/Phi-4-mini-instruct-onnx (INT4 quantized)`);
+        console.log(`   Files: model.onnx (~52MB) + model.onnx.data (~4.86GB)`);
+        console.log(``);
+        // Download main model file if missing
+        if (!mainFileExists) {
+            console.log(`📦 Downloading model.onnx...`);
+            await this.downloadModel(this.phi4Model, onProgress);
+            console.log(``);
+        }
+        // Download data file if missing
+        if (!dataFileExists) {
+            console.log(`📦 Downloading model.onnx.data (this is the large 4.86GB file)...`);
+            await this.downloadModel(this.phi4ModelData, onProgress);
+        }
+        return this.phi4Model.localPath;
+    }
+    /**
+     * Verify model file integrity (optional)
+     */
+    async verifyModel(modelPath, expectedSha256) {
+        if (!expectedSha256) {
+            return true; // Skip verification if no hash provided
+        }
+        try {
+            const fileBuffer = readFileSync(modelPath);
+            const hash = createHash('sha256').update(fileBuffer).digest('hex');
+            if (hash !== expectedSha256) {
+                console.error(`❌ Model verification failed`);
+                console.error(`   Expected: ${expectedSha256}`);
+                console.error(`   Got:      ${hash}`);
+                return false;
+            }
+            console.log(`✅ Model verification passed`);
+            return true;
+        }
+        catch (error) {
+            console.error(`❌ Model verification error:`, error);
+            return false;
+        }
+    }
+    /**
+     * Get model info
+     */
+    getModelInfo() {
+        return this.phi4Model;
+    }
+    /**
+     * Format download progress for display
+     */
+    static formatProgress(progress) {
+        const mb = (bytes) => (bytes / (1024 * 1024)).toFixed(2);
+        return `${progress.percentage.toFixed(1)}% (${mb(progress.downloaded)}/${mb(progress.total)} MB)`;
+    }
+}
+/**
+ * Global singleton instance
+ */
+export const modelDownloader = new ModelDownloader();
+/**
+ * Convenience function for downloading Phi-4 model
+ */
+export async function ensurePhi4Model(onProgress) {
+    return modelDownloader.ensurePhi4Model(onProgress);
+}

package/dist/utils/retry.js

@@ -0,0 +1,54 @@
+// Retry utility with exponential backoff
+import { logger } from './logger.js';
+const defaultOptions = {
+    maxAttempts: 3,
+    baseDelay: 1000,
+    maxDelay: 10000,
+    shouldRetry: (error) => {
+        // Retry on network errors, rate limits, and server errors
+        if (error?.status >= 500)
+            return true;
+        if (error?.status === 429)
+            return true;
+        if (error?.code === 'ECONNRESET')
+            return true;
+        if (error?.code === 'ETIMEDOUT')
+            return true;
+        return false;
+    }
+};
+export async function withRetry(fn, options = {}) {
+    const opts = { ...defaultOptions, ...options };
+    let lastError;
+    for (let attempt = 1; attempt <= opts.maxAttempts; attempt++) {
+        try {
+            logger.debug('Attempting operation', { attempt, maxAttempts: opts.maxAttempts });
+            return await fn();
+        }
+        catch (error) {
+            lastError = error;
+            if (attempt >= opts.maxAttempts) {
+                logger.error('Max retry attempts reached', {
+                    attempt,
+                    maxAttempts: opts.maxAttempts,
+                    error
+                });
+                throw error;
+            }
+            if (!opts.shouldRetry(error)) {
+                logger.warn('Error not retryable', { error });
+                throw error;
+            }
+            // Calculate backoff delay with jitter
+            const delay = Math.min(opts.baseDelay * Math.pow(2, attempt - 1) + Math.random() * 1000, opts.maxDelay);
+            logger.warn('Operation failed, retrying', {
+                attempt,
+                nextAttempt: attempt + 1,
+                delayMs: Math.round(delay),
+                error
+            });
+            await new Promise(resolve => setTimeout(resolve, delay));
+        }
+    }
+    throw lastError;
+}

package/docs/.claude-flow/metrics/agent-metrics.json

@@ -0,0 +1 @@
+{}

package/docs/.claude-flow/metrics/performance.json

@@ -0,0 +1,9 @@
+{
+  "startTime": 1759590740471,
+  "totalTasks": 1,
+  "successfulTasks": 1,
+  "failedTasks": 0,
+  "totalAgents": 0,
+  "activeAgents": 0,
+  "neuralEvents": 0
+}

package/docs/.claude-flow/metrics/task-metrics.json

@@ -0,0 +1,10 @@
+[
+  {
+    "id": "cmd-hooks-1759590741432",
+    "type": "hooks",
+    "success": true,
+    "duration": 506.32141699999966,
+    "timestamp": 1759590741946,
+    "metadata": {}
+  }
+]