monomind 1.10.0 → 1.10.2

package/packages/@monomind/cli/dist/src/ruvector/index.d.ts

@@ -0,0 +1,39 @@
+/**
+ * RuVector Integration Module for Monomind CLI
+ *
+ * Provides integration with @ruvector packages for:
+ * - Q-Learning based task routing
+ * - Mixture of Experts (MoE) routing
+ * - AST code analysis
+ * - Diff classification
+ * - Coverage-based routing
+ * - Graph boundary analysis
+ * - Flash Attention for faster similarity computations
+ *
+ * @module @monomind/cli/ruvector
+ */
+export { QLearningRouter, createQLearningRouter, type QLearningRouterConfig, type RouteDecision } from './q-learning-router.js';
+export { MoERouter, getMoERouter, resetMoERouter, createMoERouter, EXPERT_NAMES, NUM_EXPERTS, INPUT_DIM, HIDDEN_DIM, type ExpertType, type MoERouterConfig, type RoutingResult, type LoadBalanceStats, } from './moe-router.js';
+export { ASTAnalyzer, createASTAnalyzer, type ASTAnalysis, type ASTNode, type ASTAnalyzerConfig } from './ast-analyzer.js';
+export { DiffClassifier, createDiffClassifier, analyzeDiff, analyzeDiffSync, assessFileRisk, assessOverallRisk, classifyDiff, suggestReviewers, getGitDiffNumstat, getGitDiffNumstatAsync, clearDiffCache, clearAllDiffCaches, type DiffClassification, type DiffHunk, type DiffChange, type FileDiff, type DiffAnalysis, type DiffClassifierConfig, type DiffFile, type RiskLevel, type FileRisk, type OverallRisk, type DiffAnalysisResult, } from './diff-classifier.js';
+export { CoverageRouter, createCoverageRouter, coverageRoute, coverageSuggest, coverageGaps, clearCoverageCache, getCoverageCacheStats, type CoverageRouterConfig, type FileCoverage, type CoverageReport, type CoverageRouteResult, type CoverageSuggestResult, type CoverageGapsResult, type CoverageRouteOptions, type CoverageSuggestOptions, type CoverageGapsOptions, } from './coverage-router.js';
+export { coverageRouterTools, hooksCoverageRoute, hooksCoverageSuggest, hooksCoverageGaps } from './coverage-tools.js';
+export { buildDependencyGraph, analyzeGraph, analyzeMinCutBoundaries, analyzeModuleCommunities, detectCircularDependencies, exportToDot, loadRuVector, fallbackMinCut, fallbackLouvain, clearGraphCaches, getGraphCacheStats, type GraphNode, type GraphEdge, type DependencyGraph, type MinCutBoundary, type ModuleCommunity, type CircularDependency, type GraphAnalysisResult, } from './graph-analyzer.js';
+export { FlashAttention, getFlashAttention, resetFlashAttention, computeAttention, benchmarkFlashAttention, getFlashAttentionSpeedup, type FlashAttentionConfig, type AttentionResult, type BenchmarkResult, } from './flash-attention.js';
+export { ModelRouter, getModelRouter, resetModelRouter, createModelRouter, routeToModel, routeToModelFull, analyzeTaskComplexity, getModelRouterStats, recordModelOutcome, MODEL_CAPABILITIES, COMPLEXITY_INDICATORS, type ClaudeModel, type ModelRouterConfig, type ModelRoutingResult, type ComplexityAnalysis, } from './model-router.js';
+export { SemanticRouter, createSemanticRouter, type Intent, type RouteResult, type RouterConfig, } from './semantic-router.js';
+export { isRuvllmWasmAvailable, initRuvllmWasm, getRuvllmStatus, createHnswRouter, createSonaInstant, createMicroLora, formatChat, createKvCache, createGenerateConfig, createBufferPool, createInferenceArena, HNSW_MAX_SAFE_PATTERNS, type HnswRouterConfig, type HnswPattern, type HnswRouteResult, type SonaConfig, type MicroLoraConfig, type ChatMessage, type GenerateOptions, type RuvllmStatus, } from './ruvllm-wasm.js';
+export { isAgentWasmAvailable, initAgentWasm, createWasmAgent, promptWasmAgent, executeWasmTool, getWasmAgent, listWasmAgents, terminateWasmAgent, getWasmAgentState, getWasmAgentTools, getWasmAgentTodos, exportWasmState, createWasmMcpServer, listGalleryTemplates, getGalleryCount, getGalleryCategories, searchGalleryTemplates, getGalleryTemplate, createAgentFromTemplate, buildRvfContainer, buildRvfFromTemplate, type WasmAgentConfig, type WasmAgentInfo, type GalleryTemplate, type GalleryTemplateDetail, type ToolResult, } from './agent-wasm.js';
+/**
+ * Check if ruvector packages are available
+ */
+export declare function isRuvectorAvailable(): Promise<boolean>;
+/**
+ * Check if @ruvector/learning-wasm is available and loadable
+ */
+export declare function isWasmBackendAvailable(): Promise<boolean>;
+/**
+ * Get ruvector version if available
+ */
+export declare function getRuvectorVersion(): Promise<string | null>;
+//# sourceMappingURL=index.d.ts.map

