ruvector 0.1.77 → 0.1.79

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"}