stigmergy 1.2.13 → 1.3.2-beta.1

package/src/cli/commands/resume.js

@@ -0,0 +1,136 @@
+/**
+ * Resume Session Commands
+ * Modular implementation for resume/resumesession/sg-resume commands
+ */
+
+const chalk = require('chalk');
+const { spawnSync } = require('child_process');
+const { getCLIPath } = require('../../core/cli_tools');
+
+/**
+ * Handle resume session command - Forward to @stigmergy/resume CLI tool
+ * @param {Array} args - Arguments to pass to resumesession
+ * @param {Object} options - Command options
+ */
+async function handleResumeCommand(args = [], options = {}) {
+  try {
+    console.log(chalk.blue('[RESUME] Checking for ResumeSession CLI tool...'));
+
+    // Check if resumesession command is available
+    const resumesessionPath = await getCLIPath('resumesession');
+
+    if (resumesessionPath) {
+      console.log(chalk.green(`[RESUME] Found ResumeSession at: ${resumesessionPath}`));
+
+      // Forward all arguments to the resumesession CLI tool
+      const resumeArgs = args; // Pass all arguments through
+      console.log(chalk.blue(`[RESUME] Forwarding to resumesession: ${resumeArgs.join(' ') || '(no args)'}`));
+
+      // Execute resumesession with the provided arguments
+      const result = spawnSync(resumesessionPath, resumeArgs, {
+        stdio: 'inherit',
+        shell: true,
+        cwd: process.cwd(),
+        env: { ...process.env, FORCE_COLOR: '1' } // Ensure colors are preserved
+      });
+
+      if (result.status !== 0) {
+        console.log(chalk.yellow(`[WARN] ResumeSession exited with code ${result.status}`));
+        return { success: false, exitCode: result.status, forwarded: true };
+      }
+
+      return { success: true, exitCode: result.status, forwarded: true };
+
+    } else {
+      // ResumeSession CLI tool not found
+      console.log(chalk.red('[ERROR] ResumeSession CLI tool not found'));
+      console.log(chalk.yellow('[INFO] ResumeSession is an optional component for session recovery'));
+
+      console.log(chalk.blue('\n📦 To install ResumeSession:'));
+      console.log('  npm install -g @stigmergy/resume');
+      console.log('');
+      console.log(chalk.blue('🔧 ResumeSession provides:'));
+      console.log('  • Cross-CLI session history');
+      console.log('  • Memory sharing between CLI tools');
+      console.log('  • Session recovery and continuation');
+      console.log('  • Centralized configuration management');
+      console.log('');
+      console.log(chalk.blue('📋 Usage examples:'));
+      console.log('  stigmergy resume list                    # Show session history');
+      console.log('  stigmergy resume continue <session-id>    # Continue a session');
+      console.log('  stigmergy resume export                   # Export session data');
+      console.log('  stigmergy resume --help                   # Show all options');
+
+      return { success: false, error: 'ResumeSession CLI tool not found', forwarded: false };
+    }
+
+  } catch (error) {
+    console.error(chalk.red('[ERROR] Resume command failed:'), error.message);
+
+    if (options.verbose) {
+      console.error(chalk.red('Stack trace:'), error.stack);
+    }
+
+    return { success: false, error: error.message, forwarded: false };
+  }
+}
+
+/**
+ * Handle resumesession command alias
+ * @param {Array} args - Arguments
+ * @param {Object} options - Options
+ */
+async function handleResumeSessionCommand(args = [], options = {}) {
+  return await handleResumeCommand(args, options);
+}
+
+/**
+ * Handle sg-resume command alias
+ * @param {Array} args - Arguments
+ * @param {Object} options - Options
+ */
+async function handleSgResumeCommand(args = [], options = {}) {
+  return await handleResumeCommand(args, options);
+}
+
+/**
+ * Print resume help information
+ */
+function printResumeHelp() {
+  console.log(chalk.cyan(`
+🔄 Stigmergy Resume Session System
+
+📋 ResumeSession forwards to the @stigmergy/resume CLI tool for session management.
+
+🛠️  Available Commands:
+  stigmergy resume [args]              Forward to resumesession CLI
+  stigmergy resumesession [args]       Same as resume (full name)
+  stigmergy sg-resume [args]           Same as resume (short alias)
+
+📦 Requirements:
+  @stigmergy/resume CLI tool must be installed separately.
+
+💾 Installation:
+  npm install -g @stigmergy/resume
+
+🔍 Common Usage:
+  stigmergy resume list                # Show available sessions
+  stigmergy resume continue <id>       # Continue a specific session
+  stigmergy resume export              # Export session data
+  stigmergy resume clean               # Clean old sessions
+
+📚 More Information:
+  ResumeSession provides cross-CLI memory sharing and session recovery
+  capabilities, allowing you to maintain context across different AI CLI tools.
+
+  If ResumeSession is not installed, you can still use all other Stigmergy
+  CLI features normally.
+  `));
+}
+
+module.exports = {
+  handleResumeCommand,
+  handleResumeSessionCommand,
+  handleSgResumeCommand,
+  printResumeHelp
+};

