moflo 4.8.31 → 4.8.33

package/src/@claude-flow/cli/dist/src/mcp-tools/session-tools.d.ts

@@ -1,8 +0,0 @@
-/**
- * Session MCP Tools for CLI
- *
- * Tool definitions for session management with file persistence.
- */
-import type { MCPTool } from './types.js';
-export declare const sessionTools: MCPTool[];
-//# sourceMappingURL=session-tools.d.ts.map

package/src/@claude-flow/cli/dist/src/mcp-tools/swarm-tools.d.ts

@@ -1,8 +0,0 @@
-/**
- * Swarm MCP Tools for CLI
- *
- * Tool definitions for swarm coordination.
- */
-import type { MCPTool } from './types.js';
-export declare const swarmTools: MCPTool[];
-//# sourceMappingURL=swarm-tools.d.ts.map

package/src/@claude-flow/cli/dist/src/mcp-tools/system-tools.d.ts

@@ -1,13 +0,0 @@
-/**
- * System MCP Tools for CLI
- *
- * V2 Compatibility - System monitoring tools: status, metrics, health
- *
- * ✅ Uses REAL system metrics via Node.js APIs:
- * - process.memoryUsage() for real memory stats
- * - process.cpuUsage() for real CPU stats
- * - os module for system information
- */
-import type { MCPTool } from './types.js';
-export declare const systemTools: MCPTool[];
-//# sourceMappingURL=system-tools.d.ts.map

package/src/@claude-flow/cli/dist/src/mcp-tools/task-tools.d.ts

@@ -1,8 +0,0 @@
-/**
- * Task MCP Tools for CLI
- *
- * Tool definitions for task management with file persistence.
- */
-import type { MCPTool } from './types.js';
-export declare const taskTools: MCPTool[];
-//# sourceMappingURL=task-tools.d.ts.map

package/src/@claude-flow/cli/dist/src/mcp-tools/terminal-tools.d.ts

@@ -1,13 +0,0 @@
-/**
- * Terminal MCP Tools for CLI
- *
- * V2 Compatibility - Terminal session management tools
- *
- * ⚠️ IMPORTANT: These tools provide STATE MANAGEMENT only.
- * - terminal/execute does NOT actually execute commands
- * - Commands are recorded for tracking/coordination purposes
- * - For real command execution, use Claude Code's Bash tool
- */
-import type { MCPTool } from './types.js';
-export declare const terminalTools: MCPTool[];
-//# sourceMappingURL=terminal-tools.d.ts.map

package/src/@claude-flow/cli/dist/src/mcp-tools/transfer-tools.d.ts

@@ -1,14 +0,0 @@
-/**
- * Transfer MCP Tools
- * Pattern and plugin sharing via IPFS-based decentralized registry
- *
- * @module @claude-flow/cli/mcp-tools/transfer-tools
- * @version 3.0.0
- */
-import type { MCPTool } from './types.js';
-/**
- * Transfer MCP tools for pattern export, import, anonymization, and sharing
- */
-export declare const transferTools: MCPTool[];
-export default transferTools;
-//# sourceMappingURL=transfer-tools.d.ts.map

package/src/@claude-flow/cli/dist/src/mcp-tools/types.d.ts

@@ -1,31 +0,0 @@
-/**
- * MCP Tool Types for CLI
- *
- * Local type definitions to avoid external imports outside package boundary.
- */
-export interface MCPToolInputSchema {
-    type: 'object';
-    properties: Record<string, unknown>;
-    required?: string[];
-}
-export interface MCPToolResult {
-    content: Array<{
-        type: 'text' | 'image' | 'resource';
-        text?: string;
-        data?: string;
-        mimeType?: string;
-    }>;
-    isError?: boolean;
-}
-export interface MCPTool {
-    name: string;
-    description: string;
-    inputSchema: MCPToolInputSchema;
-    category?: string;
-    tags?: string[];
-    version?: string;
-    cacheable?: boolean;
-    cacheTTL?: number;
-    handler: (input: Record<string, unknown>, context?: Record<string, unknown>) => Promise<MCPToolResult | unknown>;
-}
-//# sourceMappingURL=types.d.ts.map

package/src/@claude-flow/cli/dist/src/mcp-tools/workflow-tools.d.ts

