ruvector 0.1.77 → 0.1.79

package/bin/cli.js

@@ -6123,8 +6123,233 @@ workersCmd.command('cancel')
     }
   });
 
+// Custom Worker System (agentic-flow@alpha.39+)
+workersCmd.command('presets')
+  .description('List available worker presets (quick-scan, deep-analysis, security-scan, etc.)')
+  .action(async () => {
+    try {
+      await runAgenticFlow(['workers', 'presets']);
+    } catch (e) {
+      console.error(chalk.red('Presets list failed:'), e.message);
+    }
+  });
+
+workersCmd.command('phases')
+  .description('List available phase executors (24 phases: file-discovery, security-analysis, etc.)')
+  .action(async () => {
+    try {
+      await runAgenticFlow(['workers', 'phases']);
+    } catch (e) {
+      console.error(chalk.red('Phases list failed:'), e.message);
+    }
+  });
+
+workersCmd.command('create')
+  .description('Create a custom worker from preset')
+  .argument('<name>', 'Worker name')
+  .option('--preset <preset>', 'Base preset (quick-scan, deep-analysis, security-scan, learning, api-docs, test-analysis)')
+  .option('--triggers <triggers>', 'Comma-separated trigger keywords')
+  .action(async (name, opts) => {
+    try {
+      const args = ['workers', 'create', name];
+      if (opts.preset) args.push('--preset', opts.preset);
+      if (opts.triggers) args.push('--triggers', opts.triggers);
+      await runAgenticFlow(args);
+    } catch (e) {
+      console.error(chalk.red('Worker creation failed:'), e.message);
+    }
+  });
+
+workersCmd.command('run')
+  .description('Run a custom worker')
+  .argument('<name>', 'Worker name')
+  .option('--path <path>', 'Target path to analyze', '.')
+  .action(async (name, opts) => {
+    try {
+      const args = ['workers', 'run', name];
+      if (opts.path) args.push('--path', opts.path);
+      await runAgenticFlow(args);
+    } catch (e) {
+      console.error(chalk.red('Worker run failed:'), e.message);
+    }
+  });
+
+workersCmd.command('custom')
+  .description('List registered custom workers')
+  .action(async () => {
+    try {
+      await runAgenticFlow(['workers', 'custom']);
+    } catch (e) {
+      console.error(chalk.red('Custom workers list failed:'), e.message);
+    }
+  });
+
+workersCmd.command('init-config')
+  .description('Generate example workers.yaml config file')
+  .option('--force', 'Overwrite existing config')
+  .action(async (opts) => {
+    try {
+      const args = ['workers', 'init-config'];
+      if (opts.force) args.push('--force');
+      await runAgenticFlow(args);
+    } catch (e) {
+      console.error(chalk.red('Config init failed:'), e.message);
+    }
+  });
+
+workersCmd.command('load-config')
+  .description('Load custom workers from workers.yaml')
+  .option('--file <file>', 'Config file path', 'workers.yaml')
+  .action(async (opts) => {
+    try {
+      const args = ['workers', 'load-config'];
+      if (opts.file !== 'workers.yaml') args.push('--file', opts.file);
+      await runAgenticFlow(args);
+    } catch (e) {
+      console.error(chalk.red('Config load failed:'), e.message);
+    }
+  });
+
 console.log && false; // Force registration
 
