moflo 4.8.30 → 4.8.32

package/src/@claude-flow/cli/dist/src/services/learning-service.d.ts

@@ -1,161 +0,0 @@
-/**
- * Learning Service
- *
- * Persistent pattern learning with HNSW indexing and sql.js backend.
- * Manages short-term and long-term pattern storage with automatic
- * promotion, deduplication, and consolidation.
- *
- * Features:
- * - Pattern storage/search with sql.js backend (.swarm/memory.db)
- * - Short-term -> long-term pattern promotion (promote after 3 uses)
- * - Quality thresholds: minimum quality 0.6, dedup threshold 0.95
- * - Consolidation: max 500 short-term, 2000 long-term, prune after 30 days
- * - HNSW indexing for fast similarity search
- */
-declare const CONFIG: {
-    hnsw: {
-        M: number;
-        efConstruction: number;
-        efSearch: number;
-    };
-    patterns: {
-        promotionThreshold: number;
-        qualityThreshold: number;
-        maxShortTerm: number;
-        maxLongTerm: number;
-        dedupThreshold: number;
-    };
-    embedding: {
-        dimension: number;
-    };
-    consolidation: {
-        pruneAge: number;
-        minUsageForKeep: number;
-    };
-};
-declare class HNSWIndex {
-    private vectors;
-    private idToVector;
-    private vectorToId;
-    private nextVectorId;
-    private layers;
-    private entryPoint;
-    private readonly maxConnections;
-    constructor(maxConnections?: number);
-    add(patternId: string, embedding: Float32Array): number;
-    search(queryEmbedding: Float32Array, k?: number): {
-        results: SearchResult[];
-        searchTimeMs: number;
-    };
-    remove(patternId: string): boolean;
-    size(): number;
-    private cosineDistance;
-    private insertIntoGraph;
-    private searchGraph;
-    private findNearestBrute;
-    private pruneConnections;
-    private removeFromGraph;
-}
-interface SearchResult {
-    patternId: string;
-    similarity: number;
-    vectorId: number;
-}
-interface PatternRow {
-    id: string;
-    pattern: string;
-    domain: string;
-    quality: number;
-    uses: number;
-    tier: string;
-    embedding: Uint8Array | null;
-    created_at: string;
-    last_used_at: string | null;
-    promoted_at: string | null;
-}
-interface PatternSearchResult {
-    patternId: string;
-    similarity: number;
-    pattern: string;
-    domain: string;
-    quality: number;
-    uses: number;
-    tier: string;
-}
-interface StoreResult {
-    id: string;
-    action: 'created' | 'updated';
-    similarity?: number;
-}
-interface ConsolidateResult {
-    promoted: number;
-    pruned: number;
-    deduplicated: number;
-    durationMs: number;
-}
-interface LearningStats {
-    shortTermPatterns: number;
-    longTermPatterns: number;
-    totalPatterns: number;
-    avgQuality: number;
-    domains: string[];
-}
-declare function hashEmbed(text: string): Float32Array;
-declare function cosineSimilarity(a: Float32Array, b: Float32Array): number;
-export declare class LearningService {
-    private db;
-    private shortTermIndex;
-    private longTermIndex;
-    private dirty;
-    private dbPath;
-    private dataDir;
-    constructor(projectRoot?: string);
-    /**
-     * Initialize the learning service, opening or creating the DB.
-     */
-    initialize(): Promise<void>;
-    /**
-     * Store a learning pattern.
-     */
-    storePattern(pattern: string, domain?: string, quality?: number): Promise<StoreResult>;
-    /**
-     * Search for patterns similar to the query.
-     */
-    searchPatterns(query: string, k?: number): Promise<PatternSearchResult[]>;
-    /**
-     * Promote short-term patterns that meet the threshold.
-     */
-    promotePatterns(): Promise<number>;
-    /**
-     * Consolidate patterns: promote eligible, prune old, deduplicate.
-     */
-    consolidate(): Promise<ConsolidateResult>;
-    /**
-     * Get statistics about stored patterns.
-     */
-    getStats(): LearningStats;
-    /**
-     * List patterns, optionally filtered by domain.
-     */
-    listPatterns(domain?: string, limit?: number): PatternRow[];
-    /**
-     * Save DB to disk and close.
-     */
-    close(): void;
-    /**
-     * Save DB to disk.
-     */
-    save(): void;
-    private requireDb;
-    private ensureSchema;
-    private loadIndexes;
-    private checkPromotion;
-    private pruneShortTerm;
-    private enforceMaxShortTerm;
-    private enforceMaxLongTerm;
-    private deduplicateLongTerm;
-}
-export declare function getLearningService(projectRoot?: string): LearningService;
-export { CONFIG as LEARNING_CONFIG, HNSWIndex, hashEmbed, cosineSimilarity };
-export type { PatternSearchResult, StoreResult, ConsolidateResult, LearningStats, PatternRow };
-//# sourceMappingURL=learning-service.d.ts.map

