snow-flow 3.0.8 → 3.0.10

package/dist/utils/mcp-timeout-fix.js

@@ -1,221 +0,0 @@
-"use strict";
-/**
- * MCP Timeout Fix
- * Addresses timeout issues with MCP operations, especially memory_usage
- * v2.10.0 - Critical fix for hanging MCP operations
- */
-var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
-    if (k2 === undefined) k2 = k;
-    var desc = Object.getOwnPropertyDescriptor(m, k);
-    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
-      desc = { enumerable: true, get: function() { return m[k]; } };
-    }
-    Object.defineProperty(o, k2, desc);
-}) : (function(o, m, k, k2) {
-    if (k2 === undefined) k2 = k;
-    o[k2] = m[k];
-}));
-var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
-    Object.defineProperty(o, "default", { enumerable: true, value: v });
-}) : function(o, v) {
-    o["default"] = v;
-});
-var __importStar = (this && this.__importStar) || (function () {
-    var ownKeys = function(o) {
-        ownKeys = Object.getOwnPropertyNames || function (o) {
-            var ar = [];
-            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
-            return ar;
-        };
-        return ownKeys(o);
-    };
-    return function (mod) {
-        if (mod && mod.__esModule) return mod;
-        var result = {};
-        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
-        __setModuleDefault(result, mod);
-        return result;
-    };
-})();
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.mcpTimeoutManager = exports.MCPTimeoutManager = void 0;
-const logger_js_1 = require("./logger.js");
-const logger = new logger_js_1.Logger('MCPTimeoutFix');
-class MCPTimeoutManager {
-    constructor() {
-        // Load timeout values from environment with increased defaults
-        this.config = {
-            startup: parseInt(process.env.SNOW_MCP_STARTUP_TIMEOUT || '120000'), // 2 minutes
-            operation: parseInt(process.env.SNOW_MCP_OPERATION_TIMEOUT || '300000'), // 5 minutes
-            deployment: parseInt(process.env.MCP_DEPLOYMENT_TIMEOUT || '720000'), // 12 minutes
-            memory: parseInt(process.env.SNOW_MCP_MEMORY_TIMEOUT || '60000'), // 1 minute for memory ops
-            global: parseInt(process.env.SNOW_API_TIMEOUT || '180000') // 3 minutes global
-        };
-        logger.info('🕐 MCP Timeout Configuration:', {
-            startup: `${this.config.startup / 1000}s`,
-            operation: `${this.config.operation / 1000}s`,
-            deployment: `${this.config.deployment / 1000}s`,
-            memory: `${this.config.memory / 1000}s`,
-            global: `${this.config.global / 1000}s`
-        });
-    }
-    static getInstance() {
-        if (!this.instance) {
-            this.instance = new MCPTimeoutManager();
-        }
-        return this.instance;
-    }
-    /**
-     * Get timeout for specific operation type
-     */
-    getTimeout(operationType) {
-        return this.config[operationType];
-    }
-    /**
-     * Execute an operation with timeout protection
-     */
-    async executeWithTimeout(operation, timeoutMs, operationName) {
-        return new Promise((resolve, reject) => {
-            let timeoutHandle;
-            let completed = false;
-            // Set up timeout
-            timeoutHandle = setTimeout(() => {
-                if (!completed) {
-                    completed = true;
-                    logger.error(`⏱️ Operation '${operationName}' timed out after ${timeoutMs / 1000}s`);
-                    reject(new Error(`Operation '${operationName}' timed out after ${timeoutMs / 1000} seconds`));
-                }
-            }, timeoutMs);
-            // Execute operation
-            operation
-                .then(result => {
-                if (!completed) {
-                    completed = true;
-                    clearTimeout(timeoutHandle);
-                    resolve(result);
-                }
-            })
-                .catch(error => {
-                if (!completed) {
-                    completed = true;
-                    clearTimeout(timeoutHandle);
-                    reject(error);
-                }
-            });
-        });
-    }
-    /**
-     * Create a timeout-protected wrapper for MCP operations
-     */
-    wrapMCPOperation(operation, operationType = 'operation', customTimeout) {
-        const timeout = customTimeout || this.getTimeout(operationType);
-        const operationName = `MCP ${operationType}`;
-        logger.debug(`⏱️ Starting ${operationName} with ${timeout / 1000}s timeout`);
-        return this.executeWithTimeout(operation(), timeout, operationName);
-    }
-    /**
-     * Special handling for memory operations which tend to hang
-     * WORKAROUND: Use file-based fallback when MCP memory operations fail
-     */
-    async executeMemoryOperation(operation, fallbackToFile = true) {
-        const maxRetries = 2; // Reduced retries to fail faster
-        let lastError = null;
-        for (let attempt = 1; attempt <= maxRetries; attempt++) {
-            try {
-                logger.debug(`🧠 Memory operation attempt ${attempt}/${maxRetries}`);
-                // Use even shorter timeout for memory operations
-                const result = await this.wrapMCPOperation(operation, 'memory', Math.min(this.config.memory, 30000) // Max 30 seconds
-                );
-                logger.debug(`✅ Memory operation succeeded on attempt ${attempt}`);
-                return result;
-            }
-            catch (error) {
-                lastError = error;
-                logger.warn(`⚠️ Memory operation attempt ${attempt} failed:`, error.message);
-                if (attempt < maxRetries) {
-                    // Shorter wait before retrying
-                    const delay = 500; // Fixed short delay
-                    logger.debug(`⏳ Waiting ${delay}ms before retry...`);
-                    await new Promise(resolve => setTimeout(resolve, delay));
-                }
-            }
-        }
-        // FALLBACK: If memory operations fail, suggest file-based storage
-        if (fallbackToFile) {
-            logger.warn('🔄 Memory operation failed, falling back to file-based storage');
-            throw new Error(`Memory operation failed after ${maxRetries} attempts. ` +
-                `WORKAROUND: Use file-based storage instead. ` +
-                `Original error: ${lastError?.message}`);
-        }
-        throw new Error(`Memory operation failed after ${maxRetries} attempts: ${lastError?.message}`);
-    }
-    /**
-     * WORKAROUND: Kill hanging MCP operations
-     */
-    async killHangingOperation(operationId) {
-        logger.warn(`🔪 Killing hanging operation: ${operationId}`);
-        try {
-            // Try to find and kill the specific process
-            const { execSync } = await Promise.resolve().then(() => __importStar(require('child_process')));
-            if (process.platform === 'win32') {
-                execSync(`taskkill /F /FI "WINDOWTITLE eq *${operationId}*" 2>nul`, { stdio: 'ignore' });
-            }
-            else {
-                execSync(`pkill -f "${operationId}" 2>/dev/null || true`, { stdio: 'ignore' });
-            }
-        }
-        catch (e) {
-            logger.debug('Could not kill specific operation, may have already terminated');
-        }
-    }
-    /**
-     * Get recommended timeout settings for slow instances
-     */
-    getSlowInstanceRecommendations() {
-        return {
-            SNOW_API_TIMEOUT: '300000', // 5 minutes
-            SNOW_MCP_STARTUP_TIMEOUT: '180000', // 3 minutes
-            SNOW_MCP_OPERATION_TIMEOUT: '600000', // 10 minutes
-            MCP_DEPLOYMENT_TIMEOUT: '900000', // 15 minutes
-            SNOW_MCP_MEMORY_TIMEOUT: '120000', // 2 minutes
-            SNOW_MAX_CONCURRENT_REQUESTS: '5',
-            SNOW_BATCH_DELAY: '500'
-        };
-    }
-    /**
-     * WORKAROUND: Emergency timeout reduction for stuck systems
-     */
-    applyEmergencyTimeouts() {
-        logger.warn('🚨 Applying emergency timeout settings to prevent hangs');
-        this.config = {
-            startup: 30000, // 30 seconds
-            operation: 60000, // 1 minute
-            deployment: 120000, // 2 minutes
-            memory: 15000, // 15 seconds for memory ops
-            global: 60000 // 1 minute global
-        };
-    }
-    /**
-     * Apply timeout override if configured
-     */
-    applyOverride() {
-        const override = process.env.SNOW_TIMEOUT_OVERRIDE;
-        if (override) {
-            const overrideMs = parseInt(override);
-            if (!isNaN(overrideMs)) {
-                logger.warn(`⚠️ Applying global timeout override: ${overrideMs / 1000}s`);
-                this.config = {
-                    startup: overrideMs,
-                    operation: overrideMs,
-                    deployment: overrideMs,
-                    memory: Math.min(overrideMs, 120000), // Cap memory ops at 2 minutes
-                    global: overrideMs
-                };
-            }
-        }
-    }
-}
-exports.MCPTimeoutManager = MCPTimeoutManager;
-// Export singleton instance
-exports.mcpTimeoutManager = MCPTimeoutManager.getInstance();
-//# sourceMappingURL=mcp-timeout-fix.js.map