+// Native Workers command group - Deep ruvector integration (no agentic-flow delegation)
+const nativeCmd = program.command('native').description('Native workers with deep ONNX/VectorDB integration (no external deps)');
+
+nativeCmd.command('run')
+  .description('Run a native worker type')
+  .argument('<type>', 'Worker type: security, analysis, learning')
+  .option('--path <path>', 'Target path to analyze', '.')
+  .option('--json', 'Output as JSON')
+  .action(async (type, opts) => {
+    try {
+      const { createSecurityWorker, createAnalysisWorker, createLearningWorker } = require('../dist/workers/native-worker.js');
+
+      let worker;
+      switch (type) {
+        case 'security':
+          worker = createSecurityWorker();
+          break;
+        case 'analysis':
+          worker = createAnalysisWorker();
+          break;
+        case 'learning':
+          worker = createLearningWorker();
+          break;
+        default:
+          console.error(chalk.red(`Unknown worker type: ${type}`));
+          console.log(chalk.dim('Available types: security, analysis, learning'));
+          return;
+      }
+
+      console.log(chalk.cyan(`\n🔧 Running native ${type} worker on ${opts.path}...\n`));
+      const result = await worker.run(opts.path);
+
+      if (opts.json) {
+        console.log(JSON.stringify(result, null, 2));
+      } else {
+        console.log(chalk.bold(`Worker: ${result.worker}`));
+        console.log(chalk.dim(`Status: ${result.success ? chalk.green('✓ Success') : chalk.red('✗ Failed')}`));
+        console.log(chalk.dim(`Time: ${result.totalTimeMs.toFixed(0)}ms\n`));
+
+        console.log(chalk.bold('Phases:'));
+        for (const phase of result.phases) {
+          const status = phase.success ? chalk.green('✓') : chalk.red('✗');
+          console.log(`  ${status} ${phase.phase} (${phase.timeMs.toFixed(0)}ms)`);
+          if (phase.data) {
+            const dataStr = JSON.stringify(phase.data);
+            if (dataStr.length < 100) {
+              console.log(chalk.dim(`    ${dataStr}`));
+            }
+          }
+        }
+
+        if (result.summary) {
+          console.log(chalk.bold('\nSummary:'));
+          console.log(`  Files analyzed: ${result.summary.filesAnalyzed}`);
+          console.log(`  Patterns found: ${result.summary.patternsFound}`);
+          console.log(`  Embeddings: ${result.summary.embeddingsGenerated}`);
+          console.log(`  Vectors stored: ${result.summary.vectorsStored}`);
+
+          if (result.summary.findings.length > 0) {
+            console.log(chalk.bold('\nFindings:'));
+            const byType = { info: 0, warning: 0, error: 0, security: 0 };
+            result.summary.findings.forEach(f => byType[f.type]++);
+            if (byType.security > 0) console.log(chalk.red(`  🔒 Security: ${byType.security}`));
+            if (byType.error > 0) console.log(chalk.red(`  ❌ Errors: ${byType.error}`));
+            if (byType.warning > 0) console.log(chalk.yellow(`  ⚠️  Warnings: ${byType.warning}`));
+            if (byType.info > 0) console.log(chalk.blue(`  ℹ️  Info: ${byType.info}`));
+
+            // Show top findings
+            console.log(chalk.dim('\nTop findings:'));
+            result.summary.findings.slice(0, 5).forEach(f => {
+              const icon = f.type === 'security' ? '🔒' : f.type === 'warning' ? '⚠️' : 'ℹ️';
+              console.log(chalk.dim(`  ${icon} ${f.message.slice(0, 60)}${f.file ? ` (${path.basename(f.file)})` : ''}`));
+            });
+          }
+        }
+      }
+    } catch (e) {
+      console.error(chalk.red('Native worker failed:'), e.message);
+      if (e.stack) console.error(chalk.dim(e.stack));
+    }
+  });
+
+nativeCmd.command('benchmark')
+  .description('Run performance benchmark suite')
+  .option('--path <path>', 'Target path for worker benchmarks', '.')
+  .option('--embeddings-only', 'Only benchmark embeddings')
+  .option('--workers-only', 'Only benchmark workers')
+  .action(async (opts) => {
+    try {
+      const benchmark = require('../dist/workers/benchmark.js');
+
+      if (opts.embeddingsOnly) {
+        console.log(chalk.cyan('\n📊 Benchmarking ONNX Embeddings...\n'));
+        const results = await benchmark.benchmarkEmbeddings(10);
+        console.log(benchmark.formatBenchmarkResults(results));
+      } else if (opts.workersOnly) {
+        console.log(chalk.cyan('\n🔧 Benchmarking Native Workers...\n'));
+        const results = await benchmark.benchmarkWorkers(opts.path);
+        console.log(benchmark.formatBenchmarkResults(results));
+      } else {
+        await benchmark.runFullBenchmark(opts.path);
+      }
+    } catch (e) {
+      console.error(chalk.red('Benchmark failed:'), e.message);
+      if (e.stack) console.error(chalk.dim(e.stack));
+    }
+  });
+
+nativeCmd.command('list')
+  .description('List available native worker types')
+  .action(() => {
+    console.log(chalk.cyan('\n🔧 Native Worker Types\n'));
+    console.log(chalk.bold('security'));
+    console.log(chalk.dim('  Security vulnerability scanner'));
+    console.log(chalk.dim('  Phases: file-discovery → security-scan → summarization'));
+    console.log(chalk.dim('  No ONNX/VectorDB required\n'));
+
+    console.log(chalk.bold('analysis'));
+    console.log(chalk.dim('  Full code analysis with embeddings'));
+    console.log(chalk.dim('  Phases: file-discovery → pattern-extraction → embedding-generation'));
+    console.log(chalk.dim('          → vector-storage → complexity-analysis → summarization'));
+    console.log(chalk.dim('  Requires: ONNX embedder, VectorDB\n'));
+
+    console.log(chalk.bold('learning'));
+    console.log(chalk.dim('  Pattern learning with vector storage'));
+    console.log(chalk.dim('  Phases: file-discovery → pattern-extraction → embedding-generation'));
+    console.log(chalk.dim('          → vector-storage → summarization'));
+    console.log(chalk.dim('  Requires: ONNX embedder, VectorDB, Intelligence memory\n'));
+
+    console.log(chalk.bold('Available Phases:'));
+    const phases = [
+      'file-discovery', 'pattern-extraction', 'embedding-generation',
+      'vector-storage', 'similarity-search', 'security-scan',
+      'complexity-analysis', 'summarization'
+    ];
+    phases.forEach(p => console.log(chalk.dim(`  • ${p}`)));
+  });
+
 // MCP Server command
 const mcpCmd = program.command('mcp').description('MCP (Model Context Protocol) server for Claude Code integration');
 

