ruvector 0.1.80 → 0.1.82

package/dist/analysis/patterns.js

@@ -0,0 +1,243 @@
+"use strict";
+/**
+ * Pattern Extraction Module - Consolidated code pattern detection
+ *
+ * Single source of truth for extracting functions, imports, exports, etc.
+ * Used by native-worker.ts and parallel-workers.ts
+ */
+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.detectLanguage = detectLanguage;
+exports.extractFunctions = extractFunctions;
+exports.extractClasses = extractClasses;
+exports.extractImports = extractImports;
+exports.extractExports = extractExports;
+exports.extractTodos = extractTodos;
+exports.extractAllPatterns = extractAllPatterns;
+exports.extractFromFiles = extractFromFiles;
+exports.toPatternMatches = toPatternMatches;
+const fs = __importStar(require("fs"));
+/**
+ * Detect language from file extension
+ */
+function detectLanguage(file) {
+    const ext = file.split('.').pop()?.toLowerCase() || '';
+    const langMap = {
+        ts: 'typescript', tsx: 'typescript', js: 'javascript', jsx: 'javascript',
+        rs: 'rust', py: 'python', go: 'go', java: 'java', rb: 'ruby',
+        cpp: 'cpp', c: 'c', h: 'c', hpp: 'cpp', cs: 'csharp',
+        md: 'markdown', json: 'json', yaml: 'yaml', yml: 'yaml',
+        sql: 'sql', sh: 'shell', bash: 'shell', zsh: 'shell',
+    };
+    return langMap[ext] || ext || 'unknown';
+}
+/**
+ * Extract function names from content
+ */
+function extractFunctions(content) {
+    const patterns = [
+        /function\s+(\w+)/g,
+        /const\s+(\w+)\s*=\s*(?:async\s*)?\([^)]*\)\s*=>/g,
+        /let\s+(\w+)\s*=\s*(?:async\s*)?\([^)]*\)\s*=>/g,
+        /(?:async\s+)?(?:public|private|protected)?\s+(\w+)\s*\([^)]*\)\s*[:{]/g,
+        /(\w+)\s*:\s*(?:async\s*)?\([^)]*\)\s*=>/g,
+        /def\s+(\w+)\s*\(/g, // Python
+        /fn\s+(\w+)\s*[<(]/g, // Rust
+        /func\s+(\w+)\s*\(/g, // Go
+    ];
+    const funcs = new Set();
+    const reserved = new Set(['if', 'for', 'while', 'switch', 'catch', 'try', 'else', 'return', 'new', 'class', 'function', 'async', 'await']);
+    for (const pattern of patterns) {
+        const regex = new RegExp(pattern.source, pattern.flags);
+        let match;
+        while ((match = regex.exec(content)) !== null) {
+            const name = match[1];
+            if (name && !reserved.has(name) && name.length > 1) {
+                funcs.add(name);
+            }
+        }
+    }
+    return Array.from(funcs);
+}
+/**
+ * Extract class names from content
+ */
+function extractClasses(content) {
+    const patterns = [
+        /class\s+(\w+)/g,
+        /interface\s+(\w+)/g,
+        /type\s+(\w+)\s*=/g,
+        /enum\s+(\w+)/g,
+        /struct\s+(\w+)/g,
+    ];
+    const classes = new Set();
+    for (const pattern of patterns) {
+        const regex = new RegExp(pattern.source, pattern.flags);
+        let match;
+        while ((match = regex.exec(content)) !== null) {
+            if (match[1])
+                classes.add(match[1]);
+        }
+    }
+    return Array.from(classes);
+}
+/**
+ * Extract import statements from content
+ */
+function extractImports(content) {
+    const patterns = [
+        /import\s+.*?from\s+['"]([^'"]+)['"]/g,
+        /import\s+['"]([^'"]+)['"]/g,
+        /require\s*\(['"]([^'"]+)['"]\)/g,
+        /from\s+(\w+)\s+import/g, // Python
+        /use\s+(\w+(?:::\w+)*)/g, // Rust
+    ];
+    const imports = [];
+    for (const pattern of patterns) {
+        const regex = new RegExp(pattern.source, pattern.flags);
+        let match;
+        while ((match = regex.exec(content)) !== null) {
+            if (match[1])
+                imports.push(match[1]);
+        }
+    }
+    return [...new Set(imports)];
+}
+/**
+ * Extract export statements from content
+ */
+function extractExports(content) {
+    const patterns = [
+        /export\s+(?:default\s+)?(?:class|function|const|let|var|interface|type|enum)\s+(\w+)/g,
+        /export\s*\{\s*([^}]+)\s*\}/g,
+        /module\.exports\s*=\s*(\w+)/g,
+        /exports\.(\w+)\s*=/g,
+        /pub\s+(?:fn|struct|enum|type)\s+(\w+)/g, // Rust
+    ];
+    const exports = [];
+    for (const pattern of patterns) {
+        const regex = new RegExp(pattern.source, pattern.flags);
+        let match;
+        while ((match = regex.exec(content)) !== null) {
+            if (match[1]) {
+                // Handle grouped exports: export { a, b, c }
+                const names = match[1].split(',').map(s => s.trim().split(/\s+as\s+/)[0].trim());
+                exports.push(...names.filter(n => n && /^\w+$/.test(n)));
+            }
+        }
+    }
+    return [...new Set(exports)];
+}
+/**
+ * Extract TODO/FIXME comments from content
+ */
+function extractTodos(content) {
+    const pattern = /\/\/\s*(TODO|FIXME|HACK|XXX|BUG|NOTE):\s*(.+)/gi;
+    const todos = [];
+    let match;
+    while ((match = pattern.exec(content)) !== null) {
+        todos.push(`${match[1]}: ${match[2].trim()}`);
+    }
+    return todos;
+}
+/**
+ * Extract all patterns from a file
+ */
+function extractAllPatterns(filePath, content) {
+    try {
+        const fileContent = content ?? (fs.existsSync(filePath) ? fs.readFileSync(filePath, 'utf-8') : '');
+        return {
+            file: filePath,
+            language: detectLanguage(filePath),
+            functions: extractFunctions(fileContent),
+            classes: extractClasses(fileContent),
+            imports: extractImports(fileContent),
+            exports: extractExports(fileContent),
+            todos: extractTodos(fileContent),
+            variables: [], // Could add variable extraction if needed
+        };
+    }
+    catch {
+        return {
+            file: filePath,
+            language: detectLanguage(filePath),
+            functions: [],
+            classes: [],
+            imports: [],
+            exports: [],
+            todos: [],
+            variables: [],
+        };
+    }
+}
+/**
+ * Extract patterns from multiple files
+ */
+function extractFromFiles(files, maxFiles = 100) {
+    return files.slice(0, maxFiles).map(f => extractAllPatterns(f));
+}
+/**
+ * Convert FilePatterns to PatternMatch array (for native-worker compatibility)
+ */
+function toPatternMatches(patterns) {
+    const matches = [];
+    for (const func of patterns.functions) {
+        matches.push({ type: 'function', match: func, file: patterns.file });
+    }
+    for (const cls of patterns.classes) {
+        matches.push({ type: 'class', match: cls, file: patterns.file });
+    }
+    for (const imp of patterns.imports) {
+        matches.push({ type: 'import', match: imp, file: patterns.file });
+    }
+    for (const exp of patterns.exports) {
+        matches.push({ type: 'export', match: exp, file: patterns.file });
+    }
+    for (const todo of patterns.todos) {
+        matches.push({ type: 'todo', match: todo, file: patterns.file });
+    }
+    return matches;
+}
+exports.default = {
+    detectLanguage,
+    extractFunctions,
+    extractClasses,
+    extractImports,
+    extractExports,
+    extractTodos,
+    extractAllPatterns,
+    extractFromFiles,
+    toPatternMatches,
+};

