claude-flow-novice 1.0.0

package/dist/src/config/ruv-swarm-config.js

@@ -0,0 +1,332 @@
+/**
+ * ruv-swarm configuration management for Claude Code integration
+ *
+ * This module handles configuration settings for ruv-swarm integration,
+ * including topology preferences, agent limits, and coordination patterns.
+ */ import { readFileSync, writeFileSync, existsSync } from 'fs';
+import { join } from 'path';
+import { deepMerge } from '../utils/helpers.js';
+/**
+ * Default ruv-swarm configuration
+ */ export const defaultRuvSwarmConfig = {
+    swarm: {
+        defaultTopology: 'mesh',
+        maxAgents: 8,
+        defaultStrategy: 'adaptive',
+        autoInit: true,
+        enableHooks: true
+    },
+    agents: {
+        defaultCapabilities: [
+            'filesystem',
+            'search',
+            'memory',
+            'coordination'
+        ],
+        spawnTimeout: 30000,
+        heartbeatInterval: 5000,
+        maxRetries: 3
+    },
+    tasks: {
+        defaultStrategy: 'adaptive',
+        defaultPriority: 'medium',
+        timeout: 300000,
+        enableMonitoring: true
+    },
+    memory: {
+        enablePersistence: true,
+        compressionLevel: 6,
+        ttl: 86400000,
+        maxSize: 100 * 1024 * 1024
+    },
+    neural: {
+        enableTraining: true,
+        patterns: [
+            'convergent',
+            'divergent',
+            'lateral',
+            'systems'
+        ],
+        learningRate: 0.1,
+        trainingIterations: 10
+    },
+    monitoring: {
+        enableMetrics: true,
+        metricsInterval: 10000,
+        enableAlerts: true,
+        alertThresholds: {
+            cpu: 80,
+            memory: 85,
+            taskFailureRate: 20
+        }
+    },
+    integration: {
+        enableMCPTools: true,
+        enableCLICommands: true,
+        enableHooks: true,
+        sessionTimeout: 3600000
+    }
+};
+/**
+ * ruv-swarm configuration manager
+ */ export class RuvSwarmConfigManager {
+    logger;
+    config;
+    configPath;
+    constructor(logger, configPath){
+        this.logger = logger;
+        this.configPath = configPath || join(process.cwd(), '.claude', 'ruv-swarm-config.json');
+        this.config = this.loadConfig();
+    }
+    /**
+   * Load configuration from file or use defaults
+   */ loadConfig() {
+        try {
+            if (existsSync(this.configPath)) {
+                const configData = readFileSync(this.configPath, 'utf-8');
+                const userConfig = JSON.parse(configData);
+                // Merge with defaults
+                const mergedConfig = deepMerge(defaultRuvSwarmConfig, userConfig);
+                this.logger.debug('Loaded ruv-swarm config from file', {
+                    path: this.configPath,
+                    config: mergedConfig
+                });
+                return mergedConfig;
+            }
+        } catch (error) {
+            this.logger.warn('Failed to load ruv-swarm config, using defaults', {
+                error: error instanceof Error ? error instanceof Error ? error.message : String(error) : error
+            });
+        }
+        this.logger.debug('Using default ruv-swarm config');
+        return {
+            ...defaultRuvSwarmConfig
+        };
+    }
+    /**
+   * Save configuration to file
+   */ saveConfig() {
+        try {
+            const configDir = join(this.configPath, '..');
+            // Ensure config directory exists
+            if (!existsSync(configDir)) {
+                const fs = require('fs');
+                fs.mkdirSync(configDir, {
+                    recursive: true
+                });
+            }
+            writeFileSync(this.configPath, JSON.stringify(this.config, null, 2), 'utf-8');
+            this.logger.debug('Saved ruv-swarm config to file', {
+                path: this.configPath
+            });
+        } catch (error) {
+            this.logger.error('Failed to save ruv-swarm config', {
+                error: error instanceof Error ? error instanceof Error ? error.message : String(error) : error
+            });
+        }
+    }
+    /**
+   * Get current configuration
+   */ getConfig() {
+        return {
+            ...this.config
+        };
+    }
+    /**
+   * Update configuration
+   */ updateConfig(updates) {
+        this.config = deepMerge(this.config, updates);
+        this.saveConfig();
+        this.logger.info('Updated ruv-swarm config', {
+            updates
+        });
+    }
+    /**
+   * Reset configuration to defaults
+   */ resetConfig() {
+        this.config = {
+            ...defaultRuvSwarmConfig
+        };
+        this.saveConfig();
+        this.logger.info('Reset ruv-swarm config to defaults');
+    }
+    /**
+   * Get specific configuration section
+   */ getSwarmConfig() {
+        return this.config.swarm;
+    }
+    getAgentsConfig() {
+        return this.config.agents;
+    }
+    getTasksConfig() {
+        return this.config.tasks;
+    }
+    getMemoryConfig() {
+        return this.config.memory;
+    }
+    getNeuralConfig() {
+        return this.config.neural;
+    }
+    getMonitoringConfig() {
+        return this.config.monitoring;
+    }
+    getIntegrationConfig() {
+        return this.config.integration;
+    }
+    /**
+   * Update specific configuration section
+   */ updateSwarmConfig(updates) {
+        this.updateConfig({
+            swarm: {
+                ...this.config.swarm,
+                ...updates
+            }
+        });
+    }
+    updateAgentsConfig(updates) {
+        this.updateConfig({
+            agents: {
+                ...this.config.agents,
+                ...updates
+            }
+        });
+    }
+    updateTasksConfig(updates) {
+        this.updateConfig({
+            tasks: {
+                ...this.config.tasks,
+                ...updates
+            }
+        });
+    }
+    updateMemoryConfig(updates) {
+        this.updateConfig({
+            memory: {
+                ...this.config.memory,
+                ...updates
+            }
+        });
+    }
+    updateNeuralConfig(updates) {
+        this.updateConfig({
+            neural: {
+                ...this.config.neural,
+                ...updates
+            }
+        });
+    }
+    updateMonitoringConfig(updates) {
+        this.updateConfig({
+            monitoring: {
+                ...this.config.monitoring,
+                ...updates
+            }
+        });
+    }
+    updateIntegrationConfig(updates) {
+        this.updateConfig({
+            integration: {
+                ...this.config.integration,
+                ...updates
+            }
+        });
+    }
+    /**
+   * Validate configuration
+   */ validateConfig() {
+        const errors = [];
+        // Validate swarm settings
+        if (this.config.swarm.maxAgents < 1 || this.config.swarm.maxAgents > 100) {
+            errors.push('swarm.maxAgents must be between 1 and 100');
+        }
+        // Validate agent settings
+        if (this.config.agents.spawnTimeout < 1000) {
+            errors.push('agents.spawnTimeout must be at least 1000ms');
+        }
+        if (this.config.agents.heartbeatInterval < 1000) {
+            errors.push('agents.heartbeatInterval must be at least 1000ms');
+        }
+        // Validate task settings
+        if (this.config.tasks.timeout < 10000) {
+            errors.push('tasks.timeout must be at least 10000ms');
+        }
+        // Validate memory settings
+        if (this.config.memory.maxSize < 1024 * 1024) {
+            // 1MB minimum
+            errors.push('memory.maxSize must be at least 1MB');
+        }
+        if (this.config.memory.compressionLevel < 0 || this.config.memory.compressionLevel > 9) {
+            errors.push('memory.compressionLevel must be between 0 and 9');
+        }
+        // Validate neural settings
+        if (this.config.neural.learningRate <= 0 || this.config.neural.learningRate > 1) {
+            errors.push('neural.learningRate must be between 0 and 1');
+        }
+        if (this.config.neural.trainingIterations < 1) {
+            errors.push('neural.trainingIterations must be at least 1');
+        }
+        // Validate monitoring settings
+        const { alertThresholds } = this.config.monitoring;
+        if (alertThresholds.cpu < 0 || alertThresholds.cpu > 100) {
+            errors.push('monitoring.alertThresholds.cpu must be between 0 and 100');
+        }
+        if (alertThresholds.memory < 0 || alertThresholds.memory > 100) {
+            errors.push('monitoring.alertThresholds.memory must be between 0 and 100');
+        }
+        if (alertThresholds.taskFailureRate < 0 || alertThresholds.taskFailureRate > 100) {
+            errors.push('monitoring.alertThresholds.taskFailureRate must be between 0 and 100');
+        }
+        return {
+            valid: errors.length === 0,
+            errors
+        };
+    }
+    /**
+   * Get configuration as command-line arguments for ruv-swarm
+   */ getCommandArgs() {
+        const args = [];
+        // Add swarm configuration
+        args.push('--topology', this.config.swarm.defaultTopology);
+        args.push('--max-agents', String(this.config.swarm.maxAgents));
+        args.push('--strategy', this.config.swarm.defaultStrategy);
+        if (this.config.swarm.enableHooks) {
+            args.push('--enable-hooks');
+        }
+        // Add task configuration
+        args.push('--task-strategy', this.config.tasks.defaultStrategy);
+        args.push('--task-priority', this.config.tasks.defaultPriority);
+        args.push('--task-timeout', String(this.config.tasks.timeout));
+        if (this.config.tasks.enableMonitoring) {
+            args.push('--enable-monitoring');
+        }
+        // Add memory configuration
+        if (this.config.memory.enablePersistence) {
+            args.push('--enable-persistence');
+            args.push('--compression-level', String(this.config.memory.compressionLevel));
+            args.push('--memory-ttl', String(this.config.memory.ttl));
+        }
+        // Add neural configuration
+        if (this.config.neural.enableTraining) {
+            args.push('--enable-training');
+            args.push('--learning-rate', String(this.config.neural.learningRate));
+            args.push('--training-iterations', String(this.config.neural.trainingIterations));
+        }
+        return args;
+    }
+}
+/**
+ * Create or get singleton instance of ruv-swarm config manager
+ */ let configManagerInstance = null;
+export function getRuvSwarmConfigManager(logger, configPath) {
+    if (!configManagerInstance) {
+        configManagerInstance = new RuvSwarmConfigManager(logger, configPath);
+    }
+    return configManagerInstance;
+}
+export default {
+    RuvSwarmConfigManager,
+    getRuvSwarmConfigManager,
+    defaultRuvSwarmConfig
+};
+
+//# sourceMappingURL=ruv-swarm-config.js.map