package/bin/mcp-server.js

@@ -970,6 +970,81 @@ const TOOLS = [
       properties: {},
       required: []
     }
+  },
+  // Custom Worker System (agentic-flow@alpha.39+)
+  {
+    name: 'workers_presets',
+    description: 'List available worker presets (quick-scan, deep-analysis, security-scan, learning, api-docs, test-analysis)',
+    inputSchema: {
+      type: 'object',
+      properties: {},
+      required: []
+    }
+  },
+  {
+    name: 'workers_phases',
+    description: 'List available phase executors (24 phases including file-discovery, security-analysis, pattern-extraction)',
+    inputSchema: {
+      type: 'object',
+      properties: {},
+      required: []
+    }
+  },
+  {
+    name: 'workers_create',
+    description: 'Create a custom worker from preset with composable phases',
+    inputSchema: {
+      type: 'object',
+      properties: {
+        name: { type: 'string', description: 'Worker name' },
+        preset: { type: 'string', description: 'Base preset (quick-scan, deep-analysis, security-scan, learning, api-docs, test-analysis)' },
+        triggers: { type: 'string', description: 'Comma-separated trigger keywords' }
+      },
+      required: ['name']
+    }
+  },
+  {
+    name: 'workers_run',
+    description: 'Run a custom worker on target path',
+    inputSchema: {
+      type: 'object',
+      properties: {
+        name: { type: 'string', description: 'Worker name' },
+        path: { type: 'string', description: 'Target path to analyze (default: .)' }
+      },
+      required: ['name']
+    }
+  },
+  {
+    name: 'workers_custom',
+    description: 'List registered custom workers',
+    inputSchema: {
+      type: 'object',
+      properties: {},
+      required: []
+    }
+  },
+  {
+    name: 'workers_init_config',
+    description: 'Generate example workers.yaml config file',
+    inputSchema: {
+      type: 'object',
+      properties: {
+        force: { type: 'boolean', description: 'Overwrite existing config' }
+      },
+      required: []
+    }
+  },
+  {
+    name: 'workers_load_config',
+    description: 'Load custom workers from workers.yaml config file',
+    inputSchema: {
+      type: 'object',
+      properties: {
+        file: { type: 'string', description: 'Config file path (default: workers.yaml)' }
+      },
+      required: []
+    }
   }
 ];
 
@@ -2237,6 +2312,162 @@ server.setRequestHandler(CallToolRequestSchema, async (request) => {
         }
       }
 
