ruvector 0.1.78 → 0.1.79

package/bin/cli.js

@@ -6212,6 +6212,144 @@ workersCmd.command('load-config')
 
 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/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"}

package/dist/workers/benchmark.js

@@ -0,0 +1,230 @@
+"use strict";
+/**
+ * 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
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.benchmarkEmbeddings = benchmarkEmbeddings;
+exports.benchmarkWorkers = benchmarkWorkers;
+exports.benchmarkPhases = benchmarkPhases;
+exports.formatBenchmarkResults = formatBenchmarkResults;
+exports.runFullBenchmark = runFullBenchmark;
+const perf_hooks_1 = require("perf_hooks");
+const native_worker_1 = require("./native-worker");
+const onnx_embedder_1 = require("../core/onnx-embedder");
+/**
+ * Run a benchmark function multiple times and collect stats
+ */
+async function runBenchmark(name, fn, iterations = 10, warmup = 2) {
+    // Warmup runs
+    for (let i = 0; i < warmup; i++) {
+        await fn();
+    }
+    // Actual benchmark runs
+    const times = [];
+    for (let i = 0; i < iterations; i++) {
+        const start = perf_hooks_1.performance.now();
+        await fn();
+        times.push(perf_hooks_1.performance.now() - start);
+    }
+    // Calculate statistics
+    times.sort((a, b) => a - b);
+    const sum = times.reduce((a, b) => a + b, 0);
+    return {
+        name,
+        iterations,
+        results: {
+            min: times[0],
+            max: times[times.length - 1],
+            avg: sum / times.length,
+            p50: times[Math.floor(times.length * 0.5)],
+            p95: times[Math.floor(times.length * 0.95)],
+            p99: times[Math.floor(times.length * 0.99)],
+        },
+    };
+}
+/**
+ * Benchmark ONNX embedding generation
+ */
+async function benchmarkEmbeddings(iterations = 10) {
+    const results = [];
+    // Initialize embedder
+    await (0, onnx_embedder_1.initOnnxEmbedder)();
+    const stats = (0, onnx_embedder_1.getStats)();
+    console.log(`\n📊 ONNX Embedder: ${stats.dimension}d, SIMD: ${stats.simd}`);
+    // Single embedding benchmark
+    const singleResult = await runBenchmark('Single embedding (short text)', async () => {
+        await (0, onnx_embedder_1.embed)('This is a test sentence for embedding.');
+    }, iterations);
+    results.push(singleResult);
+    // Single embedding - long text
+    const longText = 'This is a much longer text that contains more content. '.repeat(20);
+    const singleLongResult = await runBenchmark('Single embedding (long text)', async () => {
+        await (0, onnx_embedder_1.embed)(longText);
+    }, iterations);
+    results.push(singleLongResult);
+    // Batch embedding - small batch
+    const smallBatch = Array(4).fill(0).map((_, i) => `Test sentence number ${i}`);
+    const batchSmallResult = await runBenchmark('Batch embedding (4 texts)', async () => {
+        await (0, onnx_embedder_1.embedBatch)(smallBatch);
+    }, iterations);
+    batchSmallResult.throughput = {
+        itemsPerSecond: (4 * 1000) / batchSmallResult.results.avg,
+    };
+    results.push(batchSmallResult);
+    // Batch embedding - medium batch
+    const mediumBatch = Array(16).fill(0).map((_, i) => `Test sentence number ${i} with some content`);
+    const batchMediumResult = await runBenchmark('Batch embedding (16 texts)', async () => {
+        await (0, onnx_embedder_1.embedBatch)(mediumBatch);
+    }, iterations);
+    batchMediumResult.throughput = {
+        itemsPerSecond: (16 * 1000) / batchMediumResult.results.avg,
+    };
+    results.push(batchMediumResult);
+    // Batch embedding - large batch
+    const largeBatch = Array(64).fill(0).map((_, i) => `Test sentence number ${i} with additional content here`);
+    const batchLargeResult = await runBenchmark('Batch embedding (64 texts)', async () => {
+        await (0, onnx_embedder_1.embedBatch)(largeBatch);
+    }, Math.min(iterations, 5) // Fewer iterations for large batches
+    );
+    batchLargeResult.throughput = {
+        itemsPerSecond: (64 * 1000) / batchLargeResult.results.avg,
+    };
+    results.push(batchLargeResult);
+    return results;
+}
+/**
+ * Benchmark worker execution
+ */
+async function benchmarkWorkers(targetPath = '.') {
+    const results = [];
+    // Security worker (no embeddings - fastest)
+    const securityWorker = (0, native_worker_1.createSecurityWorker)();
+    const securityResult = await runBenchmark('Security worker (no embeddings)', async () => {
+        await securityWorker.run(targetPath);
+    }, 5, 1);
+    results.push(securityResult);
+    // Analysis worker (with embeddings)
+    const analysisWorker = (0, native_worker_1.createAnalysisWorker)();
+    const analysisResult = await runBenchmark('Analysis worker (with embeddings)', async () => {
+        await analysisWorker.run(targetPath);
+    }, 3, 1);
+    results.push(analysisResult);
+    return results;
+}
+/**
+ * Benchmark individual phases
+ */
+async function benchmarkPhases(targetPath = '.') {
+    const results = [];
+    // File discovery phase only
+    const discoveryWorker = new native_worker_1.NativeWorker({
+        name: 'discovery-only',
+        phases: [{ type: 'file-discovery' }],
+        capabilities: {},
+    });
+    const discoveryResult = await runBenchmark('Phase: file-discovery', async () => {
+        await discoveryWorker.run(targetPath);
+    }, 10);
+    results.push(discoveryResult);
+    // Pattern extraction phase
+    const patternWorker = new native_worker_1.NativeWorker({
+        name: 'pattern-only',
+        phases: [{ type: 'file-discovery' }, { type: 'pattern-extraction' }],
+        capabilities: {},
+    });
+    const patternResult = await runBenchmark('Phase: pattern-extraction', async () => {
+        await patternWorker.run(targetPath);
+    }, 5);
+    results.push(patternResult);
+    // Embedding generation phase
+    const embeddingWorker = new native_worker_1.NativeWorker({
+        name: 'embedding-only',
+        phases: [
+            { type: 'file-discovery', config: { patterns: ['**/*.ts'], exclude: ['**/node_modules/**'] } },
+            { type: 'pattern-extraction' },
+            { type: 'embedding-generation' },
+        ],
+        capabilities: { onnxEmbeddings: true },
+    });
+    const embeddingResult = await runBenchmark('Phase: embedding-generation', async () => {
+        await embeddingWorker.run(targetPath);
+    }, 3, 1);
+    results.push(embeddingResult);
+    return results;
+}
+/**
+ * Format benchmark results as table
+ */
+function formatBenchmarkResults(results) {
+    const lines = [];
+    lines.push('');
+    lines.push('┌─────────────────────────────────────┬──────────┬──────────┬──────────┬──────────┬──────────────┐');
+    lines.push('│ Benchmark                           │ Min (ms) │ Avg (ms) │ P95 (ms) │ Max (ms) │ Throughput   │');
+    lines.push('├─────────────────────────────────────┼──────────┼──────────┼──────────┼──────────┼──────────────┤');
+    for (const result of results) {
+        const name = result.name.padEnd(35).slice(0, 35);
+        const min = result.results.min.toFixed(1).padStart(8);
+        const avg = result.results.avg.toFixed(1).padStart(8);
+        const p95 = result.results.p95.toFixed(1).padStart(8);
+        const max = result.results.max.toFixed(1).padStart(8);
+        const throughput = result.throughput
+            ? `${result.throughput.itemsPerSecond.toFixed(1)}/s`.padStart(12)
+            : '           -';
+        lines.push(`│ ${name} │ ${min} │ ${avg} │ ${p95} │ ${max} │ ${throughput} │`);
+    }
+    lines.push('└─────────────────────────────────────┴──────────┴──────────┴──────────┴──────────┴──────────────┘');
+    lines.push('');
+    return lines.join('\n');
+}
+/**
+ * Run full benchmark suite
+ */
+async function runFullBenchmark(targetPath = '.') {
+    console.log('🚀 RuVector Native Worker Benchmark Suite\n');
+    console.log('='.repeat(60));
+    // Embeddings benchmark
+    console.log('\n📊 Benchmarking ONNX Embeddings...');
+    const embeddings = await benchmarkEmbeddings(10);
+    console.log(formatBenchmarkResults(embeddings));
+    // Phases benchmark
+    console.log('\n⚡ Benchmarking Individual Phases...');
+    const phases = await benchmarkPhases(targetPath);
+    console.log(formatBenchmarkResults(phases));
+    // Workers benchmark
+    console.log('\n🔧 Benchmarking Full Workers...');
+    const workers = await benchmarkWorkers(targetPath);
+    console.log(formatBenchmarkResults(workers));
+    // Summary
+    const stats = (0, onnx_embedder_1.getStats)();
+    const summary = `
+RuVector Native Worker Benchmark Summary
+========================================
+ONNX Model: all-MiniLM-L6-v2 (${stats.dimension}d)
+SIMD: ${stats.simd ? 'Enabled ✓' : 'Disabled'}
+Parallel Workers: ${stats.parallel ? `${stats.parallelWorkers} workers` : 'Disabled'}
+
+Embedding Performance:
+  Single: ${embeddings[0].results.avg.toFixed(1)}ms avg
+  Batch (16): ${embeddings[3].results.avg.toFixed(1)}ms avg (${embeddings[3].throughput?.itemsPerSecond.toFixed(0)}/s)
+  Batch (64): ${embeddings[4].results.avg.toFixed(1)}ms avg (${embeddings[4].throughput?.itemsPerSecond.toFixed(0)}/s)
+
+Worker Performance:
+  Security scan: ${workers[0].results.avg.toFixed(0)}ms avg
+  Full analysis: ${workers[1].results.avg.toFixed(0)}ms avg
+`;
+    console.log(summary);
+    return { embeddings, phases, workers, summary };
+}
+exports.default = {
+    benchmarkEmbeddings,
+    benchmarkWorkers,
+    benchmarkPhases,
+    runFullBenchmark,
+    formatBenchmarkResults,
+};