package/src/cli/commands/scan.js

@@ -0,0 +1,97 @@
+/**
+ * Scan Command Module
+ * Handles CLI tool scanning and discovery commands
+ */
+
+const { CLI_TOOLS } = require('../../core/cli_tools');
+const chalk = require('chalk');
+const { ensureSkillsCache } = require('../utils/skills_cache');
+
+/**
+ * Handle scan command
+ * @param {Object} options - Command options
+ * @param {boolean} options.deep - Deep scan for CLI tools
+ * @param {boolean} options.json - Output in JSON format
+ * @param {boolean} options.verbose - Verbose output
+ */
+async function handleScanCommand(options = {}) {
+  try {
+    // Initialize or update skills/agents cache
+    await ensureSkillsCache({ verbose: options.verbose });
+
+    console.log(chalk.blue('🔍 Scanning for CLI tools...'));
+
+    const scanOptions = {
+      deep: options.deep || false,
+      verbose: options.verbose || false
+    };
+
+    // Scan for available CLI tools
+    const results = await CLI_TOOLS.scanForTools(scanOptions);
+
+    if (results.found && results.found.length > 0) {
+      console.log(chalk.green(`\n✅ Found ${results.found.length} CLI tools:`));
+
+      for (const tool of results.found) {
+        console.log(chalk.cyan(`  📦 ${tool.name}`));
+        console.log(chalk.gray(`     Version: ${tool.version || 'unknown'}`));
+        console.log(chalk.gray(`     Path: ${tool.path}`));
+
+        if (options.verbose) {
+          console.log(chalk.gray(`     Type: ${tool.type}`));
+          console.log(chalk.gray(`     Status: ${tool.status}`));
+          if (tool.description) {
+            console.log(chalk.gray(`     Description: ${tool.description}`));
+          }
+        }
+      }
+    } else {
+      console.log(chalk.yellow('\n⚠️  No CLI tools found'));
+    }
+
+    // Show missing tools
+    if (results.missing && results.missing.length > 0) {
+      console.log(chalk.yellow(`\n❌ Missing ${results.missing.length} tools:`));
+      results.missing.forEach(tool => {
+        console.log(chalk.red(`  ❌ ${tool}`));
+      });
+
+      console.log(chalk.cyan('\n💡 To install missing tools:'));
+      console.log(chalk.cyan('   stigmergy install'));
+    }
+
+    // Summary
+    console.log('');
+    console.log(chalk.blue('📊 Scan Summary:'));
+    console.log(`  Total tools checked: ${results.total || 0}`);
+    console.log(`  Found: ${results.found?.length || 0}`);
+    console.log(`  Missing: ${results.missing?.length || 0}`);
+
+    if (options.json) {
+      console.log('');
+      console.log(chalk.blue('📄 JSON Output:'));
+      console.log(JSON.stringify(results, null, 2));
+    }
+
+    // Recommendations
+    if (results.found && results.found.length > 0) {
+      console.log(chalk.cyan('\n💡 You can now use these tools:'));
+      const toolExamples = results.found.slice(0, 3);
+      toolExamples.forEach(tool => {
+        console.log(chalk.cyan(`   stigmergy ${tool.name} "your prompt here"`));
+      });
+
+      if (results.found.length > 3) {
+        console.log(chalk.cyan(`   ... and ${results.found.length - 3} more tools`));
+      }
+    }
+
+  } catch (error) {
+    console.log(chalk.red(`❌ Scan failed: ${error.message}`));
+    process.exit(1);
+  }
+}
+
+module.exports = {
+  handleScanCommand
+};

package/src/cli/commands/skills.js

