ruvector 0.2.15 → 0.2.17

package/dist/core/core/parallel-intelligence.js

@@ -1,340 +0,0 @@
-"use strict";
-/**
- * Parallel Intelligence - Worker-based acceleration for IntelligenceEngine
- *
- * Provides parallel processing for:
- * - Q-learning batch updates (3-4x faster)
- * - Multi-file pattern matching
- * - Background memory indexing
- * - Parallel similarity search
- * - Multi-file code analysis
- * - Parallel git commit analysis
- *
- * Uses worker_threads for CPU-bound operations, keeping hooks non-blocking.
- */
-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.ParallelIntelligence = void 0;
-exports.getParallelIntelligence = getParallelIntelligence;
-exports.initParallelIntelligence = initParallelIntelligence;
-const worker_threads_1 = require("worker_threads");
-const os = __importStar(require("os"));
-// ============================================================================
-// Worker Pool Manager
-// ============================================================================
-class ParallelIntelligence {
-    constructor(config = {}) {
-        this.workers = [];
-        this.taskQueue = [];
-        this.busyWorkers = new Set();
-        this.initialized = false;
-        const isCLI = process.env.RUVECTOR_CLI === '1';
-        const isMCP = process.env.MCP_SERVER === '1';
-        this.config = {
-            numWorkers: config.numWorkers ?? Math.max(1, os.cpus().length - 1),
-            enabled: config.enabled ?? (isMCP || (!isCLI && process.env.RUVECTOR_PARALLEL === '1')),
-            batchThreshold: config.batchThreshold ?? 4,
-        };
-    }
-    /**
-     * Initialize worker pool
-     */
-    async init() {
-        if (this.initialized || !this.config.enabled)
-            return;
-        for (let i = 0; i < this.config.numWorkers; i++) {
-            const worker = new worker_threads_1.Worker(__filename, {
-                workerData: { workerId: i },
-            });
-            worker.on('message', (result) => {
-                this.busyWorkers.delete(worker);
-                this.processQueue();
-            });
-            worker.on('error', (err) => {
-                console.error(`Worker ${i} error:`, err);
-                this.busyWorkers.delete(worker);
-            });
-            this.workers.push(worker);
-        }
-        this.initialized = true;
-        console.error(`ParallelIntelligence: ${this.config.numWorkers} workers ready`);
-    }
-    processQueue() {
-        while (this.taskQueue.length > 0 && this.busyWorkers.size < this.workers.length) {
-            const availableWorker = this.workers.find(w => !this.busyWorkers.has(w));
-            if (!availableWorker)
-                break;
-            const task = this.taskQueue.shift();
-            this.busyWorkers.add(availableWorker);
-            availableWorker.postMessage(task.task);
-        }
-    }
-    /**
-     * Execute task in worker pool
-     */
-    async executeInWorker(task) {
-        if (!this.initialized || !this.config.enabled) {
-            throw new Error('ParallelIntelligence not initialized');
-        }
-        return new Promise((resolve, reject) => {
-            const availableWorker = this.workers.find(w => !this.busyWorkers.has(w));
-            if (availableWorker) {
-                this.busyWorkers.add(availableWorker);
-                const handler = (result) => {
-                    this.busyWorkers.delete(availableWorker);
-                    availableWorker.off('message', handler);
-                    if (result.error) {
-                        reject(new Error(result.error));
-                    }
-                    else {
-                        resolve(result.data);
-                    }
-                };
-                availableWorker.on('message', handler);
-                availableWorker.postMessage(task);
-            }
-            else {
-                this.taskQueue.push({ task, resolve, reject });
-            }
-        });
-    }
-    // =========================================================================
-    // Parallel Operations
-    // =========================================================================
-    /**
-     * Batch Q-learning episode recording (3-4x faster)
-     */
-    async recordEpisodesBatch(episodes) {
-        if (episodes.length < this.config.batchThreshold || !this.config.enabled) {
-            // Fall back to sequential
-            return;
-        }
-        // Split into chunks for workers
-        const chunkSize = Math.ceil(episodes.length / this.config.numWorkers);
-        const chunks = [];
-        for (let i = 0; i < episodes.length; i += chunkSize) {
-            chunks.push(episodes.slice(i, i + chunkSize));
-        }
-        await Promise.all(chunks.map(chunk => this.executeInWorker({ type: 'recordEpisodes', episodes: chunk })));
-    }
-    /**
-     * Multi-file pattern matching (parallel pretrain)
-     */
-    async matchPatternsParallel(files) {
-        if (files.length < this.config.batchThreshold || !this.config.enabled) {
-            return [];
-        }
-        const chunkSize = Math.ceil(files.length / this.config.numWorkers);
-        const chunks = [];
-        for (let i = 0; i < files.length; i += chunkSize) {
-            chunks.push(files.slice(i, i + chunkSize));
-        }
-        const results = await Promise.all(chunks.map(chunk => this.executeInWorker({ type: 'matchPatterns', files: chunk })));
-        return results.flat();
-    }
-    /**
-     * Background memory indexing (non-blocking)
-     */
-    async indexMemoriesBackground(memories) {
-        if (memories.length === 0 || !this.config.enabled)
-            return;
-        // Fire and forget - non-blocking
-        this.executeInWorker({ type: 'indexMemories', memories }).catch(() => { });
-    }
-    /**
-     * Parallel similarity search with sharding
-     */
-    async searchParallel(query, topK = 5) {
-        if (!this.config.enabled)
-            return [];
-        // Each worker searches its shard
-        const shardResults = await Promise.all(this.workers.map((_, i) => this.executeInWorker({
-            type: 'search',
-            query,
-            topK,
-            shardId: i,
-        })));
-        // Merge and sort results
-        return shardResults
-            .flat()
-            .sort((a, b) => b.score - a.score)
-            .slice(0, topK);
-    }
-    /**
-     * Multi-file AST analysis for routing
-     */
-    async analyzeFilesParallel(files) {
-        if (files.length < this.config.batchThreshold || !this.config.enabled) {
-            return new Map();
-        }
-        const chunkSize = Math.ceil(files.length / this.config.numWorkers);
-        const chunks = [];
-        for (let i = 0; i < files.length; i += chunkSize) {
-            chunks.push(files.slice(i, i + chunkSize));
-        }
-        const results = await Promise.all(chunks.map(chunk => this.executeInWorker({
-            type: 'analyzeFiles',
-            files: chunk,
-        })));
-        return new Map(results.flat());
-    }
-    /**
-     * Parallel git commit analysis for co-edit detection
-     */
-    async analyzeCommitsParallel(commits) {
-        if (commits.length < this.config.batchThreshold || !this.config.enabled) {
-            return [];
-        }
-        const chunkSize = Math.ceil(commits.length / this.config.numWorkers);
-        const chunks = [];
-        for (let i = 0; i < commits.length; i += chunkSize) {
-            chunks.push(commits.slice(i, i + chunkSize));
-        }
-        const results = await Promise.all(chunks.map(chunk => this.executeInWorker({ type: 'analyzeCommits', commits: chunk })));
-        return results.flat();
-    }
-    /**
-     * Get worker pool stats
-     */
-    getStats() {
-        return {
-            enabled: this.config.enabled,
-            workers: this.workers.length,
-            busy: this.busyWorkers.size,
-            queued: this.taskQueue.length,
-        };
-    }
-    /**
-     * Shutdown worker pool
-     */
-    async shutdown() {
-        await Promise.all(this.workers.map(w => w.terminate()));
-        this.workers = [];
-        this.busyWorkers.clear();
-        this.taskQueue = [];
-        this.initialized = false;
-    }
-}
-exports.ParallelIntelligence = ParallelIntelligence;
-// ============================================================================
-// Worker Thread Code
-// ============================================================================
-if (!worker_threads_1.isMainThread && worker_threads_1.parentPort) {
-    // This code runs in worker threads
-    const { workerId } = worker_threads_1.workerData;
-    worker_threads_1.parentPort.on('message', async (task) => {
-        try {
-            let result;
-            switch (task.type) {
-                case 'recordEpisodes':
-                    // Process episode batch
-                    result = await processEpisodes(task.episodes);
-                    break;
-                case 'matchPatterns':
-                    // Match patterns in files
-                    result = await matchPatterns(task.files);
-                    break;
-                case 'indexMemories':
-                    // Index memories
-                    result = await indexMemories(task.memories);
-                    break;
-                case 'search':
-                    // Search shard
-                    result = await searchShard(task.query, task.topK, task.shardId);
-                    break;
-                case 'analyzeFiles':
-                    // Analyze file ASTs
-                    result = await analyzeFiles(task.files);
-                    break;
-                case 'analyzeCommits':
-                    // Analyze git commits
-                    result = await analyzeCommits(task.commits);
-                    break;
-                default:
-                    throw new Error(`Unknown task type: ${task.type}`);
-            }
-            worker_threads_1.parentPort.postMessage({ data: result });
-        }
-        catch (error) {
-            worker_threads_1.parentPort.postMessage({ error: error.message });
-        }
-    });
-    // Worker task implementations
-    async function processEpisodes(episodes) {
-        // Embed and process episodes
-        // In a real implementation, this would use the embedder and update Q-values
-        return episodes.length;
-    }
-    async function matchPatterns(files) {
-        // Match patterns in files
-        // Would read files and extract patterns
-        return files.map(file => ({
-            file,
-            patterns: [],
-        }));
-    }
-    async function indexMemories(memories) {
-        // Index memories in background
-        return memories.length;
-    }
-    async function searchShard(query, topK, shardId) {
-        // Search this worker's shard
-        return [];
-    }
-    async function analyzeFiles(files) {
-        // Analyze file ASTs
-        return files.map(f => [f, { agent: 'coder', confidence: 0.5 }]);
-    }
-    async function analyzeCommits(commits) {
-        // Analyze git commits for co-edit patterns
-        return [];
-    }
-}
-// ============================================================================
-// Singleton for easy access
-// ============================================================================
-let instance = null;
-function getParallelIntelligence(config) {
-    if (!instance) {
-        instance = new ParallelIntelligence(config);
-    }
-    return instance;
-}
-async function initParallelIntelligence(config) {
-    const pi = getParallelIntelligence(config);
-    await pi.init();
-    return pi;
-}
-exports.default = ParallelIntelligence;

