kynjal-cli 3.1.3 → 4.0.0

package/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 ruv.io
- */
-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/dist/src/ruvector/flash-attention.d.ts.map

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

package/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/dist/src/ruvector/graph-analyzer.d.ts.map

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

package/dist/src/ruvector/index.d.ts

@@ -1,34 +0,0 @@
-/**
- * RuVector Integration Module for KynjalFlow 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

package/dist/src/ruvector/index.d.ts.map

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

package/dist/src/ruvector/lora-adapter.d.ts

@@ -1,218 +0,0 @@
-/**
- * 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

package/dist/src/ruvector/lora-adapter.d.ts.map

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