claude-flow-novice 1.0.0

package/dist/src/cli/init/swarm-commands.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../../../src/cli/init/swarm-commands.ts"],"names":["createSwarmCommands","fs","path","swarmDir","swarmCommands","createResearchCommand","createDevelopmentCommand","createAnalysisCommand","createTestingCommand","createOptimizationCommand","createMaintenanceCommand","createSwarmExamples","createCoordinationModes","createBestPractices","createTaskTracking","filename","content","Object","entries","writeFile","join","console","log"],"mappings":"AAAA,gEAAgE;AAChE,OAAO,eAAeA;IACpB,MAAMC,KAAK,MAAM,MAAM,CAAC;IACxB,MAAMC,OAAO,MAAM,MAAM,CAAC;IAE1B,MAAMC,WAAW;IAEjB,oCAAoC;IACpC,MAAMC,gBAAgB;QACpB,eAAeC;QACf,kBAAkBC;QAClB,eAAeC;QACf,cAAcC;QACd,mBAAmBC;QACnB,kBAAkBC;QAClB,eAAeC;QACf,yBAAyBC;QACzB,qBAAqBC;QACrB,oBAAoBC;IACtB;IAEA,oCAAoC;IACpC,KAAK,MAAM,CAACC,UAAUC,QAAQ,IAAIC,OAAOC,OAAO,CAACd,eAAgB;QAC/D,MAAMH,GAAGkB,SAAS,CAACjB,KAAKkB,IAAI,CAACjB,UAAUY,WAAWC;QAClDK,QAAQC,GAAG,CAAC,CAAC,YAAY,EAAEP,UAAU;IACvC;AACF;AAEA,SAASV;IACP,OAAO,CAAC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAwCV,CAAC;AACD;AAEA,SAASC;IACP,OAAO,CAAC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AA2CV,CAAC;AACD;AAEA,SAASC;IACP,OAAO,CAAC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AA4CV,CAAC;AACD;AAEA,SAASC;IACP,OAAO,CAAC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AA6CV,CAAC;AACD;AAEA,SAASC;IACP,OAAO,CAAC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AA4CV,CAAC;AACD;AAEA,SAASC;IACP,OAAO,CAAC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AA6CV,CAAC;AACD;AAEA,SAASC;IACP,OAAO,CAAC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AA2DV,CAAC;AACD;AAEA,SAASC;IACP,OAAO,CAAC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAgIV,CAAC;AACD;AAEA,SAASC;IACP,OAAO,CAAC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AA2HV,CAAC;AACD;AAEA,SAASC;IACP,OAAO,CAAC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAyKV,CAAC;AACD"}

package/dist/src/cli/init/utils.js

@@ -0,0 +1,15 @@
+// init/utils.ts - Utility functions for init module
+export function printSuccess(message) {
+    console.log(`\x1b[32m✅ ${message}\x1b[0m`);
+}
+export function printError(message) {
+    console.log(`\x1b[31m❌ ${message}\x1b[0m`);
+}
+export function printWarning(message) {
+    console.log(`\x1b[33m⚠️  ${message}\x1b[0m`);
+}
+export function printInfo(message) {
+    console.log(`\x1b[36mℹ️  ${message}\x1b[0m`);
+}
+
+//# sourceMappingURL=utils.js.map

package/dist/src/cli/init/utils.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../../../src/cli/init/utils.ts"],"names":["printSuccess","message","console","log","printError","printWarning","printInfo"],"mappings":"AAAA,oDAAoD;AACpD,OAAO,SAASA,aAAaC,OAAe;IAC1CC,QAAQC,GAAG,CAAC,CAAC,UAAU,EAAEF,QAAQ,OAAO,CAAC;AAC3C;AAEA,OAAO,SAASG,WAAWH,OAAe;IACxCC,QAAQC,GAAG,CAAC,CAAC,UAAU,EAAEF,QAAQ,OAAO,CAAC;AAC3C;AAEA,OAAO,SAASI,aAAaJ,OAAe;IAC1CC,QAAQC,GAAG,CAAC,CAAC,YAAY,EAAEF,QAAQ,OAAO,CAAC;AAC7C;AAEA,OAAO,SAASK,UAAUL,OAAe;IACvCC,QAAQC,GAAG,CAAC,CAAC,YAAY,EAAEF,QAAQ,OAAO,CAAC;AAC7C"}