package/dist/analysis/security.d.ts

@@ -0,0 +1,51 @@
+/**
+ * Security Analysis Module - Consolidated security scanning
+ *
+ * Single source of truth for security patterns and vulnerability detection.
+ * Used by native-worker.ts and parallel-workers.ts
+ */
+export interface SecurityPattern {
+    pattern: RegExp;
+    rule: string;
+    severity: 'low' | 'medium' | 'high' | 'critical';
+    message: string;
+    suggestion?: string;
+}
+export interface SecurityFinding {
+    file: string;
+    line: number;
+    severity: 'low' | 'medium' | 'high' | 'critical';
+    rule: string;
+    message: string;
+    match?: string;
+    suggestion?: string;
+}
+/**
+ * Default security patterns for vulnerability detection
+ */
+export declare const SECURITY_PATTERNS: SecurityPattern[];
+/**
+ * Scan a single file for security issues
+ */
+export declare function scanFile(filePath: string, content?: string, patterns?: SecurityPattern[]): SecurityFinding[];
+/**
+ * Scan multiple files for security issues
+ */
+export declare function scanFiles(files: string[], patterns?: SecurityPattern[], maxFiles?: number): SecurityFinding[];
+/**
+ * Get severity score (for sorting/filtering)
+ */
+export declare function getSeverityScore(severity: string): number;
+/**
+ * Sort findings by severity (highest first)
+ */
+export declare function sortBySeverity(findings: SecurityFinding[]): SecurityFinding[];
+declare const _default: {
+    SECURITY_PATTERNS: SecurityPattern[];
+    scanFile: typeof scanFile;
+    scanFiles: typeof scanFiles;
+    getSeverityScore: typeof getSeverityScore;
+    sortBySeverity: typeof sortBySeverity;
+};
+export default _default;
+//# sourceMappingURL=security.d.ts.map

