stigmergy 1.2.13 → 1.3.2-beta.1

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
+};

package/src/cli/commands/project.js

@@ -0,0 +1,449 @@
+/**
+ * Project Commands
+ * Modular implementation for init, setup, deploy, upgrade, call commands
+ */
+
+const chalk = require('chalk');
+const { handleStatusCommand } = require('./status');
+const path = require('path');
+const os = require('os');
+const { getCLIPath, setupCLIPaths } = require('../../core/cli_tools');
+const SmartRouter = require('../../core/smart_router');
+const EnhancedCLIInstaller = require('../../core/enhanced_cli_installer');
+const StigmergyInstaller = require('../../core/installer');
+const { executeCommand } = require('../../utils');
+const LocalSkillScanner = require('../../core/local_skill_scanner');
+const CLIHelpAnalyzer = require('../../core/cli_help_analyzer');
+const { CLI_TOOLS } = require('../../core/cli_tools');
+const { ensureSkillsCache } = require('../utils/skills_cache');
+
+// Import execution mode detection and CLI adapters
+const ExecutionModeDetector = require('../../core/execution_mode_detector');
+const { CLIAdapterManager } = require('../../core/cli_adapters');
+
+// Create instances
+const modeDetector = new ExecutionModeDetector();
+const cliAdapterManager = new CLIAdapterManager();
+
+/**
+ * Handle upgrade command
+ * @param {Object} options - Command options
+ */
+async function handleUpgradeCommand(options = {}) {
+  try {
+    console.log(chalk.cyan('[UPGRADE] Starting AI CLI tools upgrade process...\n'));
+
+    // Initialize or update skills/agents cache
+    await ensureSkillsCache({ verbose: process.env.DEBUG === 'true' });
+
+    const upgradeOptions = {
+      dryRun: options.dryRun || false,
+      force: options.force || false,
+      verbose: options.verbose || process.env.DEBUG === 'true'
+    };
+
+    // Use enhanced CLI installer for upgrade
+    const enhancedInstaller = new EnhancedCLIInstaller({
+      verbose: upgradeOptions.verbose,
+      autoRetry: true,
+      maxRetries: 2
+    });
+
+    // Get installed tools
+    const installer = new StigmergyInstaller({ verbose: upgradeOptions.verbose });
+    const { available: installedTools } = await installer.scanCLI();
+
+    if (Object.keys(installedTools).length === 0) {
+      console.log(chalk.yellow('[INFO] No CLI tools found to upgrade'));
+      console.log(chalk.blue('💡 Run: stigmergy install to install CLI tools first'));
+      return { success: true, upgraded: 0 };
+    }
+
+    console.log(chalk.blue(`[INFO] Found ${Object.keys(installedTools).length} CLI tools to upgrade`));
+
+    if (upgradeOptions.dryRun) {
+      console.log(chalk.yellow('[DRY RUN] Would upgrade the following tools:'));
+      Object.keys(installedTools).forEach(tool => {
+        console.log(`  • ${tool}`);
+      });
+      return { success: true, upgraded: Object.keys(installedTools).length };
+    }
+
+    // Perform upgrade
+    console.log(chalk.blue('[INFO] Starting upgrade process...'));
+    const toolsToUpgrade = Object.keys(installedTools);
+
+    const upgradeResult = await enhancedInstaller.upgradeTools(toolsToUpgrade, installedTools);
+
+    if (upgradeResult) {
+      console.log(chalk.green(`\n✅ Successfully upgraded ${toolsToUpgrade.length} CLI tools!`));
+      return { success: true, upgraded: toolsToUpgrade.length };
+    } else {
+      console.log(chalk.red('\n❌ Upgrade process encountered issues'));
+      return { success: false, upgraded: 0 };
+    }
+
+  } catch (error) {
+    console.error(chalk.red('[ERROR] Upgrade failed:'), error.message);
+    if (options.verbose) {
+      console.error(error.stack);
+    }
+    return { success: false, error: error.message };
+  }
+}
+
+/**
+ * Handle deploy command
+ * @param {Object} options - Command options
+ */
+async function handleDeployCommand(options = {}) {
+  try {
+    console.log(chalk.cyan('[DEPLOY] Starting hook deployment...\n'));
+
+    const installer = new StigmergyInstaller({ verbose: options.verbose });
+    const { available: deployedTools } = await installer.scanCLI();
+
+    if (Object.keys(deployedTools).length === 0) {
+      console.log(chalk.yellow('[INFO] No CLI tools found for deployment'));
+      console.log(chalk.blue('💡 Run: stigmergy install to install CLI tools first'));
+      return { success: true, deployed: 0 };
+    }
+
+    console.log(chalk.blue(`[INFO] Deploying hooks for ${Object.keys(deployedTools).length} tools...`));
+
+    await installer.deployHooks(deployedTools);
+
+    console.log(chalk.green('\n✅ Hook deployment completed successfully!'));
+    return { success: true, deployed: Object.keys(deployedTools).length };
+
+  } catch (error) {
+    console.error(chalk.red('[ERROR] Deployment failed:'), error.message);
+    return { success: false, error: error.message };
+  }
+}
+
+/**
+ * Handle init command
+ * @param {Object} options - Command options
+ */
+async function handleInitCommand(options = {}) {
+  try {
+    console.log(chalk.cyan('[INIT] Initializing Stigmergy project in current directory...\n'));
+
+    // Initialize or update skills/agents cache
+    await ensureSkillsCache({ verbose: true });
+
+    // Quick path detection for better tool availability
+    console.log(chalk.blue('[INIT] Detecting CLI tool paths...'));
+    const pathSetup = await setupCLIPaths();
+
+    console.log(`[INIT] CLI tool detection: ${pathSetup.report.summary.found}/${pathSetup.report.summary.total} tools found`);
+
+    // Quick setup for basic project structure
+    const projectDir = process.cwd();
+    const stigmergyDir = path.join(projectDir, '.stigmergy');
+
+    const fs = require('fs').promises;
+
+    // Create .stigmergy directory
+    await fs.mkdir(stigmergyDir, { recursive: true });
+
+    // Create basic config
+    const config = {
+      version: '1.3.0-beta.0',
+      created: new Date().toISOString(),
+      project: path.basename(projectDir)
+    };
+
+    await fs.writeFile(
+      path.join(stigmergyDir, 'config.json'),
+      JSON.stringify(config, null, 2)
+    );
+
+    console.log(chalk.green(`✅ Stigmergy project initialized in: ${projectDir}`));
+    console.log(chalk.blue(`📁 Configuration created: ${stigmergyDir}/config.json`));
+    console.log(chalk.gray('\n💡 Next steps:'));
+    console.log(chalk.gray('  • stigmergy install    # Install CLI tools'));
+    console.log(chalk.gray('  • stigmergy deploy     # Deploy integration hooks'));
+    console.log(chalk.gray('  • stigmergy status     # Check tool status'));
+
+    if (pathSetup.report.summary.missing > 0) {
+      console.log(chalk.gray('\n💡 For full CLI integration, run:'));
+      console.log(chalk.gray('  • stigmergy setup  # Complete setup with PATH configuration'));
+    }
+
+    return { success: true, projectDir };
+
+  } catch (error) {
+    console.error(chalk.red('[ERROR] Initialization failed:'), error.message);
+    return { success: false, error: error.message };
+  }
+}
+
+/**
+ * Handle setup command
+ * @param {Object} options - Command options
+ */
+async function handleSetupCommand(options = {}) {
+  try {
+    console.log(chalk.cyan('[SETUP] Starting complete Stigmergy setup...\n'));
+
+    // Initialize or update skills/agents cache (explicit call, will also be called in init)
+    await ensureSkillsCache({ verbose: true });
+
+    // Step 0: Setup CLI paths detection and configuration
+    console.log(chalk.blue('[STEP 0] Setting up CLI path detection...'));
+    const pathSetup = await setupCLIPaths();
+
+    console.log(`[PATH] Path detection complete:`);
+    console.log(`  - Found: ${pathSetup.report.summary.found} CLI tools`);
+    console.log(`  - Missing: ${pathSetup.report.summary.missing} CLI tools`);
+
+    if (pathSetup.pathStatus.updated) {
+      console.log(chalk.green('\n[PATH] ✓ All npm global directories are now available in PATH'));
+      console.log(chalk.gray('[PATH] CLI tools will be globally accessible after terminal restart'));
+    } else {
+      console.log(chalk.yellow('\n[PATH] ⚠️ PATH update failed:'));
+      console.log(chalk.gray(`  Error: ${pathSetup.pathStatus.message}`));
+      console.log(chalk.gray('\n[PATH] Manual update required:'));
+      console.log(chalk.gray('  Run the generated scripts to update PATH:'));
+      if (pathSetup.pathStatus.scriptPath) {
+        console.log(chalk.gray(`  - Script directory: ${pathSetup.pathStatus.scriptPath}`));
+      }
+      console.log(chalk.gray('  - Windows: Run PowerShell as Administrator and execute the scripts'));
+      console.log(chalk.gray('  - Unix/Linux: Source the shell script (source update-path.sh)'));
+    }
+
+    // Initialize project (will call ensureSkillsCache again, that's ok)
+    await handleInitCommand({ verbose: options.verbose });
+
+    // Install CLI tools
+    const installer = new StigmergyInstaller({ verbose: options.verbose });
+    const { available: setupAvailable, missing: setupMissing } = await installer.scanCLI();
+
+    if (Object.keys(setupMissing).length > 0) {
+      console.log(chalk.yellow('\n[STEP 1] Missing tools found:'));
+      for (const [toolName, toolInfo] of Object.entries(setupMissing)) {
+        console.log(`  - ${toolInfo.name}: ${toolInfo.install}`);
+      }
+
+      console.log(chalk.blue('\n[INFO] To install missing tools, run:'));
+      for (const [toolName, toolInfo] of Object.entries(setupMissing)) {
+        console.log(`  ${toolInfo.install}`);
+      }
+    } else {
+      console.log(chalk.green('\n[STEP 1] All required tools are already installed!'));
+    }
+
+    // Deploy hooks to available CLI tools
+    if (Object.keys(setupAvailable).length > 0) {
+      console.log(chalk.blue('\n[STEP 2] Deploying hooks to available tools...'));
+      await installer.deployHooks(setupAvailable);
+    } else {
+      console.log(chalk.yellow('\n[STEP 2] No tools available for hook deployment'));
+    }
+
+    // Verify setup
+    console.log(chalk.blue('\n[STEP 3] Verifying installation...'));
+    await handleStatusCommand({ verbose: false });
+
+    console.log(chalk.green('\n🎉 Setup completed successfully!'));
+    console.log(chalk.blue('\n[USAGE] Get started with these commands:'));
+    console.log(chalk.gray('  stigmergy d        - System diagnostic (recommended first)'));
+    console.log(chalk.gray('  stigmergy inst     - Install missing AI CLI tools'));
+    console.log(chalk.gray('  stigmergy deploy   - Deploy hooks to installed tools'));
+    console.log(chalk.gray('  stigmergy call     - Execute prompts with auto-routing'));
+
+    return { success: true };
+
+  } catch (error) {
+    console.error(chalk.red('[ERROR] Setup failed:'), error.message);
+    return { success: false, error: error.message };
+  }
+}
+
+/**
+ * Get working directory for a specific CLI tool
+ */
+function getWorkingDirectoryForTool(toolName) {
+  const toolConfig = CLI_TOOLS[toolName];
+  if (toolConfig && toolConfig.workingDirectory) {
+    return toolConfig.workingDirectory;
+  }
+  return process.cwd();
+}
+
+/**
+ * Get environment for a specific CLI tool
+ */
+function getEnvironmentForTool(toolName) {
+  const env = { ...process.env };
+
+  // Tool-specific environment handling
+  if (toolName === 'qwen') {
+    // Qwen CLI requires NODE_PATH to be unset
+    delete env.NODE_PATH;
+  }
+
+  return env;
+}
+
+/**
+ * Add OAuth authentication arguments to command args
+ */
+function addOAuthAuthArgs(toolName, args = []) {
+  const toolConfig = CLI_TOOLS[toolName];
+
+  if (toolConfig && toolConfig.oauth) {
+    const oauth = toolConfig.oauth;
+    if (oauth.authRequired) {
+      // Qwen-specific OAuth handling
+      if (toolName === 'qwen' && process.env.QWEN_ACCESS_TOKEN) {
+        return [...args, '--access-token', process.env.QWEN_ACCESS_TOKEN];
+      }
+    }
+  }
+
+  return args;
+}
+
+/**
+ * Execute a smart routed command with full parameter handling and mode detection
+ * @param {Object} route - Route object with tool and prompt
+ * @param {Object} options - Execution options
+ */
+async function executeSmartRoutedCommand(route, options = {}) {
+  const { verbose = false, maxRetries = 3, interactive, print } = options;
+
+  try {
+    // Detect execution mode
+    const mode = modeDetector.detect({
+      interactive,
+      print,
+      verbose
+    });
+
+    const modeDescription = modeDetector.getModeDescription(mode);
+    if (verbose) {
+      console.log(chalk.gray(`[MODE] ${modeDescription}`));
+    }
+
+    // Get adapted arguments for the tool and mode
+    let toolArgs = cliAdapterManager.getArguments(route.tool, mode, route.prompt);
+
+    // Add OAuth authentication if needed
+    toolArgs = addOAuthAuthArgs(route.tool, toolArgs);
+
+    // Use enhanced parameter handling for one-time mode only
+    if (mode === 'one-time') {
+      const EnhancedCLIParameterHandler = require('../../core/enhanced_cli_parameter_handler');
+      const paramHandler = new EnhancedCLIParameterHandler();
+
+      // Generate optimized arguments with agent/skill support
+      const paramResult = await paramHandler.generateArgumentsWithRetry(
+        route.tool,
+        route.prompt,
+        {
+          maxRetries,
+          enableAgentSkillOptimization: true
+        }
+      );
+
+      toolArgs = paramResult.arguments;
+
+      // Re-add OAuth authentication (paramResult might overwrite)
+      toolArgs = addOAuthAuthArgs(route.tool, toolArgs);
+
+      if (verbose) {
+        console.log(chalk.gray(`[DEBUG] Generated args: ${toolArgs.join(' ')}`));
+      }
+    } else {
+      if (verbose) {
+        console.log(chalk.gray(`[DEBUG] Adapted args: ${toolArgs.join(' ')}`));
+      }
+    }
+
+    // Get tool path
+    const toolPath = await getCLIPath(route.tool);
+    if (!toolPath) {
+      throw new Error(`Tool ${route.tool} not found`);
+    }
+
+    // Prepare execution environment
+    const cwd = getWorkingDirectoryForTool(route.tool);
+    const env = getEnvironmentForTool(route.tool);
+
+    if (verbose) {
+      console.log(chalk.gray(`[DEBUG] Executing: ${toolPath} ${toolArgs.join(' ')}`));
+      console.log(chalk.gray(`[DEBUG] Working directory: ${cwd}`));
+      console.log(chalk.gray(`[DEBUG] Mode: ${mode}`));
+    }
+
+    // Execute the command
+    // For interactive mode, we need stdio: 'inherit' to allow user interaction
+    const result = await executeCommand(toolPath, toolArgs, {
+      stdio: mode === 'interactive' ? 'inherit' : 'pipe',
+      shell: true,
+      cwd,
+      env,
+      timeout: 300000 // 5 minutes
+    });
+
+    return { success: true, tool: route.tool, result, mode };
+
+  } catch (error) {
+    if (verbose) {
+      console.error(chalk.red('[ERROR] Execution failed:'), error.message);
+    }
+    throw error;
+  }
+}
+
+/**
+ * Handle call command - Smart tool routing
+ * @param {string} prompt - Prompt to process
+ * @param {Object} options - Command options
+ */
+async function handleCallCommand(prompt, options = {}) {
+  try {
+    if (!prompt) {
+      console.log(chalk.red('[ERROR] Usage: stigmergy call "<prompt>"'));
+      console.log(chalk.blue('\n💡 Examples:'));
+      console.log(chalk.gray('  • stigmergy call "Write a Python function to sort a list"'));
+      console.log(chalk.gray('  • stigmergy call "Create a React component with TypeScript"'));
+      console.log(chalk.gray('  • stigmergy call "Help me debug this JavaScript code"'));
+      console.log(chalk.gray('\n  • stigmergy call -i "Start interactive session"'));
+      console.log(chalk.gray('  • stigmergy call --print "Quick answer"'));
+      return { success: false, error: 'Prompt required' };
+    }
+
+    // Use smart router to determine which tool to use
+    const router = new SmartRouter();
+    await router.initialize();
+    const route = await router.smartRoute(prompt);
+
+    console.log(chalk.blue(`[CALL] Routing to ${route.tool}: ${route.prompt}`));
+
+    // Use enhanced execution with parameter handling and mode detection
+    await executeSmartRoutedCommand(route, {
+      verbose: options.verbose || process.env.DEBUG === 'true',
+      maxRetries: options.maxRetries || 3,
+      interactive: options.interactive,
+      print: options.print
+    });
+
+    return { success: true, tool: route.tool };
+
+  } catch (error) {
+    console.error(chalk.red('[ERROR] Call command failed:'), error.message);
+    return { success: false, error: error.message };
+  }
+}
+
+module.exports = {
+  handleUpgradeCommand,
+  handleDeployCommand,
+  handleInitCommand,
+  handleSetupCommand,
+  handleCallCommand
+};