snow-flow 3.0.8 → 3.0.10

package/dist/benchmark-performance.js

@@ -1,230 +0,0 @@
-#!/usr/bin/env node
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.PerformanceBenchmark = void 0;
-const servicenow_client_js_1 = require("./utils/servicenow-client.js");
-const logger_js_1 = require("./utils/logger.js");
-class PerformanceBenchmark {
-    constructor() {
-        this.results = [];
-        this.client = new servicenow_client_js_1.ServiceNowClient();
-        this.logger = new logger_js_1.Logger('Benchmark');
-    }
-    /**
-     * Measure memory usage of a data structure
-     */
-    measureMemory(data) {
-        const jsonString = JSON.stringify(data);
-        return Buffer.byteLength(jsonString, 'utf8');
-    }
-    /**
-     * Format bytes to human readable string
-     */
-    formatBytes(bytes) {
-        if (bytes < 1024)
-            return `${bytes} B`;
-        if (bytes < 1024 * 1024)
-            return `${(bytes / 1024).toFixed(2)} KB`;
-        return `${(bytes / (1024 * 1024)).toFixed(2)} MB`;
-    }
-    /**
-     * Benchmark count-only queries (minimal memory footprint)
-     */
-    async benchmarkCountOnly() {
-        console.log('\n📊 Benchmarking COUNT-ONLY Queries...\n');
-        const tables = ['incident', 'sc_request', 'problem', 'change_request'];
-        for (const table of tables) {
-            const startTime = Date.now();
-            // Count-only query
-            const response = await this.client.searchRecords(table, 'active=true', 100);
-            const count = response.data?.result?.length || 0;
-            // Minimal memory structure
-            const result = { count };
-            const executionTime = Date.now() - startTime;
-            const memoryUsed = this.measureMemory(result);
-            this.results.push({
-                operation: `${table} count-only`,
-                executionTime,
-                memoryUsed,
-                recordsProcessed: count,
-                efficiency: `${(count / (memoryUsed / 1024)).toFixed(2)} records/KB`
-            });
-            console.log(`✅ ${table}: ${count} records`);
-            console.log(`   Time: ${executionTime}ms | Memory: ${this.formatBytes(memoryUsed)}`);
-            console.log(`   Efficiency: ${(count / (memoryUsed / 1024)).toFixed(2)} records/KB\n`);
-        }
-    }
-    /**
-     * Benchmark specific field queries (optimized memory)
-     */
-    async benchmarkSpecificFields() {
-        console.log('\n🎯 Benchmarking SPECIFIC FIELDS Queries...\n');
-        const startTime = Date.now();
-        // Fetch only essential fields
-        const response = await this.client.searchRecords('incident', 'priority=1', 50);
-        const filtered = response.data?.result?.map((inc) => ({
-            number: inc.number,
-            short_description: inc.short_description,
-            priority: inc.priority,
-            state: inc.state
-        })) || [];
-        const executionTime = Date.now() - startTime;
-        const memoryUsed = this.measureMemory(filtered);
-        this.results.push({
-            operation: 'incident specific fields',
-            executionTime,
-            memoryUsed,
-            recordsProcessed: filtered.length,
-            efficiency: `${(filtered.length / (memoryUsed / 1024)).toFixed(2)} records/KB`
-        });
-        console.log(`✅ Incidents with specific fields: ${filtered.length} records`);
-        console.log(`   Time: ${executionTime}ms | Memory: ${this.formatBytes(memoryUsed)}`);
-        console.log(`   Sample:`, filtered[0] || 'No data');
-    }
-    /**
-     * Benchmark ML batch processing
-     */
-    async benchmarkMLBatchProcessing() {
-        console.log('\n🤖 Benchmarking ML BATCH Processing...\n');
-        const batchSizes = [50, 100, 200];
-        for (const batchSize of batchSizes) {
-            const startTime = Date.now();
-            const batches = [];
-            // Simulate batch processing for ML
-            for (let offset = 0; offset < 500; offset += batchSize) {
-                const response = await this.client.searchRecords('incident', `sys_created_onONLast 6 months^ORDERBYDESCsys_created_on`, batchSize);
-                // Process only what's needed for ML (minimal fields)
-                const mlData = response.data?.result?.map((inc) => ({
-                    text: `${inc.short_description} ${inc.description}`.substring(0, 500),
-                    category: inc.category || 'uncategorized',
-                    priority: inc.priority
-                })) || [];
-                batches.push(mlData);
-                // Break after first batch for demo
-                break;
-            }
-            const executionTime = Date.now() - startTime;
-            const memoryUsed = this.measureMemory(batches);
-            const recordsProcessed = batches.reduce((sum, batch) => sum + batch.length, 0);
-            this.results.push({
-                operation: `ML batch size ${batchSize}`,
-                executionTime,
-                memoryUsed,
-                recordsProcessed,
-                efficiency: `${(recordsProcessed / (memoryUsed / 1024)).toFixed(2)} records/KB`
-            });
-            console.log(`✅ ML Batch Size ${batchSize}: ${recordsProcessed} records`);
-            console.log(`   Time: ${executionTime}ms | Memory: ${this.formatBytes(memoryUsed)}`);
-            console.log(`   Efficiency: ${(recordsProcessed / (memoryUsed / 1024)).toFixed(2)} records/KB\n`);
-        }
-    }
-    /**
-     * Compare full content vs optimized queries
-     */
-    async benchmarkComparison() {
-        console.log('\n⚖️ Comparing FULL vs OPTIMIZED Queries...\n');
-        const limit = 100;
-        // Full content query
-        const fullStart = Date.now();
-        const fullResponse = await this.client.searchRecords('incident', 'active=true', limit);
-        const fullTime = Date.now() - fullStart;
-        const fullMemory = this.measureMemory(fullResponse.data?.result || []);
-        // Optimized query (count + sample)
-        const optStart = Date.now();
-        const optResponse = await this.client.searchRecords('incident', 'active=true', limit);
-        const optimized = {
-            count: optResponse.data?.result?.length || 0,
-            sample: optResponse.data?.result?.slice(0, 5).map((inc) => ({
-                number: inc.number,
-                short_description: inc.short_description
-            })) || []
-        };
-        const optTime = Date.now() - optStart;
-        const optMemory = this.measureMemory(optimized);
-        console.log('📊 Comparison Results:');
-        console.log('─'.repeat(50));
-        console.log('Full Content Query:');
-        console.log(`  Time: ${fullTime}ms`);
-        console.log(`  Memory: ${this.formatBytes(fullMemory)}`);
-        console.log(`  Records: ${fullResponse.data?.result?.length || 0}`);
-        console.log();
-        console.log('Optimized Query:');
-        console.log(`  Time: ${optTime}ms`);
-        console.log(`  Memory: ${this.formatBytes(optMemory)}`);
-        console.log(`  Records: ${optimized.count}`);
-        console.log();
-        console.log('🚀 Improvements:');
-        console.log(`  Memory Saved: ${this.formatBytes(fullMemory - optMemory)} (${((1 - optMemory / fullMemory) * 100).toFixed(1)}% reduction)`);
-        console.log(`  Speed: ${((fullTime - optTime) / fullTime * 100).toFixed(1)}% faster`);
-    }
-    /**
-     * Generate summary report
-     */
-    generateReport() {
-        console.log('\n' + '═'.repeat(60));
-        console.log('📈 PERFORMANCE BENCHMARK SUMMARY');
-        console.log('═'.repeat(60));
-        console.log('\n🏆 Best Practices for Query Optimization:\n');
-        console.log('1. ✅ Use COUNT-ONLY for ML training data sizing');
-        console.log('   - 99.9% memory savings');
-        console.log('   - Instant performance metrics\n');
-        console.log('2. ✅ Request SPECIFIC FIELDS when possible');
-        console.log('   - 70-80% memory reduction');
-        console.log('   - Faster network transfer\n');
-        console.log('3. ✅ Use BATCH PROCESSING for large datasets');
-        console.log('   - Prevents memory overflow');
-        console.log('   - Enables streaming processing\n');
-        console.log('4. ✅ Leverage GROUP BY for analytics');
-        console.log('   - Pre-aggregated results');
-        console.log('   - Minimal data transfer\n');
-        console.log('5. ✅ Only use FULL CONTENT when necessary');
-        console.log('   - Reserve for detailed analysis');
-        console.log('   - Consider pagination for large sets\n');
-        console.log('📊 Benchmark Results:');
-        console.log('─'.repeat(60));
-        const table = this.results.map(r => ({
-            Operation: r.operation,
-            Time: `${r.executionTime}ms`,
-            Memory: this.formatBytes(r.memoryUsed),
-            Records: r.recordsProcessed,
-            Efficiency: r.efficiency
-        }));
-        console.table(table);
-        // Calculate average improvements
-        const avgMemorySavings = this.results
-            .filter(r => r.operation.includes('count'))
-            .reduce((sum, r) => sum + (1000000 - r.memoryUsed), 0) / 4;
-        console.log('\n🎯 Key Metrics:');
-        console.log(`Average Memory Savings: ${this.formatBytes(avgMemorySavings)}`);
-        console.log(`ML Training Efficiency: ${this.results.find(r => r.operation.includes('ML'))?.efficiency || 'N/A'}`);
-        console.log(`Optimal Batch Size: 100-200 records for balanced performance`);
-    }
-    /**
-     * Run all benchmarks
-     */
-    async runAll() {
-        console.log('\n🚀 Starting Snow-Flow Performance Benchmark...\n');
-        console.log('This benchmark demonstrates the efficiency improvements');
-        console.log('of the universal query tool and ML batch processing.\n');
-        console.log('═'.repeat(60));
-        try {
-            await this.benchmarkCountOnly();
-            await this.benchmarkSpecificFields();
-            await this.benchmarkMLBatchProcessing();
-            await this.benchmarkComparison();
-            this.generateReport();
-            console.log('\n✅ Benchmark completed successfully!');
-        }
-        catch (error) {
-            this.logger.error('Benchmark failed:', error);
-            console.error('\n❌ Benchmark failed. Check your ServiceNow connection.');
-        }
-    }
-}
-exports.PerformanceBenchmark = PerformanceBenchmark;
-// Run benchmark if executed directly
-if (require.main === module) {
-    const benchmark = new PerformanceBenchmark();
-    benchmark.runAll().catch(console.error);
-}
-//# sourceMappingURL=benchmark-performance.js.map