@@ -1,8 +0,0 @@
-/**
- * Workflow MCP Tools for CLI
- *
- * Tool definitions for workflow automation and orchestration.
- */
-import type { MCPTool } from './types.js';
-export declare const workflowTools: MCPTool[];
-//# sourceMappingURL=workflow-tools.d.ts.map

package/src/@claude-flow/cli/dist/src/memory/ewc-consolidation.d.ts

@@ -1,271 +0,0 @@
-/**
- * EWC++ (Elastic Weight Consolidation) Implementation
- * Prevents catastrophic forgetting of important patterns during continual learning
- *
- * Algorithm:
- * L_total = L_new + (lambda/2) * sum_i(F_i * (theta_i - theta_old_i)^2)
- *
- * Where:
- * - L_new is the loss on new data
- * - lambda is the importance weight (ewcLambda)
- * - F_i is the Fisher information for parameter i
- * - theta_i is the current parameter value
- * - theta_old_i is the previous parameter value
- *
- * Features:
- * - Fisher Information Matrix computation from gradient history
- * - Online EWC updates for streaming patterns
- * - Selective consolidation based on pattern importance
- * - Persistent storage in .swarm/ewc-fisher.json
- *
- * @module v3/cli/memory/ewc-consolidation
- */
-/**
- * Pattern weight vector for EWC consolidation
- */
-export interface PatternWeights {
-    /** Unique pattern identifier */
-    id: string;
-    /** Weight vector (embedding or learned parameters) */
-    weights: number[];
-    /** Fisher information values per weight */
-    fisherDiagonal: number[];
-    /** Importance score (0-1) */
-    importance: number;
-    /** Number of successful uses */
-    successCount: number;
-    /** Number of failed uses */
-    failureCount: number;
-    /** Timestamp of last update */
-    lastUpdated: number;
-    /** Pattern type for categorization */
-    type: string;
-    /** Pattern description */
-    description?: string;
-}
-/**
- * Fisher Information Matrix entry (diagonal approximation)
- */
-export interface FisherEntry {
-    /** Parameter index */
-    index: number;
-    /** Fisher information value (importance) */
-    value: number;
-    /** Number of samples used to compute this value */
-    sampleCount: number;
-    /** Exponential moving average decay rate */
-    decayRate: number;
-}
-/**
- * EWC consolidation configuration
- */
-export interface EWCConfig {
-    /** Regularization strength (lambda) */
-    lambda: number;
-    /** Number of patterns to keep for Fisher computation */
-    maxPatterns: number;
-    /** Decay rate for online Fisher updates */
-    fisherDecayRate: number;
-    /** Minimum importance threshold for consolidation */
-    importanceThreshold: number;
-    /** Path to persist Fisher matrix */
-    storagePath: string;
-    /** Enable online updates (EWC++) */
-    onlineMode: boolean;
-    /** Dimensions of weight vectors */
-    dimensions: number;
-}
-/**
- * Consolidation result
- */
-export interface ConsolidationResult {
-    /** Whether consolidation was successful */
-    success: boolean;
-    /** Number of patterns consolidated */
-    patternsConsolidated: number;
-    /** Total penalty applied */
-    totalPenalty: number;
-    /** Patterns that were modified */
-    modifiedPatterns: string[];
-    /** Patterns that were protected (high Fisher) */
-    protectedPatterns: string[];
-    /** Time taken in milliseconds */
-    duration: number;
-    /** Error message if failed */
-    error?: string;
-}
-/**
- * Statistics about EWC consolidation state
- */
-export interface EWCStats {
-    /** Total patterns tracked */
-    totalPatterns: number;
-    /** Patterns with high importance (above threshold) */
-    highImportancePatterns: number;
-    /** Average Fisher information across all parameters */
-    avgFisherValue: number;
-    /** Maximum Fisher information value */
-    maxFisherValue: number;
-    /** Total successful consolidations */
-    consolidationCount: number;
-    /** Last consolidation timestamp */
-    lastConsolidation: number | null;
-    /** Average penalty per consolidation */
-    avgPenalty: number;
-    /** Storage size in bytes */
-    storageSizeBytes: number;
-}
-/**
- * EWC++ Consolidator
- * Implements Elastic Weight Consolidation with online updates
- * for preventing catastrophic forgetting in continual learning
- */
-export declare class EWCConsolidator {
-    private config;
-    private patterns;
-    private gradientHistory;
-    private globalFisher;
-    private consolidationHistory;
-    private initialized;
-    constructor(config?: Partial<EWCConfig>);
-    /**
-     * Initialize the consolidator by loading persisted state
-     */
-    initialize(): Promise<boolean>;
-    /**
-     * Compute Fisher Information Matrix from gradient history
-     * Uses diagonal approximation for efficiency: F_i = E[g_i^2]
-     *
-     * @param patterns - Array of patterns with their gradients/embeddings
-     * @returns Fisher information diagonal
-     */
-    computeFisherMatrix(patterns: {
-        id: string;
-        embedding: number[];
-        success: boolean;
-    }[]): number[];
-    /**
-     * Consolidate new patterns with old patterns without forgetting
-     * Applies EWC penalty to preserve important weights
-     *
-     * @param newPatterns - New patterns to incorporate
-     * @param oldPatterns - Existing patterns to preserve
-     * @returns Consolidated patterns with modified weights
-     */
-    consolidate(newPatterns: {
-        id: string;
-        embedding: number[];
-        type: string;
-        description?: string;
-    }[], oldPatterns?: PatternWeights[]): ConsolidationResult;
-    /**
-     * Calculate EWC regularization penalty
-     *
-     * L_ewc = (lambda/2) * sum_i(F_i * (theta_i - theta_old_i)^2)
-     *
-     * @param oldWeights - Previous weight values
-     * @param newWeights - New weight values
-     * @param fisher - Fisher information diagonal (optional, uses global if not provided)
-     * @returns Regularization penalty value
-     */
-    getPenalty(oldWeights: number[], newWeights: number[], fisher?: number[]): number;
-    /**
-     * Get consolidation statistics
-     */
-    getConsolidationStats(): EWCStats;
-    /**
-     * Record a gradient sample for Fisher computation
-     */
-    recordGradient(patternId: string, gradients: number[], success: boolean): void;
-    /**
-     * Get pattern weights by ID
-     */
-    getPatternWeights(id: string): PatternWeights | undefined;
-    /**
-     * Get all stored patterns
-     */
-    getAllPatterns(): PatternWeights[];
-    /**
-     * Update EWC lambda (regularization strength)
-     */
-    setLambda(lambda: number): void;
-    /**
-     * Get current lambda value
-     */
-    getLambda(): number;
-    /**
-     * Reset Fisher matrix (use with caution - allows forgetting)
-     */
-    resetFisher(): void;
-    /**
-     * Clear all patterns and history (full reset)
-     */
-    clear(): void;
-    /**
-     * Calculate importance score for a pattern based on usage
-     */
-    private calculateImportance;
-    /**
-     * Blend old and new weights using Fisher-weighted interpolation
-     */
-    private blendWeights;
-    /**
-     * Prune old, low-importance patterns to stay within limit
-     */
-    private pruneOldPatterns;
-    /**
-     * Save state to disk
-     */
-    private saveToDisk;
-    /**
-     * Load state from disk
-     */
-    private loadFromDisk;
-}
-/**
- * Get the singleton EWC Consolidator instance
- *
- * @param config - Optional configuration overrides
- * @returns EWC Consolidator instance
- */
-export declare function getEWCConsolidator(config?: Partial<EWCConfig>): Promise<EWCConsolidator>;
-/**
- * Reset the singleton instance (for testing)
- */
-export declare function resetEWCConsolidator(): void;
-/**
- * Quick consolidation helper for common use case
- * Consolidates new patterns with existing ones using EWC
- *
- * @param newPatterns - New patterns to add
- * @returns Consolidation result
- */
-export declare function consolidatePatterns(newPatterns: {
-    id: string;
-    embedding: number[];
-    type: string;
-    description?: string;
-}[]): Promise<ConsolidationResult>;
-/**
- * Record pattern usage outcome
- * Updates Fisher information and pattern importance
- *
- * @param patternId - Pattern identifier
- * @param embedding - Pattern embedding (used as gradient proxy)
- * @param success - Whether the pattern was successful
- */
-export declare function recordPatternOutcome(patternId: string, embedding: number[], success: boolean): Promise<void>;
-/**
- * Get EWC statistics
- */
-export declare function getEWCStats(): Promise<EWCStats>;
-declare const _default: {
-    EWCConsolidator: typeof EWCConsolidator;
-    getEWCConsolidator: typeof getEWCConsolidator;
-    resetEWCConsolidator: typeof resetEWCConsolidator;
-    consolidatePatterns: typeof consolidatePatterns;
-    recordPatternOutcome: typeof recordPatternOutcome;
-    getEWCStats: typeof getEWCStats;
-};
-export default _default;
-//# sourceMappingURL=ewc-consolidation.d.ts.map