package/src/@claude-flow/cli/dist/src/services/moflo-require.d.ts

@@ -1,34 +0,0 @@
-/**
- * moflo-require — Resolve moflo's own dependencies from its own node_modules.
- *
- * When moflo runs via `npx` in a consuming project, bare `await import('sql.js')`
- * resolves from the *consuming project's* node_modules, not moflo's.  Since moflo
- * ships these dependencies itself, we always resolve from moflo's own context first
- * and only fall back to a bare import as a last resort.
- *
- * Usage:
- *   import { mofloImport } from '../services/moflo-require.js';
- *   const sqlJs = await mofloImport('sql.js');
- *   const transformers = await mofloImport('@xenova/transformers');
- */
-/**
- * Dynamically import a package, resolving from moflo's own node_modules first.
- * Falls back to bare import only if local resolution fails (e.g. monorepo hoisting).
- *
- * On Windows, `createRequire.resolve()` returns a native path (C:\...) which
- * `import()` rejects — it requires a file:// URL.  We convert via pathToFileURL.
- *
- * @param specifier  Package specifier, e.g. 'sql.js' or '@xenova/transformers'
- * @returns          The imported module, or null if not available
- */
-export declare function mofloImport(specifier: string): Promise<any>;
-/**
- * Like mofloImport but throws if the package is not found (for required deps).
- */
-export declare function mofloImportRequired(specifier: string): Promise<any>;
-/**
- * Resolve a package path without importing (useful for WASM file paths etc).
- * Returns the resolved path, or null if not found.
- */
-export declare function mofloResolve(specifier: string): string | null;
-//# sourceMappingURL=moflo-require.d.ts.map

package/src/@claude-flow/cli/dist/src/services/registry-api.d.ts