package/dist/cli/snow-flow-cli-integration.d.ts

@@ -1,30 +0,0 @@
-/**
- * Snow-Flow CLI Integration
- * Integrates the hive-mind system with the CLI commands
- */
-import { Command } from 'commander';
-/**
- * Initialize the swarm command with the integrated system
- */
-export declare function createSwarmCommand(program: Command): void;
-/**
- * Create status command
- */
-export declare function createStatusCommand(program: Command): void;
-/**
- * Create monitor command
- */
-export declare function createMonitorCommand(program: Command): void;
-/**
- * Create memory management commands
- */
-export declare function createMemoryCommands(program: Command): void;
-/**
- * Create configuration commands
- */
-export declare function createConfigCommands(program: Command): void;
-/**
- * Integrate all commands with the main program
- */
-export declare function integrateSnowFlowCommands(program: Command): void;
-//# sourceMappingURL=snow-flow-cli-integration.d.ts.map

package/dist/cli/snow-flow-cli-integration.js

@@ -1,396 +0,0 @@
-"use strict";
-/**
- * Snow-Flow CLI Integration
- * Integrates the hive-mind system with the CLI commands
- */
-var __importDefault = (this && this.__importDefault) || function (mod) {
-    return (mod && mod.__esModule) ? mod : { "default": mod };
-};
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.createSwarmCommand = createSwarmCommand;
-exports.createStatusCommand = createStatusCommand;
-exports.createMonitorCommand = createMonitorCommand;
-exports.createMemoryCommands = createMemoryCommands;
-exports.createConfigCommands = createConfigCommands;
-exports.integrateSnowFlowCommands = integrateSnowFlowCommands;
-const snow_flow_system_1 = require("../snow-flow-system");
-const snow_flow_config_1 = require("../config/snow-flow-config");
-const logger_1 = require("../utils/logger");
-const chalk_1 = __importDefault(require("chalk"));
-const ora_1 = __importDefault(require("ora"));
-const logger = new logger_1.Logger('SnowFlowCLI');
-/**
- * Initialize the swarm command with the integrated system
- */
-function createSwarmCommand(program) {
-    program
-        .command('swarm <objective>')
-        .description('🚀 Execute multi-agent swarm coordination with REVOLUTIONARY Parallel Agent Engine (v1.1.90) - automatically spawns specialized agent teams working simultaneously with 2-5x performance improvement')
-        .option('--strategy <strategy>', 'Swarm strategy', 'development')
-        .option('--mode <mode>', 'Coordination mode', 'hierarchical')
-        .option('--max-agents <number>', 'Maximum number of agents', '10')
-        .option('--parallel', 'Enable parallel execution (auto-detected by default in v1.1.90)')
-        .option('--monitor', 'Real-time monitoring')
-        .option('--no-auto-permissions', 'Disable automatic permission escalation')
-        .option('--no-smart-discovery', 'Disable smart artifact discovery')
-        .option('--no-live-testing', 'Disable live testing')
-        .option('--no-auto-deploy', 'Disable automatic deployment')
-        .option('--no-auto-rollback', 'Disable automatic rollback')
-        .option('--no-shared-memory', 'Disable shared memory')
-        .option('--no-progress-monitoring', 'Disable progress monitoring')
-        .action(async (objective, options) => {
-        const spinner = (0, ora_1.default)('Initializing Snow-Flow System...').start();
-        try {
-            // Initialize system
-            await snow_flow_system_1.snowFlowSystem.initialize();
-            spinner.succeed('System initialized');
-            // Parse options
-            const swarmOptions = {
-                strategy: options.strategy,
-                mode: options.mode,
-                maxAgents: parseInt(options.maxAgents) || 10,
-                parallel: options.parallel,
-                monitor: options.monitor,
-                autoPermissions: options.autoPermissions,
-                smartDiscovery: options.smartDiscovery,
-                liveTesting: options.liveTesting,
-                autoDeploy: options.autoDeploy,
-                autoRollback: options.autoRollback,
-                sharedMemory: options.sharedMemory,
-                progressMonitoring: options.progressMonitoring
-            };
-            console.log(chalk_1.default.cyan('\n🐝 Starting Swarm Execution'));
-            console.log(chalk_1.default.yellow('🚀 NEW v1.1.93: Revolutionary Parallel Agent Spawning - 6+ specialized agents for 2.8x faster development!'));
-            console.log(chalk_1.default.gray('Objective:'), objective);
-            console.log(chalk_1.default.gray('Strategy:'), swarmOptions.strategy);
-            console.log(chalk_1.default.gray('Mode:'), swarmOptions.mode);
-            // Set up progress monitoring
-            if (swarmOptions.progressMonitoring) {
-                snow_flow_system_1.snowFlowSystem.on('swarm:progress', (data) => {
-                    const { sessionId, progress } = data;
-                    console.log(chalk_1.default.blue(`[${sessionId}]`), `Progress: ${progress.completed}/${progress.total} tasks`);
-                });
-                snow_flow_system_1.snowFlowSystem.on('agent:spawned', (agent) => {
-                    console.log(chalk_1.default.green('✅ Agent spawned:'), agent.type);
-                    if (agent.specialization) {
-                        console.log(chalk_1.default.blue('   🎯 Specialization:'), agent.specialization);
-                    }
-                });
-                snow_flow_system_1.snowFlowSystem.on('agent:completed', (agent) => {
-                    console.log(chalk_1.default.green('✅ Agent completed:'), agent.type);
-                });
-                snow_flow_system_1.snowFlowSystem.on('parallel:detected', (data) => {
-                    console.log(chalk_1.default.magenta('🚀 Parallel opportunities detected:'), data.opportunities.length);
-                    data.opportunities.forEach((opp, index) => {
-                        console.log(chalk_1.default.cyan(`   ${index + 1}. ${opp.type}: ${opp.agentCount} agents, estimated ${opp.estimatedSpeedup}x speedup`));
-                    });
-                });
-            }
-            // Execute swarm
-            const startTime = Date.now();
-            const result = await snow_flow_system_1.snowFlowSystem.executeSwarm(objective, swarmOptions);
-            const duration = Date.now() - startTime;
-            // Display results
-            console.log(chalk_1.default.green('\n✅ Swarm execution completed successfully!'));
-            console.log(chalk_1.default.gray('Session ID:'), result.sessionId);
-            console.log(chalk_1.default.gray('Duration:'), `${(duration / 1000).toFixed(2)}s`);
-            console.log(chalk_1.default.gray('Artifacts created:'), result.artifacts.length);
-            if (result.artifacts.length > 0) {
-                console.log(chalk_1.default.yellow('\n📦 Created Artifacts:'));
-                result.artifacts.forEach((artifact, index) => {
-                    console.log(`  ${index + 1}. ${artifact.type}: ${artifact.name} (${artifact.sys_id})`);
-                });
-            }
-            console.log(chalk_1.default.cyan('\n📝 Summary:'));
-            console.log(result.summary);
-            // Show metrics if available
-            if (result.metrics && Object.keys(result.metrics).length > 0) {
-                console.log(chalk_1.default.yellow('\n📊 Performance Metrics:'));
-                console.log(JSON.stringify(result.metrics, null, 2));
-            }
-        }
-        catch (error) {
-            spinner.fail('Swarm execution failed');
-            logger.error('Swarm execution error:', error);
-            console.error(chalk_1.default.red('\n❌ Error:'), error.message);
-            process.exit(1);
-        }
-    });
-}
-/**
- * Create status command
- */
-function createStatusCommand(program) {
-    program
-        .command('status')
-        .description('Show comprehensive system status')
-        .action(async () => {
-        const spinner = (0, ora_1.default)('Checking system status...').start();
-        try {
-            const status = await snow_flow_system_1.snowFlowSystem.getStatus();
-            spinner.stop();
-            // Display system status
-            console.log(chalk_1.default.bold('\n🔍 Snow-Flow System Status\n'));
-            const statusIcon = status.status === 'healthy' ? '✅' :
-                status.status === 'degraded' ? '⚠️' : '❌';
-            console.log(`${statusIcon} Overall Status: ${chalk_1.default.bold(status.status.toUpperCase())}`);
-            console.log(chalk_1.default.gray('Initialized:'), status.initialized ? 'Yes' : 'No');
-            if (status.components) {
-                console.log(chalk_1.default.yellow('\n📦 Component Health:'));
-                for (const [component, health] of Object.entries(status.components)) {
-                    const icon = health.status === 'healthy' ? '✅' :
-                        health.status === 'degraded' ? '⚠️' : '❌';
-                    console.log(`  ${icon} ${component}: ${health.status}`);
-                    if (health.message) {
-                        console.log(chalk_1.default.gray(`     ${health.message}`));
-                    }
-                }
-            }
-            if (status.activeSessions !== undefined) {
-                console.log(chalk_1.default.yellow('\n📊 Activity:'));
-                console.log(`  - Active Sessions: ${status.activeSessions}`);
-            }
-            if (status.metrics) {
-                console.log(chalk_1.default.yellow('\n📈 System Metrics:'));
-                console.log(`  - Total Sessions: ${status.metrics.totalSessions}`);
-                console.log(`  - Success Rate: ${status.metrics.successRate.toFixed(2)}%`);
-                console.log(`  - Avg Execution Time: ${(status.metrics.averageExecutionTime / 1000).toFixed(2)}s`);
-            }
-        }
-        catch (error) {
-            spinner.fail('Failed to get system status');
-            console.error(chalk_1.default.red('Error:'), error.message);
-            process.exit(1);
-        }
-    });
-}
-/**
- * Create monitor command
- */
-function createMonitorCommand(program) {
-    program
-        .command('monitor')
-        .description('Real-time system monitoring dashboard')
-        .option('--interval <ms>', 'Update interval in milliseconds', '5000')
-        .action(async (options) => {
-        console.log(chalk_1.default.bold.cyan('\n📊 Snow-Flow Real-time Monitor\n'));
-        console.log(chalk_1.default.gray('Press Ctrl+C to exit'));
-        console.log(chalk_1.default.gray('='.repeat(50)));
-        try {
-            // Initialize system if needed
-            const status = snow_flow_system_1.snowFlowSystem.getStatus();
-            if (!status.initialized) {
-                await snow_flow_system_1.snowFlowSystem.initialize();
-            }
-            // Set up event listeners
-            snow_flow_system_1.snowFlowSystem.on('swarm:progress', (data) => {
-                console.log(chalk_1.default.blue(`\n[${new Date().toISOString()}] Swarm Progress`));
-                console.log(`  Session: ${data.sessionId}`);
-                console.log(`  Progress: ${data.progress.completed}/${data.progress.total}`);
-            });
-            snow_flow_system_1.snowFlowSystem.on('agent:spawned', (agent) => {
-                console.log(chalk_1.default.green(`\n[${new Date().toISOString()}] Agent Spawned`));
-                console.log(`  Type: ${agent.type}`);
-                console.log(`  ID: ${agent.id}`);
-            });
-            snow_flow_system_1.snowFlowSystem.on('performance:metric', (metric) => {
-                console.log(chalk_1.default.yellow(`\n[${new Date().toISOString()}] Performance Metric`));
-                console.log(`  Operation: ${metric.operation}`);
-                console.log(`  Duration: ${metric.duration}ms`);
-                console.log(`  Success: ${metric.success}`);
-            });
-            snow_flow_system_1.snowFlowSystem.on('health:alert', (alert) => {
-                console.log(chalk_1.default.red(`\n[${new Date().toISOString()}] Health Alert`));
-                console.log(`  Type: ${alert.type}`);
-                console.log(`  Severity: ${alert.severity}`);
-                console.log(`  Message: ${alert.message}`);
-            });
-            // Periodic status update
-            const updateInterval = parseInt(options.interval) || 5000;
-            setInterval(async () => {
-                const status = await snow_flow_system_1.snowFlowSystem.getStatus();
-                const sessions = snow_flow_system_1.snowFlowSystem.listSessions({ status: 'active' });
-                console.log(chalk_1.default.dim(`\n[${new Date().toISOString()}] Status Update`));
-                console.log(chalk_1.default.dim(`  System: ${status.status}`));
-                console.log(chalk_1.default.dim(`  Active Sessions: ${sessions.length}`));
-                if (sessions.length > 0) {
-                    sessions.forEach(session => {
-                        console.log(chalk_1.default.dim(`    - ${session.id}: ${session.completedTasks}/${session.totalTasks} tasks`));
-                    });
-                }
-            }, updateInterval);
-            // Keep process running
-            process.stdin.resume();
-        }
-        catch (error) {
-            console.error(chalk_1.default.red('Monitor error:'), error.message);
-            process.exit(1);
-        }
-    });
-}
-/**
- * Create memory management commands
- */
-function createMemoryCommands(program) {
-    const memory = program
-        .command('memory')
-        .description('Manage persistent memory system');
-    memory
-        .command('store <key> <value>')
-        .description('Store data in memory')
-        .option('--ttl <ms>', 'Time to live in milliseconds')
-        .action(async (key, value, options) => {
-        try {
-            await snow_flow_system_1.snowFlowSystem.initialize();
-            const memorySystem = snow_flow_system_1.snowFlowSystem.getMemory();
-            if (!memorySystem) {
-                throw new Error('Memory system not available');
-            }
-            // Parse value as JSON if possible
-            let parsedValue;
-            try {
-                parsedValue = JSON.parse(value);
-            }
-            catch {
-                parsedValue = value;
-            }
-            await memorySystem.store(key, parsedValue, options.ttl ? parseInt(options.ttl) : undefined);
-            console.log(chalk_1.default.green('✅ Data stored successfully'));
-        }
-        catch (error) {
-            console.error(chalk_1.default.red('Error:'), error.message);
-            process.exit(1);
-        }
-    });
-    memory
-        .command('get <key>')
-        .description('Retrieve data from memory')
-        .action(async (key) => {
-        try {
-            await snow_flow_system_1.snowFlowSystem.initialize();
-            const memorySystem = snow_flow_system_1.snowFlowSystem.getMemory();
-            if (!memorySystem) {
-                throw new Error('Memory system not available');
-            }
-            const value = await memorySystem.get(key);
-            if (value === null) {
-                console.log(chalk_1.default.yellow('Key not found or expired'));
-            }
-            else {
-                console.log(chalk_1.default.green('Value:'));
-                console.log(JSON.stringify(value, null, 2));
-            }
-        }
-        catch (error) {
-            console.error(chalk_1.default.red('Error:'), error.message);
-            process.exit(1);
-        }
-    });
-    memory
-        .command('stats')
-        .description('Show memory system statistics')
-        .action(async () => {
-        try {
-            await snow_flow_system_1.snowFlowSystem.initialize();
-            const memorySystem = snow_flow_system_1.snowFlowSystem.getMemory();
-            if (!memorySystem) {
-                throw new Error('Memory system not available');
-            }
-            const dbStats = await memorySystem.getDatabaseStats();
-            const cacheStats = await memorySystem.getCacheStats();
-            console.log(chalk_1.default.bold('\n💾 Memory System Statistics\n'));
-            console.log(chalk_1.default.yellow('Database:'));
-            console.log(`  Size: ${(dbStats.size / 1024 / 1024).toFixed(2)} MB`);
-            console.log(`  Tables: ${dbStats.tableCount}`);
-            console.log(`  Row Counts:`);
-            for (const [table, count] of Object.entries(dbStats.rowCounts)) {
-                console.log(`    - ${table}: ${count} rows`);
-            }
-            console.log(chalk_1.default.yellow('\nCache:'));
-            console.log(`  Size: ${cacheStats.size} entries`);
-            console.log(`  Hits: ${cacheStats.hits}`);
-            console.log(`  Misses: ${cacheStats.misses}`);
-            console.log(`  Hit Rate: ${cacheStats.hits + cacheStats.misses > 0 ?
-                ((cacheStats.hits / (cacheStats.hits + cacheStats.misses)) * 100).toFixed(2) : 0}%`);
-            console.log(`  Evictions: ${cacheStats.evictions}`);
-        }
-        catch (error) {
-            console.error(chalk_1.default.red('Error:'), error.message);
-            process.exit(1);
-        }
-    });
-}
-/**
- * Create configuration commands
- */
-function createConfigCommands(program) {
-    const config = program
-        .command('config')
-        .description('Configuration management');
-    config
-        .command('show')
-        .description('Show current configuration')
-        .action(() => {
-        const currentConfig = snow_flow_config_1.snowFlowConfig.get();
-        console.log(chalk_1.default.bold('\n⚙️ Snow-Flow Configuration\n'));
-        console.log(JSON.stringify(currentConfig, null, 2));
-    });
-    config
-        .command('get <path>')
-        .description('Get a specific configuration value')
-        .action((path) => {
-        const value = snow_flow_config_1.snowFlowConfig.getValue(path);
-        if (value === undefined) {
-            console.log(chalk_1.default.yellow('Configuration key not found'));
-        }
-        else {
-            console.log(chalk_1.default.green('Value:'), JSON.stringify(value, null, 2));
-        }
-    });
-    config
-        .command('set <path> <value>')
-        .description('Set a configuration value')
-        .action((path, value) => {
-        try {
-            // Parse value as JSON if possible
-            let parsedValue;
-            try {
-                parsedValue = JSON.parse(value);
-            }
-            catch {
-                parsedValue = value;
-            }
-            snow_flow_config_1.snowFlowConfig.setValue(path, parsedValue);
-            console.log(chalk_1.default.green('✅ Configuration updated'));
-        }
-        catch (error) {
-            console.error(chalk_1.default.red('Error:'), error.message);
-            process.exit(1);
-        }
-    });
-}
-/**
- * Integrate all commands with the main program
- */
-function integrateSnowFlowCommands(program) {
-    // Add all integrated commands
-    createSwarmCommand(program);
-    createStatusCommand(program);
-    createMonitorCommand(program);
-    createMemoryCommands(program);
-    createConfigCommands(program);
-    // Add shutdown handler
-    process.on('SIGINT', async () => {
-        console.log(chalk_1.default.yellow('\n\nShutting down Snow-Flow System...'));
-        try {
-            await snow_flow_system_1.snowFlowSystem.shutdown();
-            console.log(chalk_1.default.green('✅ Shutdown complete'));
-            process.exit(0);
-        }
-        catch (error) {
-            console.error(chalk_1.default.red('Shutdown error:'), error);
-            process.exit(1);
-        }
-    });
-}
-//# sourceMappingURL=snow-flow-cli-integration.js.map