monomind 2.7.12 → 2.7.13

package/packages/@monomind/cli/dist/src/memory/embedding-operations.d.ts

@@ -1,58 +0,0 @@
-/**
- * Embedding Operations
- * ONNX model loading, embedding generation, and hash-based fallback.
- * Extracted from memory-initializer.ts (ARCH-4)
- *
- * @module v1/cli/embedding-operations
- */
-/**
- * Lazy load ONNX embedding model
- * Only loads when first embedding is requested
- */
-export declare function loadEmbeddingModel(options?: {
-    modelPath?: string;
-    verbose?: boolean;
-}): Promise<{
-    success: boolean;
-    dimensions: number;
-    modelName: string;
-    loadTime?: number;
-    error?: string;
-}>;
-/**
- * Generate real embedding for text
- * Uses ONNX model if available, falls back to deterministic hash
- */
-export declare function generateEmbedding(text: string): Promise<{
-    embedding: number[];
-    dimensions: number;
-    model: string;
-}>;
-/**
- * Generate embeddings for multiple texts
- * Uses parallel execution for API-based providers (2-4x faster)
- * Note: Local ONNX inference is CPU-bound, so parallelism has limited benefit
- *
- * @param texts - Array of texts to embed
- * @param options - Batch options
- * @returns Array of embedding results with timing info
- */
-export declare function generateBatchEmbeddings(texts: string[], options?: {
-    concurrency?: number;
-    onProgress?: (completed: number, total: number) => void;
-}): Promise<{
-    results: Array<{
-        text: string;
-        embedding: number[];
-        dimensions: number;
-        model: string;
-    }>;
-    totalTime: number;
-    avgTime: number;
-}>;
-/**
- * Generate deterministic hash-based embedding
- * Not semantic, but deterministic and useful for testing
- */
-export declare function generateHashEmbedding(text: string, dimensions: number): number[];
-//# sourceMappingURL=embedding-operations.d.ts.map

package/packages/@monomind/cli/dist/src/memory/embedding-operations.js