package/dist/core/core/sona-wrapper.d.ts

@@ -1,214 +0,0 @@
-/**
- * SONA Wrapper - Self-Optimizing Neural Architecture
- *
- * Provides a safe, flexible interface to @ruvector/sona with:
- * - Automatic array type conversion (Array <-> Float64Array)
- * - Graceful handling when sona is not installed
- * - TypeScript types for all APIs
- *
- * SONA Features:
- * - Micro-LoRA: Ultra-fast rank-1/2 adaptations (~0.1ms)
- * - Base-LoRA: Deeper adaptations for complex patterns
- * - EWC++: Elastic Weight Consolidation to prevent catastrophic forgetting
- * - ReasoningBank: Pattern storage and retrieval
- * - Trajectory tracking: Record and learn from execution paths
- */
-/** Array input type - accepts both regular arrays and typed arrays */
-export type ArrayInput = number[] | Float32Array | Float64Array;
-/** SONA configuration options */
-export interface SonaConfig {
-    /** Hidden dimension size (required) */
-    hiddenDim: number;
-    /** Embedding dimension (defaults to hiddenDim) */
-    embeddingDim?: number;
-    /** Micro-LoRA rank (1-2, default: 1) */
-    microLoraRank?: number;
-    /** Base LoRA rank (default: 8) */
-    baseLoraRank?: number;
-    /** Micro-LoRA learning rate (default: 0.001) */
-    microLoraLr?: number;
-    /** Base LoRA learning rate (default: 0.0001) */
-    baseLoraLr?: number;
-    /** EWC lambda regularization (default: 1000.0) */
-    ewcLambda?: number;
-    /** Number of pattern clusters (default: 50) */
-    patternClusters?: number;
-    /** Trajectory buffer capacity (default: 10000) */
-    trajectoryCapacity?: number;
-    /** Background learning interval in ms (default: 3600000 = 1 hour) */
-    backgroundIntervalMs?: number;
-    /** Quality threshold for learning (default: 0.5) */
-    qualityThreshold?: number;
-    /** Enable SIMD optimizations (default: true) */
-    enableSimd?: boolean;
-}
-/** Learned pattern from ReasoningBank */
-export interface LearnedPattern {
-    /** Pattern identifier */
-    id: string;
-    /** Cluster centroid embedding */
-    centroid: number[];
-    /** Number of trajectories in cluster */
-    clusterSize: number;
-    /** Total weight of trajectories */
-    totalWeight: number;
-    /** Average quality of member trajectories */
-    avgQuality: number;
-    /** Creation timestamp */
-    createdAt: string;
-    /** Last access timestamp */
-    lastAccessed: string;
-    /** Total access count */
-    accessCount: number;
-    /** Pattern type */
-    patternType: string;
-}
-/** SONA engine statistics */
-export interface SonaStats {
-    trajectoriesRecorded: number;
-    patternsLearned: number;
-    microLoraUpdates: number;
-    baseLoraUpdates: number;
-    ewcConsolidations: number;
-    avgLearningTimeMs: number;
-}
-/** Check if sona is available */
-export declare function isSonaAvailable(): boolean;
-/**
- * SONA Engine - Self-Optimizing Neural Architecture
- *
- * Provides runtime-adaptive learning with:
- * - Micro-LoRA for instant adaptations
- * - Base-LoRA for deeper learning
- * - EWC++ for preventing forgetting
- * - ReasoningBank for pattern storage
- *
- * @example
- * ```typescript
- * import { Sona } from 'ruvector';
- *
- * // Create engine with hidden dimension
- * const engine = new Sona.Engine(256);
- *
- * // Or with custom config
- * const engine = Sona.Engine.withConfig({
- *   hiddenDim: 256,
- *   microLoraRank: 2,
- *   patternClusters: 100
- * });
- *
- * // Record a trajectory
- * const trajId = engine.beginTrajectory([0.1, 0.2, ...]);
- * engine.addStep(trajId, activations, attentionWeights, 0.8);
- * engine.endTrajectory(trajId, 0.9);
- *
- * // Apply learned adaptations
- * const adapted = engine.applyMicroLora(input);
- * ```
- */
-export declare class SonaEngine {
-    private _native;
-    /**
-     * Create a new SONA engine
-     * @param hiddenDim Hidden dimension size (e.g., 256, 512, 768)
-     */
-    constructor(hiddenDim: number);
-    /**
-     * Create engine with custom configuration
-     * @param config SONA configuration options
-     */
-    static withConfig(config: SonaConfig): SonaEngine;
-    /**
-     * Begin recording a new trajectory
-     * @param queryEmbedding Initial query embedding
-     * @returns Trajectory ID for subsequent operations
-     */
-    beginTrajectory(queryEmbedding: ArrayInput): number;
-    /**
-     * Add a step to an active trajectory
-     * @param trajectoryId Trajectory ID from beginTrajectory
-     * @param activations Layer activations
-     * @param attentionWeights Attention weights
-     * @param reward Reward signal for this step (0.0 - 1.0)
-     */
-    addStep(trajectoryId: number, activations: ArrayInput, attentionWeights: ArrayInput, reward: number): void;
-    /**
-     * Alias for addStep for API compatibility
-     */
-    addTrajectoryStep(trajectoryId: number, activations: ArrayInput, attentionWeights: ArrayInput, reward: number): void;
-    /**
-     * Set the model route for a trajectory
-     * @param trajectoryId Trajectory ID
-     * @param route Model route identifier (e.g., "gpt-4", "claude-3")
-     */
-    setRoute(trajectoryId: number, route: string): void;
-    /**
-     * Add context to a trajectory
-     * @param trajectoryId Trajectory ID
-     * @param contextId Context identifier
-     */
-    addContext(trajectoryId: number, contextId: string): void;
-    /**
-     * Complete a trajectory and submit for learning
-     * @param trajectoryId Trajectory ID
-     * @param quality Final quality score (0.0 - 1.0)
-     */
-    endTrajectory(trajectoryId: number, quality: number): void;
-    /**
-     * Apply micro-LoRA transformation (ultra-fast, ~0.1ms)
-     * @param input Input vector
-     * @returns Transformed output vector
-     */
-    applyMicroLora(input: ArrayInput): number[];
-    /**
-     * Apply base-LoRA transformation to a specific layer
-     * @param layerIdx Layer index
-     * @param input Input vector
-     * @returns Transformed output vector
-     */
-    applyBaseLora(layerIdx: number, input: ArrayInput): number[];
-    /**
-     * Run background learning cycle if due
-     * Call this periodically (e.g., every few seconds)
-     * @returns Status message if learning occurred, null otherwise
-     */
-    tick(): string | null;
-    /**
-     * Force immediate background learning cycle
-     * @returns Status message with learning results
-     */
-    forceLearn(): string;
-    /**
-     * Flush pending instant loop updates
-     */
-    flush(): void;
-    /**
-     * Find similar learned patterns to a query
-     * @param queryEmbedding Query embedding
-     * @param k Number of patterns to return
-     * @returns Array of similar patterns
-     */
-    findPatterns(queryEmbedding: ArrayInput, k: number): LearnedPattern[];
-    /**
-     * Get engine statistics
-     * @returns Statistics object
-     */
-    getStats(): SonaStats;
-    /**
-     * Enable or disable the engine
-     * @param enabled Whether to enable
-     */
-    setEnabled(enabled: boolean): void;
-    /**
-     * Check if engine is enabled
-     */
-    isEnabled(): boolean;
-}
-/**
- * SONA namespace with all exports
- */
-export declare const Sona: {
-    Engine: typeof SonaEngine;
-    isAvailable: typeof isSonaAvailable;
-};
-export default Sona;