@aigentic/claude-flow 3.7.0-alpha.69

package/v3/@claude-flow/cli/dist/src/ruvector/graph-backend.d.ts

@@ -0,0 +1,79 @@
+/**
+ * @ruvector/graph-node native graph database backend (ADR-087)
+ *
+ * Provides persistent graph storage for agent relationships, causal edges,
+ * task dependencies, and swarm topology using native Rust bindings.
+ *
+ * API requirements discovered via testing:
+ * - createNode: requires { id, type, embedding }
+ * - createEdge: requires { from, to, label, description, embedding, properties }
+ * - createHyperedge: requires { nodes[], label, description, embedding, properties }
+ * - kHopNeighbors(nodeId, k): returns string[] of node IDs
+ * - stats(): returns { totalNodes, totalEdges, avgDegree }
+ */
+export interface GraphNodeData {
+    id: string;
+    type: string;
+    name?: string;
+    properties?: Record<string, unknown>;
+}
+export interface GraphEdgeData {
+    from: string;
+    to: string;
+    label: string;
+    description?: string;
+    weight?: number;
+    properties?: Record<string, unknown>;
+}
+export interface GraphStats {
+    totalNodes: number;
+    totalEdges: number;
+    avgDegree: number;
+    backend: 'graph-node' | 'unavailable';
+}
+/**
+ * Check if graph-node backend is available
+ */
+export declare function isGraphBackendAvailable(): Promise<boolean>;
+/**
+ * Add a node to the graph (agent, task, pattern, etc.)
+ */
+export declare function addNode(data: GraphNodeData): Promise<string | null>;
+/**
+ * Add an edge between two nodes
+ */
+export declare function addEdge(data: GraphEdgeData): Promise<string | null>;
+/**
+ * Create a hyperedge connecting multiple nodes (e.g., swarm teams)
+ */
+export declare function addHyperedge(nodeIds: string[], label: string, description?: string, properties?: Record<string, unknown>): Promise<string | null>;
+/**
+ * Get k-hop neighbors of a node
+ */
+export declare function getNeighbors(nodeId: string, hops?: number): Promise<string[]>;
+/**
+ * Get graph statistics
+ */
+export declare function getGraphStats(): Promise<GraphStats>;
+/**
+ * Record a causal edge (used by agentdb_causal-edge MCP tool)
+ */
+export declare function recordCausalEdge(sourceId: string, targetId: string, relation: string, weight?: number): Promise<{
+    success: boolean;
+    edgeId?: string;
+    backend: string;
+}>;
+/**
+ * Record agent collaboration (used by swarm coordination)
+ */
+export declare function recordCollaboration(agentId: string, agentType: string, taskId: string, taskName: string): Promise<{
+    success: boolean;
+}>;
+/**
+ * Record swarm team as a hyperedge
+ */
+export declare function recordSwarmTeam(agentIds: string[], topology: string, taskDescription?: string): Promise<{
+    success: boolean;
+    hyperedgeId?: string;
+}>;
+//# sourceMappingURL=graph-backend.d.ts.map

package/v3/@claude-flow/cli/dist/src/ruvector/graph-backend.js

