stigmergy 1.2.12 → 1.3.1-beta

package/src/cli/commands/system.js

@@ -0,0 +1,301 @@
+/**
+ * System Commands
+ * Modular implementation for clean, diagnostic, and other system commands
+ */
+
+const chalk = require('chalk');
+const fs = require('fs').promises;
+const path = require('path');
+const os = require('os');
+
+/**
+ * Handle diagnostic command
+ * @param {Object} options - Command options
+ */
+async function handleDiagnosticCommand(options = {}) {
+  try {
+    console.log(chalk.cyan('[DIAGNOSTIC] Stigmergy CLI System Diagnostic...\n'));
+
+    const results = {
+      system: {},
+      directories: {},
+      files: {},
+      permissions: {},
+      summary: { issues: 0, warnings: 0, ok: 0 }
+    };
+
+    // System information
+    console.log(chalk.blue('🖥️  System Information:'));
+    const systemInfo = {
+      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',
+      homeDir: os.homedir(),
+      currentDir: process.cwd()
+    };
+
+    results.system = systemInfo;
+    Object.entries(systemInfo).forEach(([key, value]) => {
+      console.log(`  ${key}: ${chalk.green(value)}`);
+    });
+
+    // Directory checks
+    console.log(chalk.blue('\n📁 Directory Structure:'));
+    const directories = [
+      path.join(os.homedir(), '.stigmergy'),
+      path.join(os.homedir(), '.claude'),
+      path.join(os.homedir(), '.gemini'),
+      path.join(os.homedir(), '.qwen'),
+      path.join(process.cwd(), 'node_modules')
+    ];
+
+    for (const dir of directories) {
+      try {
+        const stats = await fs.stat(dir);
+        results.directories[dir] = { exists: true, size: stats.size };
+        console.log(`  ${chalk.green('✅')} ${dir}`);
+        results.summary.ok++;
+      } catch (error) {
+        results.directories[dir] = { exists: false, error: error.code };
+        console.log(`  ${chalk.yellow('⚠️')} ${dir} (${error.code})`);
+        results.summary.warnings++;
+      }
+    }
+
+    // Permission checks
+    console.log(chalk.blue('\n🔐 Permission Checks:'));
+    try {
+      await fs.access(process.cwd(), fs.constants.W_OK);
+      console.log(`  ${chalk.green('✅')} Current directory writable`);
+      results.permissions.currentDir = true;
+      results.summary.ok++;
+    } catch (error) {
+      console.log(`  ${chalk.red('❌')} Current directory not writable`);
+      results.permissions.currentDir = false;
+      results.summary.issues++;
+    }
+
+    try {
+      await fs.access(os.homedir(), fs.constants.W_OK);
+      console.log(`  ${chalk.green('✅')} Home directory writable`);
+      results.permissions.homeDir = true;
+      results.summary.ok++;
+    } catch (error) {
+      console.log(`  ${chalk.red('❌')} Home directory not writable`);
+      results.permissions.homeDir = false;
+      results.summary.issues++;
+    }
+
+    // Summary
+    console.log(chalk.blue('\n📊 Diagnostic Summary:'));
+    console.log(`  Issues: ${chalk.red(results.summary.issues)}`);
+    console.log(`  Warnings: ${chalk.yellow(results.summary.warnings)}`);
+    console.log(`  OK: ${chalk.green(results.summary.ok)}`);
+
+    if (results.summary.issues > 0) {
+      console.log(chalk.red('\n❌ Critical issues found - Fix recommended'));
+      console.log('Run: stigmergy fix-perms');
+    } else if (results.summary.warnings > 0) {
+      console.log(chalk.yellow('\n⚠️  Some warnings found - Check recommended'));
+    } else {
+      console.log(chalk.green('\n✅ System looks healthy!'));
+    }
+
+    return { success: true, results };
+  } catch (error) {
+    console.error(chalk.red('[ERROR] Diagnostic failed:'), error.message);
+    return { success: false, error: error.message };
+  }
+}
+
+/**
+ * Handle clean command
+ * @param {Object} options - Command options
+ */
+async function handleCleanCommand(options = {}) {
+  try {
+    console.log(chalk.cyan('[CLEAN] Starting intelligent cache cleaning...\n'));
+
+    const stats = {
+      found: 0,
+      cleaned: 0,
+      skipped: 0,
+      totalSize: 0,
+      cleanedSize: 0,
+      errors: []
+    };
+
+    // Define cleanup targets with priority and safety levels
+    const cleanupTargets = [
+      // Priority 1: Always safe to clean
+      {
+        path: path.join(os.tmpdir(), 'stigmergy-*'),
+        priority: 1,
+        safe: true,
+        description: 'Stigmergy temporary files'
+      },
+      {
+        path: path.join(os.homedir(), '.stigmergy', 'cache'),
+        priority: 1,
+        safe: true,
+        description: 'Stigmergy cache'
+      },
+
+      // Priority 2: Generally safe (user data)
+      {
+        path: path.join(process.cwd(), 'node_modules', '.cache'),
+        priority: 2,
+        safe: true,
+        description: 'Project cache'
+      },
+
+      // Priority 3: CLI tool caches (may have permission issues)
+      {
+        path: path.join(os.homedir(), '.claude', 'cache'),
+        priority: 3,
+        safe: false,
+        description: 'Claude CLI cache'
+      },
+      {
+        path: path.join(os.homedir(), '.gemini', 'cache'),
+        priority: 3,
+        safe: false,
+        description: 'Gemini CLI cache'
+      },
+      {
+        path: path.join(os.homedir(), '.qwen', 'cache'),
+        priority: 3,
+        safe: false,
+        description: 'Qwen CLI cache'
+      }
+    ];
+
+    // Sort by priority
+    cleanupTargets.sort((a, b) => a.priority - b.priority);
+
+    console.log(chalk.blue('🔍 Scanning cleanup targets...'));
+
+    for (const target of cleanupTargets) {
+      try {
+        const isPattern = target.path.includes('*');
+        let targetPaths = [];
+
+        if (isPattern) {
+          // Simple glob pattern handling
+          const baseDir = path.dirname(target.path);
+          const pattern = path.basename(target.path).replace('*', '');
+          try {
+            const files = await fs.readdir(baseDir);
+            targetPaths = files
+              .filter(file => file.includes(pattern))
+              .map(file => path.join(baseDir, file));
+          } catch (error) {
+            // Directory doesn't exist, skip silently
+            continue;
+          }
+        } else {
+          targetPaths = [target.path];
+        }
+
+        for (const targetPath of targetPaths) {
+          try {
+            const targetStats = await fs.stat(targetPath);
+            stats.found++;
+            stats.totalSize += targetStats.size;
+
+            if (!options.dryRun) {
+              // Attempt to clean with better error handling
+              try {
+                if (targetStats.isDirectory()) {
+                  await fs.rmdir(targetPath, { recursive: true });
+                } else {
+                  await fs.unlink(targetPath);
+                }
+                stats.cleaned++;
+                stats.cleanedSize += targetStats.size;
+
+                // Only show successful cleanups in normal mode
+                if (!options.quiet) {
+                  console.log(`  ${chalk.green('✅')} Cleaned ${target.description}`);
+                }
+              } catch (cleanError) {
+                // Silent failure for permission issues
+                stats.skipped++;
+                stats.errors.push({
+                  path: targetPath,
+                  error: cleanError.code,
+                  safe: target.safe
+                });
+              }
+            } else {
+              // Dry run mode
+              console.log(`  ${chalk.blue('🔍')} Would clean: ${target.description} (${Math.round(targetStats.size / 1024)} KB)`);
+            }
+          } catch (statError) {
+            // File might be locked or in use
+            stats.skipped++;
+          }
+        }
+      } catch (error) {
+        // Silently skip inaccessible targets
+        stats.skipped++;
+      }
+    }
+
+    // Show summary with user-friendly output
+    console.log(chalk.blue('\n📊 Cleanup Results:'));
+
+    if (stats.cleaned > 0) {
+      console.log(`  ${chalk.green('✅')} Cleaned: ${stats.cleaned} items (${Math.round(stats.cleanedSize / 1024)} KB)`);
+    }
+
+    if (stats.skipped > 0) {
+      console.log(`  ${chalk.yellow('⚠️')}  Skipped: ${stats.skipped} items (in use or permission protected)`);
+    }
+
+    // Show critical errors only (safe targets that failed)
+    const criticalErrors = stats.errors.filter(e => e.safe && e.error === 'EPERM');
+    if (criticalErrors.length > 0 && options.verbose) {
+      console.log(`  ${chalk.red('❌')} Permission issues on ${criticalErrors.length} safe targets`);
+    }
+
+    // Final user-friendly message
+    if (!options.dryRun) {
+      if (stats.cleaned > 0) {
+        console.log(chalk.green('\n✅ Cache cleanup completed successfully!'));
+      } else {
+        console.log(chalk.yellow('\n💡 No cache files were available for cleaning'));
+      }
+
+      if (stats.skipped > 0 && stats.cleaned === 0) {
+        console.log(chalk.gray('   Some files were in use or require admin permissions'));
+      }
+    } else {
+      console.log(chalk.blue('\n💡 Dry run completed. Run without --dry-run to actually clean.'));
+    }
+
+    return {
+      success: true,
+      stats: {
+        cleaned: stats.cleaned,
+        skipped: stats.skipped,
+        totalSize: Math.round(stats.totalSize / 1024),
+        cleanedSize: Math.round(stats.cleanedSize / 1024)
+      }
+    };
+
+  } catch (error) {
+    // Show only critical errors to user
+    if (options.verbose) {
+      console.error(chalk.red('[ERROR] Cache cleaning failed:'), error.message);
+    }
+    return { success: false, error: error.message };
+  }
+}
+
+module.exports = {
+  handleDiagnosticCommand,
+  handleCleanCommand
+};

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

@@ -0,0 +1,394 @@
+#!/usr/bin/env node
+/**
+ * Universal Session Recovery Tool
+ * Find and recover the latest session across all CLIs
+ */
+
+const fs = require('fs');
+const path = require('path');
+const os = require('os');
+
+class UniversalSessionRecovery {
+  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 UniversalSessionRecovery();
+
+  // 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 = UniversalSessionRecovery;