package/dist/src/cli/maestro-cli-bridge.js

@@ -0,0 +1,426 @@
+/**
+ * Maestro CLI Bridge - Optimization Implementation
+ *
+ * This bridge provides optimized CLI integration for the Maestro specifications-driven
+ * development framework, implementing performance enhancements and intelligent features
+ * while maintaining compatibility with existing infrastructure.
+ *
+ * Key optimizations:
+ * - Parallel dependency initialization with caching
+ * - Performance monitoring integration
+ * - Configuration validation and management
+ * - Intelligent error handling and recovery
+ */ import { join } from 'path';
+import chalk from 'chalk';
+import { EventEmitter } from 'events';
+import { AgentManager } from '../agents/agent-manager.js';
+import { Orchestrator } from '../core/orchestrator.js';
+// Maestro system
+import { MaestroSwarmCoordinator } from '../maestro/maestro-swarm-coordinator.js';
+// Performance monitoring
+import { agenticHookManager } from '../services/agentic-flow-hooks/index.js';
+/**
+ * CLI Bridge for optimized Maestro integration
+ */ export class MaestroCLIBridge {
+    bridgeConfig;
+    swarmCoordinator;
+    initializationCache = new Map();
+    configCache;
+    performanceMetrics = [];
+    initialized = false;
+    constructor(bridgeConfig = {}){
+        this.bridgeConfig = bridgeConfig;
+        // Set default configuration
+        this.bridgeConfig = {
+            enablePerformanceMonitoring: true,
+            initializationTimeout: 30000,
+            cacheEnabled: true,
+            logLevel: 'info',
+            ...this.bridgeConfig
+        };
+    }
+    /**
+   * Initialize orchestrator with parallel dependency loading and caching
+   */ async initializeOrchestrator() {
+        const startTime = Date.now();
+        try {
+            if (this.swarmCoordinator && this.initialized) {
+                console.log(chalk.green('✅ Using cached Maestro swarm coordinator'));
+                return this.swarmCoordinator;
+            }
+            console.log(chalk.blue('🚀 Initializing Maestro orchestrator...'));
+            // Parallel initialization with caching
+            const [config, eventBus, logger, memoryManager, agentManager, mainOrchestrator] = await Promise.all([
+                this.getOrCreateConfig(),
+                this.getOrCreateEventBus(),
+                this.getOrCreateLogger(),
+                this.getOrCreateMemoryManager(),
+                this.getOrCreateAgentManager(),
+                this.getOrCreateMainOrchestrator()
+            ]);
+            // Create optimized Maestro configuration
+            const maestroConfig = this.getOptimizedMaestroConfig();
+            // Initialize native swarm coordinator
+            this.swarmCoordinator = new MaestroSwarmCoordinator(maestroConfig, eventBus, logger);
+            // Initialize native hive mind swarm with performance monitoring
+            await this.executeWithMonitoring('swarm_init', async ()=>{
+                const swarmId = await this.swarmCoordinator.initialize();
+                console.log(chalk.green(`✅ Native hive mind swarm initialized: ${swarmId}`));
+            });
+            this.initialized = true;
+            const duration = Date.now() - startTime;
+            console.log(chalk.green(`✅ Maestro orchestrator ready (${duration}ms)`));
+            // Report performance metrics
+            await this.reportPerformanceMetric('orchestrator_init', duration, true);
+            return this.swarmCoordinator;
+        } catch (error) {
+            const duration = Date.now() - startTime;
+            await this.reportPerformanceMetric('orchestrator_init', duration, false, error instanceof Error ? error.message : String(error));
+            console.error(chalk.red(`❌ Failed to initialize Maestro orchestrator: ${error instanceof Error ? error.message : String(error)}`));
+            throw error;
+        }
+    }
+    /**
+   * Execute operation with performance monitoring
+   */ async executeWithMonitoring(operation, fn, context) {
+        if (!this.bridgeConfig.enablePerformanceMonitoring) {
+            return await fn();
+        }
+        const startTime = Date.now();
+        const startMemory = process.memoryUsage().heapUsed;
+        try {
+            // Execute pre-operation hooks
+            await this.executePerformanceHook('performance-metric', {
+                metric: `${operation}_start`,
+                value: startTime,
+                unit: 'timestamp',
+                context: {
+                    operation,
+                    ...context
+                }
+            });
+            const result = await fn();
+            const endTime = Date.now();
+            const endMemory = process.memoryUsage().heapUsed;
+            const duration = endTime - startTime;
+            const memoryDelta = endMemory - startMemory;
+            // Record metrics
+            await this.reportPerformanceMetric(operation, duration, true, undefined, memoryDelta);
+            // Execute post-operation hooks
+            await this.executePerformanceHook('performance-metric', {
+                metric: `${operation}_complete`,
+                value: duration,
+                unit: 'milliseconds',
+                context: {
+                    operation,
+                    success: true,
+                    memoryDelta: memoryDelta / 1024 / 1024,
+                    ...context
+                }
+            });
+            return result;
+        } catch (error) {
+            const duration = Date.now() - startTime;
+            const memoryDelta = process.memoryUsage().heapUsed - startMemory;
+            await this.reportPerformanceMetric(operation, duration, false, error instanceof Error ? error.message : String(error), memoryDelta);
+            // Execute error hooks
+            await this.executePerformanceHook('performance-metric', {
+                metric: `${operation}_error`,
+                value: duration,
+                unit: 'milliseconds',
+                context: {
+                    operation,
+                    success: false,
+                    error: error instanceof Error ? error.message : String(error),
+                    memoryDelta: memoryDelta / 1024 / 1024,
+                    ...context
+                }
+            });
+            throw error;
+        }
+    }
+    /**
+   * Get optimized Maestro configuration
+   */ getOptimizedMaestroConfig() {
+        return {
+            hiveMindConfig: {
+                name: 'maestro-specs-driven-swarm',
+                topology: 'specs-driven',
+                queenMode: 'strategic',
+                maxAgents: 8,
+                consensusThreshold: 0.66,
+                memoryTTL: 86400000,
+                autoSpawn: true,
+                enableConsensus: true,
+                enableMemory: true,
+                enableCommunication: true
+            },
+            enableConsensusValidation: true,
+            enableLivingDocumentation: true,
+            enableSteeringIntegration: true,
+            specsDirectory: join(process.cwd(), 'docs', 'maestro', 'specs'),
+            steeringDirectory: join(process.cwd(), 'docs', 'maestro', 'steering')
+        };
+    }
+    /**
+   * Cached configuration management
+   */ async getOrCreateConfig() {
+        const cacheKey = 'config';
+        if (this.bridgeConfig.cacheEnabled && this.initializationCache.has(cacheKey)) {
+            return this.initializationCache.get(cacheKey);
+        }
+        // Create basic configuration - in a real implementation, this would load from file
+        const config = {
+            env: process.env.NODE_ENV || 'development',
+            logLevel: this.bridgeConfig.logLevel || 'info',
+            enableMetrics: this.bridgeConfig.enablePerformanceMonitoring || true
+        };
+        if (this.bridgeConfig.cacheEnabled) {
+            this.initializationCache.set(cacheKey, config);
+        }
+        return config;
+    }
+    /**
+   * Cached event bus creation
+   */ async getOrCreateEventBus() {
+        const cacheKey = 'eventBus';
+        if (this.bridgeConfig.cacheEnabled && this.initializationCache.has(cacheKey)) {
+            return this.initializationCache.get(cacheKey);
+        }
+        // Create simple event bus implementation
+        const eventBus = new EventEmitter();
+        if (this.bridgeConfig.cacheEnabled) {
+            this.initializationCache.set(cacheKey, eventBus);
+        }
+        return eventBus;
+    }
+    /**
+   * Cached logger creation
+   */ async getOrCreateLogger() {
+        const cacheKey = 'logger';
+        if (this.bridgeConfig.cacheEnabled && this.initializationCache.has(cacheKey)) {
+            return this.initializationCache.get(cacheKey);
+        }
+        // Create simple logger implementation
+        const logger = {
+            debug: (message, ...args)=>{
+                if (this.bridgeConfig.logLevel === 'debug') {
+                    console.log(chalk.gray(`[DEBUG] ${message}`), ...args);
+                }
+            },
+            info: (message, ...args)=>{
+                console.log(chalk.blue(`[INFO] ${message}`), ...args);
+            },
+            warn: (message, ...args)=>{
+                console.log(chalk.yellow(`[WARN] ${message}`), ...args);
+            },
+            error: (message, ...args)=>{
+                console.log(chalk.red(`[ERROR] ${message}`), ...args);
+            },
+            configure: async (config)=>{
+            /* no-op */ },
+            level: this.bridgeConfig.logLevel
+        };
+        if (this.bridgeConfig.cacheEnabled) {
+            this.initializationCache.set(cacheKey, logger);
+        }
+        return logger;
+    }
+    /**
+   * Cached memory manager creation
+   */ async getOrCreateMemoryManager() {
+        const cacheKey = 'memoryManager';
+        if (this.bridgeConfig.cacheEnabled && this.initializationCache.has(cacheKey)) {
+            return this.initializationCache.get(cacheKey);
+        }
+        // Create simple memory manager implementation
+        const memoryManager = {
+            initialize: async ()=>{},
+            shutdown: async ()=>{},
+            createBank: async (agentId)=>`bank-${agentId}`,
+            closeBank: async (bankId)=>{},
+            store: async (entry)=>{},
+            retrieve: async (id)=>undefined,
+            query: async (query)=>[],
+            update: async (id, updates)=>{},
+            delete: async (id)=>{},
+            getHealthStatus: async ()=>({
+                    healthy: true
+                }),
+            performMaintenance: async ()=>{}
+        };
+        if (this.bridgeConfig.cacheEnabled) {
+            this.initializationCache.set(cacheKey, memoryManager);
+        }
+        return memoryManager;
+    }
+    /**
+   * Cached agent manager creation
+   */ async getOrCreateAgentManager() {
+        const cacheKey = 'agentManager';
+        if (this.bridgeConfig.cacheEnabled && this.initializationCache.has(cacheKey)) {
+            return this.initializationCache.get(cacheKey);
+        }
+        // Create agent manager - this would integrate with existing system
+        const config = await this.getOrCreateConfig();
+        const eventBus = await this.getOrCreateEventBus();
+        const logger = await this.getOrCreateLogger();
+        const memoryManager = await this.getOrCreateMemoryManager();
+        const agentManager = new AgentManager({
+            maxAgents: 10
+        }, logger, eventBus, memoryManager);
+        if (this.bridgeConfig.cacheEnabled) {
+            this.initializationCache.set(cacheKey, agentManager);
+        }
+        return agentManager;
+    }
+    /**
+   * Cached main orchestrator creation
+   */ async getOrCreateMainOrchestrator() {
+        const cacheKey = 'mainOrchestrator';
+        if (this.bridgeConfig.cacheEnabled && this.initializationCache.has(cacheKey)) {
+            return this.initializationCache.get(cacheKey);
+        }
+        // Create main orchestrator with required parameters
+        const config = await this.getOrCreateConfig();
+        const eventBus = await this.getOrCreateEventBus();
+        const logger = await this.getOrCreateLogger();
+        const memoryManager = await this.getOrCreateMemoryManager();
+        // Create mock dependencies for orchestrator
+        const mockTerminalManager = {};
+        const mockCoordinationManager = {};
+        const mockMCPServer = {};
+        const orchestrator = new Orchestrator(config, mockTerminalManager, memoryManager, mockCoordinationManager, mockMCPServer, eventBus, logger);
+        if (this.bridgeConfig.cacheEnabled) {
+            this.initializationCache.set(cacheKey, orchestrator);
+        }
+        return orchestrator;
+    }
+    /**
+   * Execute performance hooks
+   */ async executePerformanceHook(type, data) {
+        try {
+            await agenticHookManager.executeHooks(type, data, {
+                sessionId: `maestro-cli-${Date.now()}`,
+                timestamp: Date.now(),
+                correlationId: `maestro-performance`,
+                metadata: {
+                    source: 'maestro-cli-bridge'
+                },
+                memory: {
+                    namespace: 'maestro',
+                    provider: 'memory',
+                    cache: new Map()
+                },
+                neural: {
+                    modelId: 'default',
+                    patterns: null,
+                    training: null
+                },
+                performance: {
+                    metrics: new Map(),
+                    bottlenecks: [],
+                    optimizations: []
+                }
+            });
+        } catch (error) {
+            // Don't let hook failures break the main operation
+            console.warn(chalk.yellow(`⚠️  Performance hook failed: ${error instanceof Error ? error.message : String(error)}`));
+        }
+    }
+    /**
+   * Report performance metrics
+   */ async reportPerformanceMetric(operation, duration, success, error, memoryUsage) {
+        const metric = {
+            operation,
+            duration,
+            success,
+            timestamp: Date.now(),
+            memoryUsage,
+            error
+        };
+        this.performanceMetrics.push(metric);
+        // Keep only last 100 metrics
+        if (this.performanceMetrics.length > 100) {
+            this.performanceMetrics.shift();
+        }
+        // Log performance information
+        if (this.bridgeConfig.logLevel === 'debug') {
+            const memoryInfo = memoryUsage ? ` (${(memoryUsage / 1024 / 1024).toFixed(2)}MB)` : '';
+            console.log(chalk.gray(`[PERF] ${operation}: ${duration}ms ${success ? '✓' : '✗'}${memoryInfo}`));
+        }
+    }
+    /**
+   * Get performance summary
+   */ getPerformanceSummary() {
+        const successful = this.performanceMetrics.filter((m)=>m.success);
+        const failed = this.performanceMetrics.filter((m)=>!m.success);
+        const avgDuration = successful.length > 0 ? successful.reduce((sum, m)=>sum + m.duration, 0) / successful.length : 0;
+        return {
+            totalOperations: this.performanceMetrics.length,
+            successfulOperations: successful.length,
+            failedOperations: failed.length,
+            successRate: this.performanceMetrics.length > 0 ? successful.length / this.performanceMetrics.length * 100 : 0,
+            averageDuration: Math.round(avgDuration),
+            recentMetrics: this.performanceMetrics.slice(-10)
+        };
+    }
+    /**
+   * Validate configuration and environment
+   */ async validateConfiguration() {
+        const issues = [];
+        try {
+            // Check Node.js version
+            const nodeVersion = process.versions.node;
+            const majorVersion = parseInt(nodeVersion.split('.')[0]);
+            if (majorVersion < 16) {
+                issues.push(`Node.js version ${nodeVersion} is not supported. Minimum required: 16.0.0`);
+            }
+            // Check available memory
+            const memoryUsage = process.memoryUsage();
+            const availableMemory = memoryUsage.heapTotal;
+            if (availableMemory < 100 * 1024 * 1024) {
+                // 100MB
+                issues.push('Low available memory detected. Maestro requires at least 100MB heap space');
+            }
+            // Check file system permissions
+            const specsDir = join(process.cwd(), 'docs', 'maestro', 'specs');
+            try {
+                const fs = await import('fs/promises');
+                await fs.access(specsDir, fs.constants.F_OK);
+            } catch  {
+            // Directory doesn't exist, which is fine - it will be created
+            }
+            return {
+                valid: issues.length === 0,
+                issues
+            };
+        } catch (error) {
+            issues.push(`Configuration validation failed: ${error instanceof Error ? error.message : String(error)}`);
+            return {
+                valid: false,
+                issues
+            };
+        }
+    }
+    /**
+   * Clear caches and reset state
+   */ clearCache() {
+        this.initializationCache.clear();
+        this.configCache = undefined;
+        this.initialized = false;
+        console.log(chalk.gray('🧹 Maestro CLI bridge cache cleared'));
+    }
+    /**
+   * Shutdown and cleanup resources
+   */ async shutdown() {
+        if (this.swarmCoordinator) {
+            await this.swarmCoordinator.shutdown();
+        }
+        this.clearCache();
+        this.performanceMetrics = [];
+        console.log(chalk.green('✅ Maestro CLI bridge shutdown complete'));
+    }
+}
+
+//# sourceMappingURL=maestro-cli-bridge.js.map