@@ -0,0 +1,220 @@
+/**
+ * @ruvector/graph-node native graph database backend (ADR-087)
+ *
+ * Provides persistent graph storage for agent relationships, causal edges,
+ * task dependencies, and swarm topology using native Rust bindings.
+ *
+ * API requirements discovered via testing:
+ * - createNode: requires { id, type, embedding }
+ * - createEdge: requires { from, to, label, description, embedding, properties }
+ * - createHyperedge: requires { nodes[], label, description, embedding, properties }
+ * - kHopNeighbors(nodeId, k): returns string[] of node IDs
+ * - stats(): returns { totalNodes, totalEdges, avgDegree }
+ */
+import { join } from 'path';
+// Lazy-loaded graph-node module
+let graphNodeModule = null;
+let graphDb = null;
+let graphBackendLoaded = false;
+let graphBackendAvailable = false;
+const DEFAULT_EMBEDDING_DIM = 8; // Minimal embedding for graph structure
+/**
+ * Load @ruvector/graph-node via createRequire (CJS package)
+ */
+async function loadGraphNode() {
+    if (graphBackendLoaded)
+        return graphNodeModule;
+    graphBackendLoaded = true;
+    try {
+        const { createRequire } = await import('module');
+        const requireCjs = createRequire(import.meta.url);
+        graphNodeModule = requireCjs('@ruvector/graph-node');
+        graphBackendAvailable = true;
+        return graphNodeModule;
+    }
+    catch {
+        graphBackendAvailable = false;
+        return null;
+    }
+}
+/**
+ * Get or create the singleton graph database instance
+ */
+async function getGraphDb() {
+    if (graphDb)
+        return graphDb;
+    const mod = await loadGraphNode();
+    if (!mod)
+        return null;
+    // Use persistent path if available, otherwise in-memory
+    const dataDir = join(process.cwd(), '.claude-flow', 'graph');
+    try {
+        const fs = await import('fs');
+        fs.mkdirSync(dataDir, { recursive: true });
+        graphDb = new mod.GraphDatabase(join(dataDir, 'agents.db'));
+    }
+    catch {
+        // Fallback to in-memory
+        graphDb = new mod.GraphDatabase();
+    }
+    return graphDb;
+}
+/**
+ * Create a minimal embedding for non-vector graph operations.
+ * Uses a deterministic hash of the string content.
+ */
+function textToMiniEmbedding(text) {
+    const emb = new Float32Array(DEFAULT_EMBEDDING_DIM);
+    for (let i = 0; i < text.length; i++) {
+        emb[i % DEFAULT_EMBEDDING_DIM] += text.charCodeAt(i) / 256;
+    }
+    // Normalize
+    let norm = 0;
+    for (let i = 0; i < emb.length; i++)
+        norm += emb[i] * emb[i];
+    norm = Math.sqrt(norm) || 1;
+    for (let i = 0; i < emb.length; i++)
+        emb[i] /= norm;
+    return emb;
+}
+/**
+ * Check if graph-node backend is available
+ */
+export async function isGraphBackendAvailable() {
+    await loadGraphNode();
+    return graphBackendAvailable;
+}
+/**
+ * Add a node to the graph (agent, task, pattern, etc.)
+ */
+export async function addNode(data) {
+    const db = await getGraphDb();
+    if (!db)
+        return null;
+    try {
+        const embedding = textToMiniEmbedding(`${data.type}:${data.name || data.id}`);
+        return await db.createNode({
+            id: data.id,
+            type: data.type,
+            ...data.properties,
+            embedding,
+        });
+    }
+    catch {
+        return null;
+    }
+}
+/**
+ * Add an edge between two nodes
+ */
+export async function addEdge(data) {
+    const db = await getGraphDb();
+    if (!db)
+        return null;
+    try {
+        const embedding = textToMiniEmbedding(`${data.label}:${data.from}->${data.to}`);
+        return await db.createEdge({
+            from: data.from,
+            to: data.to,
+            label: data.label,
+            description: data.description || data.label,
+            embedding,
+            properties: { weight: data.weight ?? 1.0, ...data.properties },
+        });
+    }
+    catch {
+        return null;
+    }
+}
+/**
+ * Create a hyperedge connecting multiple nodes (e.g., swarm teams)
+ */
+export async function addHyperedge(nodeIds, label, description, properties) {
+    const db = await getGraphDb();
+    if (!db)
+        return null;
+    try {
+        const embedding = textToMiniEmbedding(`${label}:${nodeIds.join(',')}`);
+        return await db.createHyperedge({
+            nodes: nodeIds,
+            label,
+            description: description || label,
+            embedding,
+            properties: properties || {},
+        });
+    }
+    catch {
+        return null;
+    }
+}
+/**
+ * Get k-hop neighbors of a node
+ */
+export async function getNeighbors(nodeId, hops = 2) {
+    const db = await getGraphDb();
+    if (!db)
+        return [];
+    try {
+        return await db.kHopNeighbors(nodeId, hops);
+    }
+    catch {
+        return [];
+    }
+}
+/**
+ * Get graph statistics
+ */
+export async function getGraphStats() {
+    const db = await getGraphDb();
+    if (!db)
+        return { totalNodes: 0, totalEdges: 0, avgDegree: 0, backend: 'unavailable' };
+    try {
+        const stats = await db.stats();
+        return { ...stats, backend: 'graph-node' };
+    }
+    catch {
+        return { totalNodes: 0, totalEdges: 0, avgDegree: 0, backend: 'unavailable' };
+    }
+}
+/**
+ * Record a causal edge (used by agentdb_causal-edge MCP tool)
+ */
+export async function recordCausalEdge(sourceId, targetId, relation, weight) {
+    // Ensure both nodes exist
+    await addNode({ id: sourceId, type: 'memory-entry' });
+    await addNode({ id: targetId, type: 'memory-entry' });
+    const edgeId = await addEdge({
+        from: sourceId,
+        to: targetId,
+        label: relation,
+        description: `${relation}: ${sourceId} -> ${targetId}`,
+        weight,
+    });
+    return {
+        success: edgeId !== null,
+        edgeId: edgeId ?? undefined,
+        backend: graphBackendAvailable ? 'graph-node' : 'unavailable',
+    };
+}
+/**
+ * Record agent collaboration (used by swarm coordination)
+ */
+export async function recordCollaboration(agentId, agentType, taskId, taskName) {
+    await addNode({ id: agentId, type: 'agent', name: agentType });
+    await addNode({ id: taskId, type: 'task', name: taskName });
+    const edgeId = await addEdge({
+        from: agentId,
+        to: taskId,
+        label: 'assigned_to',
+        description: `${agentType} works on ${taskName}`,
+    });
+    return { success: edgeId !== null };
+}
+/**
+ * Record swarm team as a hyperedge
+ */
+export async function recordSwarmTeam(agentIds, topology, taskDescription) {
+    const heId = await addHyperedge(agentIds, 'swarm-team', taskDescription || `${topology} swarm with ${agentIds.length} agents`, { topology, agentCount: agentIds.length });
+    return { success: heId !== null, hyperedgeId: heId ?? undefined };
+}
+//# sourceMappingURL=graph-backend.js.map