@@ -1,58 +0,0 @@
-/**
- * Registry API Client
- * Secure integration with Claude Flow 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/src/@claude-flow/cli/dist/src/services/ruvector-training.d.ts

@@ -1,214 +0,0 @@
-/**
- * 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
- *
- * Created with ❤️ by motailz.com
- */
-type BenchmarkResult = any;
-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
- */
-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[]>;
-/**
- * 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;
-    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

package/src/@claude-flow/cli/dist/src/services/worker-daemon.d.ts

@@ -1,225 +0,0 @@
-/**
- * Worker Daemon Service
- * Node.js-based background worker system that auto-runs like shell daemons
- *
- * Workers:
- * - map: Codebase mapping (5 min interval)
- * - audit: Security analysis (10 min interval)
- * - optimize: Performance optimization (15 min interval)
- * - consolidate: Memory consolidation (30 min interval)
- * - testgaps: Test coverage analysis (20 min interval)
- */
-import { EventEmitter } from 'events';
-import { HeadlessWorkerExecutor } from './headless-worker-executor.js';
-export type WorkerType = 'ultralearn' | 'optimize' | 'consolidate' | 'predict' | 'audit' | 'map' | 'preload' | 'deepdive' | 'document' | 'refactor' | 'benchmark' | 'testgaps';
-interface WorkerConfig {
-    type: WorkerType;
-    intervalMs: number;
-    priority: 'low' | 'normal' | 'high' | 'critical';
-    description: string;
-    enabled: boolean;
-}
-interface WorkerState {
-    lastRun?: Date;
-    nextRun?: Date;
-    runCount: number;
-    successCount: number;
-    failureCount: number;
-    averageDurationMs: number;
-    isRunning: boolean;
-}
-interface WorkerResult {
-    workerId: string;
-    type: WorkerType;
-    success: boolean;
-    durationMs: number;
-    output?: unknown;
-    error?: string;
-    timestamp: Date;
-}
-interface DaemonStatus {
-    running: boolean;
-    pid: number;
-    startedAt?: Date;
-    workers: Map<WorkerType, WorkerState>;
-    config: DaemonConfig;
-}
-export interface DaemonConfig {
-    autoStart: boolean;
-    logDir: string;
-    stateFile: string;
-    maxConcurrent: number;
-    workerTimeoutMs: number;
-    resourceThresholds: {
-        maxCpuLoad: number;
-        minFreeMemoryPercent: number;
-    };
-    workers: WorkerConfig[];
-}
-/**
- * Worker Daemon - Manages background workers with Node.js
- */
-export declare class WorkerDaemon extends EventEmitter {
-    private config;
-    private workers;
-    private timers;
-    private running;
-    private startedAt?;
-    private projectRoot;
-    private runningWorkers;
-    private pendingWorkers;
-    private headlessExecutor;
-    private headlessAvailable;
-    private originalConfig?;
-    private _osProvider?;
-    constructor(projectRoot: string, config?: Partial<DaemonConfig>);
-    /**
-     * Initialize headless executor if Claude Code is available
-     */
-    private initHeadlessExecutor;
-    /**
-     * Check if headless execution is available
-     */
-    isHeadlessAvailable(): boolean;
-    /**
-     * Get headless executor instance
-     */
-    getHeadlessExecutor(): HeadlessWorkerExecutor | null;
-    /**
-     * Detect effective CPU count for the current environment.
-     *
-     * Inside Docker / K8s containers, os.cpus().length reports the HOST cpu
-     * count, not the container limit (Node.js #28762 — wontfix).  We read
-     * cgroup v2 / v1 quota files first so the maxCpuLoad threshold stays
-     * meaningful under resource-limited containers.
-     */
-    static getEffectiveCpuCount(): number;
-    /**
-     * Read daemon-specific config from .claude-flow/config.json
-     * Supports dot-notation keys like 'daemon.resourceThresholds.maxCpuLoad'
-     */
-    private readDaemonConfigFromFile;
-    /**
-     * Setup graceful shutdown handlers
-     */
-    private setupShutdownHandlers;
-    /**
-     * Check if system resources allow worker execution
-     */
-    private canRunWorker;
-    /**
-     * Process pending workers queue
-     *
-     * When executeWorkerWithConcurrencyControl defers a worker (returns null),
-     * we break immediately to avoid a busy-wait loop — the deferred worker is
-     * already back on the pendingWorkers queue by that point. If no workers are
-     * currently running when we break, we schedule a backoff retry so the queue
-     * does not get permanently stuck.
-     */
-    private processPendingWorkers;
-    private initializeWorkerStates;
-    /**
-     * Start the daemon and all enabled workers
-     */
-    start(): Promise<void>;
-    /**
-     * Stop the daemon and all workers
-     */
-    stop(): Promise<void>;
-    /**
-     * Get daemon status
-     */
-    getStatus(): DaemonStatus;
-    /**
-     * Schedule a worker to run at intervals with staggered start
-     */
-    private scheduleWorker;
-    /**
-     * Execute a worker with concurrency control (P0 fix)
-     */
-    private executeWorkerWithConcurrencyControl;
-    /**
-     * Execute a worker with timeout protection
-     */
-    private executeWorker;
-    /**
-     * Run a function with timeout (P1 fix)
-     */
-    private runWithTimeout;
-    /**
-     * Run the actual worker logic
-     */
-    private runWorkerLogic;
-    private runMapWorker;
-    /**
-     * Local audit worker (fallback when headless unavailable)
-     */
-    private runAuditWorkerLocal;
-    /**
-     * Local optimize worker (fallback when headless unavailable)
-     */
-    private runOptimizeWorkerLocal;
-    private runConsolidateWorker;
-    /**
-     * Local testgaps worker (fallback when headless unavailable)
-     */
-    private runTestGapsWorkerLocal;
-    /**
-     * Local predict worker (fallback when headless unavailable)
-     */
-    private runPredictWorkerLocal;
-    /**
-     * Local document worker (fallback when headless unavailable)
-     */
-    private runDocumentWorkerLocal;
-    /**
-     * Local ultralearn worker (fallback when headless unavailable)
-     */
-    private runUltralearnWorkerLocal;
-    /**
-     * Local refactor worker (fallback when headless unavailable)
-     */
-    private runRefactorWorkerLocal;
-    /**
-     * Local deepdive worker (fallback when headless unavailable)
-     */
-    private runDeepdiveWorkerLocal;
-    /**
-     * Local benchmark worker
-     */
-    private runBenchmarkWorkerLocal;
-    /**
-     * Local preload worker
-     */
-    private runPreloadWorkerLocal;
-    /**
-     * Manually trigger a worker
-     */
-    triggerWorker(type: WorkerType): Promise<WorkerResult>;
-    /**
-     * Enable/disable a worker
-     */
-    setWorkerEnabled(type: WorkerType, enabled: boolean): void;
-    /**
-     * Save daemon state to file
-     */
-    private saveState;
-    /**
-     * Log message
-     */
-    private log;
-}
-/**
- * Get or create daemon instance
- */
-export declare function getDaemon(projectRoot?: string, config?: Partial<DaemonConfig>): WorkerDaemon;
-/**
- * Start daemon (for use in session-start hook)
- */
-export declare function startDaemon(projectRoot: string, config?: Partial<DaemonConfig>): Promise<WorkerDaemon>;
-/**
- * Stop daemon
- */
-export declare function stopDaemon(): Promise<void>;
-export default WorkerDaemon;
-//# sourceMappingURL=worker-daemon.d.ts.map