stigmergy 1.2.13 → 1.3.2-beta.0

package/src/cli/commands/errors.js

@@ -0,0 +1,190 @@
+/**
+ * Error Reporting Commands
+ * Modular implementation for error reporting and system troubleshooting
+ */
+
+const chalk = require('chalk');
+const { errorHandler } = require('../../core/error_handler');
+const fs = require('fs').promises;
+const path = require('path');
+const os = require('os');
+
+/**
+ * Handle errors command - Generate comprehensive error report
+ * @param {Object} options - Command options
+ */
+async function handleErrorsCommand(options = {}) {
+  try {
+    console.log(chalk.cyan('[ERRORS] Generating Stigmergy CLI error report...\n'));
+
+    const report = {
+      timestamp: new Date().toISOString(),
+      system: {},
+      environment: {},
+      errors: [],
+      diagnostics: {}
+    };
+
+    // System information
+    console.log(chalk.blue('🖥️  System Information:'));
+    report.system = {
+      platform: os.platform(),
+      arch: os.arch(),
+      nodeVersion: process.version,
+      memory: Math.round(os.totalmem() / 1024 / 1024) + ' MB',
+      freeMemory: Math.round(os.freemem() / 1024 / 1024) + ' MB'
+    };
+
+    Object.entries(report.system).forEach(([key, value]) => {
+      console.log(`  ${key}: ${chalk.green(value)}`);
+    });
+
+    // Environment information
+    console.log(chalk.blue('\n🌍 Environment Information:'));
+    report.environment = {
+      pwd: process.cwd(),
+      home: os.homedir(),
+      shell: process.env.SHELL || process.env.COMSPEC || 'unknown',
+      path: process.env.PATH ? process.env.PATH.split(path.delimiter).slice(0, 3).join(path.delimiter) + '...' : 'unknown',
+      nodeEnv: process.env.NODE_ENV || 'undefined',
+      debugMode: process.env.DEBUG === 'true'
+    };
+
+    Object.entries(report.environment).forEach(([key, value]) => {
+      console.log(`  ${key}: ${chalk.green(value)}`);
+    });
+
+    // Error handler report (if available)
+    console.log(chalk.blue('\n📋 Error Handler Report:'));
+    try {
+      if (errorHandler && typeof errorHandler.printErrorReport === 'function') {
+        await errorHandler.printErrorReport();
+        console.log(chalk.green('  ✅ Error handler report generated'));
+      } else {
+        console.log(chalk.yellow('  ⚠️  Error handler not available'));
+      }
+    } catch (error) {
+      console.log(chalk.red(`  ❌ Error handler failed: ${error.message}`));
+      report.errors.push({
+        type: 'error_handler',
+        message: error.message,
+        timestamp: new Date().toISOString()
+      });
+    }
+
+    // Check for common issues
+    console.log(chalk.blue('\n🔍 Common Issues Check:'));
+
+    const checks = [
+      {
+        name: 'Current directory writable',
+        check: async () => {
+          try {
+            await fs.access(process.cwd(), fs.constants.W_OK);
+            return true;
+          } catch {
+            return false;
+          }
+        }
+      },
+      {
+        name: 'Home directory accessible',
+        check: async () => {
+          try {
+            await fs.access(os.homedir(), fs.constants.R_OK);
+            return true;
+          } catch {
+            return false;
+          }
+        }
+      },
+      {
+        name: 'Node modules accessible',
+        check: async () => {
+          try {
+            await fs.access(path.join(process.cwd(), 'node_modules'), fs.constants.R_OK);
+            return true;
+          } catch {
+            return false;
+          }
+        }
+      },
+      {
+        name: 'Package.json exists',
+        check: async () => {
+          try {
+            await fs.access(path.join(process.cwd(), 'package.json'), fs.constants.R_OK);
+            return true;
+          } catch {
+            return false;
+          }
+        }
+      }
+    ];
+
+    for (const check of checks) {
+      try {
+        const passed = await check.check();
+        const icon = passed ? chalk.green('✅') : chalk.red('❌');
+        console.log(`  ${icon} ${check.name}`);
+
+        if (!passed) {
+          report.errors.push({
+            type: 'common_issue',
+            message: `${check.name} failed`,
+            timestamp: new Date().toISOString()
+          });
+        }
+      } catch (error) {
+        console.log(`  ${chalk.yellow('⚠️')} ${check.name} - Check failed`);
+      }
+    }
+
+    // Log files check
+    console.log(chalk.blue('\n📄 Log Files:'));
+    const logLocations = [
+      path.join(os.homedir(), '.stigmergy', 'logs'),
+      path.join(process.cwd(), 'logs'),
+      path.join(os.tmpdir(), 'stigmergy-logs')
+    ];
+
+    for (const logLocation of logLocations) {
+      try {
+        const stats = await fs.stat(logLocation);
+        console.log(`  ${chalk.green('✅')} ${logLocation} (${stats.size} bytes)`);
+      } catch {
+        console.log(`  ${chalk.gray('⚪')} ${logLocation} (not found)`);
+      }
+    }
+
+    // Summary
+    console.log(chalk.blue('\n📊 Error Report Summary:'));
+    const errorCount = report.errors.length;
+    const warningCount = report.environment.debugMode ? 1 : 0;
+
+    console.log(`  Errors: ${chalk.red(errorCount)}`);
+    console.log(`  Warnings: ${chalk.yellow(warningCount)}`);
+
+    if (errorCount === 0) {
+      console.log(chalk.green('\n✅ No critical errors detected!'));
+    } else {
+      console.log(chalk.red(`\n❌ ${errorCount} issue(s) found - see details above`));
+    }
+
+    // Save report to file if requested
+    if (options.save) {
+      const reportPath = path.join(process.cwd(), `stigmergy-error-report-${Date.now()}.json`);
+      await fs.writeFile(reportPath, JSON.stringify(report, null, 2));
+      console.log(chalk.blue(`\n💾 Report saved to: ${reportPath}`));
+    }
+
+    return { success: true, report };
+  } catch (error) {
+    console.error(chalk.red('[ERROR] Failed to generate error report:'), error.message);
+    return { success: false, error: error.message };
+  }
+}
+
+module.exports = {
+  handleErrorsCommand
+};