package/dist/workers/index.d.ts

@@ -0,0 +1,10 @@
+/**
+ * RuVector Native Workers
+ *
+ * Deep integration with ONNX embeddings, VectorDB, and intelligence engine.
+ * No external dependencies - pure ruvector execution.
+ */
+export * from './types';
+export * from './native-worker';
+export * from './benchmark';
+//# sourceMappingURL=index.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/workers/index.ts"],"names":[],"mappings":"AAAA;;;;;GAKG;AAEH,cAAc,SAAS,CAAC;AACxB,cAAc,iBAAiB,CAAC;AAChC,cAAc,aAAa,CAAC"}

package/dist/workers/index.js

@@ -0,0 +1,25 @@
+"use strict";
+/**
+ * RuVector Native Workers
+ *
+ * Deep integration with ONNX embeddings, VectorDB, and intelligence engine.
+ * No external dependencies - pure ruvector execution.
+ */
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+__exportStar(require("./types"), exports);
+__exportStar(require("./native-worker"), exports);
+__exportStar(require("./benchmark"), exports);

package/dist/workers/native-worker.d.ts

@@ -0,0 +1,76 @@
+/**
+ * Native Worker Runner for RuVector
+ *
+ * Direct integration with:
+ * - ONNX embedder (384d, SIMD-accelerated)
+ * - VectorDB (HNSW indexing)
+ * - Intelligence engine (Q-learning, memory)
+ *
+ * No delegation to external tools - pure ruvector execution.
+ */
+import { WorkerConfig, WorkerResult } from './types';
+/**
+ * Native Worker Runner
+ */
+export declare class NativeWorker {
+    private config;
+    private vectorDb;
+    private findings;
+    private stats;
+    constructor(config: WorkerConfig);
+    /**
+     * Initialize worker with capabilities
+     */
+    init(): Promise<void>;
+    /**
+     * Run all phases in sequence
+     */
+    run(targetPath?: string): Promise<WorkerResult>;
+    /**
+     * Execute a single phase
+     */
+    private executePhase;
+    /**
+     * Phase: File Discovery
+     */
+    private phaseFileDiscovery;
+    /**
+     * Phase: Pattern Extraction
+     */
+    private phasePatternExtraction;
+    /**
+     * Phase: Embedding Generation (ONNX)
+     */
+    private phaseEmbeddingGeneration;
+    /**
+     * Phase: Vector Storage
+     */
+    private phaseVectorStorage;
+    /**
+     * Phase: Similarity Search
+     */
+    private phaseSimilaritySearch;
+    /**
+     * Phase: Security Scan
+     */
+    private phaseSecurityScan;
+    /**
+     * Phase: Complexity Analysis
+     */
+    private phaseComplexityAnalysis;
+    /**
+     * Phase: Summarization
+     */
+    private phaseSummarization;
+    /**
+     * Summarize phase data for results
+     */
+    private summarizePhaseData;
+}
+/**
+ * Quick worker factory functions
+ */
+export declare function createSecurityWorker(name?: string): NativeWorker;
+export declare function createAnalysisWorker(name?: string): NativeWorker;
+export declare function createLearningWorker(name?: string): NativeWorker;
+//# sourceMappingURL=native-worker.d.ts.map

