moflo 4.8.31 → 4.8.32

package/src/@claude-flow/cli/dist/src/ruvector/enhanced-model-router.d.ts

@@ -1,146 +0,0 @@
-/**
- * Enhanced Model Router with Agent Booster AST Integration
- *
- * Implements ADR-026: 3-tier intelligent model routing:
- * - Tier 1: Agent Booster (WASM) - <1ms, $0 for simple transforms
- * - Tier 2: Haiku - ~500ms for low complexity
- * - Tier 3: Sonnet/Opus - 2-5s for high complexity
- *
- * @module enhanced-model-router
- */
-import { ClaudeModel, ModelRouter } from './model-router.js';
-/**
- * Code editing intent types that Agent Booster can handle
- */
-export type EditIntentType = 'var-to-const' | 'add-types' | 'add-error-handling' | 'async-await' | 'add-logging' | 'remove-console';
-/**
- * Detected edit intent from task analysis
- */
-export interface EditIntent {
-    type: EditIntentType;
-    confidence: number;
-    filePath?: string;
-    language?: string;
-    description: string;
-}
-/**
- * Enhanced routing result with Agent Booster support
- */
-export interface EnhancedRouteResult {
-    tier: 1 | 2 | 3;
-    handler: 'agent-booster' | 'haiku' | 'sonnet' | 'opus';
-    model?: ClaudeModel;
-    confidence: number;
-    complexity?: number;
-    reasoning: string;
-    agentBoosterIntent?: EditIntent;
-    canSkipLLM?: boolean;
-    estimatedLatencyMs: number;
-    estimatedCost: number;
-}
-/**
- * Enhanced model router configuration
- */
-export interface EnhancedModelRouterConfig {
-    agentBoosterEnabled: boolean;
-    agentBoosterConfidenceThreshold: number;
-    enabledIntents: EditIntentType[];
-    complexityThresholds: {
-        haiku: number;
-        sonnet: number;
-        opus: number;
-    };
-    preferCost: boolean;
-    preferQuality: boolean;
-}
-/**
- * Enhanced Model Router with Agent Booster AST integration
- *
- * Provides intelligent 3-tier routing:
- * - Tier 1: Agent Booster for simple code transforms (352x faster, $0)
- * - Tier 2: Haiku for low complexity tasks
- * - Tier 3: Sonnet/Opus for complex reasoning tasks
- */
-export declare class EnhancedModelRouter {
-    private config;
-    private tinyDancerRouter;
-    constructor(config?: Partial<EnhancedModelRouterConfig>);
-    /**
-     * Detect code editing intent from task description
-     */
-    detectIntent(task: string): EditIntent | null;
-    /**
-     * Extract file path from task description
-     */
-    private extractFilePath;
-    /**
-     * Detect language from file extension
-     */
-    private detectLanguage;
-    /**
-     * Check if task contains Tier 3 (Opus) keywords
-     */
-    private containsTier3Keywords;
-    /**
-     * Route a task to the optimal tier and handler
-     */
-    route(task: string, context?: {
-        filePath?: string;
-    }): Promise<EnhancedRouteResult>;
-    /**
-     * Analyze AST complexity of a file
-     * Returns normalized complexity score (0-1)
-     */
-    private analyzeASTComplexity;
-    /**
-     * Execute task using the appropriate tier
-     * Returns the result and routing information
-     */
-    execute(task: string, context?: {
-        filePath?: string;
-        originalCode?: string;
-    }): Promise<{
-        result: string | {
-            applied: boolean;
-            confidence: number;
-        };
-        routeResult: EnhancedRouteResult;
-    }>;
-    /**
-     * Try to apply edit using Agent Booster
-     */
-    private tryAgentBooster;
-    /**
-     * Get router statistics
-     */
-    getStats(): {
-        config: EnhancedModelRouterConfig;
-        tinyDancerStats: ReturnType<ModelRouter['getStats']>;
-    };
-}
-/**
- * Get or create the singleton EnhancedModelRouter instance
- */
-export declare function getEnhancedModelRouter(config?: Partial<EnhancedModelRouterConfig>): EnhancedModelRouter;
-/**
- * Reset the singleton instance
- */
-export declare function resetEnhancedModelRouter(): void;
-/**
- * Create a new EnhancedModelRouter instance (non-singleton)
- */
-export declare function createEnhancedModelRouter(config?: Partial<EnhancedModelRouterConfig>): EnhancedModelRouter;
-/**
- * Quick route function with enhanced routing
- */
-export declare function enhancedRouteToModel(task: string, context?: {
-    filePath?: string;
-}): Promise<EnhancedRouteResult>;
-/**
- * Detect if a task can be handled by Agent Booster
- */
-export declare function canUseAgentBooster(task: string): {
-    canUse: boolean;
-    intent?: EditIntent;
-};
-//# sourceMappingURL=enhanced-model-router.d.ts.map

