stigmergy 1.2.12 → 1.3.1-beta

package/src/cli/commands/independent-resume.js

@@ -0,0 +1,395 @@
+#!/usr/bin/env node
+/**
+ * Independent Session Recovery Tool
+ * Find and recover the latest session across all CLIs
+ * Does NOT depend on Stigmergy installation
+ */
+
+const fs = require('fs');
+const path = require('path');
+const os = require('os');
+
+class IndependentSessionRecovery {
+  constructor() {
+    this.projectPath = process.cwd();
+    this.cliPaths = this.getAllCLISessionPaths();
+  }
+
+  // Get all CLI session paths
+  getAllCLISessionPaths() {
+    const homeDir = os.homedir();
+    return {
+      claude: path.join(homeDir, '.claude', 'projects'),
+      gemini: path.join(homeDir, '.config', 'gemini', 'tmp'),
+      qwen: path.join(homeDir, '.qwen', 'projects'),
+      iflow: path.join(homeDir, '.iflow', 'projects'),
+      codebuddy: path.join(homeDir, '.codebuddy'),
+      codex: path.join(homeDir, '.config', 'codex'),
+      qodercli: path.join(homeDir, '.qoder', 'projects'),
+      kode: path.join(homeDir, '.kode', 'projects')
+    };
+  }
+
+  // Get project directory name (normalized)
+  getProjectDirName(cliType) {
+    // Windows drive letter format: D:\path -> D--path
+    return this.projectPath
+      .replace(/^([A-Za-z]):\\/, '$1--')
+      .replace(/\\/g, '-');
+  }
+
+  // Find latest session across all CLIs
+  findLatestSession() {
+    let latestSession = null;
+    let latestTime = new Date(0);
+
+    for (const [cliType, basePath] of Object.entries(this.cliPaths)) {
+      if (!fs.existsSync(basePath)) continue;
+
+      const session = this.findLatestSessionForCLI(cliType, basePath);
+      if (session && session.modified > latestTime) {
+        latestSession = session;
+        latestTime = session.modified;
+      }
+    }
+
+    return latestSession;
+  }
+
+  // Find latest session for a specific CLI
+  findLatestSessionForCLI(cliType, basePath) {
+    const projectDirName = this.getProjectDirName(cliType);
+
+    // Different CLIs have different directory structures
+    let sessionPath = basePath;
+
+    if (['claude', 'iflow', 'qodercli', 'kode'].includes(cliType) && basePath.includes('projects')) {
+      sessionPath = path.join(basePath, projectDirName);
+    } else if (cliType === 'gemini' && basePath.includes('tmp')) {
+      // Gemini uses hash directories
+      try {
+        const hashDirs = fs.readdirSync(basePath);
+        for (const hashDir of hashDirs) {
+          const hashDirPath = path.join(basePath, hashDir);
+          const chatsPath = path.join(hashDirPath, 'chats');
+          if (fs.existsSync(chatsPath)) {
+            const session = this.findLatestSessionInDir(chatsPath, cliType, hashDir);
+            if (session) return session;
+          }
+        }
+        return null;
+      } catch (error) {
+        return null;
+      }
+    } else if (cliType === 'qwen' && basePath.includes('projects')) {
+      // Qwen uses projects/<projectName>/chats
+      const chatsPath = path.join(basePath, projectDirName, 'chats');
+      if (fs.existsSync(chatsPath)) {
+        return this.findLatestSessionInDir(chatsPath, cliType, projectDirName);
+      }
+      return null;
+    } else if (cliType === 'codebuddy') {
+      // CodeBuddy uses projects/<projectName> or root
+      const projectsPath = path.join(basePath, 'projects');
+      if (fs.existsSync(projectsPath)) {
+        const projectPath = path.join(projectsPath, projectDirName);
+        if (fs.existsSync(projectPath)) {
+          const session = this.findLatestSessionInDir(projectPath, cliType, projectDirName);
+          if (session) return session;
+        }
+      }
+      return this.findLatestSessionInDir(basePath, cliType, 'root');
+    }
+
+    if (!fs.existsSync(sessionPath)) return null;
+
+    return this.findLatestSessionInDir(sessionPath, cliType, projectDirName);
+  }
+
+  // Find latest session in a directory
+  findLatestSessionInDir(dirPath, cliType, context) {
+    try {
+      const files = fs.readdirSync(dirPath);
+
+      // Filter for session files only
+      const sessionFiles = files.filter(file => {
+        // CodeBuddy's user-state.json should be skipped
+        if (cliType === 'codebuddy' && file === 'user-state.json') {
+          return false;
+        }
+        // Codex's slash_commands.json should be skipped
+        if (cliType === 'codex' && file === 'slash_commands.json') {
+          return false;
+        }
+        return file.endsWith('.jsonl') || file.endsWith('.json') || file.endsWith('.session');
+      });
+
+      if (sessionFiles.length === 0) return null;
+
+      let latestFile = null;
+      let latestTime = new Date(0);
+
+      for (const file of sessionFiles) {
+        const filePath = path.join(dirPath, file);
+        try {
+          const stats = fs.statSync(filePath);
+          if (stats.mtime > latestTime) {
+            latestTime = stats.mtime;
+            latestFile = file;
+          }
+        } catch (error) {
+          continue;
+        }
+      }
+
+      if (!latestFile) return null;
+
+      return {
+        cliType,
+        file: latestFile,
+        path: path.join(dirPath, latestFile),
+        modified: latestTime,
+        context
+      };
+    } catch (error) {
+      return null;
+    }
+  }
+
+  // Read and parse full session content
+  readFullSession(sessionPath) {
+    try {
+      const content = fs.readFileSync(sessionPath, 'utf8');
+
+      if (sessionPath.endsWith('.jsonl')) {
+        const lines = content.trim().split('\n').filter(line => line.trim());
+        return lines.map(line => {
+          try {
+            return JSON.parse(line);
+          } catch (e) {
+            return null;
+          }
+        }).filter(msg => msg !== null);
+      } else {
+        return JSON.parse(content);
+      }
+    } catch (error) {
+      console.error(`Error reading session: ${error.message}`);
+      return null;
+    }
+  }
+
+  // Format full session for output
+  formatFullSession(session) {
+    const messages = this.readFullSession(session.path);
+    if (!messages) {
+      return null;
+    }
+
+    // Handle different message formats
+    const messageList = Array.isArray(messages) ? messages :
+                       (messages.messages && Array.isArray(messages.messages)) ? messages.messages : [];
+
+    if (messageList.length === 0) {
+      return null;
+    }
+
+    const output = [];
+    output.push('📋 最新会话恢复');
+    output.push('');
+    output.push(`🔧 来源: ${session.cliType.toUpperCase()}`);
+    output.push(`📅 最后修改: ${session.modified.toLocaleString()}`);
+    output.push(`📁 文件: ${session.file}`);
+    output.push('');
+    output.push('---');
+    output.push('');
+    output.push('📝 完整对话内容:');
+    output.push('');
+
+    // Extract and format all messages
+    messageList.forEach((msg, index) => {
+      const role = msg.type || msg.role || 'unknown';
+      const prefix = role === 'user' ? '👤 用户' : '🤖 助手';
+      const content = this.extractMessageContent(msg);
+
+      if (content && content.trim()) {
+        output.push(`${prefix}:`);
+        output.push(content);
+        output.push('');
+      }
+    });
+
+    return output.join('\n');
+  }
+
+  // Extract text content from a message
+  extractMessageContent(msg) {
+    if (msg.message && typeof msg.message === 'object') {
+      const content = msg.message.content || msg.message.text || '';
+      return this.extractTextFromContent(content);
+    }
+
+    const content = msg.content || msg.text || '';
+    return this.extractTextFromContent(content);
+  }
+
+  // Extract text from content
+  extractTextFromContent(content) {
+    if (typeof content === 'string') {
+      return content;
+    }
+
+    if (Array.isArray(content)) {
+      return content
+        .map(item => {
+          if (typeof item === 'string') return item;
+          if (item && typeof item === 'object') {
+            return item.text || item.content || '';
+          }
+          return '';
+        })
+        .filter(text => text && typeof text === 'string')
+        .join(' ');
+    }
+
+    if (content && typeof content === 'object') {
+      return content.text || content.content || '';
+    }
+
+    return '';
+  }
+
+  // Execute recovery
+  execute(options = {}) {
+    const {
+      fullRecovery = true,  // Default: recover full session
+      listOnly = false,      // List sessions without recovery
+      cliFilter = null        // Filter by specific CLI
+    } = options;
+
+    if (listOnly) {
+      // Advanced mode: list all sessions
+      return this.listAllSessions(cliFilter);
+    }
+
+    // Default mode: find and recover latest session
+    let session;
+
+    if (cliFilter) {
+      // Filter by specific CLI
+      const basePath = this.cliPaths[cliFilter.toLowerCase()];
+      if (basePath && fs.existsSync(basePath)) {
+        session = this.findLatestSessionForCLI(cliFilter.toLowerCase(), basePath);
+      }
+    } else {
+      // Find latest across all CLIs
+      session = this.findLatestSession();
+    }
+
+    if (!session) {
+      console.log('📭 未找到任何会话');
+      console.log('');
+      console.log(`💡 项目路径: ${this.projectPath}`);
+      if (cliFilter) {
+        console.log(`💡 指定CLI: ${cliFilter}`);
+      }
+      return 1;
+    }
+
+    if (!fullRecovery) {
+      // Show summary only
+      this.showSessionSummary(session);
+    } else {
+      // Show full session
+      const formatted = this.formatFullSession(session);
+      if (formatted) {
+        console.log(formatted);
+      } else {
+        console.log('📭 无法解析会话内容');
+        return 1;
+      }
+    }
+
+    return 0;
+  }
+
+  // Show session summary (advanced mode)
+  showSessionSummary(session) {
+    const output = [];
+    output.push('📋 会话信息');
+    output.push('');
+    output.push(`🔧 来源: ${session.cliType.toUpperCase()}`);
+    output.push(`📅 最后修改: ${session.modified.toLocaleString()}`);
+    output.push(`📁 文件: ${session.file}`);
+    output.push(`📂 路径: ${session.path}`);
+    if (session.context) {
+      output.push(`🔍 上下文: ${session.context}`);
+    }
+    console.log(output.join('\n'));
+  }
+
+  // List all sessions (advanced mode)
+  listAllSessions(cliFilter = null) {
+    const sessions = [];
+
+    for (const [cliType, basePath] of Object.entries(this.cliPaths)) {
+      if (cliFilter && cliType.toLowerCase() !== cliFilter.toLowerCase()) continue;
+
+      if (!fs.existsSync(basePath)) continue;
+
+      const session = this.findLatestSessionForCLI(cliType, basePath);
+      if (session) {
+        sessions.push(session);
+      }
+    }
+
+    if (sessions.length === 0) {
+      console.log('📭 未找到任何会话');
+      return 1;
+    }
+
+    // Sort by modification time (newest first)
+    sessions.sort((a, b) => b.modified - a.modified);
+
+    const output = [];
+    output.push('📋 所有会话列表');
+    output.push('');
+    output.push(`📊 共找到 ${sessions.length} 个会话`);
+    output.push('');
+
+    sessions.forEach((session, index) => {
+      output.push(`${index + 1}. ${session.cliType.toUpperCase()}`);
+      output.push(`   📅 ${session.modified.toLocaleString()}`);
+      output.push(`   📁 ${session.file}`);
+      output.push('');
+    });
+
+    console.log(output.join('\n'));
+    return 0;
+  }
+}
+
+// Run as CLI command
+if (require.main === module) {
+  const recovery = new IndependentSessionRecovery();
+
+  // Parse command line options
+  const options = {};
+  const args = process.argv.slice(2);
+
+  for (let i = 0; i < args.length; i++) {
+    const arg = args[i];
+
+    if (arg === '--list' || arg === '-l') {
+      options.listOnly = true;
+    } else if (arg === '--summary' || arg === '-s') {
+      options.fullRecovery = false;
+    } else if (arg === '--cli' && i + 1 < args.length) {
+      options.cliFilter = args[++i];
+    }
+  }
+
+  process.exit(recovery.execute(options));
+}
+
+module.exports = IndependentSessionRecovery;