package/dist/src/cli/maestro-cli-bridge.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../../src/cli/maestro-cli-bridge.ts"],"names":["join","chalk","EventEmitter","AgentManager","Orchestrator","MaestroSwarmCoordinator","agenticHookManager","MaestroCLIBridge","swarmCoordinator","initializationCache","Map","configCache","performanceMetrics","initialized","bridgeConfig","enablePerformanceMonitoring","initializationTimeout","cacheEnabled","logLevel","initializeOrchestrator","startTime","Date","now","console","log","green","blue","config","eventBus","logger","memoryManager","agentManager","mainOrchestrator","Promise","all","getOrCreateConfig","getOrCreateEventBus","getOrCreateLogger","getOrCreateMemoryManager","getOrCreateAgentManager","getOrCreateMainOrchestrator","maestroConfig","getOptimizedMaestroConfig","executeWithMonitoring","swarmId","initialize","duration","reportPerformanceMetric","error","Error","message","String","red","operation","fn","context","startMemory","process","memoryUsage","heapUsed","executePerformanceHook","metric","value","unit","result","endTime","endMemory","memoryDelta","undefined","success","hiveMindConfig","name","topology","queenMode","maxAgents","consensusThreshold","memoryTTL","autoSpawn","enableConsensus","enableMemory","enableCommunication","enableConsensusValidation","enableLivingDocumentation","enableSteeringIntegration","specsDirectory","cwd","steeringDirectory","cacheKey","has","get","env","NODE_ENV","enableMetrics","set","debug","args","gray","info","warn","yellow","configure","level","shutdown","createBank","agentId","closeBank","bankId","store","entry","retrieve","id","query","update","updates","delete","getHealthStatus","healthy","performMaintenance","mockTerminalManager","mockCoordinationManager","mockMCPServer","orchestrator","type","data","executeHooks","sessionId","timestamp","correlationId","metadata","source","memory","namespace","provider","cache","neural","modelId","patterns","training","performance","metrics","bottlenecks","optimizations","push","length","shift","memoryInfo","toFixed","getPerformanceSummary","successful","filter","m","failed","avgDuration","reduce","sum","totalOperations","successfulOperations","failedOperations","successRate","averageDuration","Math","round","recentMetrics","slice","validateConfiguration","issues","nodeVersion","versions","node","majorVersion","parseInt","split","availableMemory","heapTotal","specsDir","fs","access","constants","F_OK","valid","clearCache","clear"],"mappings":"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"}