package/src/@claude-flow/cli/dist/src/ruvector/flash-attention.d.ts

@@ -1,195 +0,0 @@
-/**
- * Flash Attention Implementation for RuVector Intelligence System
- *
- * Implements block-wise attention computation for faster similarity calculations.
- * Achieves O(N) memory instead of O(N^2) through tiling strategy.
- *
- * Key optimizations:
- * - Block-wise computation to fit in L1 cache
- * - Fused softmax-matmul operations
- * - Float32Array for all operations
- * - Online softmax for numerical stability
- *
- * Target: 2-5x speedup on CPU vs naive attention
- *
- * Created with love by motailz.com
- */
-export interface FlashAttentionConfig {
-    /** Block size for tiling (32-64 optimal for CPU L1 cache) */
-    blockSize: number;
-    /** Number of dimensions in embedding vectors */
-    dimensions: number;
-    /** Temperature for softmax scaling */
-    temperature: number;
-    /** Enable numerical stability optimizations */
-    useStableMode: boolean;
-    /** Use optimized CPU path (default: true) */
-    useCPUOptimizations: boolean;
-}
-export interface AttentionResult {
-    /** Output vectors after attention */
-    output: Float32Array[];
-    /** Attention weights (optional, for debugging) */
-    weights?: Float32Array[];
-    /** Computation time in milliseconds */
-    computeTimeMs: number;
-}
-export interface BenchmarkResult {
-    /** Naive attention time in milliseconds */
-    naiveTimeMs: number;
-    /** Flash attention time in milliseconds */
-    flashTimeMs: number;
-    /** Speedup factor (naive / flash) */
-    speedup: number;
-    /** Number of vectors benchmarked */
-    numVectors: number;
-    /** Dimensions of vectors */
-    dimensions: number;
-    /** Memory usage estimate for naive (bytes) */
-    naiveMemoryBytes: number;
-    /** Memory usage estimate for flash (bytes) */
-    flashMemoryBytes: number;
-    /** Memory reduction factor */
-    memoryReduction: number;
-}
-export declare class FlashAttention {
-    private config;
-    private lastSpeedup;
-    private benchmarkHistory;
-    private scoreBuffer;
-    private expBuffer;
-    private accumBuffer;
-    constructor(config?: Partial<FlashAttentionConfig>);
-    /**
-     * Main attention computation using Flash Attention algorithm
-     *
-     * @param queries - Query vectors [N x D]
-     * @param keys - Key vectors [M x D]
-     * @param values - Value vectors [M x D]
-     * @returns Attention output [N x D]
-     */
-    attention(queries: Float32Array[], keys: Float32Array[], values: Float32Array[]): AttentionResult;
-    /**
-     * CPU-optimized attention with aggressive optimizations
-     *
-     * Key optimizations:
-     * - Blocked score computation (better cache utilization)
-     * - Top-K sparse attention (only use most relevant keys)
-     * - Pre-allocated buffers to avoid GC pressure
-     * - 8x loop unrolling for dot products
-     * - Fused max-finding during score computation
-     */
-    private cpuOptimizedAttention;
-    /**
-     * Partial dot product using only first N dimensions (for screening)
-     */
-    private partialDotProduct;
-    /**
-     * Partial sort to get top-K elements (QuickSelect-like)
-     * Only ensures first K elements are the largest, not sorted
-     */
-    private partialSort;
-    /**
-     * Swap two indices in array
-     */
-    private swapIndices;
-    /**
-     * Fast dot product with 8x unrolling
-     */
-    private fastDotProduct;
-    /**
-     * Block-wise attention computation (Flash Attention core algorithm)
-     *
-     * Algorithm:
-     * For each block of queries Q_b:
-     *   For each block of keys K_b:
-     *     S_b = Q_b @ K_b.T / sqrt(d)  // Block scores
-     *     P_b = softmax(S_b)           // Block attention
-     *     O_b += P_b @ V_b             // Accumulate output
-     *
-     * @param Q - Query vectors
-     * @param K - Key vectors
-     * @param V - Value vectors
-     * @param blockSize - Block size for tiling
-     */
-    blockAttention(Q: Float32Array[], K: Float32Array[], V: Float32Array[], blockSize: number): Float32Array[];
-    /**
-     * Get the speedup factor from the last benchmark
-     */
-    getSpeedup(): number;
-    /**
-     * Run benchmark comparing naive vs CPU-optimized attention
-     *
-     * @param numVectors - Number of vectors to test
-     * @param dimensions - Dimensions per vector
-     * @param iterations - Number of iterations for averaging
-     */
-    benchmark(numVectors?: number, dimensions?: number, iterations?: number): BenchmarkResult;
-    /**
-     * Get benchmark history
-     */
-    getBenchmarkHistory(): BenchmarkResult[];
-    /**
-     * Get configuration
-     */
-    getConfig(): FlashAttentionConfig;
-    /**
-     * Update configuration
-     */
-    setConfig(config: Partial<FlashAttentionConfig>): void;
-    /**
-     * Naive O(N^2) attention implementation for comparison
-     */
-    private naiveAttention;
-    /**
-     * Compute block of attention scores
-     */
-    private computeBlockScores;
-    /**
-     * Online softmax with output accumulation (key to Flash Attention)
-     *
-     * Uses the online softmax trick to maintain numerical stability
-     * while processing blocks incrementally.
-     */
-    private onlineSoftmaxAccumulate;
-    /**
-     * Compute dot product of two vectors
-     */
-    private dotProduct;
-    /**
-     * Stable softmax implementation
-     */
-    private softmax;
-    /**
-     * Generate random vectors for benchmarking
-     */
-    private generateRandomVectors;
-    /**
-     * Validate input arrays
-     */
-    private validateInputs;
-}
-/**
- * Get singleton FlashAttention instance
- *
- * @param config - Optional configuration (only used on first call)
- * @returns FlashAttention instance
- */
-export declare function getFlashAttention(config?: Partial<FlashAttentionConfig>): FlashAttention;
-/**
- * Reset singleton (for testing)
- */
-export declare function resetFlashAttention(): void;
-/**
- * Compute attention using Flash Attention
- */
-export declare function computeAttention(queries: Float32Array[], keys: Float32Array[], values: Float32Array[], config?: Partial<FlashAttentionConfig>): AttentionResult;
-/**
- * Run Flash Attention benchmark
- */
-export declare function benchmarkFlashAttention(numVectors?: number, dimensions?: number, iterations?: number): BenchmarkResult;
-/**
- * Get current speedup from last benchmark
- */
-export declare function getFlashAttentionSpeedup(): number;
-//# sourceMappingURL=flash-attention.d.ts.map

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