package/src/cli/commands/install.js

@@ -0,0 +1,179 @@
+/**
+ * Install Command Module
+ * Handles CLI tool installation commands
+ */
+
+const StigmergyInstaller = require('../../core/installer');
+const chalk = require('chalk');
+const { ensureSkillsCache } = require('../utils/skills_cache');
+const { handleDeployCommand } = require('./project');
+
+/**
+ * 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();
+
+      // Filter to only install tools with autoInstall: true, unless --all is specified
+      let toolsToInstall;
+      if (options.all) {
+        console.log(chalk.blue('[AUTO-INSTALL] Installing ALL CLI tools (--all mode)'));
+        toolsToInstall = Object.entries(missingTools);
+      } else {
+        console.log(chalk.blue('[AUTO-INSTALL] Installing only auto-install tools'));
+        toolsToInstall = Object.entries(missingTools)
+          .filter(([toolName]) => installer.router.tools[toolName]?.autoInstall === true);
+      }
+      
+      const filteredMissingTools = Object.fromEntries(toolsToInstall);
+
+      if (Object.keys(filteredMissingTools).length === 0) {
+        console.log(chalk.green('✅ All CLI tools are already installed!'));
+        return {
+          success: true,
+          installed: [],
+          existing: Object.keys(availableTools)
+        };
+      }
+
+      // Install all missing tools in auto mode
+      const selectedTools = Object.keys(filteredMissingTools);
+      console.log(chalk.blue(`[AUTO-INSTALL] Installing ${selectedTools.length} tools: ${selectedTools.join(', ')}`));
+
+      const installResult = await installer.installTools(selectedTools, filteredMissingTools);
+
+      if (installResult.success) {
+        console.log(chalk.green('✅ Auto-install completed successfully!'));
+        
+        // 如果是 --all 模式，自动部署所有工具
+        if (options.all) {
+          console.log(chalk.blue('\n🚀 Deploying hooks for all installed tools...'));
+          try {
+            const deployResult = await handleDeployCommand({
+              verbose: options.verbose || process.env.DEBUG === 'true',
+              force: options.force || false,
+              all: true
+            });
+            if (deployResult.success) {
+              console.log(chalk.green('✅ Hooks deployed successfully!'));
+            }
+          } catch (deployError) {
+            console.log(chalk.yellow(`⚠️  Hook deployment warning: ${deployError.message}`));
+          }
+        }
+        
+        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();
+
+    // Filter to only show tools with autoInstall: true
+    const toolsToInstall = Object.entries(missingTools)
+      .filter(([toolName]) => installer.router.tools[toolName]?.autoInstall === true);
+    const filteredMissingTools = Object.fromEntries(toolsToInstall);
+
+    if (Object.keys(filteredMissingTools).length === 0) {
+      console.log(chalk.green('✅ All auto-install 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(filteredMissingTools).length} missing tools:`));
+    Object.entries(filteredMissingTools).forEach(([toolName, toolInfo]) => {
+      console.log(`  - ${toolInfo.name}: ${toolInfo.install}`);
+    });
+
+    // For now, install all missing tools
+    const selectedTools = Object.keys(filteredMissingTools);
+    const installResult = await installer.installTools(selectedTools, filteredMissingTools);
+
+    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
+};