ruvector 0.1.78 → 0.1.80

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.80",
   "description": "High-performance vector database for Node.js with automatic native/WASM fallback",
   "main": "dist/index.js",
   "types": "dist/index.d.ts",