package/dist/src/config/ruv-swarm-config.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../../src/config/ruv-swarm-config.ts"],"names":["readFileSync","writeFileSync","existsSync","join","deepMerge","defaultRuvSwarmConfig","swarm","defaultTopology","maxAgents","defaultStrategy","autoInit","enableHooks","agents","defaultCapabilities","spawnTimeout","heartbeatInterval","maxRetries","tasks","defaultPriority","timeout","enableMonitoring","memory","enablePersistence","compressionLevel","ttl","maxSize","neural","enableTraining","patterns","learningRate","trainingIterations","monitoring","enableMetrics","metricsInterval","enableAlerts","alertThresholds","cpu","taskFailureRate","integration","enableMCPTools","enableCLICommands","sessionTimeout","RuvSwarmConfigManager","config","configPath","logger","process","cwd","loadConfig","configData","userConfig","JSON","parse","mergedConfig","debug","path","error","warn","Error","message","String","saveConfig","configDir","fs","require","mkdirSync","recursive","stringify","getConfig","updateConfig","updates","info","resetConfig","getSwarmConfig","getAgentsConfig","getTasksConfig","getMemoryConfig","getNeuralConfig","getMonitoringConfig","getIntegrationConfig","updateSwarmConfig","updateAgentsConfig","updateTasksConfig","updateMemoryConfig","updateNeuralConfig","updateMonitoringConfig","updateIntegrationConfig","validateConfig","errors","push","valid","length","getCommandArgs","args","configManagerInstance","getRuvSwarmConfigManager"],"mappings":"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"}

