ruvector 0.2.21 → 0.2.23

package/dist/workers/native-worker.js

@@ -1,490 +0,0 @@
-"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"));
-let cachedGlob = null;
-// Fallback glob implementation using fs
-function createFallbackGlob() {
-    return async (pattern, options) => {
-        const cwd = options?.cwd || process.cwd();
-        const results = [];
-        const walk = (dir) => {
-            try {
-                const entries = fs.readdirSync(dir, { withFileTypes: true });
-                for (const entry of entries) {
-                    const fullPath = path.join(dir, entry.name);
-                    if (entry.isDirectory() && !entry.name.startsWith('.') && entry.name !== 'node_modules') {
-                        walk(fullPath);
-                    }
-                    else if (entry.isFile()) {
-                        results.push(path.relative(cwd, fullPath));
-                    }
-                }
-            }
-            catch { /* ignore permission errors */ }
-        };
-        walk(cwd);
-        // Simple pattern matching for *.ext patterns
-        const ext = pattern.match(/\*\.(\w+)$/)?.[1];
-        return ext ? results.filter(f => f.endsWith('.' + ext)) : results;
-    };
-}
-async function getGlob() {
-    if (cachedGlob)
-        return cachedGlob;
-    try {
-        // Dynamic import - may fail if glob not installed
-        const mod = await Function('return import("glob")')();
-        if (mod && typeof mod.glob === 'function') {
-            cachedGlob = mod.glob;
-            return cachedGlob;
-        }
-    }
-    catch { /* glob not available */ }
-    // Fallback to simple implementation
-    cachedGlob = createFallbackGlob();
-    return cachedGlob;
-}
-const onnx_embedder_1 = require("../core/onnx-embedder");
-const security_1 = require("../analysis/security");
-const complexity_1 = require("../analysis/complexity");
-const patterns_1 = require("../analysis/patterns");
-// 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 = [];
-        const glob = await getGlob();
-        for (const pattern of patterns) {
-            const matches = await 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 (uses shared analysis module)
-     */
-    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 filePatterns = (0, patterns_1.extractAllPatterns)(file);
-                const matches = (0, patterns_1.toPatternMatches)(filePatterns);
-                // Filter by requested pattern types
-                for (const match of matches) {
-                    if (patternTypes.includes(match.type)) {
-                        patterns.push(match);
-                        // Add findings for TODOs
-                        if (match.type === 'todo') {
-                            this.findings.push({
-                                type: 'info',
-                                message: match.match,
-                                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 (uses shared analysis module)
-     */
-    async phaseSecurityScan(context, config) {
-        // Use consolidated security scanner
-        const findings = (0, security_1.scanFiles)(context.files, undefined, 100);
-        // Convert to worker findings format
-        for (const finding of findings) {
-            this.findings.push({
-                type: 'security',
-                message: `${finding.rule}: ${finding.message}`,
-                file: finding.file,
-                line: finding.line,
-                severity: finding.severity === 'critical' ? 4 :
-                    finding.severity === 'high' ? 3 :
-                        finding.severity === 'medium' ? 2 : 1,
-            });
-        }
-        return context;
-    }
-    /**
-     * Phase: Complexity Analysis (uses shared analysis module)
-     */
-    async phaseComplexityAnalysis(context, config) {
-        const complexityThreshold = config?.threshold || 10;
-        const complexFiles = [];
-        for (const file of context.files.slice(0, 50)) {
-            // Use consolidated complexity analyzer
-            const result = (0, complexity_1.analyzeFile)(file);
-            if (result.cyclomaticComplexity > complexityThreshold) {
-                complexFiles.push(result);
-                const rating = (0, complexity_1.getComplexityRating)(result.cyclomaticComplexity);
-                this.findings.push({
-                    type: 'warning',
-                    message: `High complexity: ${result.cyclomaticComplexity} (threshold: ${complexityThreshold})`,
-                    file,
-                    severity: rating === 'critical' ? 4 : rating === 'high' ? 3 : 2,
-                });
-            }
-        }
-        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

@@ -1,69 +0,0 @@
-/**
- * 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

@@ -1 +0,0 @@
-{"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

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