monomind 1.10.0 → 1.10.2

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

@@ -0,0 +1,13 @@
+/**
+ * CLI Services Index
+ * Central registry for all background services
+ */
+export { WorkerDaemon, getDaemon, startDaemon, stopDaemon, type WorkerType, } from './worker-daemon.js';
+export { HeadlessWorkerExecutor, HEADLESS_WORKER_TYPES, HEADLESS_WORKER_CONFIGS, LOCAL_WORKER_TYPES, LOCAL_WORKER_CONFIGS, ALL_WORKER_CONFIGS, isHeadlessWorker, isLocalWorker, getModelId, getWorkerConfig, type HeadlessWorkerType, type LocalWorkerType, type HeadlessWorkerConfig, type HeadlessExecutionResult, type HeadlessExecutorConfig, type HeadlessOptions, type PoolStatus, type SandboxMode, type ModelType, type OutputFormat, type ExecutionMode, type WorkerPriority, type WorkerConfig, } from './headless-worker-executor.js';
+export { ContainerWorkerPool, type ContainerInfo, type ContainerPoolConfig, type ContainerExecutionOptions, type ContainerPoolStatus, type ContainerState, } from './container-worker-pool.js';
+export { WorkerQueue, type QueueTask, type WorkerQueueConfig, type QueueStats, type WorkerRegistration, type TaskStatus, } from './worker-queue.js';
+export type { default as WorkerDaemonType, DaemonConfig } from './worker-daemon.js';
+export type { default as HeadlessWorkerExecutorType } from './headless-worker-executor.js';
+export type { default as ContainerWorkerPoolType } from './container-worker-pool.js';
+export type { default as WorkerQueueType } from './worker-queue.js';
+//# sourceMappingURL=index.d.ts.map

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

@@ -0,0 +1,11 @@
+/**
+ * CLI Services Index
+ * Central registry for all background services
+ */
+export { WorkerDaemon, getDaemon, startDaemon, stopDaemon, } from './worker-daemon.js';
+export { HeadlessWorkerExecutor, HEADLESS_WORKER_TYPES, HEADLESS_WORKER_CONFIGS, LOCAL_WORKER_TYPES, LOCAL_WORKER_CONFIGS, ALL_WORKER_CONFIGS, isHeadlessWorker, isLocalWorker, getModelId, getWorkerConfig, } from './headless-worker-executor.js';
+// Container Worker Pool (Phase 3)
+export { ContainerWorkerPool, } from './container-worker-pool.js';
+// Worker Queue (Phase 4)
+export { WorkerQueue, } from './worker-queue.js';
+//# sourceMappingURL=index.js.map

package/packages/@monomind/cli/dist/src/services/registry-api.d.ts

@@ -0,0 +1,58 @@
+/**
+ * Registry API Client
+ * Secure integration with Monomind Cloud Functions
+ *
+ * Security:
+ * - HTTPS only
+ * - No credentials stored in code
+ * - Rate limiting respected
+ * - Input validation
+ */
+export interface RatingResponse {
+    success: boolean;
+    itemId: string;
+    average: number;
+    count: number;
+    error?: string;
+}
+export interface BulkRatingsResponse {
+    [itemId: string]: {
+        average: number;
+        count: number;
+    };
+}
+export interface AnalyticsResponse {
+    downloads: Record<string, number>;
+    exports: number;
+    imports: number;
+    publishes: number;
+}
+/**
+ * Rate a plugin or model
+ */
+export declare function rateItem(itemId: string, rating: number, itemType?: 'plugin' | 'model', userId?: string): Promise<RatingResponse>;
+/**
+ * Get ratings for a single item
+ */
+export declare function getRating(itemId: string, itemType?: 'plugin' | 'model'): Promise<RatingResponse>;
+/**
+ * Get ratings for multiple items (batch)
+ */
+export declare function getBulkRatings(itemIds: string[], itemType?: 'plugin' | 'model'): Promise<BulkRatingsResponse>;
+/**
+ * Get analytics data
+ */
+export declare function getAnalytics(): Promise<AnalyticsResponse>;
+/**
+ * Track a download event
+ */
+export declare function trackDownload(pluginId: string): Promise<void>;
+/**
+ * Check API health
+ */
+export declare function checkHealth(): Promise<{
+    healthy: boolean;
+    latestCid?: string;
+    error?: string;
+}>;
+//# sourceMappingURL=registry-api.d.ts.map