@@ -1,262 +0,0 @@
-/**
- * Embedding Operations
- * ONNX model loading, embedding generation, and hash-based fallback.
- * Extracted from memory-initializer.ts (ARCH-4)
- *
- * @module v1/cli/embedding-operations
- */
-// ADR-053: Lazy import of memory bridge
-let _bridge;
-async function getBridge() {
-    if (_bridge === null)
-        return null;
-    if (_bridge)
-        return _bridge;
-    try {
-        _bridge = await import('./memory-bridge.js');
-        return _bridge;
-    }
-    catch {
-        _bridge = null;
-        return null;
-    }
-}
-let embeddingModelState = null;
-/**
- * Lazy load ONNX embedding model
- * Only loads when first embedding is requested
- */
-export async function loadEmbeddingModel(options) {
-    const { verbose = false } = options || {};
-    const startTime = Date.now();
-    // Already loaded
-    if (embeddingModelState?.loaded) {
-        return {
-            success: true,
-            dimensions: embeddingModelState.dimensions,
-            modelName: 'cached',
-            loadTime: 0
-        };
-    }
-    // ADR-053: Try SQLite-backed memory bridge first
-    const bridge = await getBridge();
-    if (bridge) {
-        const bridgeResult = await bridge.bridgeLoadEmbeddingModel();
-        if (bridgeResult && bridgeResult.success) {
-            // Mark local state as loaded too so subsequent calls use cache
-            embeddingModelState = {
-                loaded: true,
-                model: null, // Bridge handles embedding
-                tokenizer: null,
-                dimensions: bridgeResult.dimensions
-            };
-            return bridgeResult;
-        }
-    }
-    try {
-        // Try to import @xenova/transformers for ONNX embeddings
-        const transformers = await import('@xenova/transformers').catch(() => null);
-        if (transformers) {
-            if (verbose) {
-                console.log('Loading ONNX embedding model (all-MiniLM-L6-v2)...');
-            }
-            // Use small, fast model for local embeddings
-            const { pipeline } = transformers;
-            const embedder = await pipeline('feature-extraction', 'Xenova/all-MiniLM-L6-v2');
-            embeddingModelState = {
-                loaded: true,
-                model: embedder,
-                tokenizer: null,
-                dimensions: 384 // MiniLM-L6 produces 384-dim vectors
-            };
-            return {
-                success: true,
-                dimensions: 384,
-                modelName: 'Xenova/all-MiniLM-L6-v2',
-                loadTime: Date.now() - startTime
-            };
-        }
-        // Fallback: Check for monovector ONNX embedder (bundled MiniLM-L6-v2 since v0.2.15)
-        // v0.2.16: LoRA B=0 fix makes AdaptiveEmbedder safe (identity when untrained)
-        // Note: isReady() returns false until first embed() call (lazy init), so we
-        // skip the isReady() gate and verify with a probe embed instead.
-        const monovector = await import('monovector').catch(() => null);
-        if (monovector?.initOnnxEmbedder) {
-            try {
-                await monovector.initOnnxEmbedder();
-                // Fallback: OptimizedOnnxEmbedder (raw ONNX, lazy-inits on first embed)
-                const onnxEmb = monovector.getOptimizedOnnxEmbedder?.();
-                if (onnxEmb?.embed) {
-                    // Probe embed to trigger lazy ONNX init and verify it works
-                    const probe = await onnxEmb.embed('test');
-                    const probeArr = ArrayBuffer.isView(probe) ? Array.from(probe) : (Array.isArray(probe) ? probe : []);
-                    if (probe && probe.length > 0 && probeArr.some((v) => v !== 0)) {
-                        if (verbose) {
-                            console.log(`Loading monovector ONNX embedder (all-MiniLM-L6-v2, ${probe.length}d)...`);
-                        }
-                        embeddingModelState = {
-                            loaded: true,
-                            model: (text) => onnxEmb.embed(text),
-                            tokenizer: null,
-                            dimensions: probe.length || 384
-                        };
-                        return {
-                            success: true,
-                            dimensions: probe.length || 384,
-                            modelName: 'monovector/onnx',
-                            loadTime: Date.now() - startTime
-                        };
-                    }
-                }
-            }
-            catch {
-                // monovector ONNX init failed, continue to next fallback
-            }
-        }
-        // No ONNX model available - use fallback
-        embeddingModelState = {
-            loaded: true,
-            model: null, // Will use simple hash-based fallback
-            tokenizer: null,
-            dimensions: 128 // Smaller fallback dimensions
-        };
-        return {
-            success: true,
-            dimensions: 128,
-            modelName: 'hash-fallback',
-            loadTime: Date.now() - startTime
-        };
-    }
-    catch (error) {
-        return {
-            success: false,
-            dimensions: 0,
-            modelName: 'none',
-            error: error instanceof Error ? error.message : String(error)
-        };
-    }
-}
-/**
- * Generate real embedding for text
- * Uses ONNX model if available, falls back to deterministic hash
- */
-export async function generateEmbedding(text) {
-    // Cap input text — caller may pass arbitrarily large content. Without this
-    // cap, the hash-fallback below burns O(text.length × dimension) sin() calls
-    // per call, and ONNX tokenization can saturate memory on multi-MB inputs.
-    if (typeof text !== 'string')
-        text = String(text ?? '');
-    if (text.length > 16 * 1024)
-        text = text.slice(0, 16 * 1024);
-    // ADR-053: Try SQLite-backed memory bridge first
-    const bridge = await getBridge();
-    if (bridge) {
-        const bridgeResult = await bridge.bridgeGenerateEmbedding(text);
-        if (bridgeResult)
-            return bridgeResult;
-    }
-    // Ensure model is loaded
-    if (!embeddingModelState?.loaded) {
-        await loadEmbeddingModel();
-    }
-    const state = embeddingModelState;
-    // Use ONNX model if available
-    if (state.model && typeof state.model === 'function') {
-        try {
-            const output = await state.model(text, { pooling: 'mean', normalize: true });
-            // Handle both @xenova/transformers (output.data) and monovector (plain array) formats
-            const embedding = output?.data
-                ? Array.from(output.data)
-                : Array.isArray(output) ? output : null;
-            if (embedding) {
-                return {
-                    embedding,
-                    dimensions: embedding.length,
-                    model: 'onnx'
-                };
-            }
-        }
-        catch {
-            // Fall through to fallback
-        }
-    }
-    // Deterministic hash-based fallback (for testing/demo without ONNX)
-    const embedding = generateHashEmbedding(text, state.dimensions);
-    return {
-        embedding,
-        dimensions: state.dimensions,
-        model: 'hash-fallback'
-    };
-}
-/**
- * Generate embeddings for multiple texts
- * Uses parallel execution for API-based providers (2-4x faster)
- * Note: Local ONNX inference is CPU-bound, so parallelism has limited benefit
- *
- * @param texts - Array of texts to embed
- * @param options - Batch options
- * @returns Array of embedding results with timing info
- */
-export async function generateBatchEmbeddings(texts, options) {
-    const { concurrency = texts.length, onProgress } = options || {};
-    const startTime = Date.now();
-    // Ensure model is loaded first (prevents cold start in parallel)
-    if (!embeddingModelState?.loaded) {
-        await loadEmbeddingModel();
-    }
-    // Process in parallel with optional concurrency limit
-    if (concurrency >= texts.length) {
-        // Full parallelism
-        const embeddings = await Promise.all(texts.map(async (text, i) => {
-            const result = await generateEmbedding(text);
-            onProgress?.(i + 1, texts.length);
-            return { text, ...result };
-        }));
-        const totalTime = Date.now() - startTime;
-        return {
-            results: embeddings,
-            totalTime,
-            avgTime: totalTime / texts.length
-        };
-    }
-    // Limited concurrency using chunking
-    const results = [];
-    let completed = 0;
-    for (let i = 0; i < texts.length; i += concurrency) {
-        const chunk = texts.slice(i, i + concurrency);
-        const chunkResults = await Promise.all(chunk.map(async (text) => {
-            const result = await generateEmbedding(text);
-            completed++;
-            onProgress?.(completed, texts.length);
-            return { text, ...result };
-        }));
-        results.push(...chunkResults);
-    }
-    const totalTime = Date.now() - startTime;
-    return {
-        results,
-        totalTime,
-        avgTime: totalTime / texts.length
-    };
-}
-/**
- * Generate deterministic hash-based embedding
- * Not semantic, but deterministic and useful for testing
- */
-export function generateHashEmbedding(text, dimensions) {
-    const embedding = new Array(dimensions).fill(0);
-    // Simple hash-based approach for reproducibility
-    const words = text.toLowerCase().split(/\s+/);
-    for (let i = 0; i < words.length; i++) {
-        const word = words[i];
-        for (let j = 0; j < word.length; j++) {
-            const charCode = word.charCodeAt(j);
-            const idx = (charCode * (i + 1) * (j + 1)) % dimensions;
-            embedding[idx] += Math.sin(charCode * 0.1) * 0.1;
-        }
-    }
-    // Normalize to unit vector
-    const magnitude = Math.sqrt(embedding.reduce((sum, v) => sum + v * v, 0)) || 1;
-    return embedding.map(v => v / magnitude);
-}
-//# sourceMappingURL=embedding-operations.js.map