package/src/@claude-flow/cli/dist/src/memory/intelligence.d.ts

@@ -1,285 +0,0 @@
-/**
- * V3 Intelligence Module
- * Optimized SONA (Self-Optimizing Neural Architecture) and ReasoningBank
- * for adaptive learning and pattern recognition
- *
- * Performance targets:
- * - Signal recording: <0.05ms (achieved: ~0.01ms)
- * - Pattern search: O(log n) with HNSW
- * - Memory efficient circular buffers
- *
- * @module v3/cli/intelligence
- */
-export interface SonaConfig {
-    instantLoopEnabled: boolean;
-    backgroundLoopEnabled: boolean;
-    loraLearningRate: number;
-    loraRank: number;
-    ewcLambda: number;
-    maxTrajectorySize: number;
-    patternThreshold: number;
-    maxSignals: number;
-    maxPatterns: number;
-}
-export interface TrajectoryStep {
-    type: 'observation' | 'thought' | 'action' | 'result';
-    content: string;
-    embedding?: number[];
-    metadata?: Record<string, unknown>;
-    timestamp?: number;
-}
-export interface Pattern {
-    id: string;
-    type: string;
-    embedding: number[];
-    content: string;
-    confidence: number;
-    usageCount: number;
-    createdAt: number;
-    lastUsedAt: number;
-}
-export interface IntelligenceStats {
-    sonaEnabled: boolean;
-    reasoningBankSize: number;
-    patternsLearned: number;
-    trajectoriesRecorded: number;
-    lastAdaptation: number | null;
-    avgAdaptationTime: number;
-}
-interface Signal {
-    type: string;
-    content: string;
-    embedding: number[];
-    metadata?: Record<string, unknown>;
-    timestamp: number;
-}
-interface StoredPattern {
-    id: string;
-    type: string;
-    embedding: number[];
-    content: string;
-    confidence: number;
-    usageCount: number;
-    createdAt: number;
-    lastUsedAt: number;
-    metadata?: Record<string, unknown>;
-}
-/**
- * Lightweight SONA Coordinator
- * Uses circular buffer for O(1) signal recording
- * Achieves <0.05ms per operation
- */
-declare class LocalSonaCoordinator {
-    private config;
-    private signals;
-    private signalHead;
-    private signalCount;
-    private trajectories;
-    private adaptationTimes;
-    constructor(config: SonaConfig);
-    /**
-     * Record a signal - O(1) operation
-     * Target: <0.05ms
-     */
-    recordSignal(signal: Signal): void;
-    /**
-     * Record complete trajectory
-     */
-    recordTrajectory(trajectory: {
-        steps: TrajectoryStep[];
-        verdict: string;
-        timestamp: number;
-    }): void;
-    /**
-     * Get recent signals
-     */
-    getRecentSignals(count?: number): Signal[];
-    /**
-     * Get average adaptation time
-     */
-    getAvgAdaptationTime(): number;
-    /**
-     * Get statistics
-     */
-    stats(): {
-        signalCount: number;
-        trajectoryCount: number;
-        avgAdaptationMs: number;
-    };
-}
-/**
- * Lightweight ReasoningBank
- * Uses Map for O(1) storage and array for similarity search
- * Supports persistence to disk
- */
-declare class LocalReasoningBank {
-    private patterns;
-    private patternList;
-    private maxSize;
-    private persistenceEnabled;
-    private dirty;
-    private saveTimeout;
-    constructor(options: {
-        maxSize: number;
-        persistence?: boolean;
-    });
-    /**
-     * Load patterns from disk
-     */
-    private loadFromDisk;
-    /**
-     * Save patterns to disk (debounced)
-     */
-    private saveToDisk;
-    /**
-     * Immediately flush patterns to disk
-     */
-    flushToDisk(): void;
-    /**
-     * Store a pattern - O(1)
-     */
-    store(pattern: Omit<StoredPattern, 'usageCount' | 'createdAt' | 'lastUsedAt'> & Partial<StoredPattern>): void;
-    /**
-     * Find similar patterns by embedding
-     */
-    findSimilar(queryEmbedding: number[], options: {
-        k?: number;
-        threshold?: number;
-        type?: string;
-    }): StoredPattern[];
-    /**
-     * Optimized cosine similarity
-     */
-    private cosineSim;
-    /**
-     * Get statistics
-     */
-    stats(): {
-        size: number;
-        patternCount: number;
-    };
-    /**
-     * Get pattern by ID
-     */
-    get(id: string): StoredPattern | undefined;
-    /**
-     * Get all patterns
-     */
-    getAll(): StoredPattern[];
-    /**
-     * Get patterns by type
-     */
-    getByType(type: string): StoredPattern[];
-    /**
-     * Delete a pattern by ID
-     */
-    delete(id: string): boolean;
-    /**
-     * Clear all patterns
-     */
-    clear(): void;
-}
-/**
- * Initialize the intelligence system (SONA + ReasoningBank)
- * Uses optimized local implementations
- */
-export declare function initializeIntelligence(config?: Partial<SonaConfig>): Promise<{
-    success: boolean;
-    sonaEnabled: boolean;
-    reasoningBankEnabled: boolean;
-    error?: string;
-}>;
-/**
- * Record a trajectory step for learning
- * Performance: <0.05ms without embedding generation
- */
-export declare function recordStep(step: TrajectoryStep): Promise<boolean>;
-/**
- * Record a complete trajectory with verdict
- */
-export declare function recordTrajectory(steps: TrajectoryStep[], verdict: 'success' | 'failure' | 'partial'): Promise<boolean>;
-/**
- * Find similar patterns from ReasoningBank
- */
-export interface PatternMatch extends Pattern {
-    similarity: number;
-}
-export declare function findSimilarPatterns(query: string, options?: {
-    k?: number;
-    threshold?: number;
-    type?: string;
-}): Promise<PatternMatch[]>;
-/**
- * Get intelligence system statistics
- */
-export declare function getIntelligenceStats(): IntelligenceStats;
-/**
- * Get SONA coordinator for advanced operations
- */
-export declare function getSonaCoordinator(): LocalSonaCoordinator | null;
-/**
- * Get ReasoningBank for advanced operations
- */
-export declare function getReasoningBank(): LocalReasoningBank | null;
-/**
- * Clear intelligence state
- */
-export declare function clearIntelligence(): void;
-/**
- * Benchmark SONA adaptation time
- */
-export declare function benchmarkAdaptation(iterations?: number): {
-    totalMs: number;
-    avgMs: number;
-    minMs: number;
-    maxMs: number;
-    targetMet: boolean;
-};
-/**
- * Get all patterns from ReasoningBank
- * Returns persisted patterns even after process restart
- */
-export declare function getAllPatterns(): Promise<Pattern[]>;
-/**
- * Get patterns by type from ReasoningBank
- */
-export declare function getPatternsByType(type: string): Promise<Pattern[]>;
-/**
- * Flush patterns to disk immediately
- * Call this at the end of training to ensure all patterns are saved
- */
-export declare function flushPatterns(): void;
-/**
- * Compact patterns by removing duplicates/similar patterns
- * @param threshold Similarity threshold (0-1), patterns above this are considered duplicates
- */
-export declare function compactPatterns(threshold?: number): Promise<{
-    before: number;
-    after: number;
-    removed: number;
-}>;
-/**
- * Delete a pattern by ID
- */
-export declare function deletePattern(id: string): Promise<boolean>;
-/**
- * Clear all patterns (both in memory and on disk)
- */
-export declare function clearAllPatterns(): Promise<void>;
-/**
- * Get the neural data directory path
- */
-export declare function getNeuralDataDir(): string;
-/**
- * Get persistence status
- */
-export declare function getPersistenceStatus(): {
-    enabled: boolean;
-    dataDir: string;
-    patternsFile: string;
-    statsFile: string;
-    patternsExist: boolean;
-    statsExist: boolean;
-};
-export {};
-//# sourceMappingURL=intelligence.d.ts.map