package/dist/src/cli/main.js

@@ -0,0 +1,26 @@
+#!/usr/bin/env node
+/**
+ * Claude-Flow CLI - Main entry point for Node.js
+ */ import { CLI } from './cli-core.js';
+import { setupCommands } from './commands/index.js';
+import { fileURLToPath } from 'node:url';
+import { dirname } from 'node:path';
+async function main() {
+    const cli = new CLI('claude-flow', 'Advanced AI Agent Orchestration System');
+    // Setup all commands
+    setupCommands(cli);
+    // Run the CLI (args default to process.argv.slice(2) in Node.js version)
+    await cli.run();
+}
+// Check if this module is being run directly (Node.js equivalent of import.meta.main)
+const __filename = fileURLToPath(import.meta.url);
+const __dirname = dirname(__filename);
+const isMainModule = process.argv[1] === __filename || process.argv[1].endsWith('/main.js');
+if (isMainModule) {
+    main().catch((error)=>{
+        console.error('Fatal error:', error);
+        process.exit(1);
+    });
+}
+
+//# sourceMappingURL=main.js.map

package/dist/src/cli/main.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../../src/cli/main.ts"],"names":["CLI","setupCommands","fileURLToPath","dirname","main","cli","run","__filename","url","__dirname","isMainModule","process","argv","endsWith","catch","error","console","exit"],"mappings":";AACA;;CAEC,GAED,SAASA,GAAG,QAAiB,gBAAgB;AAC7C,SAASC,aAAa,QAAQ,sBAAsB;AACpD,SAASC,aAAa,QAAQ,WAAW;AACzC,SAASC,OAAO,QAAQ,YAAY;AAEpC,eAAeC;IACb,MAAMC,MAAM,IAAIL,IAAI,eAAe;IAEnC,qBAAqB;IACrBC,cAAcI;IAEd,yEAAyE;IACzE,MAAMA,IAAIC,GAAG;AACf;AAEA,sFAAsF;AACtF,MAAMC,aAAaL,cAAc,YAAYM,GAAG;AAChD,MAAMC,YAAYN,QAAQI;AAC1B,MAAMG,eAAeC,QAAQC,IAAI,CAAC,EAAE,KAAKL,cAAcI,QAAQC,IAAI,CAAC,EAAE,CAACC,QAAQ,CAAC;AAEhF,IAAIH,cAAc;IAChBN,OAAOU,KAAK,CAAC,CAACC;QACZC,QAAQD,KAAK,CAAC,gBAAgBA;QAC9BJ,QAAQM,IAAI,CAAC;IACf;AACF"}