package/src/cli/commands/install.js

@@ -0,0 +1,142 @@
+/**
+ * Install Command Module
+ * Handles CLI tool installation commands
+ */
+
+const StigmergyInstaller = require('../../core/installer');
+const chalk = require('chalk');
+const { ensureSkillsCache } = require('../utils/skills_cache');
+
+/**
+ * Handle install command
+ * @param {Object} options - Command options
+ * @param {string} options.cli - Specific CLI to install
+ * @param {boolean} options.verbose - Verbose output
+ * @param {boolean} options.force - Force installation
+ */
+async function handleInstallCommand(options = {}) {
+  const installer = new StigmergyInstaller();
+
+  try {
+    // Initialize or update skills/agents cache
+    await ensureSkillsCache({ verbose: options.verbose || process.env.DEBUG === 'true' });
+
+    console.log(chalk.blue('🚀 Starting CLI tools installation...'));
+
+    // Handle auto-install mode (non-interactive)
+    if (options.nonInteractive) {
+      console.log(chalk.blue('[AUTO-INSTALL] Running in non-interactive mode'));
+
+      // Scan for available and missing tools
+      const { missing: missingTools, available: availableTools } = await installer.scanCLI();
+
+      if (Object.keys(missingTools).length === 0) {
+        console.log(chalk.green('✅ All AI CLI tools are already installed!'));
+        return {
+          success: true,
+          installed: [],
+          existing: Object.keys(availableTools)
+        };
+      }
+
+      // Install all missing tools in auto mode
+      const selectedTools = Object.keys(missingTools);
+      console.log(chalk.blue(`[AUTO-INSTALL] Installing ${selectedTools.length} tools: ${selectedTools.join(', ')}`));
+
+      const installResult = await installer.installTools(selectedTools, missingTools);
+
+      if (installResult.success) {
+        console.log(chalk.green('✅ Auto-install completed successfully!'));
+        return {
+          success: true,
+          installed: installResult.installed || [],
+          failed: installResult.failed || [],
+          existing: Object.keys(availableTools)
+        };
+      } else {
+        console.log(chalk.yellow('⚠️ Some tools may not have installed successfully'));
+        return {
+          success: false,
+          installed: installResult.installed || [],
+          failed: installResult.failed || [],
+          existing: Object.keys(availableTools),
+          error: 'Some installations failed'
+        };
+      }
+    }
+
+    // Interactive install mode
+    const { missing: missingTools, available: availableTools } = await installer.scanCLI();
+
+    if (Object.keys(missingTools).length === 0) {
+      console.log(chalk.green('✅ All AI CLI tools are already installed!'));
+
+      if (Object.keys(availableTools).length > 0) {
+        console.log(chalk.cyan('\n📦 Available tools:'));
+        Object.keys(availableTools).forEach(tool => {
+          console.log(`  ✅ ${tool}`);
+        });
+      }
+
+      return {
+        success: true,
+        installed: [],
+        existing: Object.keys(availableTools)
+      };
+    }
+
+    console.log(chalk.yellow(`\n⚠️ Found ${Object.keys(missingTools).length} missing tools:`));
+    Object.entries(missingTools).forEach(([toolName, toolInfo]) => {
+      console.log(`  - ${toolInfo.name}: ${toolInfo.install}`);
+    });
+
+    // For now, install all missing tools
+    const selectedTools = Object.keys(missingTools);
+    const installResult = await installer.installTools(selectedTools, missingTools);
+
+    if (installResult.success) {
+      console.log(chalk.green('✅ Installation completed successfully!'));
+
+      if (installResult.installed && installResult.installed.length > 0) {
+        console.log(chalk.cyan('\n📦 Installed tools:'));
+        installResult.installed.forEach(tool => {
+          console.log(`  ✅ ${tool}`);
+        });
+      }
+
+      if (installResult.failed && installResult.failed.length > 0) {
+        console.log(chalk.red('\n❌ Failed tools:'));
+        installResult.failed.forEach(tool => {
+          console.log(`  ❌ ${tool}`);
+        });
+      }
+
+      return {
+        success: true,
+        installed: installResult.installed || [],
+        failed: installResult.failed || [],
+        existing: Object.keys(availableTools)
+      };
+    } else {
+      console.log(chalk.red('❌ Installation failed!'));
+      return {
+        success: false,
+        installed: installResult.installed || [],
+        failed: installResult.failed || [],
+        existing: Object.keys(availableTools),
+        error: 'Installation failed'
+      };
+    }
+  } catch (error) {
+    console.log(chalk.red(`❌ Installation error: ${error.message}`));
+    return {
+      success: false,
+      error: error.message,
+      installed: []
+    };
+  }
+}
+
+module.exports = {
+  handleInstallCommand
+};