package/dist/src/config/ruv-swarm-integration.js

@@ -0,0 +1,285 @@
+/**
+ * ruv-swarm integration helper for Claude Code configuration
+ *
+ * This module bridges the main claude-flow configuration with
+ * ruv-swarm specific settings and provides utility functions
+ * for seamless integration.
+ */ import { configManager } from './config-manager.js';
+import { getRuvSwarmConfigManager } from './ruv-swarm-config.js';
+// import { createLogger } from '../core/logger.js';
+// Create logger for integration
+// const logger = createLogger('ruv-swarm-integration');
+/**
+ * Integration manager that synchronizes configurations
+ */ export class RuvSwarmIntegration {
+    configManager;
+    ruvSwarmManager;
+    constructor(configManager, ruvSwarmManager){
+        this.configManager = configManager;
+        this.ruvSwarmManager = ruvSwarmManager;
+    }
+    /**
+   * Synchronize main config with ruv-swarm config
+   */ syncConfiguration() {
+        const mainConfig = this.configManager.getRuvSwarmConfig();
+        const ruvSwarmConfig = this.ruvSwarmManager.getConfig();
+        // Update ruv-swarm config from main config
+        if (mainConfig.enabled) {
+            this.ruvSwarmManager.updateSwarmConfig({
+                defaultTopology: mainConfig.defaultTopology,
+                maxAgents: mainConfig.maxAgents,
+                defaultStrategy: mainConfig.defaultStrategy,
+                enableHooks: mainConfig.enableHooks
+            });
+            this.ruvSwarmManager.updateIntegrationConfig({
+                enableMCPTools: true,
+                enableCLICommands: true,
+                enableHooks: mainConfig.enableHooks
+            });
+            this.ruvSwarmManager.updateMemoryConfig({
+                enablePersistence: mainConfig.enablePersistence
+            });
+            this.ruvSwarmManager.updateNeuralConfig({
+                enableTraining: mainConfig.enableNeuralTraining
+            });
+        }
+    // logger.debug('Configuration synchronized between main and ruv-swarm configs');
+    }
+    /**
+   * Get unified command arguments for ruv-swarm CLI
+   */ getUnifiedCommandArgs() {
+        const mainArgs = this.configManager.getRuvSwarmArgs();
+        const ruvSwarmArgs = this.ruvSwarmManager.getCommandArgs();
+        // Main config takes precedence, then ruv-swarm specific
+        const unified = [
+            ...mainArgs
+        ];
+        // Add ruv-swarm specific args that aren't in main config
+        for(let i = 0; i < ruvSwarmArgs.length; i += 2){
+            const flag = ruvSwarmArgs[i];
+            const value = ruvSwarmArgs[i + 1];
+            // Skip if already set by main config
+            if (!unified.includes(flag)) {
+                unified.push(flag, value);
+            }
+        }
+        return unified;
+    }
+    /**
+   * Initialize ruv-swarm integration
+   */ async initialize() {
+        try {
+            // Check if ruv-swarm is enabled in main config
+            if (!this.configManager.isRuvSwarmEnabled()) {
+                return {
+                    success: false,
+                    message: 'ruv-swarm is disabled in main configuration'
+                };
+            }
+            // Sync configurations
+            this.syncConfiguration();
+            // Validate configurations
+            const mainValidation = this.validateMainConfig();
+            if (!mainValidation.valid) {
+                return {
+                    success: false,
+                    message: `Main config validation failed: ${mainValidation.errors.join(', ')}`
+                };
+            }
+            const ruvSwarmValidation = this.ruvSwarmManager.validateConfig();
+            if (!ruvSwarmValidation.valid) {
+                return {
+                    success: false,
+                    message: `ruv-swarm config validation failed: ${ruvSwarmValidation.errors.join(', ')}`
+                };
+            }
+            // logger.info('ruv-swarm integration initialized successfully');
+            return {
+                success: true,
+                message: 'ruv-swarm integration initialized and configured'
+            };
+        } catch (error) {
+            const message = `Failed to initialize ruv-swarm integration: ${error.message}`;
+            // logger.error(message, { error });
+            return {
+                success: false,
+                message
+            };
+        }
+    }
+    /**
+   * Validate main configuration for ruv-swarm compatibility
+   */ validateMainConfig() {
+        const errors = [];
+        const ruvSwarmConfig = this.configManager.getRuvSwarmConfig();
+        // Check required fields
+        if (!ruvSwarmConfig.defaultTopology) {
+            errors.push('ruvSwarm.defaultTopology is required');
+        }
+        if (ruvSwarmConfig.maxAgents <= 0) {
+            errors.push('ruvSwarm.maxAgents must be greater than 0');
+        }
+        if (!ruvSwarmConfig.defaultStrategy) {
+            errors.push('ruvSwarm.defaultStrategy is required');
+        }
+        return {
+            valid: errors.length === 0,
+            errors
+        };
+    }
+    /**
+   * Get current integration status
+   */ getStatus() {
+        const mainConfig = this.configManager.getRuvSwarmConfig();
+        const ruvSwarmConfig = this.ruvSwarmManager.getConfig();
+        return {
+            enabled: mainConfig.enabled,
+            mainConfig,
+            ruvSwarmConfig,
+            synchronized: this.isConfigurationSynchronized()
+        };
+    }
+    /**
+   * Check if configurations are synchronized
+   */ isConfigurationSynchronized() {
+        const mainConfig = this.configManager.getRuvSwarmConfig();
+        const ruvSwarmConfig = this.ruvSwarmManager.getConfig();
+        return ruvSwarmConfig.swarm.defaultTopology === mainConfig.defaultTopology && ruvSwarmConfig.swarm.maxAgents === mainConfig.maxAgents && ruvSwarmConfig.swarm.defaultStrategy === mainConfig.defaultStrategy && ruvSwarmConfig.swarm.enableHooks === mainConfig.enableHooks && ruvSwarmConfig.memory.enablePersistence === mainConfig.enablePersistence && ruvSwarmConfig.neural.enableTraining === mainConfig.enableNeuralTraining;
+    }
+    /**
+   * Update configuration and sync
+   */ updateConfiguration(updates) {
+        if (updates.main) {
+            this.configManager.setRuvSwarmConfig(updates.main);
+        }
+        if (updates.ruvSwarm) {
+            this.ruvSwarmManager.updateConfig(updates.ruvSwarm);
+        }
+        // Re-sync after updates
+        this.syncConfiguration();
+    }
+}
+/**
+ * Create singleton integration instance
+ */ let integrationInstance = null;
+export function getRuvSwarmIntegration() {
+    if (!integrationInstance) {
+        const ruvSwarmManager = getRuvSwarmConfigManager(logger);
+        integrationInstance = new RuvSwarmIntegration(configManager, ruvSwarmManager);
+    }
+    return integrationInstance;
+}
+/**
+ * Initialize ruv-swarm integration with claude-flow
+ */ export async function initializeRuvSwarmIntegration() {
+    const integration = getRuvSwarmIntegration();
+    return integration.initialize();
+}
+/**
+ * Helper functions for CLI commands
+ */ export class RuvSwarmConfigHelpers {
+    /**
+   * Quick setup for development environment
+   */ static setupDevelopmentConfig() {
+        const integration = getRuvSwarmIntegration();
+        integration.updateConfiguration({
+            main: {
+                enabled: true,
+                defaultTopology: 'hierarchical',
+                maxAgents: 8,
+                defaultStrategy: 'specialized',
+                autoInit: true,
+                enableHooks: true,
+                enablePersistence: true,
+                enableNeuralTraining: true
+            }
+        });
+    // logger.info('Development configuration applied');
+    }
+    /**
+   * Quick setup for research environment
+   */ static setupResearchConfig() {
+        const integration = getRuvSwarmIntegration();
+        integration.updateConfiguration({
+            main: {
+                enabled: true,
+                defaultTopology: 'mesh',
+                maxAgents: 12,
+                defaultStrategy: 'adaptive',
+                autoInit: true,
+                enableHooks: true,
+                enablePersistence: true,
+                enableNeuralTraining: true
+            }
+        });
+    // logger.info('Research configuration applied');
+    }
+    /**
+   * Quick setup for production environment
+   */ static setupProductionConfig() {
+        const integration = getRuvSwarmIntegration();
+        integration.updateConfiguration({
+            main: {
+                enabled: true,
+                defaultTopology: 'star',
+                maxAgents: 6,
+                defaultStrategy: 'balanced',
+                autoInit: false,
+                enableHooks: true,
+                enablePersistence: true,
+                enableNeuralTraining: false
+            }
+        });
+    // logger.info('Production configuration applied');
+    }
+    /**
+   * Get configuration for specific use case
+   */ static getConfigForUseCase(useCase) {
+        const integration = getRuvSwarmIntegration();
+        switch(useCase){
+            case 'development':
+                return {
+                    topology: 'hierarchical',
+                    maxAgents: 8,
+                    strategy: 'specialized',
+                    features: [
+                        'hooks',
+                        'persistence',
+                        'neural-training'
+                    ]
+                };
+            case 'research':
+                return {
+                    topology: 'mesh',
+                    maxAgents: 12,
+                    strategy: 'adaptive',
+                    features: [
+                        'hooks',
+                        'persistence',
+                        'neural-training',
+                        'advanced-metrics'
+                    ]
+                };
+            case 'production':
+                return {
+                    topology: 'star',
+                    maxAgents: 6,
+                    strategy: 'balanced',
+                    features: [
+                        'hooks',
+                        'persistence'
+                    ]
+                };
+            default:
+                return integration.getStatus().mainConfig;
+        }
+    }
+}
+export default {
+    RuvSwarmIntegration,
+    getRuvSwarmIntegration,
+    initializeRuvSwarmIntegration,
+    RuvSwarmConfigHelpers
+};
+
+//# sourceMappingURL=ruv-swarm-integration.js.map