package/packages/@monomind/cli/dist/src/services/registry-api.js

@@ -0,0 +1,199 @@
+/**
+ * Registry API Client
+ * Secure integration with Monomind Cloud Functions
+ *
+ * Security:
+ * - HTTPS only
+ * - No credentials stored in code
+ * - Rate limiting respected
+ * - Input validation
+ */
+const REGISTRY_API_URL = 'https://us-central1-monomind.cloudfunctions.net/publish-registry';
+/**
+ * Read a fetch response body with a hard byte cap. AbortSignal.timeout bounds
+ * time, NOT bytes — a hijacked endpoint or MITM (TLS without pinning) can
+ * stream a multi-GB body that the CLI buffers into memory and OOMs. Cap the
+ * read here so all downstream JSON.parse / .text() calls are bounded.
+ */
+async function readBoundedText(response, maxBytes) {
+    const lenHdr = response.headers.get('content-length');
+    if (lenHdr) {
+        const declared = parseInt(lenHdr, 10);
+        if (Number.isFinite(declared) && declared > maxBytes) {
+            throw new Error(`Response too large: ${declared} bytes (max ${maxBytes})`);
+        }
+    }
+    if (!response.body)
+        return '';
+    const reader = response.body.getReader();
+    const chunks = [];
+    let total = 0;
+    while (true) {
+        const { done, value } = await reader.read();
+        if (done)
+            break;
+        if (value) {
+            total += value.byteLength;
+            if (total > maxBytes) {
+                await reader.cancel();
+                throw new Error(`Response too large: exceeded ${maxBytes} bytes`);
+            }
+            chunks.push(value);
+        }
+    }
+    const buf = new Uint8Array(total);
+    let off = 0;
+    for (const c of chunks) {
+        buf.set(c, off);
+        off += c.byteLength;
+    }
+    return new TextDecoder('utf-8').decode(buf);
+}
+async function readBoundedJson(response, maxBytes = 1_048_576) {
+    const text = await readBoundedText(response, maxBytes);
+    return JSON.parse(text);
+}
+/**
+ * Strip control chars and cap length on attacker-controlled error body before
+ * inlining into a thrown Error.message. Without this, a malicious or
+ * compromised endpoint can deliver multi-MB error bodies that flow into log
+ * aggregators via unhandled-rejection traces.
+ */
+function safeErrText(s) {
+    return s.replace(/[\x00-\x1f\x7f]/g, '?').slice(0, 512);
+}
+/**
+ * Validate item ID to prevent injection
+ */
+function validateItemId(itemId) {
+    // Scoped packages (@scope/name) or plain identifiers — no other slashes allowed
+    return /^(@[a-zA-Z0-9][a-zA-Z0-9_-]*\/[a-zA-Z0-9][a-zA-Z0-9_-]*|[a-zA-Z0-9][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 readBoundedText(response, 64 * 1024).catch(() => 'unreadable');
+        throw new Error(`Rating failed: ${safeErrText(error)}`);
+    }
+    return readBoundedJson(response);
+}
+/**
+ * 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 readBoundedJson(response);
+}
+/**
+ * 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 readBoundedJson(response, 4 * 1024 * 1024);
+}
+/**
+ * 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 readBoundedJson(response);
+}
+/**
+ * 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 readBoundedJson(response, 64 * 1024);
+    }
+    catch (error) {
+        return {
+            healthy: false,
+            error: error instanceof Error ? error.message : 'Unknown error',
+        };
+    }
+}
+//# sourceMappingURL=registry-api.js.map

package/packages/@monomind/cli/dist/src/services/ruvector-training.d.ts

@@ -0,0 +1,222 @@
+/**
+ * RuVector Training Service
+ * Real WASM-accelerated neural training using @ruvector packages
+ *
+ * Features:
+ * - MicroLoRA: <1µs adaptation with rank-2 LoRA (2.3M ops/s)
+ * - SONA: Self-Optimizing Neural Architecture (624k learn/s, 60k search/s)
+ * - Flash Attention: 2.49x-7.47x speedup (9k ops/s)
+ * - Trajectory Buffer: Learning from success/failure
+ * - Contrastive Learning: InfoNCE loss
+ *
+ * Backward Compatible: All v1 APIs preserved, SONA adds new capabilities
+ *
+ * github.com/nokhodian/monomind
+ */
+type BenchmarkResult = any;
+/**
+ * Get which backend is active for training
+ */
+export declare function getActiveBackend(): 'wasm' | 'js-fallback';
+export interface TrainingConfig {
+    dim?: number;
+    learningRate?: number;
+    alpha?: number;
+    trajectoryCapacity?: number;
+    useFlashAttention?: boolean;
+    useMoE?: boolean;
+    useHyperbolic?: boolean;
+    totalSteps?: number;
+    warmupSteps?: number;
+    useSona?: boolean;
+    sonaRank?: 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.
+ * Attempts to load @ruvector/learning-wasm for WASM-accelerated training.
+ * Falls back to a pure-JS implementation if WASM is unavailable.
+ */
+export declare function initializeTraining(config?: TrainingConfig): Promise<{
+    success: boolean;
+    features: string[];
+    backend: 'wasm' | 'js-fallback';
+    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[]>;
+/**
+ * Check if SONA is available
+ */
+export declare function isSonaAvailable(): boolean;
+/**
+ * Force-learn a pattern with SONA (1.6μs, 624k ops/s)
+ * This is a one-shot learning mechanism for immediate pattern storage
+ */
+export declare function sonaForceLearn(embedding: Float32Array, reward: number): void;
+/**
+ * Search for similar patterns with SONA (16.7μs, 60k searches/s)
+ * Returns the k most similar patterns from the pattern bank
+ */
+export declare function sonaFindPatterns(embedding: Float32Array, k?: number): unknown[];
+/**
+ * Process SONA background tasks (0.13μs, 7.5M ticks/s)
+ * Call periodically to process background learning and consolidation
+ */
+export declare function sonaTick(): void;
+/**
+ * Get SONA statistics
+ */
+export declare function getSonaStats(): {
+    available: boolean;
+    enabled: boolean;
+    stats: Record<string, unknown> | null;
+    totalLearns: number;
+    totalSearches: number;
+};
+/**
+ * Enable/disable SONA learning
+ */
+export declare function setSonaEnabled(enabled: boolean): void;
+/**
+ * Flush SONA buffers (persist any pending patterns)
+ */
+export declare function sonaFlush(): void;
+/**
+ * Get training statistics
+ */
+export declare function getTrainingStats(): {
+    initialized: boolean;
+    backend: 'wasm' | 'js-fallback';
+    totalAdaptations: number;
+    totalForwards: number;
+    microLoraStats?: {
+        paramCount: number;
+        adaptCount: bigint;
+        forwardCount: bigint;
+        deltaNorm: number;
+    };
+    scopedLoraStats?: {
+        totalAdaptCount: bigint;
+        totalForwardCount: bigint;
+    };
+    trajectoryStats?: ReturnType<typeof getTrajectoryStats>;
+    sonaStats?: ReturnType<typeof getSonaStats>;
+    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;
+export {};
+//# sourceMappingURL=ruvector-training.d.ts.map