package/src/cli/commands/permissions.js

@@ -0,0 +1,108 @@
+/**
+ * Permission Management Commands
+ * Modular implementation for fix-perms and perm-check commands
+ */
+
+const chalk = require('chalk');
+const DirectoryPermissionManager = require('../../core/directory_permission_manager');
+
+/**
+ * Handle permission check command
+ * @param {Object} options - Command options
+ */
+async function handlePermCheckCommand(options = {}) {
+  try {
+    console.log(chalk.cyan('[PERM-CHECK] Checking current directory permissions...\n'));
+
+    const permissionManager = new DirectoryPermissionManager({
+      verbose: options.verbose || process.env.DEBUG === 'true'
+    });
+
+    const hasWritePermission = await permissionManager.checkWritePermission();
+
+    console.log(`📍 Current directory: ${process.cwd()}`);
+    console.log(`🔧 Write permission: ${hasWritePermission ? chalk.green('✅ Yes') : chalk.red('❌ No')}`);
+
+    if (!hasWritePermission) {
+      console.log('\n💡 Suggestions:');
+      console.log('1. Run: stigmergy fix-perms    # Fix permissions automatically');
+      console.log('2. Change to user directory: cd ~');
+      console.log('3. Create project directory: mkdir ~/stigmergy && cd ~/stigmergy');
+
+      console.log('\n🔍 System Info:');
+      const sysInfo = permissionManager.getSystemInfo();
+      console.log(`   Platform: ${sysInfo.platform}`);
+      console.log(`   Shell: ${sysInfo.shell}`);
+      console.log(`   Home: ${sysInfo.homeDir}`);
+    } else {
+      console.log(chalk.green('\n✅ Directory permissions are OK!'));
+    }
+
+    return { success: true, hasWritePermission };
+  } catch (error) {
+    console.error(chalk.red('[ERROR] Permission check failed:'), error.message);
+    return { success: false, error: error.message };
+  }
+}
+
+/**
+ * Handle fix permissions command
+ * @param {Object} options - Command options
+ */
+async function handleFixPermsCommand(options = {}) {
+  try {
+    console.log(chalk.cyan('[FIX-PERMS] Setting up working directory with proper permissions...\n'));
+
+    // Using DirectoryPermissionManager for permission handling
+    // This provides the core permission management functionality
+    const permissionManager = new DirectoryPermissionManager({
+      verbose: options.verbose || process.env.DEBUG === 'true',
+      createStigmergyDir: true
+    });
+
+    const hasWritePermission = await permissionManager.checkWritePermission();
+
+    if (hasWritePermission) {
+      console.log(chalk.green('✅ Current directory already has proper permissions!'));
+      return { success: true, alreadyFixed: true };
+    }
+
+    console.log(chalk.yellow('🔧 Attempting to fix permissions...'));
+
+    // Try to create a .stigmergy directory in user home as fallback
+    const fs = require('fs').promises;
+    const path = require('path');
+    const os = require('os');
+
+    const stigmergyDir = path.join(os.homedir(), '.stigmergy');
+
+    try {
+      await fs.mkdir(stigmergyDir, { recursive: true });
+      console.log(chalk.green(`✅ Created Stigmergy directory: ${stigmergyDir}`));
+      console.log(chalk.yellow('💡 Consider changing to this directory for your projects'));
+
+      return { success: true, createdDirectory: stigmergyDir };
+    } catch (mkdirError) {
+      console.log(chalk.red('❌ Could not create directory or fix permissions'));
+      console.log(chalk.red(`Error: ${mkdirError.message}`));
+
+      console.log('\n🔧 Manual fix required:');
+      console.log('1. Run in a directory where you have write permissions');
+      console.log('2. Try: cd ~ && mkdir stigmergy-workspace && cd stigmergy-workspace');
+
+      return { success: false, error: mkdirError.message };
+    }
+
+  } catch (error) {
+    console.error(chalk.red('[ERROR] Permission setup failed:'), error.message);
+    if (options.verbose) {
+      console.error(error.stack);
+    }
+    return { success: false, error: error.message };
+  }
+}
+
+module.exports = {
+  handlePermCheckCommand,
+  handleFixPermsCommand
+};