package/dist/utils/migrate-claude-flow.d.ts

@@ -1,22 +0,0 @@
-export declare class ClaudeFlowMigration {
-    private logger;
-    constructor();
-    /**
-     * Check if migration is needed
-     */
-    checkMigrationNeeded(): Promise<boolean>;
-    /**
-     * Perform migration from .snow-flow to .snow-flow
-     */
-    migrate(): Promise<void>;
-    /**
-     * Recursively copy directory
-     */
-    private copyDirectory;
-    /**
-     * Clean up old .snow-flow directory (only after user confirmation)
-     */
-    cleanup(): Promise<void>;
-}
-export declare const migrationUtil: ClaudeFlowMigration;
-//# sourceMappingURL=migrate-claude-flow.d.ts.map

package/dist/utils/migrate-claude-flow.js

@@ -1,120 +0,0 @@
-"use strict";
-var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
-    if (k2 === undefined) k2 = k;
-    var desc = Object.getOwnPropertyDescriptor(m, k);
-    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
-      desc = { enumerable: true, get: function() { return m[k]; } };
-    }
-    Object.defineProperty(o, k2, desc);
-}) : (function(o, m, k, k2) {
-    if (k2 === undefined) k2 = k;
-    o[k2] = m[k];
-}));
-var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
-    Object.defineProperty(o, "default", { enumerable: true, value: v });
-}) : function(o, v) {
-    o["default"] = v;
-});
-var __importStar = (this && this.__importStar) || (function () {
-    var ownKeys = function(o) {
-        ownKeys = Object.getOwnPropertyNames || function (o) {
-            var ar = [];
-            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
-            return ar;
-        };
-        return ownKeys(o);
-    };
-    return function (mod) {
-        if (mod && mod.__esModule) return mod;
-        var result = {};
-        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
-        __setModuleDefault(result, mod);
-        return result;
-    };
-})();
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.migrationUtil = exports.ClaudeFlowMigration = void 0;
-/**
- * Migration utility to move from .snow-flow to .snow-flow directories
- */
-const fs = __importStar(require("fs"));
-const path = __importStar(require("path"));
-const logger_js_1 = require("./logger.js");
-class ClaudeFlowMigration {
-    constructor() {
-        this.logger = new logger_js_1.Logger('Migration');
-    }
-    /**
-     * Check if migration is needed
-     */
-    async checkMigrationNeeded() {
-        const oldDir = path.join(process.cwd(), '.snow-flow');
-        const newDir = path.join(process.cwd(), '.snow-flow');
-        return fs.existsSync(oldDir) && !fs.existsSync(newDir);
-    }
-    /**
-     * Perform migration from .snow-flow to .snow-flow
-     */
-    async migrate() {
-        const oldDir = path.join(process.cwd(), '.snow-flow');
-        const newDir = path.join(process.cwd(), '.snow-flow');
-        if (!fs.existsSync(oldDir)) {
-            this.logger.debug('No .snow-flow directory found, skipping migration');
-            return;
-        }
-        if (fs.existsSync(newDir)) {
-            this.logger.warn('.snow-flow directory already exists, skipping migration');
-            return;
-        }
-        this.logger.info('🔄 Migrating from .snow-flow to .snow-flow...');
-        try {
-            // Create new directory structure
-            await this.copyDirectory(oldDir, newDir);
-            this.logger.info('✅ Migration completed successfully!');
-            this.logger.info('💡 Old .snow-flow directory preserved for safety');
-            this.logger.info('🔍 You can manually delete .snow-flow after verifying everything works');
-        }
-        catch (error) {
-            this.logger.error('❌ Migration failed:', error);
-            throw error;
-        }
-    }
-    /**
-     * Recursively copy directory
-     */
-    async copyDirectory(src, dest) {
-        // Create destination directory
-        if (!fs.existsSync(dest)) {
-            fs.mkdirSync(dest, { recursive: true });
-        }
-        // Read source directory
-        const entries = fs.readdirSync(src, { withFileTypes: true });
-        for (const entry of entries) {
-            const srcPath = path.join(src, entry.name);
-            const destPath = path.join(dest, entry.name);
-            if (entry.isDirectory()) {
-                // Recursively copy subdirectory
-                await this.copyDirectory(srcPath, destPath);
-            }
-            else {
-                // Copy file
-                fs.copyFileSync(srcPath, destPath);
-                this.logger.debug(`Copied: ${entry.name}`);
-            }
-        }
-    }
-    /**
-     * Clean up old .snow-flow directory (only after user confirmation)
-     */
-    async cleanup() {
-        const oldDir = path.join(process.cwd(), '.snow-flow');
-        if (fs.existsSync(oldDir)) {
-            this.logger.warn('⚠️  Removing old .snow-flow directory...');
-            fs.rmSync(oldDir, { recursive: true, force: true });
-            this.logger.info('✅ Cleanup completed');
-        }
-    }
-}
-exports.ClaudeFlowMigration = ClaudeFlowMigration;
-exports.migrationUtil = new ClaudeFlowMigration();
-//# sourceMappingURL=migrate-claude-flow.js.map