+      // Custom Worker System handlers (agentic-flow@alpha.39+)
+      case 'workers_presets': {
+        try {
+          const result = execSync('npx agentic-flow@alpha workers presets', {
+            encoding: 'utf-8',
+            timeout: 15000,
+            stdio: ['pipe', 'pipe', 'pipe']
+          });
+          return { content: [{ type: 'text', text: JSON.stringify({
+            success: true,
+            presets: result.trim()
+          }, null, 2) }] };
+        } catch (e) {
+          return { content: [{ type: 'text', text: JSON.stringify({
+            success: true,
+            presets: ['quick-scan', 'deep-analysis', 'security-scan', 'learning', 'api-docs', 'test-analysis'],
+            note: 'Hardcoded fallback - install agentic-flow@alpha for full support'
+          }, null, 2) }] };
+        }
+      }
+
+      case 'workers_phases': {
+        try {
+          const result = execSync('npx agentic-flow@alpha workers phases', {
+            encoding: 'utf-8',
+            timeout: 15000,
+            stdio: ['pipe', 'pipe', 'pipe']
+          });
+          return { content: [{ type: 'text', text: JSON.stringify({
+            success: true,
+            phases: result.trim()
+          }, null, 2) }] };
+        } catch (e) {
+          return { content: [{ type: 'text', text: JSON.stringify({
+            success: true,
+            phases: ['file-discovery', 'static-analysis', 'security-analysis', 'pattern-extraction', 'dependency-analysis', 'complexity-analysis', 'test-coverage', 'api-extraction', 'secret-detection', 'report-generation'],
+            note: 'Partial list - install agentic-flow@alpha for all 24 phases'
+          }, null, 2) }] };
+        }
+      }
+
+      case 'workers_create': {
+        const name = args.name;
+        const preset = args.preset || 'quick-scan';
+        const triggers = args.triggers;
+        try {
+          let cmd = `npx agentic-flow@alpha workers create "${name}" --preset ${preset}`;
+          if (triggers) cmd += ` --triggers "${triggers}"`;
+          const result = execSync(cmd, {
+            encoding: 'utf-8',
+            timeout: 30000,
+            stdio: ['pipe', 'pipe', 'pipe']
+          });
+          return { content: [{ type: 'text', text: JSON.stringify({
+            success: true,
+            message: `Worker '${name}' created with preset '${preset}'`,
+            output: result.trim()
+          }, null, 2) }] };
+        } catch (e) {
+          return { content: [{ type: 'text', text: JSON.stringify({
+            success: false,
+            error: 'Worker creation failed',
+            message: e.message
+          }, null, 2) }] };
+        }
+      }
+
+      case 'workers_run': {
+        const name = args.name;
+        const targetPath = args.path || '.';
+        try {
+          const result = execSync(`npx agentic-flow@alpha workers run "${name}" --path "${targetPath}"`, {
+            encoding: 'utf-8',
+            timeout: 120000,
+            stdio: ['pipe', 'pipe', 'pipe']
+          });
+          return { content: [{ type: 'text', text: JSON.stringify({
+            success: true,
+            worker: name,
+            path: targetPath,
+            output: result.trim()
+          }, null, 2) }] };
+        } catch (e) {
+          return { content: [{ type: 'text', text: JSON.stringify({
+            success: false,
+            error: `Worker '${name}' execution failed`,
+            message: e.message
+          }, null, 2) }] };
+        }
+      }
+
+      case 'workers_custom': {
+        try {
+          const result = execSync('npx agentic-flow@alpha workers custom', {
+            encoding: 'utf-8',
+            timeout: 15000,
+            stdio: ['pipe', 'pipe', 'pipe']
+          });
+          return { content: [{ type: 'text', text: JSON.stringify({
+            success: true,
+            workers: result.trim()
+          }, null, 2) }] };
+        } catch (e) {
+          return { content: [{ type: 'text', text: JSON.stringify({
+            success: true,
+            workers: [],
+            note: 'No custom workers registered'
+          }, null, 2) }] };
+        }
+      }
+
+      case 'workers_init_config': {
+        try {
+          let cmd = 'npx agentic-flow@alpha workers init-config';
+          if (args.force) cmd += ' --force';
+          const result = execSync(cmd, {
+            encoding: 'utf-8',
+            timeout: 15000,
+            stdio: ['pipe', 'pipe', 'pipe']
+          });
+          return { content: [{ type: 'text', text: JSON.stringify({
+            success: true,
+            message: 'workers.yaml config file created',
+            output: result.trim()
+          }, null, 2) }] };
+        } catch (e) {
+          return { content: [{ type: 'text', text: JSON.stringify({
+            success: false,
+            error: 'Config init failed',
+            message: e.message
+          }, null, 2) }] };
+        }
+      }
+
+      case 'workers_load_config': {
+        const configFile = args.file || 'workers.yaml';
+        try {
+          const result = execSync(`npx agentic-flow@alpha workers load-config --file "${configFile}"`, {
+            encoding: 'utf-8',
+            timeout: 30000,
+            stdio: ['pipe', 'pipe', 'pipe']
+          });
+          return { content: [{ type: 'text', text: JSON.stringify({
+            success: true,
+            file: configFile,
+            output: result.trim()
+          }, null, 2) }] };
+        } catch (e) {
+          return { content: [{ type: 'text', text: JSON.stringify({
+            success: false,
+            error: `Config load failed from '${configFile}'`,
+            message: e.message
+          }, null, 2) }] };
+        }
+      }
+
       default:
         return {
           content: [{

package/dist/workers/benchmark.d.ts

@@ -0,0 +1,44 @@
+/**
+ * Worker Benchmark Suite for RuVector
+ *
+ * Measures performance of:
+ * - ONNX embedding generation (single vs batch)
+ * - Vector storage and search
+ * - Phase execution times
+ * - Worker end-to-end throughput
+ */
+import { BenchmarkResult } from './types';
+/**
+ * Benchmark ONNX embedding generation
+ */
+export declare function benchmarkEmbeddings(iterations?: number): Promise<BenchmarkResult[]>;
+/**
+ * Benchmark worker execution
+ */
+export declare function benchmarkWorkers(targetPath?: string): Promise<BenchmarkResult[]>;
+/**
+ * Benchmark individual phases
+ */
+export declare function benchmarkPhases(targetPath?: string): Promise<BenchmarkResult[]>;
+/**
+ * Format benchmark results as table
+ */
+export declare function formatBenchmarkResults(results: BenchmarkResult[]): string;
+/**
+ * Run full benchmark suite
+ */
+export declare function runFullBenchmark(targetPath?: string): Promise<{
+    embeddings: BenchmarkResult[];
+    phases: BenchmarkResult[];
+    workers: BenchmarkResult[];
+    summary: string;
+}>;
+declare const _default: {
+    benchmarkEmbeddings: typeof benchmarkEmbeddings;
+    benchmarkWorkers: typeof benchmarkWorkers;
+    benchmarkPhases: typeof benchmarkPhases;
+    runFullBenchmark: typeof runFullBenchmark;
+    formatBenchmarkResults: typeof formatBenchmarkResults;
+};
+export default _default;
+//# sourceMappingURL=benchmark.d.ts.map

package/dist/workers/benchmark.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"benchmark.d.ts","sourceRoot":"","sources":["../../src/workers/benchmark.ts"],"names":[],"mappings":"AAAA;;;;;;;;GAQG;AAGH,OAAO,EAAE,eAAe,EAAE,MAAM,SAAS,CAAC;AA4C1C;;GAEG;AACH,wBAAsB,mBAAmB,CAAC,UAAU,GAAE,MAAW,GAAG,OAAO,CAAC,eAAe,EAAE,CAAC,CAwE7F;AAED;;GAEG;AACH,wBAAsB,gBAAgB,CAAC,UAAU,GAAE,MAAY,GAAG,OAAO,CAAC,eAAe,EAAE,CAAC,CA4B3F;AAED;;GAEG;AACH,wBAAsB,eAAe,CAAC,UAAU,GAAE,MAAY,GAAG,OAAO,CAAC,eAAe,EAAE,CAAC,CAsD1F;AAED;;GAEG;AACH,wBAAgB,sBAAsB,CAAC,OAAO,EAAE,eAAe,EAAE,GAAG,MAAM,CAwBzE;AAED;;GAEG;AACH,wBAAsB,gBAAgB,CAAC,UAAU,GAAE,MAAY,GAAG,OAAO,CAAC;IACxE,UAAU,EAAE,eAAe,EAAE,CAAC;IAC9B,MAAM,EAAE,eAAe,EAAE,CAAC;IAC1B,OAAO,EAAE,eAAe,EAAE,CAAC;IAC3B,OAAO,EAAE,MAAM,CAAC;CACjB,CAAC,CAyCD;;;;;;;;AAED,wBAME"}