package/dist/src/config/ruv-swarm-integration.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../../src/config/ruv-swarm-integration.ts"],"names":["configManager","getRuvSwarmConfigManager","RuvSwarmIntegration","ruvSwarmManager","syncConfiguration","mainConfig","getRuvSwarmConfig","ruvSwarmConfig","getConfig","enabled","updateSwarmConfig","defaultTopology","maxAgents","defaultStrategy","enableHooks","updateIntegrationConfig","enableMCPTools","enableCLICommands","updateMemoryConfig","enablePersistence","updateNeuralConfig","enableTraining","enableNeuralTraining","getUnifiedCommandArgs","mainArgs","getRuvSwarmArgs","ruvSwarmArgs","getCommandArgs","unified","i","length","flag","value","includes","push","initialize","isRuvSwarmEnabled","success","message","mainValidation","validateMainConfig","valid","errors","join","ruvSwarmValidation","validateConfig","error","getStatus","synchronized","isConfigurationSynchronized","swarm","memory","neural","updateConfiguration","updates","main","setRuvSwarmConfig","ruvSwarm","updateConfig","integrationInstance","getRuvSwarmIntegration","logger","initializeRuvSwarmIntegration","integration","RuvSwarmConfigHelpers","setupDevelopmentConfig","autoInit","setupResearchConfig","setupProductionConfig","getConfigForUseCase","useCase","topology","strategy","features"],"mappings":"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"}