ruvector 0.1.91 → 0.1.92

package/bin/cli.js

@@ -7380,13 +7380,13 @@ edgeNetCmd.command('status')
 // REAL AGENT COMMANDS (Actual LLM Execution)
 // ============================================
 
-const agentCmd = program.command('agent').description('Real AI agent execution with LLM APIs (requires ANTHROPIC_API_KEY or OPENAI_API_KEY)');
+const agentCmd = program.command('agent').description('Real AI agent execution - local ruvllm by default, or cloud APIs (Anthropic/OpenAI)');
 
 agentCmd.command('run')
-  .description('Execute a task with a real AI agent (calls actual LLM API)')
+  .description('Execute a task with a real AI agent (local ruvllm by default, no API key needed)')
   .argument('<type>', 'Agent type: researcher, coder, reviewer, tester, analyst, optimizer, coordinator, embedder')
   .argument('<task>', 'Task description for the agent to execute')
-  .option('-p, --provider <provider>', 'LLM provider: anthropic or openai', 'anthropic')
+  .option('-p, --provider <provider>', 'LLM provider: local (default), anthropic, openai', 'local')
   .option('-m, --model <model>', 'Model tier: fast, balanced, powerful', 'balanced')
   .option('-f, --files <files...>', 'Files to include as context')
   .option('-c, --context <context>', 'Additional context string')
