@claude-flow/cli 3.0.0-alpha.174 → 3.0.0-alpha.176

package/dist/src/services/registry-api.js

@@ -0,0 +1,146 @@
+/**
+ * Registry API Client
+ * Secure integration with Claude Flow Cloud Functions
+ *
+ * Security:
+ * - HTTPS only
+ * - No credentials stored in code
+ * - Rate limiting respected
+ * - Input validation
+ */
+const REGISTRY_API_URL = 'https://us-central1-claude-flow.cloudfunctions.net/publish-registry';
+/**
+ * Validate item ID to prevent injection
+ */
+function validateItemId(itemId) {
+    // Only allow alphanumeric, @, /, -, _
+    return /^[@a-zA-Z0-9\/_-]+$/.test(itemId) && itemId.length < 100;
+}
+/**
+ * Validate rating value
+ */
+function validateRating(rating) {
+    return Number.isInteger(rating) && rating >= 1 && rating <= 5;
+}
+/**
+ * Rate a plugin or model
+ */
+export async function rateItem(itemId, rating, itemType = 'plugin', userId) {
+    if (!validateItemId(itemId)) {
+        throw new Error('Invalid item ID');
+    }
+    if (!validateRating(rating)) {
+        throw new Error('Rating must be integer 1-5');
+    }
+    const response = await fetch(`${REGISTRY_API_URL}?action=rate`, {
+        method: 'POST',
+        headers: { 'Content-Type': 'application/json' },
+        body: JSON.stringify({
+            itemId,
+            rating,
+            itemType,
+            ...(userId && { userId }),
+        }),
+        signal: AbortSignal.timeout(10000),
+    });
+    if (!response.ok) {
+        const error = await response.text();
+        throw new Error(`Rating failed: ${error}`);
+    }
+    return response.json();
+}
+/**
+ * Get ratings for a single item
+ */
+export async function getRating(itemId, itemType = 'plugin') {
+    if (!validateItemId(itemId)) {
+        throw new Error('Invalid item ID');
+    }
+    const params = new URLSearchParams({
+        action: 'get-ratings',
+        itemId,
+        itemType,
+    });
+    const response = await fetch(`${REGISTRY_API_URL}?${params}`, {
+        signal: AbortSignal.timeout(10000),
+    });
+    if (!response.ok) {
+        throw new Error('Failed to get ratings');
+    }
+    return response.json();
+}
+/**
+ * Get ratings for multiple items (batch)
+ */
+export async function getBulkRatings(itemIds, itemType = 'plugin') {
+    // Validate all IDs
+    for (const id of itemIds) {
+        if (!validateItemId(id)) {
+            throw new Error(`Invalid item ID: ${id}`);
+        }
+    }
+    // Limit batch size
+    const limitedIds = itemIds.slice(0, 50);
+    const response = await fetch(`${REGISTRY_API_URL}?action=bulk-ratings`, {
+        method: 'POST',
+        headers: { 'Content-Type': 'application/json' },
+        body: JSON.stringify({
+            itemIds: limitedIds,
+            itemType,
+        }),
+        signal: AbortSignal.timeout(15000),
+    });
+    if (!response.ok) {
+        throw new Error('Failed to get bulk ratings');
+    }
+    return response.json();
+}
+/**
+ * Get analytics data
+ */
+export async function getAnalytics() {
+    const response = await fetch(`${REGISTRY_API_URL}?action=analytics`, {
+        signal: AbortSignal.timeout(10000),
+    });
+    if (!response.ok) {
+        throw new Error('Failed to get analytics');
+    }
+    return response.json();
+}
+/**
+ * Track a download event
+ */
+export async function trackDownload(pluginId) {
+    if (!validateItemId(pluginId)) {
+        return; // Silently fail for invalid IDs
+    }
+    try {
+        await fetch(`${REGISTRY_API_URL}?action=track-download`, {
+            method: 'POST',
+            headers: { 'Content-Type': 'application/json' },
+            body: JSON.stringify({ pluginId }),
+            signal: AbortSignal.timeout(5000),
+        });
+    }
+    catch {
+        // Non-critical, don't throw
+    }
+}
+/**
+ * Check API health
+ */
+export async function checkHealth() {
+    try {
+        const response = await fetch(`${REGISTRY_API_URL}?action=status`, {
+            signal: AbortSignal.timeout(5000),
+        });
+        return response.json();
+    }
+    catch (error) {
+        return {
+            healthy: false,
+            error: error instanceof Error ? error.message : 'Unknown error',
+        };
+    }
+}
+//# sourceMappingURL=registry-api.js.map

package/dist/src/services/registry-api.js.map

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