package/packages/@monomind/cli/dist/src/memory/ewc-consolidation.d.ts

@@ -1,319 +0,0 @@
-/**
- * EWC-inspired pattern consolidation.
- *
- * Protects high-importance stored patterns from being overwritten by newer,
- * similar ones — the pattern-store analogue of avoiding catastrophic
- * forgetting.
- *
- * HONEST SCOPE — read before extending this:
- * This is *not* Elastic Weight Consolidation. Real EWC penalises drift in a
- * model's parameters using Fisher information estimated from training
- * gradients:
- *
- *   L_total = L_new + (lambda/2) * sum_i(F_i * (theta_i - theta_old_i)^2)
- *
- * There is no model here, no training loop, and therefore no gradients. What
- * this file actually computes is a per-dimension importance weight from the
- * *squared embedding values* of stored patterns, used as a stand-in for the
- * Fisher diagonal (see computeFisherMatrix — the substitution is noted at the
- * line that performs it), smoothed with an EMA and applied as a quadratic
- * penalty when a new pattern would displace an existing one.
- *
- * That heuristic is real, deterministic, and useful. The EWC name and the
- * formula above describe the *inspiration*, not the implementation — do not
- * cite this as an EWC implementation or reason about it as if `F_i` carried
- * Fisher semantics.
- *
- * What it does:
- * - Per-dimension importance from squared embedding magnitudes (gradient proxy)
- * - Online EMA updates as new patterns stream in
- * - Selective consolidation based on that importance
- * - Persistent storage in .swarm/ewc-fisher.json
- *
- * @module v1/cli/memory/ewc-consolidation
- */
-/**
- * Pattern weight vector for EWC consolidation
- */
-export interface PatternWeights {
-    /** Unique pattern identifier */
-    id: string;
-    /** Weight vector (embedding or learned parameters) */
-    weights: number[];
-    /** Fisher information values per weight */
-    fisherDiagonal: number[];
-    /** Importance score (0-1) */
-    importance: number;
-    /** Number of successful uses */
-    successCount: number;
-    /** Number of failed uses */
-    failureCount: number;
-    /** Timestamp of last update */
-    lastUpdated: number;
-    /** Pattern type for categorization */
-    type: string;
-    /** Pattern description */
-    description?: string;
-}
-/**
- * Fisher Information Matrix entry (diagonal approximation)
- */
-export interface FisherEntry {
-    /** Parameter index */
-    index: number;
-    /** Fisher information value (importance) */
-    value: number;
-    /** Number of samples used to compute this value */
-    sampleCount: number;
-    /** Exponential moving average decay rate */
-    decayRate: number;
-}
-/**
- * EWC consolidation configuration
- */
-export interface EWCConfig {
-    /** Regularization strength (lambda) */
-    lambda: number;
-    /** Number of patterns to keep for Fisher computation */
-    maxPatterns: number;
-    /** Decay rate for online Fisher updates */
-    fisherDecayRate: number;
-    /** Minimum importance threshold for consolidation */
-    importanceThreshold: number;
-    /** Path to persist Fisher matrix */
-    storagePath: string;
-    /** Enable online updates (EWC++) */
-    onlineMode: boolean;
-    /** Dimensions of weight vectors */
-    dimensions: number;
-}
-/**
- * Consolidation result
- */
-export interface ConsolidationResult {
-    /** Whether consolidation was successful */
-    success: boolean;
-    /** Number of patterns consolidated */
-    patternsConsolidated: number;
-    /** Total penalty applied */
-    totalPenalty: number;
-    /** Patterns that were modified */
-    modifiedPatterns: string[];
-    /** Patterns that were protected (high Fisher) */
-    protectedPatterns: string[];
-    /** Time taken in milliseconds */
-    duration: number;
-    /** Error message if failed */
-    error?: string;
-}
-/**
- * Statistics about EWC consolidation state
- */
-export interface EWCStats {
-    /** Total patterns tracked */
-    totalPatterns: number;
-    /** Patterns with high importance (above threshold) */
-    highImportancePatterns: number;
-    /** Average Fisher information across all parameters */
-    avgFisherValue: number;
-    /** Maximum Fisher information value */
-    maxFisherValue: number;
-    /** Total successful consolidations */
-    consolidationCount: number;
-    /** Last consolidation timestamp */
-    lastConsolidation: number | null;
-    /** Average penalty per consolidation */
-    avgPenalty: number;
-    /** Storage size in bytes */
-    storageSizeBytes: number;
-}
-/**
- * EWC++ Consolidator
- * Implements Elastic Weight Consolidation with online updates
- * for preventing catastrophic forgetting in continual learning
- */
-export declare class EWCConsolidator {
-    private config;
-    private patterns;
-    private gradientHistory;
-    private globalFisher;
-    private consolidationHistory;
-    private initialized;
-    /** Dirty flag: true when in-memory state diverges from disk */
-    private dirty;
-    /** Pending debounced write timer */
-    private saveTimer;
-    /** Debounce window for disk writes (ms) */
-    private static readonly SAVE_DEBOUNCE_MS;
-    constructor(config?: Partial<EWCConfig>);
-    /**
-     * Initialize the consolidator by loading persisted state
-     */
-    initialize(): Promise<boolean>;
-    /**
-     * Compute Fisher Information Matrix from gradient history
-     * Uses diagonal approximation for efficiency: F_i = E[g_i^2]
-     *
-     * @param patterns - Array of patterns with their gradients/embeddings
-     * @returns Fisher information diagonal
-     */
-    computeFisherMatrix(patterns: {
-        id: string;
-        embedding: number[];
-        success: boolean;
-    }[]): number[];
-    /**
-     * Consolidate new patterns with old patterns without forgetting
-     * Applies EWC penalty to preserve important weights
-     *
-     * @param newPatterns - New patterns to incorporate
-     * @param oldPatterns - Existing patterns to preserve
-     * @returns Consolidated patterns with modified weights
-     */
-    consolidate(newPatterns: {
-        id: string;
-        embedding: number[];
-        type: string;
-        description?: string;
-    }[], oldPatterns?: PatternWeights[]): ConsolidationResult;
-    /**
-     * Calculate EWC regularization penalty
-     *
-     * L_ewc = (lambda/2) * sum_i(F_i * (theta_i - theta_old_i)^2)
-     *
-     * @param oldWeights - Previous weight values
-     * @param newWeights - New weight values
-     * @param fisher - Fisher information diagonal (optional, uses global if not provided)
-     * @returns Regularization penalty value
-     */
-    getPenalty(oldWeights: number[], newWeights: number[], fisher?: number[]): number;
-    /**
-     * Get consolidation statistics
-     */
-    getConsolidationStats(): EWCStats;
-    /**
-     * Record a gradient sample for Fisher computation
-     */
-    recordGradient(patternId: string, gradients: number[], success: boolean): void;
-    /**
-     * Get pattern weights by ID
-     */
-    getPatternWeights(id: string): PatternWeights | undefined;
-    /**
-     * Get all stored patterns
-     */
-    getAllPatterns(): PatternWeights[];
-    /**
-     * Update EWC lambda (regularization strength)
-     */
-    setLambda(lambda: number): void;
-    /**
-     * Get current lambda value
-     */
-    getLambda(): number;
-    /**
-     * Reset Fisher matrix (use with caution - allows forgetting)
-     */
-    resetFisher(): void;
-    /**
-     * Update Fisher matrix from pattern confidence changes.
-     * Called by SONA after distillLearning to track which patterns
-     * are important and should be protected from forgetting.
-     *
-     * Uses online averaging: F_new = alpha * F_old + (1-alpha) * F_current
-     *
-     * @param confidenceChanges - Array of {id, embedding, oldConf, newConf}
-     */
-    updateFisherFromConfidences(confidenceChanges: {
-        id: string;
-        embedding: number[];
-        oldConf: number;
-        newConf: number;
-    }[]): void;
-    /**
-     * Compute consolidation penalty for a proposed confidence update.
-     * Used by SONA to check whether a pattern update would cause forgetting.
-     *
-     * @param oldConfidence - Current confidence value
-     * @param newConfidence - Proposed new confidence value
-     * @returns Penalty value (higher = more forgetting risk)
-     */
-    computeConfidencePenalty(oldConfidence: number, newConfidence: number): number;
-    /**
-     * Clear all patterns and history (full reset)
-     */
-    clear(): void;
-    /**
-     * Calculate importance score for a pattern based on usage
-     */
-    private calculateImportance;
-    /**
-     * Blend old and new weights using Fisher-weighted interpolation
-     */
-    private blendWeights;
-    /**
-     * Prune old, low-importance patterns to stay within limit
-     */
-    private pruneOldPatterns;
-    /**
-     * Schedule a debounced disk flush.
-     * Multiple calls within SAVE_DEBOUNCE_MS coalesce into one write,
-     * preventing blocking I/O on every consolidation or gradient event.
-     */
-    private scheduleSave;
-    /**
-     * Save state to disk
-     */
-    private saveToDisk;
-    /**
-     * Load state from disk
-     */
-    private loadFromDisk;
-}
-/**
- * Get the singleton EWC Consolidator instance
- *
- * @param config - Optional configuration overrides
- * @returns EWC Consolidator instance
- */
-export declare function getEWCConsolidator(config?: Partial<EWCConfig>): Promise<EWCConsolidator>;
-/**
- * Reset the singleton instance (for testing)
- */
-export declare function resetEWCConsolidator(): void;
-/**
- * Quick consolidation helper for common use case
- * Consolidates new patterns with existing ones using EWC
- *
- * @param newPatterns - New patterns to add
- * @returns Consolidation result
- */
-export declare function consolidatePatterns(newPatterns: {
-    id: string;
-    embedding: number[];
-    type: string;
-    description?: string;
-}[]): Promise<ConsolidationResult>;
-/**
- * Record pattern usage outcome
- * Updates Fisher information and pattern importance
- *
- * @param patternId - Pattern identifier
- * @param embedding - Pattern embedding (used as gradient proxy)
- * @param success - Whether the pattern was successful
- */
-export declare function recordPatternOutcome(patternId: string, embedding: number[], success: boolean): Promise<void>;
-/**
- * Get EWC statistics
- */
-export declare function getEWCStats(): Promise<EWCStats>;
-declare const _default: {
-    EWCConsolidator: typeof EWCConsolidator;
-    getEWCConsolidator: typeof getEWCConsolidator;
-    resetEWCConsolidator: typeof resetEWCConsolidator;
-    consolidatePatterns: typeof consolidatePatterns;
-    recordPatternOutcome: typeof recordPatternOutcome;
-    getEWCStats: typeof getEWCStats;
-};
-export default _default;
-//# sourceMappingURL=ewc-consolidation.d.ts.map