package/v3/@claude-flow/cli/dist/src/ruvector/index.d.ts

@@ -0,0 +1,38 @@
+/**
+ * RuVector Integration Module for Claude Flow 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 @claude-flow/cli/ruvector
+ */
+export { QLearningRouter, createQLearningRouter, type QLearningRouterConfig, type RouteDecision } from './q-learning-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 { LoRAAdapter, getLoRAAdapter, resetLoRAAdapter, createLoRAAdapter, adaptEmbedding, trainLoRA, getLoRAStats, DEFAULT_RANK, DEFAULT_ALPHA, INPUT_DIM as LORA_INPUT_DIM, OUTPUT_DIM as LORA_OUTPUT_DIM, type LoRAConfig, type LoRAWeights, type AdaptationResult, type LoRAStats, } from './lora-adapter.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/v3/@claude-flow/cli/dist/src/ruvector/index.js

@@ -0,0 +1,82 @@
+/**
+ * RuVector Integration Module for Claude Flow 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 @claude-flow/cli/ruvector
+ */
+export { QLearningRouter, createQLearningRouter } from './q-learning-router.js';
+// #1773 item 4 — moe-router migrated to @claude-flow/neural. Direct
+// consumers (hooks-tools.ts) import from '@claude-flow/neural' explicitly;
+// re-exporting through this barrel would force vitest to resolve the
+// neural pkg's transitive @ruvector/sona dep eagerly. Keep imports direct.
+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';
+// #1773 item 4 — flash-attention migrated to @claude-flow/neural. Direct
+// consumers (hooks-tools.ts, neural-tools.ts) import from '@claude-flow/neural'
+// explicitly; re-exporting through this barrel pulls the package's
+// transitive @ruvector/sona dep into vitest's eager resolution.
+export { LoRAAdapter, getLoRAAdapter, resetLoRAAdapter, createLoRAAdapter, adaptEmbedding, trainLoRA, getLoRAStats, DEFAULT_RANK, DEFAULT_ALPHA, INPUT_DIM as LORA_INPUT_DIM, OUTPUT_DIM as LORA_OUTPUT_DIM, } from './lora-adapter.js';
+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/v3/@claude-flow/cli/dist/src/ruvector/lora-adapter.d.ts

@@ -0,0 +1,240 @@
+/**
+ * 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;
+    /** Training backend in use ('ruvllm' | 'js-fallback') */
+    _trainingBackend?: string;
+}
+/**
+ * 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>);
+    /**
+     * Eagerly load the ruvllm TrainingPipeline backend.
+     * Called automatically during first checkpoint operation,
+     * or call explicitly to make getStats() report backend status.
+     */
+    initBackend(): Promise<void>;
+    /**
+     * Get a readonly copy of the adapter configuration
+     */
+    getConfig(): Readonly<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;
+    /**
+     * Save a training checkpoint via ruvllm TrainingPipeline.
+     * Falls back to writing our own weight JSON if ruvllm is unavailable.
+     */
+    saveCheckpoint(path: string): Promise<boolean>;
+    /**
+     * Load a training checkpoint via ruvllm TrainingPipeline.
+     * Falls back to reading our own weight JSON if ruvllm is unavailable.
+     */
+    loadCheckpoint(path: string): Promise<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