@@ -0,0 +1,158 @@
+/**
+ * Skills Management Commands
+ * Modular implementation for all skill-related commands
+ */
+
+const chalk = require('chalk');
+const { handleSkillCommand } = require('../../commands/skill-handler');
+
+/**
+ * Handle main skill command with all subcommands
+ * @param {string} subcommand - Skill subcommand (install/list/read/remove/validate/sync)
+ * @param {Array} args - Additional arguments
+ * @param {Object} options - Command options
+ */
+async function handleSkillMainCommand(subcommand, args = [], options = {}) {
+  try {
+    // Handle skill command aliases from router-beta.js
+    let action;
+    let skillArgs;
+
+    switch (subcommand) {
+      case 'skill-i':
+        action = 'install';
+        skillArgs = args;
+        break;
+      case 'skill-l':
+        action = 'list';
+        skillArgs = args;
+        break;
+      case 'skill-v':
+        // skill-v can be validate or read, based on parameters
+        action = args[0] && (args[0].endsWith('.md') || args[0].includes('/') || args[0].includes('\\'))
+          ? 'validate'
+          : 'read';
+        skillArgs = args;
+        break;
+      case 'skill-r':
+        action = 'read';
+        skillArgs = args;
+        break;
+      case 'skill-d':
+      case 'skill-m':
+        action = 'remove';
+        skillArgs = args;
+        break;
+      default:
+        action = subcommand || 'help';
+        skillArgs = args;
+        break;
+    }
+
+    const exitCode = await handleSkillCommand(action, skillArgs, {
+      verbose: options.verbose || false,
+      force: options.force || false,
+      autoSync: !options.noAutoSync
+    });
+
+    return { success: exitCode === 0, exitCode };
+  } catch (error) {
+    console.error(chalk.red(`[ERROR] Skill command failed: ${error.message}`));
+    return { success: false, error: error.message };
+  }
+}
+
+/**
+ * Handle skill install command (skill-i alias)
+ * @param {Array} args - Arguments
+ * @param {Object} options - Options
+ */
+async function handleSkillInstallCommand(args = [], options = {}) {
+  return await handleSkillMainCommand('install', args, options);
+}
+
+/**
+ * Handle skill list command (skill-l alias)
+ * @param {Array} args - Arguments
+ * @param {Object} options - Options
+ */
+async function handleSkillListCommand(args = [], options = {}) {
+  return await handleSkillMainCommand('list', args, options);
+}
+
+/**
+ * Handle skill read command (skill-r alias)
+ * @param {Array} args - Arguments
+ * @param {Object} options - Options
+ */
+async function handleSkillReadCommand(args = [], options = {}) {
+  return await handleSkillMainCommand('read', args, options);
+}
+
+/**
+ * Handle skill validate/read command (skill-v alias)
+ * @param {Array} args - Arguments
+ * @param {Object} options - Options
+ */
+async function handleSkillValidateCommand(args = [], options = {}) {
+  return await handleSkillMainCommand('validate', args, options);
+}
+
+/**
+ * Handle skill remove command (skill-d, skill-m aliases)
+ * @param {Array} args - Arguments
+ * @param {Object} options - Options
+ */
+async function handleSkillRemoveCommand(args = [], options = {}) {
+  return await handleSkillMainCommand('remove', args, options);
+}
+
+/**
+ * Print skills help information
+ */
+function printSkillsHelp() {
+  console.log(chalk.cyan(`
+🎯 Stigmergy Skills Management System
+
+📋 Available Commands:
+  stigmergy skill install <source>     Install a skill from source
+  stigmergy skill list                 List all installed skills
+  stigmergy skill read <skill-name>    Read skill content and description
+  stigmergy skill validate <path>      Validate skill file or directory
+  stigmergy skill remove <skill-name>  Remove installed skill
+  stigmergy skill sync                 Sync skills with remote repositories
+
+🔗 Aliases (Shortcuts):
+  skill-i       → skill install
+  skill-l       → skill list
+  skill-r       → skill read
+  skill-v       → skill validate/read (auto-detect)
+  skill-d       → skill remove
+  skill-m       → skill remove (移除)
+
+💡 Examples:
+  stigmergy skill install anthropics/skills
+  stigmergy skill-i anthropics/skills          # Using alias
+  stigmergy skill list
+  stigmergy skill-l                           # Using alias
+  stigmergy skill read canvas-design
+  stigmergy skill-v ./my-skill.md             # Validate file
+  stigmergy skill-r docx                      # Using alias
+  stigmergy skill remove old-skill
+  stigmergy skill-d old-skill                 # Using alias
+
+📚 More Information:
+  Skills extend CLI tool capabilities with specialized workflows and tools.
+  Each skill contains instructions for specific tasks and integrations.
+  `));
+}
+
+module.exports = {
+  handleSkillMainCommand,
+  handleSkillInstallCommand,
+  handleSkillListCommand,
+  handleSkillReadCommand,
+  handleSkillValidateCommand,
+  handleSkillRemoveCommand,
+  printSkillsHelp
+};