package/dist/analysis/security.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"security.d.ts","sourceRoot":"","sources":["../../src/analysis/security.ts"],"names":[],"mappings":"AAAA;;;;;GAKG;AAIH,MAAM,WAAW,eAAe;IAC9B,OAAO,EAAE,MAAM,CAAC;IAChB,IAAI,EAAE,MAAM,CAAC;IACb,QAAQ,EAAE,KAAK,GAAG,QAAQ,GAAG,MAAM,GAAG,UAAU,CAAC;IACjD,OAAO,EAAE,MAAM,CAAC;IAChB,UAAU,CAAC,EAAE,MAAM,CAAC;CACrB;AAED,MAAM,WAAW,eAAe;IAC9B,IAAI,EAAE,MAAM,CAAC;IACb,IAAI,EAAE,MAAM,CAAC;IACb,QAAQ,EAAE,KAAK,GAAG,QAAQ,GAAG,MAAM,GAAG,UAAU,CAAC;IACjD,IAAI,EAAE,MAAM,CAAC;IACb,OAAO,EAAE,MAAM,CAAC;IAChB,KAAK,CAAC,EAAE,MAAM,CAAC;IACf,UAAU,CAAC,EAAE,MAAM,CAAC;CACrB;AAED;;GAEG;AACH,eAAO,MAAM,iBAAiB,EAAE,eAAe,EA0B9C,CAAC;AAEF;;GAEG;AACH,wBAAgB,QAAQ,CACtB,QAAQ,EAAE,MAAM,EAChB,OAAO,CAAC,EAAE,MAAM,EAChB,QAAQ,GAAE,eAAe,EAAsB,GAC9C,eAAe,EAAE,CA4BnB;AAED;;GAEG;AACH,wBAAgB,SAAS,CACvB,KAAK,EAAE,MAAM,EAAE,EACf,QAAQ,GAAE,eAAe,EAAsB,EAC/C,QAAQ,GAAE,MAAY,GACrB,eAAe,EAAE,CAQnB;AAED;;GAEG;AACH,wBAAgB,gBAAgB,CAAC,QAAQ,EAAE,MAAM,GAAG,MAAM,CAQzD;AAED;;GAEG;AACH,wBAAgB,cAAc,CAAC,QAAQ,EAAE,eAAe,EAAE,GAAG,eAAe,EAAE,CAE7E;;;;;;;;AAED,wBAME"}