package/dist/utils/scope-utils.d.ts

@@ -1,72 +0,0 @@
-/**
- * Utility functions for scope management and analysis
- */
-import { ScopeType } from '../strategies/global-scope-strategy.js';
-export interface ScopeAnalysisResult {
-    recommendedScope: ScopeType;
-    confidence: number;
-    indicators: {
-        global: string[];
-        application: string[];
-        system: string[];
-    };
-    complexity: 'low' | 'medium' | 'high';
-    crossAppIntegration: boolean;
-}
-export declare class ScopeUtils {
-    /**
-     * Analyze artifact content to determine optimal scope
-     */
-    static analyzeArtifactScope(artifactType: string, artifactData: any): ScopeAnalysisResult;
-    /**
-     * Extract content from artifact for analysis
-     */
-    static extractArtifactContent(artifactData: any): string;
-    /**
-     * Analyze artifact complexity
-     */
-    static analyzeComplexity(artifactType: string, artifactData: any): 'low' | 'medium' | 'high';
-    /**
-     * Check if artifact has cross-application integration
-     */
-    static hasCrossAppIntegration(content: string): boolean;
-    /**
-     * Validate scope configuration
-     */
-    static validateScopeConfiguration(config: any): {
-        isValid: boolean;
-        issues: string[];
-    };
-    /**
-     * Generate scope recommendation report
-     */
-    static generateScopeReport(_analysis: ScopeAnalysisResult): string;
-    /**
-     * Generate recommendations based on analysis
-     */
-    static generateRecommendations(_analysis: ScopeAnalysisResult): string[];
-    /**
-     * Compare two scope configurations
-     */
-    static compareScopeConfigurations(config1: any, config2: any): {
-        isDifferent: boolean;
-        differences: string[];
-    };
-    /**
-     * Get scope display name
-     */
-    static getScopeDisplayName(scope: ScopeType): string;
-    /**
-     * Get scope description
-     */
-    static getScopeDescription(scope: ScopeType): string;
-    /**
-     * Get scope benefits
-     */
-    static getScopeBenefits(scope: ScopeType): string[];
-    /**
-     * Get scope risks
-     */
-    static getScopeRisks(scope: ScopeType): string[];
-}
-//# sourceMappingURL=scope-utils.d.ts.map