@@ -7396,14 +7396,19 @@ agentCmd.command('run')
   .action(async (type, task, opts) => {
     const spinner = ora('Initializing real agent...').start();
 
-    // Check for API key
+    // Check for API key (only required for cloud providers)
     const apiKey = process.env.ANTHROPIC_API_KEY || process.env.OPENAI_API_KEY;
-    if (!apiKey && type !== 'embedder') {
-      spinner.fail('No API key found');
-      console.log(chalk.red('\n❌ Real agent execution requires an API key.\n'));
-      console.log(chalk.bold('Set one of these environment variables:'));
-      console.log(chalk.cyan('  export ANTHROPIC_API_KEY=your-key-here'));
-      console.log(chalk.cyan('  export OPENAI_API_KEY=your-key-here'));
+    const isLocal = opts.provider === 'local' || opts.provider === 'ruvllm';
+
+    if (!isLocal && !apiKey && type !== 'embedder') {
+      spinner.fail('No API key found for cloud provider');
+      console.log(chalk.red('\n❌ Cloud provider requires an API key.\n'));
+      console.log(chalk.bold('Options:'));
+      console.log(chalk.green('  1. Use local ruvllm (default, no key needed):'));
+      console.log(chalk.cyan('     ruvector agent run coder "task" -p local\n'));
+      console.log(chalk.yellow('  2. Or set a cloud API key:'));
+      console.log(chalk.cyan('     export ANTHROPIC_API_KEY=your-key-here'));
+      console.log(chalk.cyan('     export OPENAI_API_KEY=your-key-here'));
       console.log(chalk.dim('\nGet an API key:'));
       console.log(chalk.dim('  Anthropic: https://console.anthropic.com/'));
       console.log(chalk.dim('  OpenAI: https://platform.openai.com/api-keys\n'));
@@ -7578,6 +7583,249 @@ agentCmd.command('balance')
     }
   });
 
+// ============================================
+// REAL WORKER POOL COMMANDS
+// ============================================
+
+const workerCmd = program.command('worker').description('Real worker pool execution with Node.js worker_threads');
+
+workerCmd.command('create')
+  .description('Create a real worker pool for parallel task execution')
+  .option('-s, --size <size>', 'Pool size (number of workers)', String(require('os').cpus().length - 1))
+  .option('--relay <url>', 'Relay server URL for distributed mode')
+  .option('--json', 'Output as JSON')
+  .action(async (opts) => {
+    const spinner = ora('Creating worker pool...').start();
+
+    try {
+      let RealWorkerPool;
+      try {
+        const realWorkers = await import('@ruvector/edge-net/real-workers');
+        RealWorkerPool = realWorkers.RealWorkerPool;
+      } catch (e) {
+        const realWorkersPath = path.resolve(__dirname, '../../../../examples/edge-net/pkg/real-workers.js');
+        const realWorkers = await import(realWorkersPath);
+        RealWorkerPool = realWorkers.RealWorkerPool;
+      }
+
+      const pool = new RealWorkerPool({
+        size: parseInt(opts.size) || require('os').cpus().length - 1,
+      });
+
+      await pool.initialize();
+
+      spinner.succeed(`Worker pool created: ${pool.id}`);
+
+      const info = {
+        id: pool.id,
+        size: pool.size,
+        workers: pool.workers.map(w => ({ id: w.id, status: w.status })),
+        ready: pool.workers.filter(w => w.status === 'ready').length,
+      };
+
+      if (opts.json) {
+        console.log(JSON.stringify(info, null, 2));
+      } else {
+        console.log(chalk.bold.cyan('\n⚡ Real Worker Pool Created\n'));
+        console.log(`${chalk.cyan('Pool ID:')} ${info.id}`);
+        console.log(`${chalk.cyan('Size:')} ${info.size} workers`);
+        console.log(`${chalk.cyan('Ready:')} ${info.ready}/${info.size}`);
+        console.log();
+      }
+
+      if (pool.shutdown) await pool.shutdown();
+      else if (pool.close) await pool.close();
+
+    } catch (e) {
+      spinner.fail(`Failed to create pool: ${e.message}`);
+    }
+  });
+
+workerCmd.command('execute')
+  .description('Execute a task on worker pool')
+  .argument('<type>', 'Task type: compute, analyze, transform, batch')
+  .argument('<data>', 'Task data (JSON string or simple value)')
+  .option('-s, --size <size>', 'Pool size', '4')
+  .option('--timeout <ms>', 'Task timeout in milliseconds', '30000')
+  .option('--json', 'Output as JSON')
+  .action(async (type, data, opts) => {
+    const spinner = ora(`Executing ${type} task...`).start();
+
+    try {
+      let RealWorkerPool;
+      try {
+        const realWorkers = await import('@ruvector/edge-net/real-workers');
+        RealWorkerPool = realWorkers.RealWorkerPool;
+      } catch (e) {
+        const realWorkersPath = path.resolve(__dirname, '../../../../examples/edge-net/pkg/real-workers.js');
+        const realWorkers = await import(realWorkersPath);
+        RealWorkerPool = realWorkers.RealWorkerPool;
+      }
+
+      const pool = new RealWorkerPool({ size: parseInt(opts.size) || 4 });
+      await pool.initialize();
+
+      let taskData;
+      try {
+        taskData = JSON.parse(data);
+      } catch {
+        taskData = { input: data };
+      }
+
+      const startTime = Date.now();
+      const result = await pool.execute(type, taskData, {
+        timeout: parseInt(opts.timeout) || 30000,
+      });
+      const duration = Date.now() - startTime;
+
+      spinner.succeed(`Task completed in ${(duration / 1000).toFixed(2)}s`);
+
+      if (opts.json) {
+        console.log(JSON.stringify({ success: true, duration, result }, null, 2));
+      } else {
+        console.log(chalk.bold.cyan('\n⚡ Worker Execution Complete\n'));
+        console.log(`${chalk.cyan('Type:')} ${type}`);
+        console.log(`${chalk.cyan('Duration:')} ${(duration / 1000).toFixed(2)}s`);
+        console.log(`${chalk.cyan('Worker:')} ${result.workerId || 'pool'}`);
+        console.log(chalk.bold('\n📝 Result:\n'));
+        console.log(JSON.stringify(result, null, 2));
+        console.log();
+      }
+
+      if (pool.shutdown) await pool.shutdown();
+      else if (pool.close) await pool.close();
+
+    } catch (e) {
+      spinner.fail(`Execution failed: ${e.message}`);
+    }
+  });
+
+workerCmd.command('info')
+  .description('Show worker pool information')
+  .action(() => {
+    console.log(chalk.bold.cyan('\n⚡ Real Worker Pool System\n'));
+    console.log(chalk.white('Execute parallel tasks using Node.js worker_threads.\n'));
+
+    console.log(chalk.bold('Task Types:'));
+    console.log(chalk.dim('  compute   - CPU-intensive computations'));
+    console.log(chalk.dim('  analyze   - Data analysis tasks'));
+    console.log(chalk.dim('  transform - Data transformation'));
+    console.log(chalk.dim('  batch     - Batch processing'));
+
+    console.log(chalk.bold('\n📋 Examples:\n'));
+    console.log(chalk.cyan('  ruvector worker create --size 8'));
+    console.log(chalk.cyan('  ruvector worker execute compute \'{"n": 1000000}\''));
+    console.log(chalk.cyan('  ruvector worker execute analyze \'{"data": [1,2,3,4,5]}\''));
+    console.log();
+  });
+
+// ============================================
+// REAL WORKFLOW COMMANDS
+// ============================================
+
+const workflowCmd = program.command('workflow').description('Real multi-agent workflow orchestration with LLM execution');
+
+workflowCmd.command('run')
+  .description('Run a multi-agent workflow (uses local ruvllm by default)')
+  .argument('<template>', 'Workflow template: code-review, feature-dev, bug-fix, optimization, research')
+  .argument('<input>', 'Input/context for the workflow')
+  .option('-p, --provider <provider>', 'LLM provider: local (default), anthropic, openai', 'local')
+  .option('-m, --model <model>', 'Model tier: fast, balanced, powerful', 'balanced')
+  .option('--max-steps <n>', 'Maximum workflow steps', '10')
+  .option('--json', 'Output as JSON')
+  .action(async (template, input, opts) => {
+    const spinner = ora(`Running ${template} workflow...`).start();
+
+    try {
+      let RealWorkflowOrchestrator;
+      try {
+        const realWorkflows = await import('@ruvector/edge-net/real-workflows');
+        RealWorkflowOrchestrator = realWorkflows.RealWorkflowOrchestrator;
+      } catch (e) {
+        const realWorkflowsPath = path.resolve(__dirname, '../../../../examples/edge-net/pkg/real-workflows.js');
+        const realWorkflows = await import(realWorkflowsPath);
+        RealWorkflowOrchestrator = realWorkflows.RealWorkflowOrchestrator;
+      }
+
+      // Check for API key if using cloud provider
+      const isLocal = opts.provider === 'local' || opts.provider === 'ruvllm';
+      const apiKey = process.env.ANTHROPIC_API_KEY || process.env.OPENAI_API_KEY;
+
+      if (!isLocal && !apiKey) {
+        spinner.fail('No API key found for cloud provider');
+        console.log(chalk.yellow('\n  Use local provider (default) or set API key:'));
+        console.log(chalk.cyan('  ruvector workflow run code-review "my code" -p local'));
+        return;
+      }
+
+      const orchestrator = new RealWorkflowOrchestrator({
+        provider: isLocal ? 'local' : (process.env.ANTHROPIC_API_KEY ? 'anthropic' : 'openai'),
+        apiKey: isLocal ? undefined : apiKey,
+        maxConcurrency: 2,
+      });
+
+      await orchestrator.initialize();
+
+      const startTime = Date.now();
+      const result = await orchestrator.run(template, input, {
+        maxSteps: parseInt(opts.maxSteps) || 10,
+        modelTier: opts.model,
+      });
+      const duration = Date.now() - startTime;
+
+      spinner.succeed(`Workflow completed in ${(duration / 1000).toFixed(2)}s`);
+
+      if (opts.json) {
+        console.log(JSON.stringify({ success: true, duration, ...result }, null, 2));
+      } else {
+        console.log(chalk.bold.cyan(`\n🔄 Workflow: ${template}\n`));
+        console.log(`${chalk.cyan('Duration:')} ${(duration / 1000).toFixed(2)}s`);
+        console.log(`${chalk.cyan('Provider:')} ${opts.provider}`);
+        const steps = result.steps || [];
+        const completedSteps = steps.filter(s => s.status === 'completed').length;
+        console.log(`${chalk.cyan('Steps:')} ${completedSteps}/${steps.length}`);
+
+        console.log(chalk.bold('\n📝 Results by Step:\n'));
+        for (const [stepName, stepResult] of Object.entries(result.results || {})) {
+          console.log(chalk.bold.green(`  ${stepName}:`));
+          const preview = typeof stepResult === 'string'
+            ? stepResult.slice(0, 200) + (stepResult.length > 200 ? '...' : '')
+            : JSON.stringify(stepResult).slice(0, 200);
+          console.log(chalk.dim(`    ${preview}\n`));
+        }
+      }
+
+      await orchestrator.close();
+
+    } catch (e) {
+      spinner.fail(`Workflow failed: ${e.message}`);
+    }
+  });
+
+workflowCmd.command('templates')
+  .description('List available workflow templates')
+  .action(() => {
+    console.log(chalk.bold.cyan('\n🔄 Workflow Templates\n'));
+
+    const templates = [
+      { name: 'code-review', desc: 'Analyze, review, test coverage, and optimize code', steps: 4 },
+      { name: 'feature-dev', desc: 'Research, implement, test, and review a feature', steps: 4 },
+      { name: 'bug-fix', desc: 'Analyze, fix, and verify a bug', steps: 3 },
+      { name: 'optimization', desc: 'Profile, identify bottlenecks, optimize, benchmark', steps: 4 },
+      { name: 'research', desc: 'Research, analyze, and create knowledge embeddings', steps: 3 },
+    ];
+
+    templates.forEach(t => {
+      console.log(`  ${chalk.green('•')} ${chalk.bold(t.name.padEnd(14))} ${t.desc}`);
+      console.log(`    ${chalk.dim(`Steps: ${t.steps}`)}`);
+    });
+
+    console.log(chalk.bold('\n📋 Example:\n'));
+    console.log(chalk.cyan('  ruvector workflow run code-review "Review my authentication module"'));
+    console.log(chalk.cyan('  ruvector workflow run feature-dev "Add user profile page" -p anthropic'));
+    console.log();
+  });
+
 // MCP Server command
 const mcpCmd = program.command('mcp').description('MCP (Model Context Protocol) server for Claude Code integration');
 

package/bin/mcp-server.js

@@ -294,7 +294,7 @@ class Intelligence {
 const server = new Server(
   {
     name: 'ruvector',
-    version: '0.1.58',
+    version: '0.1.92',
   },
   {
     capabilities: {
@@ -1127,7 +1127,7 @@ const TOOLS = [
   },
   {
     name: 'agent_execute',
-    description: 'REAL agent execution that calls actual LLM APIs (Anthropic Claude or OpenAI). Requires ANTHROPIC_API_KEY or OPENAI_API_KEY environment variable.',
+    description: 'REAL agent execution using local ruvllm (default, no API key), or cloud APIs (Anthropic/OpenAI). Local runs without needing any API key.',
     inputSchema: {
       type: 'object',
       properties: {
@@ -1137,7 +1137,7 @@ const TOOLS = [
           enum: ['researcher', 'coder', 'reviewer', 'tester', 'analyst', 'optimizer', 'coordinator', 'embedder']
         },
         task: { type: 'string', description: 'Task for the agent to execute' },
-        provider: { type: 'string', enum: ['anthropic', 'openai'], description: 'LLM provider (auto-detected from API key)' },
+        provider: { type: 'string', enum: ['local', 'ruvllm', 'anthropic', 'openai'], default: 'local', description: 'LLM provider (local by default, no API key needed)' },
         model: { type: 'string', enum: ['fast', 'balanced', 'powerful'], default: 'balanced', description: 'Model tier' },
         context: { type: 'string', description: 'Additional context for the agent' },
         max_tokens: { type: 'number', default: 4096, description: 'Maximum tokens in response' }
@@ -2819,7 +2819,7 @@ server.setRequestHandler(CallToolRequestSchema, async (request) => {
       }
 
       case 'agent_execute': {
-        // REAL agent execution with actual LLM API calls
+        // REAL agent execution with local ruvllm by default, or cloud APIs
         const validTypes = ['researcher', 'coder', 'reviewer', 'tester', 'analyst', 'optimizer', 'coordinator', 'embedder'];
         const validModels = ['fast', 'balanced', 'powerful'];
 
@@ -2828,17 +2828,22 @@ server.setRequestHandler(CallToolRequestSchema, async (request) => {
         const model = validModels.includes(args.model) ? args.model : 'balanced';
         const maxTokens = Math.min(Math.max(parseInt(args.max_tokens) || 4096, 100), 8192);
 
-        // Check for API key
+        // Determine provider (local by default)
+        const provider = args.provider || 'local';
+        const isLocal = provider === 'local' || provider === 'ruvllm';
+
+        // Check for API key (only required for cloud providers)
         const apiKey = process.env.ANTHROPIC_API_KEY || process.env.OPENAI_API_KEY;
-        if (!apiKey && agentType !== 'embedder') {
+        if (!isLocal && !apiKey && agentType !== 'embedder') {
           return {
             content: [{
               type: 'text',
               text: JSON.stringify({
                 success: false,
-                error: 'No API key configured',
-                message: 'Set ANTHROPIC_API_KEY or OPENAI_API_KEY environment variable',
-                help: {
+                error: 'No API key configured for cloud provider',
+                message: 'Set ANTHROPIC_API_KEY or OPENAI_API_KEY, or use local provider (default)',
+                options: {
+                  local: 'Use provider=local (no API key needed)',
                   anthropic: 'https://console.anthropic.com/',
                   openai: 'https://platform.openai.com/api-keys'
                 }
@@ -2856,23 +2861,21 @@ server.setRequestHandler(CallToolRequestSchema, async (request) => {
             RealAgentManager = realAgents.RealAgentManager;
           } catch (e) {
             // Fallback to local path for development
-            const realAgentsPath = path.resolve(__dirname, '../../../examples/edge-net/pkg/real-agents.js');
+            const realAgentsPath = path.resolve(__dirname, '../../../../examples/edge-net/pkg/real-agents.js');
             const realAgents = await import(realAgentsPath);
             RealAgentManager = realAgents.RealAgentManager;
           }
 
-          // Determine provider from API key
-          const provider = args.provider || (process.env.ANTHROPIC_API_KEY ? 'anthropic' : 'openai');
-
-          // Initialize manager
+          // Initialize manager with selected provider
           const manager = new RealAgentManager({
-            provider,
-            apiKey,
+            provider: isLocal ? 'local' : (apiKey && process.env.ANTHROPIC_API_KEY ? 'anthropic' : 'openai'),
+            apiKey: isLocal ? undefined : apiKey,
           });
           await manager.initialize();
 
           // Spawn and execute
-          const agent = await manager.spawn(agentType, { provider, model });
+          const effectiveProvider = isLocal ? 'local' : (apiKey && process.env.ANTHROPIC_API_KEY ? 'anthropic' : 'openai');
+          const agent = await manager.spawn(agentType, { provider: effectiveProvider, model });
 
           const context = {
             model,
@@ -2892,15 +2895,17 @@ server.setRequestHandler(CallToolRequestSchema, async (request) => {
               text: JSON.stringify({
                 success: true,
                 real_execution: true,
+                local_mode: isLocal,
                 agent: {
                   id: agent.id,
                   type: agentType,
-                  provider,
-                  model: result.model
+                  provider: effectiveProvider,
+                  model: result.model || (isLocal ? 'ruvllm-balanced' : model)
                 },
                 execution: {
                   duration_ms: duration,
-                  tokens: agent.cost
+                  tokens: agent.cost,
+                  fallback: result.fallback || false
                 },
                 response: result.content
               }, null, 2)
@@ -2933,7 +2938,7 @@ server.setRequestHandler(CallToolRequestSchema, async (request) => {
             const realAgents = await import('@ruvector/edge-net/real-agents');
             RelaySyncClient = realAgents.RelaySyncClient;
           } catch (e) {
-            const realAgentsPath = path.resolve(__dirname, '../../../examples/edge-net/pkg/real-agents.js');
+            const realAgentsPath = path.resolve(__dirname, '../../../../examples/edge-net/pkg/real-agents.js');
             const realAgents = await import(realAgentsPath);
             RelaySyncClient = realAgents.RelaySyncClient;
           }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "ruvector",
-  "version": "0.1.91",
+  "version": "0.1.92",
   "description": "High-performance vector database for Node.js with automatic native/WASM fallback",
   "main": "dist/index.js",
   "types": "dist/index.d.ts",