package/dist/analysis/security.js

@@ -0,0 +1,139 @@
+"use strict";
+/**
+ * Security Analysis Module - Consolidated security scanning
+ *
+ * Single source of truth for security patterns and vulnerability detection.
+ * Used by native-worker.ts and parallel-workers.ts
+ */
+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.SECURITY_PATTERNS = void 0;
+exports.scanFile = scanFile;
+exports.scanFiles = scanFiles;
+exports.getSeverityScore = getSeverityScore;
+exports.sortBySeverity = sortBySeverity;
+const fs = __importStar(require("fs"));
+/**
+ * Default security patterns for vulnerability detection
+ */
+exports.SECURITY_PATTERNS = [
+    // Critical: Hardcoded secrets
+    { pattern: /password\s*=\s*['"][^'"]+['"]/gi, rule: 'no-hardcoded-password', severity: 'critical', message: 'Hardcoded password detected', suggestion: 'Use environment variables or secret management' },
+    { pattern: /api[_-]?key\s*=\s*['"][^'"]+['"]/gi, rule: 'no-hardcoded-apikey', severity: 'critical', message: 'Hardcoded API key detected', suggestion: 'Use environment variables' },
+    { pattern: /secret\s*=\s*['"][^'"]+['"]/gi, rule: 'no-hardcoded-secret', severity: 'critical', message: 'Hardcoded secret detected', suggestion: 'Use environment variables or secret management' },
+    { pattern: /private[_-]?key\s*=\s*['"][^'"]+['"]/gi, rule: 'no-hardcoded-private-key', severity: 'critical', message: 'Hardcoded private key detected', suggestion: 'Use secure key management' },
+    // High: Code execution risks
+    { pattern: /eval\s*\(/g, rule: 'no-eval', severity: 'high', message: 'Avoid eval() - code injection risk', suggestion: 'Use safer alternatives like JSON.parse()' },
+    { pattern: /exec\s*\(/g, rule: 'no-exec', severity: 'high', message: 'Avoid exec() - command injection risk', suggestion: 'Use execFile or spawn with args array' },
+    { pattern: /Function\s*\(/g, rule: 'no-function-constructor', severity: 'high', message: 'Avoid Function constructor - code injection risk' },
+    { pattern: /child_process.*exec\(/g, rule: 'no-shell-exec', severity: 'high', message: 'Shell execution detected', suggestion: 'Use execFile or spawn instead' },
+    // High: SQL injection
+    { pattern: /SELECT\s+.*\s+FROM.*\+/gi, rule: 'sql-injection-risk', severity: 'high', message: 'Potential SQL injection - string concatenation in query', suggestion: 'Use parameterized queries' },
+    { pattern: /`SELECT.*\$\{/gi, rule: 'sql-injection-template', severity: 'high', message: 'Template literal in SQL query', suggestion: 'Use parameterized queries' },
+    // Medium: XSS risks
+    { pattern: /dangerouslySetInnerHTML/g, rule: 'xss-risk', severity: 'medium', message: 'XSS risk: dangerouslySetInnerHTML', suggestion: 'Sanitize content before rendering' },
+    { pattern: /innerHTML\s*=/g, rule: 'no-inner-html', severity: 'medium', message: 'Avoid innerHTML - XSS risk', suggestion: 'Use textContent or sanitize content' },
+    { pattern: /document\.write\s*\(/g, rule: 'no-document-write', severity: 'medium', message: 'Avoid document.write - XSS risk' },
+    // Medium: Other risks
+    { pattern: /\$\{.*\}/g, rule: 'template-injection', severity: 'low', message: 'Template literal detected - verify no injection' },
+    { pattern: /new\s+RegExp\s*\([^)]*\+/g, rule: 'regex-injection', severity: 'medium', message: 'Dynamic RegExp - potential ReDoS risk', suggestion: 'Validate/sanitize regex input' },
+    { pattern: /\.on\s*\(\s*['"]error['"]/g, rule: 'unhandled-error', severity: 'low', message: 'Error handler detected - verify proper error handling' },
+];
+/**
+ * Scan a single file for security issues
+ */
+function scanFile(filePath, content, patterns = exports.SECURITY_PATTERNS) {
+    const findings = [];
+    try {
+        const fileContent = content ?? (fs.existsSync(filePath) ? fs.readFileSync(filePath, 'utf-8') : '');
+        if (!fileContent)
+            return findings;
+        for (const { pattern, rule, severity, message, suggestion } of patterns) {
+            const regex = new RegExp(pattern.source, pattern.flags);
+            let match;
+            while ((match = regex.exec(fileContent)) !== null) {
+                const lineNum = fileContent.slice(0, match.index).split('\n').length;
+                findings.push({
+                    file: filePath,
+                    line: lineNum,
+                    severity,
+                    rule,
+                    message,
+                    match: match[0].slice(0, 50),
+                    suggestion,
+                });
+            }
+        }
+    }
+    catch {
+        // Skip unreadable files
+    }
+    return findings;
+}
+/**
+ * Scan multiple files for security issues
+ */
+function scanFiles(files, patterns = exports.SECURITY_PATTERNS, maxFiles = 100) {
+    const findings = [];
+    for (const file of files.slice(0, maxFiles)) {
+        findings.push(...scanFile(file, undefined, patterns));
+    }
+    return findings;
+}
+/**
+ * Get severity score (for sorting/filtering)
+ */
+function getSeverityScore(severity) {
+    switch (severity) {
+        case 'critical': return 4;
+        case 'high': return 3;
+        case 'medium': return 2;
+        case 'low': return 1;
+        default: return 0;
+    }
+}
+/**
+ * Sort findings by severity (highest first)
+ */
+function sortBySeverity(findings) {
+    return [...findings].sort((a, b) => getSeverityScore(b.severity) - getSeverityScore(a.severity));
+}
+exports.default = {
+    SECURITY_PATTERNS: exports.SECURITY_PATTERNS,
+    scanFile,
+    scanFiles,
+    getSeverityScore,
+    sortBySeverity,
+};

package/dist/core/adaptive-embedder.d.ts

@@ -0,0 +1,148 @@
+/**
+ * AdaptiveEmbedder - Micro-LoRA Style Optimization for ONNX Embeddings
+ *
+ * Applies continual learning techniques to frozen ONNX embeddings:
+ *
+ * 1. MICRO-LORA ADAPTERS
+ *    - Low-rank projection layers (rank 2-8) on top of frozen embeddings
+ *    - Domain-specific fine-tuning with minimal parameters
+ *    - ~0.1% of base model parameters
+ *
+ * 2. CONTRASTIVE LEARNING
+ *    - Files edited together → embeddings closer
+ *    - Semantic clustering from trajectories
+ *    - Online learning from user behavior
+ *
+ * 3. EWC++ (Elastic Weight Consolidation)
+ *    - Prevents catastrophic forgetting
+ *    - Consolidates important adaptations
+ *    - Fisher information regularization
+ *
+ * 4. MEMORY-AUGMENTED RETRIEVAL
+ *    - Episodic memory for context-aware embeddings
+ *    - Attention over past similar embeddings
+ *    - Domain prototype learning
+ *
+ * Architecture:
+ *   ONNX(text) → [frozen 384d] → LoRA_A → LoRA_B → [adapted 384d]
+ *                                 (384×r)   (r×384)
+ */
+export interface AdaptiveConfig {
+    /** LoRA rank (lower = fewer params, higher = more expressive) */
+    loraRank?: number;
+    /** Learning rate for online updates */
+    learningRate?: number;
+    /** EWC regularization strength */
+    ewcLambda?: number;
+    /** Number of domain prototypes to maintain */
+    numPrototypes?: number;
+    /** Enable contrastive learning from co-edits */
+    contrastiveLearning?: boolean;
+    /** Temperature for contrastive loss */
+    contrastiveTemp?: number;
+    /** Memory capacity for episodic retrieval */
+    memoryCapacity?: number;
+}
+export interface LoRAWeights {
+    A: number[][];
+    B: number[][];
+    bias?: number[];
+}
+export interface DomainPrototype {
+    domain: string;
+    centroid: number[];
+    count: number;
+    variance: number;
+}
+export interface AdaptiveStats {
+    baseModel: string;
+    dimension: number;
+    loraRank: number;
+    loraParams: number;
+    adaptations: number;
+    prototypes: number;
+    memorySize: number;
+    ewcConsolidations: number;
+    contrastiveUpdates: number;
+}
+export declare class AdaptiveEmbedder {
+    private config;
+    private lora;
+    private prototypes;
+    private episodic;
+    private onnxReady;
+    private dimension;
+    private adaptationCount;
+    private ewcCount;
+    private contrastiveCount;
+    private coEditBuffer;
+    constructor(config?: AdaptiveConfig);
+    /**
+     * Initialize ONNX backend
+     */
+    init(): Promise<void>;
+    /**
+     * Generate adaptive embedding
+     * Pipeline: ONNX → LoRA → Prototype Adjustment → Episodic Augmentation
+     */
+    embed(text: string, options?: {
+        domain?: string;
+        useEpisodic?: boolean;
+        storeInMemory?: boolean;
+    }): Promise<number[]>;
+    /**
+     * Batch embed with adaptation
+     */
+    embedBatch(texts: string[], options?: {
+        domain?: string;
+    }): Promise<number[][]>;
+    /**
+     * Learn from co-edit pattern (contrastive learning)
+     * Files edited together should have similar embeddings
+     */
+    learnCoEdit(file1: string, content1: string, file2: string, content2: string): Promise<number>;
+    /**
+     * Process co-edit batch with contrastive loss
+     */
+    private processCoEditBatch;
+    /**
+     * Learn from trajectory outcome (reinforcement-like)
+     */
+    learnFromOutcome(context: string, action: string, success: boolean, quality?: number): Promise<void>;
+    /**
+     * EWC consolidation - prevent forgetting important adaptations
+     */
+    consolidate(): Promise<void>;
+    /**
+     * Fallback hash embedding
+     */
+    private hashEmbed;
+    private normalize;
+    /**
+     * Get statistics
+     */
+    getStats(): AdaptiveStats;
+    /**
+     * Export learned weights
+     */
+    export(): {
+        lora: LoRAWeights;
+        prototypes: DomainPrototype[];
+        stats: AdaptiveStats;
+    };
+    /**
+     * Import learned weights
+     */
+    import(data: {
+        lora?: LoRAWeights;
+        prototypes?: DomainPrototype[];
+    }): void;
+    /**
+     * Reset adaptations
+     */
+    reset(): void;
+}
+export declare function getAdaptiveEmbedder(config?: AdaptiveConfig): AdaptiveEmbedder;
+export declare function initAdaptiveEmbedder(config?: AdaptiveConfig): Promise<AdaptiveEmbedder>;
+export default AdaptiveEmbedder;
+//# sourceMappingURL=adaptive-embedder.d.ts.map

package/dist/core/adaptive-embedder.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"adaptive-embedder.d.ts","sourceRoot":"","sources":["../../src/core/adaptive-embedder.ts"],"names":[],"mappings":"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"}