package/dist/src/services/ruvector-training.d.ts

@@ -0,0 +1,170 @@
+/**
+ * RuVector Training Service
+ * Real WASM-accelerated neural training using @ruvector packages
+ *
+ * Features:
+ * - MicroLoRA: <100µs adaptation with rank-2 LoRA
+ * - Flash Attention: 2.49x-7.47x speedup
+ * - Trajectory Buffer: Learning from success/failure
+ * - Contrastive Learning: InfoNCE loss
+ *
+ * Created with ❤️ by ruv.io
+ */
+import type { BenchmarkResult } from '@ruvector/attention';
+export interface TrainingConfig {
+    dim?: number;
+    learningRate?: number;
+    alpha?: number;
+    trajectoryCapacity?: number;
+    useFlashAttention?: boolean;
+    useMoE?: boolean;
+    useHyperbolic?: boolean;
+    totalSteps?: number;
+    warmupSteps?: number;
+}
+export interface TrainingResult {
+    success: boolean;
+    adaptationCount: bigint;
+    forwardCount: bigint;
+    deltaNorm: number;
+    trajectoryStats?: {
+        successRate: number;
+        meanImprovement: number;
+        bestImprovement: number;
+        totalCount: bigint;
+    };
+    benchmark?: BenchmarkResult[];
+}
+/**
+ * Initialize the RuVector training system
+ */
+export declare function initializeTraining(config?: TrainingConfig): Promise<{
+    success: boolean;
+    features: string[];
+    error?: string;
+}>;
+/**
+ * Operator types for scoped LoRA (0-16)
+ */
+export declare const OperatorType: {
+    readonly GENERAL: 0;
+    readonly ATTENTION: 1;
+    readonly MLP: 2;
+    readonly EMBEDDING: 3;
+    readonly NORMALIZATION: 4;
+    readonly PROJECTION: 5;
+    readonly POOLING: 6;
+    readonly CONVOLUTION: 7;
+    readonly RECURRENT: 8;
+    readonly ROUTING: 9;
+    readonly MEMORY: 10;
+    readonly REASONING: 11;
+    readonly COORDINATION: 12;
+    readonly OPTIMIZATION: 13;
+    readonly SECURITY: 14;
+    readonly TESTING: 15;
+    readonly DEBUGGING: 16;
+};
+/**
+ * Train a pattern with MicroLoRA
+ */
+export declare function trainPattern(embedding: Float32Array, gradient: Float32Array, operatorType?: number): Promise<{
+    deltaNorm: number;
+    adaptCount: bigint;
+}>;
+/**
+ * Forward pass through LoRA
+ */
+export declare function forward(input: Float32Array, operatorType?: number): Float32Array;
+/**
+ * Reward-based adaptation (reinforcement learning)
+ */
+export declare function adaptWithReward(improvement: number, operatorType?: number): void;
+/**
+ * Record a learning trajectory
+ */
+export declare function recordTrajectory(embedding: Float32Array, operatorType: number, attentionType: number, executionMs: number, baselineMs: number): void;
+/**
+ * Get trajectory statistics
+ */
+export declare function getTrajectoryStats(): {
+    successRate: number;
+    meanImprovement: number;
+    bestImprovement: number;
+    totalCount: bigint;
+    highQualityCount: number;
+    variance: number;
+} | null;
+/**
+ * Compute attention with Flash Attention (2.49x-7.47x faster)
+ */
+export declare function computeFlashAttention(query: Float32Array, keys: Float32Array[], values: Float32Array[]): Float32Array;
+/**
+ * Compute MoE routing
+ */
+export declare function computeMoEAttention(query: Float32Array, keys: Float32Array[], values: Float32Array[]): Float32Array;
+/**
+ * Compute hyperbolic attention (for hierarchical patterns)
+ */
+export declare function computeHyperbolicAttention(query: Float32Array, keys: Float32Array[], values: Float32Array[]): Float32Array;
+/**
+ * Compute contrastive loss for training
+ */
+export declare function computeContrastiveLoss(anchor: Float32Array, positives: Float32Array[], negatives: Float32Array[]): {
+    loss: number;
+    gradient: Float32Array;
+};
+/**
+ * Optimizer step
+ */
+export declare function optimizerStep(params: Float32Array, gradients: Float32Array): Float32Array;
+/**
+ * Get curriculum difficulty for current step
+ */
+export declare function getCurriculumDifficulty(step: number): number;
+/**
+ * Mine hard negatives for better training
+ */
+export declare function mineHardNegatives(anchor: Float32Array, candidates: Float32Array[]): number[];
+/**
+ * Benchmark the training system
+ */
+export declare function benchmarkTraining(dim?: number, iterations?: number): Promise<BenchmarkResult[]>;
+/**
+ * Get training statistics
+ */
+export declare function getTrainingStats(): {
+    initialized: boolean;
+    totalAdaptations: number;
+    totalForwards: number;
+    microLoraStats?: {
+        paramCount: number;
+        adaptCount: bigint;
+        forwardCount: bigint;
+        deltaNorm: number;
+    };
+    scopedLoraStats?: {
+        totalAdaptCount: bigint;
+        totalForwardCount: bigint;
+    };
+    trajectoryStats?: ReturnType<typeof getTrajectoryStats>;
+    lastBenchmark?: BenchmarkResult[];
+};
+/**
+ * Reset the training system
+ */
+export declare function resetTraining(): void;
+/**
+ * Export trained weights
+ */
+export declare function exportWeights(): {
+    dim: number;
+    deltaNorm: number;
+    adaptCount: bigint;
+    trajectoryStats: ReturnType<typeof getTrajectoryStats>;
+} | null;
+/**
+ * Cleanup resources
+ */
+export declare function cleanup(): void;
+//# sourceMappingURL=ruvector-training.d.ts.map