package/dist/workers/native-worker.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"native-worker.d.ts","sourceRoot":"","sources":["../../src/workers/native-worker.ts"],"names":[],"mappings":"AAAA;;;;;;;;;GASG;AAKH,OAAO,EACL,YAAY,EACZ,YAAY,EAKb,MAAM,SAAS,CAAC;AAuBjB;;GAEG;AACH,qBAAa,YAAY;IACvB,OAAO,CAAC,MAAM,CAAe;IAC7B,OAAO,CAAC,QAAQ,CAAa;IAC7B,OAAO,CAAC,QAAQ,CAAiB;IACjC,OAAO,CAAC,KAAK,CAKX;gBAEU,MAAM,EAAE,YAAY;IAIhC;;OAEG;IACG,IAAI,IAAI,OAAO,CAAC,IAAI,CAAC;IAmB3B;;OAEG;IACG,GAAG,CAAC,UAAU,GAAE,MAAY,GAAG,OAAO,CAAC,YAAY,CAAC;IAiD1D;;OAEG;YACW,YAAY;IAmC1B;;OAEG;YACW,kBAAkB;IAqBhC;;OAEG;YACW,sBAAsB;IAoDpC;;OAEG;YACW,wBAAwB;IAgDtC;;OAEG;YACW,kBAAkB;IA8BhC;;OAEG;YACW,qBAAqB;IAoBnC;;OAEG;YACW,iBAAiB;IAyC/B;;OAEG;YACW,uBAAuB;IA0CrC;;OAEG;YACW,kBAAkB;IAqBhC;;OAEG;IACH,OAAO,CAAC,kBAAkB;CAsB3B;AAED;;GAEG;AACH,wBAAgB,oBAAoB,CAAC,IAAI,SAAqB,GAAG,YAAY,CAW5E;AAED,wBAAgB,oBAAoB,CAAC,IAAI,SAAkB,GAAG,YAAY,CAczE;AAED,wBAAgB,oBAAoB,CAAC,IAAI,SAAoB,GAAG,YAAY,CAa3E"}