@@ -1,187 +0,0 @@
-/**
- * Graph Analyzer Module
- *
- * Provides code dependency graph analysis using ruvector's graph algorithms:
- * - MinCut for code boundary detection (refactoring suggestions)
- * - Louvain for module/community detection
- * - Circular dependency detection
- * - DOT format export for visualization
- *
- * Falls back to built-in implementations when @ruvector/wasm is not available.
- *
- * @module @claude-flow/cli/ruvector/graph-analyzer
- */
-/**
- * Clear all graph caches
- */
-export declare function clearGraphCaches(): void;
-/**
- * Get cache statistics
- */
-export declare function getGraphCacheStats(): {
-    graphCacheSize: number;
-    analysisCacheSize: number;
-};
-/**
- * Node in the dependency graph
- */
-export interface GraphNode {
-    id: string;
-    path: string;
-    name: string;
-    type: 'file' | 'module' | 'package';
-    imports: string[];
-    exports: string[];
-    size: number;
-    complexity?: number;
-}
-/**
- * Edge in the dependency graph
- */
-export interface GraphEdge {
-    source: string;
-    target: string;
-    type: 'import' | 'require' | 'dynamic' | 're-export';
-    weight: number;
-}
-/**
- * Dependency graph representation
- */
-export interface DependencyGraph {
-    nodes: Map<string, GraphNode>;
-    edges: GraphEdge[];
-    metadata: {
-        rootDir: string;
-        totalFiles: number;
-        totalEdges: number;
-        buildTime: number;
-    };
-}
-/**
- * MinCut result representing a natural boundary in the codebase
- */
-export interface MinCutBoundary {
-    cutValue: number;
-    partition1: string[];
-    partition2: string[];
-    cutEdges: GraphEdge[];
-    suggestion: string;
-}
-/**
- * Community/module detection result
- */
-export interface ModuleCommunity {
-    id: number;
-    members: string[];
-    cohesion: number;
-    centralNode?: string;
-    suggestedName?: string;
-}
-/**
- * Circular dependency info
- */
-export interface CircularDependency {
-    cycle: string[];
-    severity: 'low' | 'medium' | 'high';
-    suggestion: string;
-}
-/**
- * Analysis result
- */
-export interface GraphAnalysisResult {
-    graph: DependencyGraph;
-    boundaries?: MinCutBoundary[];
-    communities?: ModuleCommunity[];
-    circularDependencies: CircularDependency[];
-    statistics: {
-        nodeCount: number;
-        edgeCount: number;
-        avgDegree: number;
-        maxDegree: number;
-        density: number;
-        componentCount: number;
-    };
-}
-/**
- * Interface for ruvector graph operations
- */
-interface IRuVectorGraph {
-    mincut(nodes: string[], edges: Array<[string, string, number]>): {
-        cutValue: number;
-        partition1: string[];
-        partition2: string[];
-        cutEdges: Array<[string, string]>;
-    };
-    louvain(nodes: string[], edges: Array<[string, string, number]>): {
-        communities: Array<{
-            id: number;
-            members: string[];
-        }>;
-        modularity: number;
-    };
-}
-/**
- * Attempt to load ruvector graph algorithms
- */
-declare function loadRuVector(): Promise<IRuVectorGraph | null>;
-/**
- * Build dependency graph from source directory (with caching)
- */
-export declare function buildDependencyGraph(rootDir: string, options?: {
-    include?: string[];
-    exclude?: string[];
-    maxDepth?: number;
-    skipCache?: boolean;
-}): Promise<DependencyGraph>;
-/**
- * Stoer-Wagner MinCut algorithm (fallback when ruvector not available)
- * Finds minimum cut with deterministic result
- */
-declare function fallbackMinCut(nodes: string[], edges: Array<[string, string, number]>): {
-    cutValue: number;
-    partition1: string[];
-    partition2: string[];
-    cutEdges: Array<[string, string]>;
-};
-/**
- * Louvain community detection algorithm (fallback when ruvector not available)
- * Greedy modularity optimization
- */
-declare function fallbackLouvain(nodes: string[], edges: Array<[string, string, number]>): {
-    communities: Array<{
-        id: number;
-        members: string[];
-    }>;
-    modularity: number;
-};
-/**
- * Detect circular dependencies using DFS
- */
-export declare function detectCircularDependencies(graph: DependencyGraph): CircularDependency[];
-/**
- * Analyze graph boundaries using MinCut algorithm
- */
-export declare function analyzeMinCutBoundaries(graph: DependencyGraph, numPartitions?: number): Promise<MinCutBoundary[]>;
-/**
- * Analyze module communities using Louvain algorithm
- */
-export declare function analyzeModuleCommunities(graph: DependencyGraph): Promise<ModuleCommunity[]>;
-/**
- * Full graph analysis (with caching)
- */
-export declare function analyzeGraph(rootDir: string, options?: {
-    includeBoundaries?: boolean;
-    includeModules?: boolean;
-    numPartitions?: number;
-    skipCache?: boolean;
-}): Promise<GraphAnalysisResult>;
-/**
- * Export graph to DOT format for visualization
- */
-export declare function exportToDot(result: GraphAnalysisResult, options?: {
-    includeLabels?: boolean;
-    colorByCommunity?: boolean;
-    highlightCycles?: boolean;
-}): string;
-export { loadRuVector, fallbackMinCut, fallbackLouvain, };
-//# sourceMappingURL=graph-analyzer.d.ts.map

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

@@ -1,34 +0,0 @@
-/**
- * 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 { 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 { 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';
-/**
- * Check if ruvector packages are available
- */
-export declare function isRuvectorAvailable(): Promise<boolean>;
-/**
- * Get ruvector version if available
- */
-export declare function getRuvectorVersion(): Promise<string | null>;
-//# sourceMappingURL=index.d.ts.map