package/packages/@monomind/cli/dist/src/ruvector/index.js

@@ -0,0 +1,76 @@
+/**
+ * RuVector Integration Module for Monomind CLI
+ *
+ * Provides integration with @ruvector packages for:
+ * - Q-Learning based task routing
+ * - Mixture of Experts (MoE) routing
+ * - AST code analysis
+ * - Diff classification
+ * - Coverage-based routing
+ * - Graph boundary analysis
+ * - Flash Attention for faster similarity computations
+ *
+ * @module @monomind/cli/ruvector
+ */
+export { QLearningRouter, createQLearningRouter } from './q-learning-router.js';
+export { MoERouter, getMoERouter, resetMoERouter, createMoERouter, EXPERT_NAMES, NUM_EXPERTS, INPUT_DIM, HIDDEN_DIM, } from './moe-router.js';
+export { ASTAnalyzer, createASTAnalyzer } from './ast-analyzer.js';
+export { DiffClassifier, createDiffClassifier, 
+// MCP tool exports
+analyzeDiff, analyzeDiffSync, assessFileRisk, assessOverallRisk, classifyDiff, suggestReviewers, getGitDiffNumstat, getGitDiffNumstatAsync, 
+// Cache control
+clearDiffCache, clearAllDiffCaches, } from './diff-classifier.js';
+export { CoverageRouter, createCoverageRouter, 
+// MCP tool exports
+coverageRoute, coverageSuggest, coverageGaps, 
+// Cache utilities (NEW)
+clearCoverageCache, getCoverageCacheStats, } from './coverage-router.js';
+export { coverageRouterTools, hooksCoverageRoute, hooksCoverageSuggest, hooksCoverageGaps } from './coverage-tools.js';
+export { buildDependencyGraph, analyzeGraph, analyzeMinCutBoundaries, analyzeModuleCommunities, detectCircularDependencies, exportToDot, loadRuVector, fallbackMinCut, fallbackLouvain, 
+// Cache utilities (NEW)
+clearGraphCaches, getGraphCacheStats, } from './graph-analyzer.js';
+export { FlashAttention, getFlashAttention, resetFlashAttention, computeAttention, benchmarkFlashAttention, getFlashAttentionSpeedup, } from './flash-attention.js';
+// lora-adapter removed — superseded by SONA instant adaptation
+export { ModelRouter, getModelRouter, resetModelRouter, createModelRouter, routeToModel, routeToModelFull, analyzeTaskComplexity, getModelRouterStats, recordModelOutcome, MODEL_CAPABILITIES, COMPLEXITY_INDICATORS, } from './model-router.js';
+export { SemanticRouter, createSemanticRouter, } from './semantic-router.js';
+// ── RuVector LLM WASM (inference utilities) ─────────────────
+export { isRuvllmWasmAvailable, initRuvllmWasm, getRuvllmStatus, createHnswRouter, createSonaInstant, createMicroLora, formatChat, createKvCache, createGenerateConfig, createBufferPool, createInferenceArena, HNSW_MAX_SAFE_PATTERNS, } from './ruvllm-wasm.js';
+// ── Agent WASM (sandboxed agent runtime) ────────────────────
+export { isAgentWasmAvailable, initAgentWasm, createWasmAgent, promptWasmAgent, executeWasmTool, getWasmAgent, listWasmAgents, terminateWasmAgent, getWasmAgentState, getWasmAgentTools, getWasmAgentTodos, exportWasmState, createWasmMcpServer, listGalleryTemplates, getGalleryCount, getGalleryCategories, searchGalleryTemplates, getGalleryTemplate, createAgentFromTemplate, buildRvfContainer, buildRvfFromTemplate, } from './agent-wasm.js';
+/**
+ * Check if ruvector packages are available
+ */
+export async function isRuvectorAvailable() {
+    try {
+        await import('@ruvector/core');
+        return true;
+    }
+    catch {
+        return false;
+    }
+}
+/**
+ * Check if @ruvector/learning-wasm is available and loadable
+ */
+export async function isWasmBackendAvailable() {
+    try {
+        const wasm = await import('@ruvector/learning-wasm');
+        return typeof wasm.WasmMicroLoRA === 'function' && typeof wasm.initSync === 'function';
+    }
+    catch {
+        return false;
+    }
+}
+/**
+ * Get ruvector version if available
+ */
+export async function getRuvectorVersion() {
+    try {
+        const ruvector = await import('@ruvector/core');
+        return ruvector.version || '1.0.0';
+    }
+    catch {
+        return null;
+    }
+}
+//# sourceMappingURL=index.js.map