package/dist/workers/native-worker.js

@@ -0,0 +1,489 @@
+"use strict";
+/**
+ * Native Worker Runner for RuVector
+ *
+ * Direct integration with:
+ * - ONNX embedder (384d, SIMD-accelerated)
+ * - VectorDB (HNSW indexing)
+ * - Intelligence engine (Q-learning, memory)
+ *
+ * No delegation to external tools - pure ruvector execution.
+ */
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.NativeWorker = void 0;
+exports.createSecurityWorker = createSecurityWorker;
+exports.createAnalysisWorker = createAnalysisWorker;
+exports.createLearningWorker = createLearningWorker;
+const fs = __importStar(require("fs"));
+const path = __importStar(require("path"));
+const glob_1 = require("glob");
+const onnx_embedder_1 = require("../core/onnx-embedder");
+// Lazy imports for optional dependencies
+let VectorDb = null;
+let intelligence = null;
+async function loadOptionalDeps() {
+    try {
+        const core = await Promise.resolve().then(() => __importStar(require('@ruvector/core')));
+        VectorDb = core.VectorDb;
+    }
+    catch {
+        // VectorDB not available
+    }
+    try {
+        const intel = await Promise.resolve().then(() => __importStar(require('../core/intelligence-engine')));
+        intelligence = intel;
+    }
+    catch {
+        // Intelligence not available
+    }
+}
+/**
+ * Native Worker Runner
+ */
+class NativeWorker {
+    constructor(config) {
+        this.vectorDb = null;
+        this.findings = [];
+        this.stats = {
+            filesAnalyzed: 0,
+            patternsFound: 0,
+            embeddingsGenerated: 0,
+            vectorsStored: 0,
+        };
+        this.config = config;
+    }
+    /**
+     * Initialize worker with capabilities
+     */
+    async init() {
+        await loadOptionalDeps();
+        // Initialize ONNX embedder if needed
+        if (this.config.capabilities?.onnxEmbeddings) {
+            await (0, onnx_embedder_1.initOnnxEmbedder)();
+        }
+        // Initialize VectorDB if needed
+        if (this.config.capabilities?.vectorDb && VectorDb) {
+            const dbPath = path.join(process.cwd(), '.ruvector', 'workers', `${this.config.name}.db`);
+            fs.mkdirSync(path.dirname(dbPath), { recursive: true });
+            this.vectorDb = new VectorDb({
+                dimensions: 384,
+                storagePath: dbPath,
+            });
+        }
+    }
+    /**
+     * Run all phases in sequence
+     */
+    async run(targetPath = '.') {
+        const startTime = performance.now();
+        const phaseResults = [];
+        await this.init();
+        let context = { targetPath, files: [], patterns: [], embeddings: [] };
+        for (const phaseConfig of this.config.phases) {
+            const phaseStart = performance.now();
+            try {
+                context = await this.executePhase(phaseConfig.type, context, phaseConfig.config);
+                phaseResults.push({
+                    phase: phaseConfig.type,
+                    success: true,
+                    data: this.summarizePhaseData(phaseConfig.type, context),
+                    timeMs: performance.now() - phaseStart,
+                });
+            }
+            catch (error) {
+                phaseResults.push({
+                    phase: phaseConfig.type,
+                    success: false,
+                    data: null,
+                    timeMs: performance.now() - phaseStart,
+                    error: error.message,
+                });
+                // Continue to next phase on error (fault-tolerant)
+            }
+        }
+        const totalTimeMs = performance.now() - startTime;
+        return {
+            worker: this.config.name,
+            success: phaseResults.every(p => p.success),
+            phases: phaseResults,
+            totalTimeMs,
+            summary: {
+                filesAnalyzed: this.stats.filesAnalyzed,
+                patternsFound: this.stats.patternsFound,
+                embeddingsGenerated: this.stats.embeddingsGenerated,
+                vectorsStored: this.stats.vectorsStored,
+                findings: this.findings,
+            },
+        };
+    }
+    /**
+     * Execute a single phase
+     */
+    async executePhase(type, context, config) {
+        switch (type) {
+            case 'file-discovery':
+                return this.phaseFileDiscovery(context, config);
+            case 'pattern-extraction':
+                return this.phasePatternExtraction(context, config);
+            case 'embedding-generation':
+                return this.phaseEmbeddingGeneration(context, config);
+            case 'vector-storage':
+                return this.phaseVectorStorage(context, config);
+            case 'similarity-search':
+                return this.phaseSimilaritySearch(context, config);
+            case 'security-scan':
+                return this.phaseSecurityScan(context, config);
+            case 'complexity-analysis':
+                return this.phaseComplexityAnalysis(context, config);
+            case 'summarization':
+                return this.phaseSummarization(context, config);
+            default:
+                throw new Error(`Unknown phase: ${type}`);
+        }
+    }
+    /**
+     * Phase: File Discovery
+     */
+    async phaseFileDiscovery(context, config) {
+        const patterns = config?.patterns || ['**/*.ts', '**/*.js', '**/*.tsx', '**/*.jsx'];
+        const exclude = config?.exclude || ['**/node_modules/**', '**/dist/**', '**/.git/**'];
+        const files = [];
+        for (const pattern of patterns) {
+            const matches = await (0, glob_1.glob)(pattern, {
+                cwd: context.targetPath,
+                ignore: exclude,
+                nodir: true,
+            });
+            files.push(...matches.map(f => path.join(context.targetPath, f)));
+        }
+        this.stats.filesAnalyzed = files.length;
+        return { ...context, files };
+    }
+    /**
+     * Phase: Pattern Extraction
+     */
+    async phasePatternExtraction(context, config) {
+        const patterns = [];
+        const patternTypes = config?.types || ['function', 'class', 'import', 'export', 'todo'];
+        for (const file of context.files.slice(0, 100)) {
+            try {
+                const content = fs.readFileSync(file, 'utf-8');
+                // Extract functions
+                if (patternTypes.includes('function')) {
+                    const funcMatches = content.match(/(?:async\s+)?function\s+(\w+)|(?:const|let|var)\s+(\w+)\s*=\s*(?:async\s*)?\(/g) || [];
+                    patterns.push(...funcMatches.map(m => ({ type: 'function', match: m, file })));
+                }
+                // Extract classes
+                if (patternTypes.includes('class')) {
+                    const classMatches = content.match(/class\s+(\w+)/g) || [];
+                    patterns.push(...classMatches.map(m => ({ type: 'class', match: m, file })));
+                }
+                // Extract imports
+                if (patternTypes.includes('import')) {
+                    const importMatches = content.match(/import\s+.*?from\s+['"][^'"]+['"]/g) || [];
+                    patterns.push(...importMatches.map(m => ({ type: 'import', match: m, file })));
+                }
+                // Extract TODOs
+                if (patternTypes.includes('todo')) {
+                    const todoMatches = content.match(/\/\/\s*(TODO|FIXME|HACK|XXX):.*/gi) || [];
+                    patterns.push(...todoMatches.map(m => ({ type: 'todo', match: m, file })));
+                    // Add findings for TODOs
+                    todoMatches.forEach(m => {
+                        this.findings.push({
+                            type: 'info',
+                            message: m,
+                            file,
+                        });
+                    });
+                }
+            }
+            catch {
+                // Skip unreadable files
+            }
+        }
+        this.stats.patternsFound = patterns.length;
+        return { ...context, patterns };
+    }
+    /**
+     * Phase: Embedding Generation (ONNX)
+     */
+    async phaseEmbeddingGeneration(context, config) {
+        if (!(0, onnx_embedder_1.isReady)()) {
+            await (0, onnx_embedder_1.initOnnxEmbedder)();
+        }
+        const embeddings = [];
+        const batchSize = config?.batchSize || 32;
+        // Collect texts to embed
+        const texts = [];
+        // Embed file content summaries
+        for (const file of context.files.slice(0, 50)) {
+            try {
+                const content = fs.readFileSync(file, 'utf-8');
+                const summary = content.slice(0, 512); // First 512 chars
+                texts.push({ text: summary, file });
+            }
+            catch {
+                // Skip
+            }
+        }
+        // Embed patterns
+        for (const pattern of context.patterns.slice(0, 100)) {
+            texts.push({ text: pattern.match, file: pattern.file });
+        }
+        // Batch embed
+        for (let i = 0; i < texts.length; i += batchSize) {
+            const batch = texts.slice(i, i + batchSize);
+            const results = await (0, onnx_embedder_1.embedBatch)(batch.map(t => t.text));
+            for (let j = 0; j < results.length; j++) {
+                embeddings.push({
+                    text: batch[j].text,
+                    embedding: results[j].embedding,
+                    file: batch[j].file,
+                });
+            }
+        }
+        this.stats.embeddingsGenerated = embeddings.length;
+        return { ...context, embeddings };
+    }
+    /**
+     * Phase: Vector Storage
+     */
+    async phaseVectorStorage(context, config) {
+        if (!this.vectorDb) {
+            return context;
+        }
+        let stored = 0;
+        for (const item of context.embeddings) {
+            try {
+                await this.vectorDb.insert({
+                    vector: new Float32Array(item.embedding),
+                    metadata: {
+                        text: item.text.slice(0, 200),
+                        file: item.file,
+                        worker: this.config.name,
+                        timestamp: Date.now(),
+                    },
+                });
+                stored++;
+            }
+            catch {
+                // Skip duplicates/errors
+            }
+        }
+        this.stats.vectorsStored = stored;
+        return context;
+    }
+    /**
+     * Phase: Similarity Search
+     */
+    async phaseSimilaritySearch(context, config) {
+        if (!this.vectorDb || context.embeddings.length === 0) {
+            return context;
+        }
+        const query = config?.query || context.embeddings[0]?.text;
+        if (!query)
+            return context;
+        const queryResult = await (0, onnx_embedder_1.embed)(query);
+        const results = await this.vectorDb.search({
+            vector: new Float32Array(queryResult.embedding),
+            k: config?.k || 5,
+        });
+        return { ...context, searchResults: results };
+    }
+    /**
+     * Phase: Security Scan
+     */
+    async phaseSecurityScan(context, config) {
+        const securityPatterns = [
+            { pattern: /password\s*=\s*['"][^'"]+['"]/gi, severity: 'high', type: 'Hardcoded password' },
+            { pattern: /api[_-]?key\s*=\s*['"][^'"]+['"]/gi, severity: 'high', type: 'Hardcoded API key' },
+            { pattern: /secret\s*=\s*['"][^'"]+['"]/gi, severity: 'high', type: 'Hardcoded secret' },
+            { pattern: /eval\s*\(/g, severity: 'medium', type: 'eval() usage' },
+            { pattern: /dangerouslySetInnerHTML/g, severity: 'medium', type: 'XSS risk' },
+            { pattern: /SELECT\s+.*\s+FROM.*\+/gi, severity: 'high', type: 'SQL injection risk' },
+            { pattern: /exec\s*\(/g, severity: 'medium', type: 'Command execution' },
+        ];
+        for (const file of context.files.slice(0, 100)) {
+            try {
+                const content = fs.readFileSync(file, 'utf-8');
+                const lines = content.split('\n');
+                for (const { pattern, severity, type } of securityPatterns) {
+                    let match;
+                    const regex = new RegExp(pattern.source, pattern.flags);
+                    while ((match = regex.exec(content)) !== null) {
+                        const lineNum = content.slice(0, match.index).split('\n').length;
+                        this.findings.push({
+                            type: 'security',
+                            message: `${type}: ${match[0].slice(0, 50)}...`,
+                            file,
+                            line: lineNum,
+                            severity: severity === 'high' ? 3 : 2,
+                        });
+                    }
+                }
+            }
+            catch {
+                // Skip
+            }
+        }
+        return context;
+    }
+    /**
+     * Phase: Complexity Analysis
+     */
+    async phaseComplexityAnalysis(context, config) {
+        const complexityThreshold = config?.threshold || 10;
+        const complexFiles = [];
+        for (const file of context.files.slice(0, 50)) {
+            try {
+                const content = fs.readFileSync(file, 'utf-8');
+                // Simple cyclomatic complexity approximation
+                const branches = (content.match(/\bif\b/g)?.length || 0) +
+                    (content.match(/\belse\b/g)?.length || 0) +
+                    (content.match(/\bfor\b/g)?.length || 0) +
+                    (content.match(/\bwhile\b/g)?.length || 0) +
+                    (content.match(/\bswitch\b/g)?.length || 0) +
+                    (content.match(/\bcase\b/g)?.length || 0) +
+                    (content.match(/\bcatch\b/g)?.length || 0) +
+                    (content.match(/\?\?/g)?.length || 0) +
+                    (content.match(/\?/g)?.length || 0);
+                const complexity = branches + 1;
+                if (complexity > complexityThreshold) {
+                    complexFiles.push({ file, complexity });
+                    this.findings.push({
+                        type: 'warning',
+                        message: `High complexity: ${complexity} (threshold: ${complexityThreshold})`,
+                        file,
+                        severity: complexity > 20 ? 3 : 2,
+                    });
+                }
+            }
+            catch {
+                // Skip
+            }
+        }
+        return { ...context, complexFiles };
+    }
+    /**
+     * Phase: Summarization
+     */
+    async phaseSummarization(context, config) {
+        const summary = {
+            filesAnalyzed: context.files?.length || 0,
+            patternsFound: context.patterns?.length || 0,
+            embeddingsGenerated: context.embeddings?.length || 0,
+            findingsCount: this.findings.length,
+            findingsByType: {
+                info: this.findings.filter(f => f.type === 'info').length,
+                warning: this.findings.filter(f => f.type === 'warning').length,
+                error: this.findings.filter(f => f.type === 'error').length,
+                security: this.findings.filter(f => f.type === 'security').length,
+            },
+            topFindings: this.findings.slice(0, 10),
+        };
+        return { ...context, summary };
+    }
+    /**
+     * Summarize phase data for results
+     */
+    summarizePhaseData(type, context) {
+        switch (type) {
+            case 'file-discovery':
+                return { filesFound: context.files?.length || 0 };
+            case 'pattern-extraction':
+                return { patternsFound: context.patterns?.length || 0 };
+            case 'embedding-generation':
+                return { embeddingsGenerated: context.embeddings?.length || 0 };
+            case 'vector-storage':
+                return { vectorsStored: this.stats.vectorsStored };
+            case 'similarity-search':
+                return { resultsFound: context.searchResults?.length || 0 };
+            case 'security-scan':
+                return { securityFindings: this.findings.filter(f => f.type === 'security').length };
+            case 'complexity-analysis':
+                return { complexFiles: context.complexFiles?.length || 0 };
+            case 'summarization':
+                return context.summary;
+            default:
+                return {};
+        }
+    }
+}
+exports.NativeWorker = NativeWorker;
+/**
+ * Quick worker factory functions
+ */
+function createSecurityWorker(name = 'security-scanner') {
+    return new NativeWorker({
+        name,
+        description: 'Security vulnerability scanner',
+        phases: [
+            { type: 'file-discovery', config: { patterns: ['**/*.ts', '**/*.js', '**/*.tsx', '**/*.jsx'] } },
+            { type: 'security-scan' },
+            { type: 'summarization' },
+        ],
+        capabilities: { onnxEmbeddings: false, vectorDb: false },
+    });
+}
+function createAnalysisWorker(name = 'code-analyzer') {
+    return new NativeWorker({
+        name,
+        description: 'Code analysis with embeddings',
+        phases: [
+            { type: 'file-discovery' },
+            { type: 'pattern-extraction' },
+            { type: 'embedding-generation' },
+            { type: 'vector-storage' },
+            { type: 'complexity-analysis' },
+            { type: 'summarization' },
+        ],
+        capabilities: { onnxEmbeddings: true, vectorDb: true },
+    });
+}
+function createLearningWorker(name = 'pattern-learner') {
+    return new NativeWorker({
+        name,
+        description: 'Pattern learning with vector storage',
+        phases: [
+            { type: 'file-discovery' },
+            { type: 'pattern-extraction' },
+            { type: 'embedding-generation' },
+            { type: 'vector-storage' },
+            { type: 'summarization' },
+        ],
+        capabilities: { onnxEmbeddings: true, vectorDb: true, intelligenceMemory: true },
+    });
+}

package/dist/workers/types.d.ts

@@ -0,0 +1,69 @@
+/**
+ * Native Worker Types for RuVector
+ *
+ * Deep integration with ONNX embeddings, VectorDB, and intelligence engine.
+ */
+export interface WorkerConfig {
+    name: string;
+    description?: string;
+    phases: PhaseConfig[];
+    capabilities?: WorkerCapabilities;
+    timeout?: number;
+    parallel?: boolean;
+}
+export interface PhaseConfig {
+    type: PhaseType;
+    config?: Record<string, any>;
+}
+export type PhaseType = 'file-discovery' | 'pattern-extraction' | 'embedding-generation' | 'vector-storage' | 'similarity-search' | 'security-scan' | 'complexity-analysis' | 'summarization';
+export interface WorkerCapabilities {
+    onnxEmbeddings?: boolean;
+    vectorDb?: boolean;
+    intelligenceMemory?: boolean;
+    parallelProcessing?: boolean;
+}
+export interface PhaseResult {
+    phase: PhaseType;
+    success: boolean;
+    data: any;
+    timeMs: number;
+    error?: string;
+}
+export interface WorkerResult {
+    worker: string;
+    success: boolean;
+    phases: PhaseResult[];
+    totalTimeMs: number;
+    summary?: WorkerSummary;
+}
+export interface WorkerSummary {
+    filesAnalyzed: number;
+    patternsFound: number;
+    embeddingsGenerated: number;
+    vectorsStored: number;
+    findings: Finding[];
+}
+export interface Finding {
+    type: 'info' | 'warning' | 'error' | 'security';
+    message: string;
+    file?: string;
+    line?: number;
+    severity?: number;
+}
+export interface BenchmarkResult {
+    name: string;
+    iterations: number;
+    results: {
+        min: number;
+        max: number;
+        avg: number;
+        p50: number;
+        p95: number;
+        p99: number;
+    };
+    throughput?: {
+        itemsPerSecond: number;
+        mbPerSecond?: number;
+    };
+}
+//# sourceMappingURL=types.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"types.d.ts","sourceRoot":"","sources":["../../src/workers/types.ts"],"names":[],"mappings":"AAAA;;;;GAIG;AAEH,MAAM,WAAW,YAAY;IAC3B,IAAI,EAAE,MAAM,CAAC;IACb,WAAW,CAAC,EAAE,MAAM,CAAC;IACrB,MAAM,EAAE,WAAW,EAAE,CAAC;IACtB,YAAY,CAAC,EAAE,kBAAkB,CAAC;IAClC,OAAO,CAAC,EAAE,MAAM,CAAC;IACjB,QAAQ,CAAC,EAAE,OAAO,CAAC;CACpB;AAED,MAAM,WAAW,WAAW;IAC1B,IAAI,EAAE,SAAS,CAAC;IAChB,MAAM,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,GAAG,CAAC,CAAC;CAC9B;AAED,MAAM,MAAM,SAAS,GACjB,gBAAgB,GAChB,oBAAoB,GACpB,sBAAsB,GACtB,gBAAgB,GAChB,mBAAmB,GACnB,eAAe,GACf,qBAAqB,GACrB,eAAe,CAAC;AAEpB,MAAM,WAAW,kBAAkB;IACjC,cAAc,CAAC,EAAE,OAAO,CAAC;IACzB,QAAQ,CAAC,EAAE,OAAO,CAAC;IACnB,kBAAkB,CAAC,EAAE,OAAO,CAAC;IAC7B,kBAAkB,CAAC,EAAE,OAAO,CAAC;CAC9B;AAED,MAAM,WAAW,WAAW;IAC1B,KAAK,EAAE,SAAS,CAAC;IACjB,OAAO,EAAE,OAAO,CAAC;IACjB,IAAI,EAAE,GAAG,CAAC;IACV,MAAM,EAAE,MAAM,CAAC;IACf,KAAK,CAAC,EAAE,MAAM,CAAC;CAChB;AAED,MAAM,WAAW,YAAY;IAC3B,MAAM,EAAE,MAAM,CAAC;IACf,OAAO,EAAE,OAAO,CAAC;IACjB,MAAM,EAAE,WAAW,EAAE,CAAC;IACtB,WAAW,EAAE,MAAM,CAAC;IACpB,OAAO,CAAC,EAAE,aAAa,CAAC;CACzB;AAED,MAAM,WAAW,aAAa;IAC5B,aAAa,EAAE,MAAM,CAAC;IACtB,aAAa,EAAE,MAAM,CAAC;IACtB,mBAAmB,EAAE,MAAM,CAAC;IAC5B,aAAa,EAAE,MAAM,CAAC;IACtB,QAAQ,EAAE,OAAO,EAAE,CAAC;CACrB;AAED,MAAM,WAAW,OAAO;IACtB,IAAI,EAAE,MAAM,GAAG,SAAS,GAAG,OAAO,GAAG,UAAU,CAAC;IAChD,OAAO,EAAE,MAAM,CAAC;IAChB,IAAI,CAAC,EAAE,MAAM,CAAC;IACd,IAAI,CAAC,EAAE,MAAM,CAAC;IACd,QAAQ,CAAC,EAAE,MAAM,CAAC;CACnB;AAED,MAAM,WAAW,eAAe;IAC9B,IAAI,EAAE,MAAM,CAAC;IACb,UAAU,EAAE,MAAM,CAAC;IACnB,OAAO,EAAE;QACP,GAAG,EAAE,MAAM,CAAC;QACZ,GAAG,EAAE,MAAM,CAAC;QACZ,GAAG,EAAE,MAAM,CAAC;QACZ,GAAG,EAAE,MAAM,CAAC;QACZ,GAAG,EAAE,MAAM,CAAC;QACZ,GAAG,EAAE,MAAM,CAAC;KACb,CAAC;IACF,UAAU,CAAC,EAAE;QACX,cAAc,EAAE,MAAM,CAAC;QACvB,WAAW,CAAC,EAAE,MAAM,CAAC;KACtB,CAAC;CACH"}

package/dist/workers/types.js

@@ -0,0 +1,7 @@
+"use strict";
+/**
+ * Native Worker Types for RuVector
+ *
+ * Deep integration with ONNX embeddings, VectorDB, and intelligence engine.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });

package/package.json

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