package/dist/src/services/ruvector-training.d.ts.map

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

package/dist/src/services/ruvector-training.js

@@ -0,0 +1,357 @@
+/**
+ * RuVector Training Service
+ * Real WASM-accelerated neural training using @ruvector packages
+ *
+ * Features:
+ * - MicroLoRA: <100µs adaptation with rank-2 LoRA
+ * - Flash Attention: 2.49x-7.47x speedup
+ * - Trajectory Buffer: Learning from success/failure
+ * - Contrastive Learning: InfoNCE loss
+ *
+ * Created with ❤️ by ruv.io
+ */
+// Lazy-loaded WASM modules
+let microLoRA = null;
+let scopedLoRA = null;
+let trajectoryBuffer = null;
+let flashAttention = null;
+let moeAttention = null;
+let hyperbolicAttention = null;
+let optimizer = null;
+let contrastiveLoss = null;
+let curriculum = null;
+let hardMiner = null;
+// Training state
+let initialized = false;
+let totalAdaptations = 0;
+let totalForwards = 0;
+let lastBenchmark = null;
+/**
+ * Initialize the RuVector training system
+ */
+export async function initializeTraining(config = {}) {
+    const features = [];
+    const dim = Math.min(config.dim || 256, 256); // Max 256 for WASM
+    const lr = config.learningRate || 0.01;
+    const alpha = config.alpha || 0.1;
+    try {
+        // Initialize MicroLoRA with direct WASM loading (Node.js compatible)
+        const fs = await import('fs');
+        const { createRequire } = await import('module');
+        const require = createRequire(import.meta.url);
+        // Load WASM file directly instead of using fetch
+        const wasmPath = require.resolve('@ruvector/learning-wasm/ruvector_learning_wasm_bg.wasm');
+        const wasmBuffer = fs.readFileSync(wasmPath);
+        const learningWasm = await import('@ruvector/learning-wasm');
+        learningWasm.initSync({ module: wasmBuffer });
+        microLoRA = new learningWasm.WasmMicroLoRA(dim, alpha, lr);
+        features.push(`MicroLoRA (${dim}-dim, <1μs adaptation)`);
+        // Initialize ScopedLoRA for per-operator learning
+        scopedLoRA = new learningWasm.WasmScopedLoRA(dim, alpha, lr);
+        scopedLoRA.set_category_fallback(true);
+        features.push('ScopedLoRA (17 operators)');
+        // Initialize trajectory buffer
+        trajectoryBuffer = new learningWasm.WasmTrajectoryBuffer(config.trajectoryCapacity || 10000, dim);
+        features.push('TrajectoryBuffer');
+        // Initialize attention mechanisms
+        const attention = await import('@ruvector/attention');
+        if (config.useFlashAttention !== false) {
+            flashAttention = new attention.FlashAttention(dim, 64);
+            features.push('FlashAttention');
+        }
+        if (config.useMoE) {
+            moeAttention = attention.MoEAttention.simple(dim, 8, 2);
+            features.push('MoE (8 experts, top-2)');
+        }
+        if (config.useHyperbolic) {
+            hyperbolicAttention = new attention.HyperbolicAttention(dim, 1.0);
+            features.push('HyperbolicAttention');
+        }
+        // Initialize optimizer and loss
+        optimizer = new attention.AdamWOptimizer(lr, 0.9, 0.999, 1e-8, 0.01);
+        features.push('AdamW Optimizer');
+        contrastiveLoss = new attention.InfoNceLoss(0.07);
+        features.push('InfoNCE Loss');
+        // Curriculum scheduler
+        if (config.totalSteps) {
+            curriculum = new attention.CurriculumScheduler(config.totalSteps, config.warmupSteps || Math.floor(config.totalSteps * 0.1));
+            features.push('Curriculum Learning');
+        }
+        // Hard negative mining - use string for MiningStrategy enum due to NAPI binding quirk
+        try {
+            // @ts-expect-error - MiningStrategy enum binding expects string not enum value
+            hardMiner = new attention.HardNegativeMiner(5, 'semi_hard');
+            features.push('Hard Negative Mining');
+        }
+        catch {
+            // Mining not available, continue without it
+        }
+        initialized = true;
+        return { success: true, features };
+    }
+    catch (error) {
+        return {
+            success: false,
+            features,
+            error: error instanceof Error ? error.message : String(error),
+        };
+    }
+}
+/**
+ * Operator types for scoped LoRA (0-16)
+ */
+export const OperatorType = {
+    GENERAL: 0,
+    ATTENTION: 1,
+    MLP: 2,
+    EMBEDDING: 3,
+    NORMALIZATION: 4,
+    PROJECTION: 5,
+    POOLING: 6,
+    CONVOLUTION: 7,
+    RECURRENT: 8,
+    ROUTING: 9,
+    MEMORY: 10,
+    REASONING: 11,
+    COORDINATION: 12,
+    OPTIMIZATION: 13,
+    SECURITY: 14,
+    TESTING: 15,
+    DEBUGGING: 16,
+};
+/**
+ * Train a pattern with MicroLoRA
+ */
+export async function trainPattern(embedding, gradient, operatorType) {
+    if (!initialized || !microLoRA) {
+        throw new Error('Training system not initialized');
+    }
+    // Use scoped LoRA if operator type specified
+    if (operatorType !== undefined && scopedLoRA) {
+        scopedLoRA.adapt_array(operatorType, gradient);
+        return {
+            deltaNorm: scopedLoRA.delta_norm(operatorType),
+            adaptCount: scopedLoRA.adapt_count(operatorType),
+        };
+    }
+    // Standard MicroLoRA adaptation
+    microLoRA.adapt_array(gradient);
+    totalAdaptations++;
+    return {
+        deltaNorm: microLoRA.delta_norm(),
+        adaptCount: microLoRA.adapt_count(),
+    };
+}
+/**
+ * Forward pass through LoRA
+ */
+export function forward(input, operatorType) {
+    if (!initialized || !microLoRA) {
+        throw new Error('Training system not initialized');
+    }
+    totalForwards++;
+    if (operatorType !== undefined && scopedLoRA) {
+        return scopedLoRA.forward_array(operatorType, input);
+    }
+    return microLoRA.forward_array(input);
+}
+/**
+ * Reward-based adaptation (reinforcement learning)
+ */
+export function adaptWithReward(improvement, operatorType) {
+    if (!initialized) {
+        throw new Error('Training system not initialized');
+    }
+    if (operatorType !== undefined && scopedLoRA) {
+        scopedLoRA.adapt_with_reward(operatorType, improvement);
+    }
+    else if (microLoRA) {
+        microLoRA.adapt_with_reward(improvement);
+    }
+    totalAdaptations++;
+}
+/**
+ * Record a learning trajectory
+ */
+export function recordTrajectory(embedding, operatorType, attentionType, executionMs, baselineMs) {
+    if (!trajectoryBuffer) {
+        throw new Error('Trajectory buffer not initialized');
+    }
+    trajectoryBuffer.record(embedding, operatorType, attentionType, executionMs, baselineMs);
+}
+/**
+ * Get trajectory statistics
+ */
+export function getTrajectoryStats() {
+    if (!trajectoryBuffer || trajectoryBuffer.is_empty()) {
+        return null;
+    }
+    return {
+        successRate: trajectoryBuffer.success_rate(),
+        meanImprovement: trajectoryBuffer.mean_improvement(),
+        bestImprovement: trajectoryBuffer.best_improvement(),
+        totalCount: trajectoryBuffer.total_count(),
+        highQualityCount: trajectoryBuffer.high_quality_count(0.1),
+        variance: trajectoryBuffer.variance(),
+    };
+}
+/**
+ * Compute attention with Flash Attention (2.49x-7.47x faster)
+ */
+export function computeFlashAttention(query, keys, values) {
+    if (!flashAttention) {
+        throw new Error('Flash attention not initialized');
+    }
+    return flashAttention.computeRaw(query, keys, values);
+}
+/**
+ * Compute MoE routing
+ */
+export function computeMoEAttention(query, keys, values) {
+    if (!moeAttention) {
+        throw new Error('MoE attention not initialized');
+    }
+    return moeAttention.computeRaw(query, keys, values);
+}
+/**
+ * Compute hyperbolic attention (for hierarchical patterns)
+ */
+export function computeHyperbolicAttention(query, keys, values) {
+    if (!hyperbolicAttention) {
+        throw new Error('Hyperbolic attention not initialized');
+    }
+    return hyperbolicAttention.computeRaw(query, keys, values);
+}
+/**
+ * Compute contrastive loss for training
+ */
+export function computeContrastiveLoss(anchor, positives, negatives) {
+    if (!contrastiveLoss) {
+        throw new Error('Contrastive loss not initialized');
+    }
+    const loss = contrastiveLoss.compute(anchor, positives, negatives);
+    const gradient = contrastiveLoss.backward(anchor, positives, negatives);
+    return { loss, gradient };
+}
+/**
+ * Optimizer step
+ */
+export function optimizerStep(params, gradients) {
+    if (!optimizer) {
+        throw new Error('Optimizer not initialized');
+    }
+    return optimizer.step(params, gradients);
+}
+/**
+ * Get curriculum difficulty for current step
+ */
+export function getCurriculumDifficulty(step) {
+    if (!curriculum) {
+        return 1.0; // Full difficulty if no curriculum
+    }
+    return curriculum.getDifficulty(step);
+}
+/**
+ * Mine hard negatives for better training
+ */
+export function mineHardNegatives(anchor, candidates) {
+    if (!hardMiner) {
+        throw new Error('Hard negative miner not initialized');
+    }
+    return hardMiner.mine(anchor, candidates);
+}
+/**
+ * Benchmark the training system
+ */
+export async function benchmarkTraining(dim, iterations) {
+    const attention = await import('@ruvector/attention');
+    lastBenchmark = attention.benchmarkAttention(dim || 256, 100, iterations || 1000);
+    return lastBenchmark;
+}
+/**
+ * Get training statistics
+ */
+export function getTrainingStats() {
+    const stats = {
+        initialized,
+        totalAdaptations,
+        totalForwards,
+    };
+    if (microLoRA) {
+        stats.microLoraStats = {
+            paramCount: microLoRA.param_count(),
+            adaptCount: microLoRA.adapt_count(),
+            forwardCount: microLoRA.forward_count(),
+            deltaNorm: microLoRA.delta_norm(),
+        };
+    }
+    if (scopedLoRA) {
+        stats.scopedLoraStats = {
+            totalAdaptCount: scopedLoRA.total_adapt_count(),
+            totalForwardCount: scopedLoRA.total_forward_count(),
+        };
+    }
+    if (trajectoryBuffer && !trajectoryBuffer.is_empty()) {
+        stats.trajectoryStats = getTrajectoryStats();
+    }
+    if (lastBenchmark) {
+        stats.lastBenchmark = lastBenchmark;
+    }
+    return stats;
+}
+/**
+ * Reset the training system
+ */
+export function resetTraining() {
+    if (microLoRA)
+        microLoRA.reset();
+    if (scopedLoRA)
+        scopedLoRA.reset_all();
+    if (trajectoryBuffer)
+        trajectoryBuffer.reset();
+    totalAdaptations = 0;
+    totalForwards = 0;
+}
+/**
+ * Export trained weights
+ */
+export function exportWeights() {
+    if (!initialized || !microLoRA) {
+        return null;
+    }
+    return {
+        dim: microLoRA.dim(),
+        deltaNorm: microLoRA.delta_norm(),
+        adaptCount: microLoRA.adapt_count(),
+        trajectoryStats: getTrajectoryStats(),
+    };
+}
+/**
+ * Cleanup resources
+ */
+export function cleanup() {
+    if (microLoRA) {
+        microLoRA.free();
+        microLoRA = null;
+    }
+    if (scopedLoRA) {
+        scopedLoRA.free();
+        scopedLoRA = null;
+    }
+    if (trajectoryBuffer) {
+        trajectoryBuffer.free();
+        trajectoryBuffer = null;
+    }
+    flashAttention = null;
+    moeAttention = null;
+    hyperbolicAttention = null;
+    optimizer = null;
+    contrastiveLoss = null;
+    curriculum = null;
+    hardMiner = null;
+    initialized = false;
+    totalAdaptations = 0;
+    totalForwards = 0;
+    lastBenchmark = null;
+}
+//# sourceMappingURL=ruvector-training.js.map