package/packages/@monomind/cli/dist/src/ruvector/lora-adapter.d.ts

@@ -0,0 +1,218 @@
+/**
+ * LoRA (Low-Rank Adaptation) Implementation
+ *
+ * Enables efficient fine-tuning by decomposing weight updates into low-rank matrices.
+ * Dramatically reduces memory requirements while maintaining adaptation quality.
+ *
+ * Features:
+ * - Rank decomposition (r << d) for memory efficiency
+ * - Additive weight updates: W' = W + BA (where B ∈ R^{d×r}, A ∈ R^{r×k})
+ * - Support for multiple adaptation heads
+ * - Persistence to .swarm/lora-weights.json
+ *
+ * Memory savings:
+ * - Original: d × k parameters
+ * - LoRA: r × (d + k) parameters
+ * - For d=384, k=384, r=8: 786,432 → 6,144 (128x reduction)
+ *
+ * @module lora-adapter
+ */
+/**
+ * Default LoRA rank (determines memory/quality tradeoff)
+ */
+export declare const DEFAULT_RANK = 8;
+/**
+ * Input dimension (384 from ONNX MiniLM-L6-v2)
+ */
+export declare const INPUT_DIM = 384;
+/**
+ * Default output dimension (same as input for adapter)
+ */
+export declare const OUTPUT_DIM = 384;
+/**
+ * Default alpha scaling factor
+ */
+export declare const DEFAULT_ALPHA = 16;
+/**
+ * LoRA configuration
+ */
+export interface LoRAConfig {
+    /** Rank of decomposition (lower = more compression) */
+    rank: number;
+    /** Alpha scaling factor for output */
+    alpha: number;
+    /** Input dimension */
+    inputDim: number;
+    /** Output dimension */
+    outputDim: number;
+    /** Learning rate for updates */
+    learningRate: number;
+    /** Path for weight persistence */
+    weightsPath: string;
+    /** Enable dropout for regularization */
+    enableDropout: boolean;
+    /** Dropout probability */
+    dropoutProb: number;
+    /** Auto-save interval in updates */
+    autoSaveInterval: number;
+}
+/**
+ * LoRA adapter weights
+ */
+export interface LoRAWeights {
+    /** A matrix (rank × inputDim) - down projection */
+    A: Float32Array;
+    /** B matrix (outputDim × rank) - up projection */
+    B: Float32Array;
+    /** Scaling factor (alpha / rank) */
+    scaling: number;
+}
+/**
+ * Adaptation result
+ */
+export interface AdaptationResult {
+    /** Adapted embedding */
+    adapted: Float32Array;
+    /** Magnitude of adaptation */
+    adaptationNorm: number;
+    /** Time taken in ms */
+    timeMs: number;
+}
+/**
+ * LoRA statistics
+ */
+export interface LoRAStats {
+    /** Total adaptations performed */
+    totalAdaptations: number;
+    /** Total training updates */
+    totalUpdates: number;
+    /** Current rank */
+    rank: number;
+    /** Memory savings ratio */
+    compressionRatio: number;
+    /** Average adaptation norm */
+    avgAdaptationNorm: number;
+    /** Last update timestamp */
+    lastUpdate: number | null;
+}
+/**
+ * Low-Rank Adaptation module for efficient embedding fine-tuning
+ */
+export declare class LoRAAdapter {
+    private config;
+    private weights;
+    private totalAdaptations;
+    private totalUpdates;
+    private adaptationNormSum;
+    private lastUpdate;
+    private updatesSinceLastSave;
+    constructor(config?: Partial<LoRAConfig>);
+    /**
+     * Initialize weights with Kaiming/He initialization
+     */
+    private initializeWeights;
+    /**
+     * Box-Muller transform for Gaussian random numbers
+     */
+    private gaussianRandom;
+    /**
+     * Initialize adapter and load persisted weights
+     */
+    initialize(): Promise<{
+        success: boolean;
+        weightsLoaded: boolean;
+    }>;
+    /**
+     * Apply LoRA adaptation to an embedding
+     * output = input + scaling * (B @ A @ input)
+     */
+    adapt(input: Float32Array): AdaptationResult;
+    /**
+     * Train the adapter with a gradient signal
+     * Uses simplified update: A += lr * hidden^T @ grad, B += lr * grad @ hidden^T
+     */
+    train(input: Float32Array, gradOutput: Float32Array, reward?: number): {
+        updated: boolean;
+        loss: number;
+    };
+    /**
+     * Merge LoRA weights into base weights (for deployment)
+     * Returns: W' = W + scaling * B @ A
+     */
+    merge(baseWeights: Float32Array): Float32Array;
+    /**
+     * Get current statistics
+     */
+    getStats(): LoRAStats;
+    /**
+     * Reset adapter to initial state
+     */
+    reset(): void;
+    /**
+     * Save weights to disk
+     */
+    saveWeights(): boolean;
+    /**
+     * Load weights from disk
+     */
+    loadWeights(): boolean;
+    /**
+     * Export weights as JSON
+     */
+    exportWeights(): {
+        A: number[];
+        B: number[];
+        scaling: number;
+        config: Partial<LoRAConfig>;
+    };
+    /**
+     * Import weights from JSON
+     */
+    importWeights(data: {
+        A: number[];
+        B: number[];
+        scaling: number;
+    }): boolean;
+}
+/**
+ * Get or create singleton LoRA adapter instance
+ */
+export declare function getLoRAAdapter(): Promise<LoRAAdapter>;
+/**
+ * Reset singleton instance (for testing)
+ */
+export declare function resetLoRAAdapter(): void;
+/**
+ * Create new LoRA adapter instance (factory)
+ */
+export declare function createLoRAAdapter(config?: Partial<LoRAConfig>): LoRAAdapter;
+/**
+ * Quick adaptation (convenience function)
+ */
+export declare function adaptEmbedding(input: Float32Array): Promise<AdaptationResult>;
+/**
+ * Quick training (convenience function)
+ */
+export declare function trainLoRA(input: Float32Array, gradOutput: Float32Array, reward?: number): Promise<{
+    updated: boolean;
+    loss: number;
+}>;
+/**
+ * Get LoRA statistics (convenience function)
+ */
+export declare function getLoRAStats(): Promise<LoRAStats>;
+declare const _default: {
+    LoRAAdapter: typeof LoRAAdapter;
+    getLoRAAdapter: typeof getLoRAAdapter;
+    resetLoRAAdapter: typeof resetLoRAAdapter;
+    createLoRAAdapter: typeof createLoRAAdapter;
+    adaptEmbedding: typeof adaptEmbedding;
+    trainLoRA: typeof trainLoRA;
+    getLoRAStats: typeof getLoRAStats;
+    DEFAULT_RANK: number;
+    DEFAULT_ALPHA: number;
+    INPUT_DIM: number;
+    OUTPUT_DIM: number;
+};
+export default _default;
+//# sourceMappingURL=lora-adapter.d.ts.map