package/src/cli/commands/status.js

@@ -0,0 +1,106 @@
+/**
+ * Status Command Module
+ * Handles CLI tool status checking commands
+ */
+
+const { CLI_TOOLS } = require('../../core/cli_tools');
+const chalk = require('chalk');
+const { formatToolStatus } = require('../utils/formatters');
+
+/**
+ * Handle status command
+ * @param {Object} options - Command options
+ * @param {string} options.cli - Specific CLI to check
+ * @param {boolean} options.json - Output in JSON format
+ * @param {boolean} options.verbose - Verbose output
+ */
+async function handleStatusCommand(options = {}) {
+  try {
+    const supportedTools = ['claude', 'gemini', 'qwen', 'codebuddy', 'codex', 'iflow', 'qodercli', 'copilot'];
+
+    if (options.cli) {
+      // Check specific CLI
+      if (!supportedTools.includes(options.cli)) {
+        console.log(chalk.red(`❌ Unknown CLI tool: ${options.cli}`));
+        console.log(chalk.yellow(`Supported tools: ${supportedTools.join(', ')}`));
+        process.exit(1);
+      }
+
+      try {
+        const status = await CLI_TOOLS.checkInstallation(options.cli);
+
+        if (options.json) {
+          console.log(JSON.stringify(status, null, 2));
+        } else {
+          console.log(chalk.cyan(`📊 ${options.cli} Status:`));
+          console.log(formatToolStatus({ ...status, tool: options.cli }));
+
+          if (options.verbose && status.installed) {
+            if (status.version) {
+              console.log(chalk.gray(`   📦 Version: ${status.version}`));
+            }
+            if (status.path) {
+              console.log(chalk.gray(`   📍 Path: ${status.path}`));
+            }
+            if (status.lastChecked) {
+              console.log(chalk.gray(`   🕐 Last checked: ${status.lastChecked}`));
+            }
+          }
+        }
+      } catch (error) {
+        console.log(chalk.red(`❌ Error checking ${options.cli}: ${error.message}`));
+        process.exit(1);
+      }
+    } else {
+      // Check all CLIs
+      console.log(chalk.cyan('📊 CLI Tools Status:'));
+
+      let installedCount = 0;
+      const results = [];
+
+      for (const tool of supportedTools) {
+        try {
+          const status = await CLI_TOOLS.checkInstallation(tool);
+          results.push({ tool, ...status });
+
+          if (status.installed) {
+            installedCount++;
+            console.log(chalk.green(`  ✅ ${tool}`));
+          } else {
+            console.log(chalk.red(`  ❌ ${tool}`));
+          }
+        } catch (error) {
+          results.push({ tool, installed: false, error: error.message });
+          console.log(chalk.yellow(`  ⚠️  ${tool}: Error checking status`));
+        }
+      }
+
+      // Summary
+      console.log('');
+      console.log(chalk.blue(`📈 Summary: ${installedCount}/${supportedTools.length} tools installed`));
+
+      if (installedCount < supportedTools.length) {
+        console.log(chalk.yellow('\n💡 To install missing tools, run:'));
+        console.log(chalk.cyan('   stigmergy install'));
+
+        const missing = results.filter(r => !r.installed);
+        if (missing.length > 0 && missing.length < supportedTools.length) {
+          console.log(chalk.cyan(`   stigmergy install --cli ${missing.map(r => r.tool).join(',')}`));
+        }
+      }
+
+      if (options.json) {
+        console.log('');
+        console.log(chalk.blue('📄 Detailed JSON output:'));
+        console.log(JSON.stringify(results, null, 2));
+      }
+    }
+  } catch (error) {
+    console.log(chalk.red(`❌ Status check failed: ${error.message}`));
+    process.exit(1);
+  }
+}
+
+module.exports = {
+  handleStatusCommand
+};