stigmergy 1.0.73 → 1.0.79

package/package.json

@@ -1,14 +1,14 @@
 {
   "name": "stigmergy",
-  "version": "1.0.73",
+  "version": "1.0.79",
   "type": "commonjs",
   "description": "Stigmergy CLI - Multi-Agents Cross-AI CLI Tools Collaboration System",
-  "main": "src/index.js",
+  "main": "src/main_english.js",
   "bin": {
-    "stigmergy": "src/index.js"
+    "stigmergy": "src/main_english.js"
   },
   "scripts": {
-    "start": "node src/main.js",
+    "start": "node src/main_english.js",
     "test": "node test/real-test.js",
     "test:all": "node test/test-all-clis.js",
     "test:cross-cli": "node test/cross-cli-real-test.js",
@@ -22,7 +22,7 @@
     "dev": "node --watch src/index.js",
     "lint": "eslint src/",
     "format": "prettier --write src/",
-    "postinstall": "node src/main.js auto-install"
+    "postinstall": "node src/main_english.js auto-install"
   },
   "keywords": [
     "ai",

package/src/core/cli_help_analyzer.js

@@ -0,0 +1,563 @@
+/**
+ * Advanced CLI Help Analyzer - International Version
+ * Analyzes CLI help information to extract command patterns and calling methods
+ */
+
+const { spawnSync } = require('child_process');
+const fs = require('fs/promises');
+const path = require('path');
+const os = require('os');
+
+class CLIHelpAnalyzer {
+    constructor() {
+        this.configDir = path.join(os.homedir(), '.stigmergy', 'cli-patterns');
+        this.persistentConfig = path.join(this.configDir, 'cli-patterns.json');
+        this.lastAnalysisFile = path.join(this.configDir, 'last-analysis.json');
+        this.cliTools = require('../main').CLI_TOOLS || {};
+
+        // Pattern recognition rules for different CLI types
+        this.patternRules = {
+            // OpenAI style CLI (codex, chatgpt)
+            openai: {
+                commandPattern: /^(\w+)(?:\s+--?[\w-]+(?:\s+[\w-]+)?)?\s*(.*)$/,
+                optionPattern: /--?[\w-]+(?:\s+[\w-]+)?/g,
+                examplePattern: /(?:example|usage|Usage)[:：]\s*\n([\s\S]*?)(?=\n\n|\n[A-Z]|\n$)/gi,
+                subcommandPattern: /^\s{2,4}(\w+)\s+.+$/gm
+            },
+            // Anthropic style CLI (claude)
+            anthropic: {
+                commandPattern: /^(\w+)(?:\s+(?:--?\w+|\[\w+\]))*\s*(.*)$/,
+                optionPattern: /--?\w+(?:\s+<\w+>)?/g,
+                examplePattern: /(?:Examples?|例子)[:：]\s*\n([\s\S]*?)(?=\n\n|\n[A-Z]|\n$)/gi,
+                subcommandPattern: /^\s{2}(\w+)\s{2,}.+$/gm
+            },
+            // Google style CLI (gemini)
+            google: {
+                commandPattern: /^(\w+)(?:\s+(?:--?\w+(?:=\w+)?|<\w+>))*\s*(.*)$/,
+                optionPattern: /--?\w+(?:=\w+)?/g,
+                examplePattern: /(?:Examples?|SAMPLE)[:：]\s*\n([\s\S]*?)(?=\n\n|\n[A-Z]|\n$)/gi,
+                subcommandPattern: /^\s{2,4}(\w+)\s{2,}.+$/gm
+            },
+            // Generic CLI pattern
+            generic: {
+                commandPattern: /^(\w+)(?:\s+.*)?$/,
+                optionPattern: /--?[a-zA-Z][\w-]*/g,
+                examplePattern: /(?:example|usage|用法|使用)[:：]\s*\n([\s\S]*?)(?=\n\n|\n[A-Z]|\n$)/gi,
+                subcommandPattern: /^\s{2,6}([a-z][a-z0-9_-]+)\s+.+$/gm
+            }
+        };
+    }
+
+    /**
+     * Initialize the analyzer and ensure config directory exists
+     */
+    async initialize() {
+        try {
+            await fs.mkdir(this.configDir, { recursive: true });
+
+            // Initialize persistent config if not exists
+            const configExists = await this.fileExists(this.persistentConfig);
+            if (!configExists) {
+                await this.savePersistentConfig({
+                    version: '1.0.0',
+                    lastUpdated: new Date().toISOString(),
+                    cliPatterns: {},
+                    failedAttempts: {}
+                });
+            }
+
+            return true;
+        } catch (error) {
+            console.error('Failed to initialize CLI Help Analyzer:', error.message);
+            return false;
+        }
+    }
+
+    /**
+     * Analyze all configured CLI tools
+     */
+    async analyzeAllCLI() {
+        const results = {};
+
+        for (const [cliName, cliConfig] of Object.entries(this.cliTools)) {
+            try {
+                console.log(`Analyzing ${cliName}...`);
+                results[cliName] = await this.analyzeCLI(cliName);
+            } catch (error) {
+                console.error(`Failed to analyze ${cliName}:`, error.message);
+                results[cliName] = {
+                    success: false,
+                    error: error.message,
+                    timestamp: new Date().toISOString()
+                };
+            }
+        }
+
+        return results;
+    }
+
+    /**
+     * Analyze a specific CLI tool's help information
+     */
+    async analyzeCLI(cliName) {
+        const cliConfig = this.cliTools[cliName];
+        if (!cliConfig) {
+            throw new Error(`CLI configuration not found for ${cliName}`);
+        }
+
+        // Check if we have recent cached analysis
+        const cached = await this.getCachedAnalysis(cliName);
+        if (cached && !this.isCacheExpired(cached.timestamp)) {
+            return cached;
+        }
+
+        try {
+            // Get help information using multiple methods
+            const helpInfo = await this.getHelpInfo(cliName, cliConfig);
+
+            // Detect CLI type for pattern recognition
+            const cliType = this.detectCLIType(helpInfo.rawHelp, cliName);
+
+            // Extract patterns based on CLI type
+            const patterns = this.extractPatterns(helpInfo.rawHelp, cliType);
+
+            // Analyze command structure
+            const commandStructure = this.analyzeCommandStructure(patterns);
+
+            // Extract usage examples
+            const examples = this.extractUsageExamples(helpInfo.rawHelp, cliType);
+
+            // Determine CLI interaction mode
+            const interactionMode = this.determineInteractionMode(helpInfo, patterns);
+
+            const analysis = {
+                success: true,
+                cliName,
+                cliType,
+                version: helpInfo.version,
+                helpMethod: helpInfo.method,
+                patterns,
+                commandStructure,
+                examples,
+                interactionMode,
+                timestamp: new Date().toISOString()
+            };
+
+            // Cache the analysis
+            await this.cacheAnalysis(cliName, analysis);
+
+            return analysis;
+
+        } catch (error) {
+            // Record failed attempt
+            await this.recordFailedAttempt(cliName, error);
+            throw error;
+        }
+    }
+
+    /**
+     * Get help information using multiple methods
+     */
+    async getHelpInfo(cliName, cliConfig) {
+        const helpMethods = [
+            ['--help'],
+            ['-h'],
+            ['help'],
+            ['--usage'],
+            [''],
+            ['version'],
+            ['--version'],
+            ['-v']
+        ];
+
+        let rawHelp = '';
+        let version = 'unknown';
+        let method = 'unknown';
+
+        // Try different help commands
+        for (const helpArgs of helpMethods) {
+            try {
+                const result = spawnSync(cliName, helpArgs, {
+                    encoding: 'utf8',
+                    timeout: 15000,
+                    shell: true
+                });
+
+                if (result.status === 0 && result.stdout) {
+                    rawHelp = result.stdout;
+                    method = `${cliName} ${helpArgs.join(' ')}`;
+                    break;
+                } else if (result.stderr) {
+                    rawHelp = result.stderr;
+                    method = `${cliName} ${helpArgs.join(' ')} (stderr)`;
+                    break;
+                }
+            } catch (error) {
+                // Try next method
+                continue;
+            }
+        }
+
+        // Try to get version separately
+        if (cliConfig.version) {
+            try {
+                const versionCmd = cliConfig.version.split(' ');
+                const versionResult = spawnSync(versionCmd[0], versionCmd.slice(1), {
+                    encoding: 'utf8',
+                    timeout: 10000,
+                    shell: true
+                });
+
+                if (versionResult.status === 0) {
+                    version = versionResult.stdout.trim() || versionResult.stderr.trim();
+                }
+            } catch (error) {
+                // Use default version
+            }
+        }
+
+        if (!rawHelp) {
+            throw new Error(`Unable to get help information for ${cliName}`);
+        }
+
+        return { rawHelp, version, method };
+    }
+
+    /**
+     * Detect CLI type based on help content and naming
+     */
+    detectCLIType(helpText, cliName) {
+        const text = helpText.toLowerCase();
+        const name = cliName.toLowerCase();
+
+        // Detect based on CLI name
+        if (name.includes('claude') || name.includes('anthropic')) {
+            return 'anthropic';
+        }
+        if (name.includes('gemini') || name.includes('google')) {
+            return 'google';
+        }
+        if (name.includes('codex') || name.includes('openai') || name.includes('chatgpt')) {
+            return 'openai';
+        }
+
+        // Detect based on help content patterns
+        if (text.includes('anthropic') || text.includes('claude')) {
+            return 'anthropic';
+        }
+        if (text.includes('google') || text.includes('gemini') || text.includes('vertex')) {
+            return 'google';
+        }
+        if (text.includes('openai') || text.includes('gpt') || text.includes('codex')) {
+            return 'openai';
+        }
+
+        // Default to generic
+        return 'generic';
+    }
+
+    /**
+     * Extract command patterns from help text
+     */
+    extractPatterns(helpText, cliType) {
+        const rules = this.patternRules[cliType] || this.patternRules.generic;
+        const patterns = {
+            commands: [],
+            options: [],
+            subcommands: [],
+            arguments: [],
+            flags: []
+        };
+
+        // Extract subcommands
+        const subcommandMatches = helpText.match(rules.subcommandPattern);
+        if (subcommandMatches) {
+            patterns.subcommands = subcommandMatches.map(match => {
+                const parts = match.trim().split(/\s+/);
+                return {
+                    name: parts[0],
+                    description: parts.slice(1).join(' '),
+                    syntax: match.trim()
+                };
+            });
+        }
+
+        // Extract options/flags
+        const optionMatches = helpText.match(rules.optionPattern);
+        if (optionMatches) {
+            patterns.options = [...new Set(optionMatches)];
+            patterns.flags = optionMatches.filter(opt => opt.startsWith('--')).map(opt => opt.replace(/^--/, ''));
+        }
+
+        // Extract main commands (first level)
+        const lines = helpText.split('\n');
+        for (const line of lines) {
+            const trimmed = line.trim();
+
+            // Look for commands that start at beginning of line
+            if (/^[a-z][a-z0-9_-]+\s+.+$/.test(trimmed)) {
+                const parts = trimmed.split(/\s+/);
+                const command = parts[0];
+                const description = parts.slice(1).join(' ');
+
+                if (!patterns.commands.find(cmd => cmd.name === command)) {
+                    patterns.commands.push({
+                        name: command,
+                        description,
+                        syntax: trimmed
+                    });
+                }
+            }
+        }
+
+        return patterns;
+    }
+
+    /**
+     * Analyze command structure and calling patterns
+     */
+    analyzeCommandStructure(patterns) {
+        const structure = {
+            primaryCommand: '',
+            commandFormat: '',
+            argumentStyle: '',
+            optionStyle: '',
+            interactiveMode: false,
+            hasSubcommands: patterns.subcommands.length > 0,
+            complexity: 'simple'
+        };
+
+        // Determine complexity based on available commands
+        if (patterns.commands.length > 10 || patterns.subcommands.length > 5) {
+            structure.complexity = 'complex';
+        } else if (patterns.commands.length > 3 || patterns.options.length > 10) {
+            structure.complexity = 'moderate';
+        }
+
+        // Determine command format based on patterns
+        if (patterns.subcommands.length > 0) {
+            structure.commandFormat = 'cli <subcommand> [options] [args]';
+        } else if (patterns.options.length > 0) {
+            structure.commandFormat = 'cli [options] [args]';
+        } else {
+            structure.commandFormat = 'cli [args]';
+        }
+
+        // Check for interactive mode indicators
+        const hasInteractiveIndicators = patterns.commands.some(cmd =>
+            cmd.name.includes('chat') ||
+            cmd.name.includes('interactive') ||
+            cmd.name.includes('shell') ||
+            cmd.description.toLowerCase().includes('interactive')
+        );
+
+        structure.interactiveMode = hasInteractiveIndicators;
+
+        return structure;
+    }
+
+    /**
+     * Extract usage examples from help text
+     */
+    extractUsageExamples(helpText, cliType) {
+        const rules = this.patternRules[cliType] || this.patternRules.generic;
+        const examples = [];
+
+        // Find example sections
+        const exampleMatches = helpText.match(rules.examplePattern);
+
+        if (exampleMatches) {
+            for (const match of exampleMatches) {
+                const exampleText = match.replace(/^(example|usage|用法|使用)[:：]\s*/i, '').trim();
+
+                // Split by lines and extract command examples
+                const lines = exampleText.split('\n')
+                    .map(line => line.trim())
+                    .filter(line => line && !line.startsWith('#') && !line.startsWith('//'));
+
+                for (const line of lines) {
+                    if (line.includes('$') || line.includes('>') || line.startsWith('cli') || /^[a-z][\w-]*\s/.test(line)) {
+                        // Extract clean command
+                        const command = line.replace(/^[>$\s]+/, '').replace(/^cli\s*/, '').trim();
+                        if (command) {
+                            examples.push({
+                                command,
+                                raw: line,
+                                description: ''
+                            });
+                        }
+                    }
+                }
+            }
+        }
+
+        return examples;
+    }
+
+    /**
+     * Determine CLI interaction mode
+     */
+    determineInteractionMode(helpInfo, patterns) {
+        const text = helpInfo.rawHelp.toLowerCase();
+
+        // Check for different interaction modes
+        if (text.includes('chat') || text.includes('conversation') || text.includes('interactive')) {
+            return 'chat';
+        }
+
+        if (text.includes('api') || text.includes('endpoint') || text.includes('request')) {
+            return 'api';
+        }
+
+        if (patterns.subcommands.length > 0) {
+            return 'subcommand';
+        }
+
+        if (patterns.options.length > 5) {
+            return 'option';
+        }
+
+        return 'simple';
+    }
+
+    /**
+     * Cache analysis results
+     */
+    async cacheAnalysis(cliName, analysis) {
+        try {
+            const config = await this.loadPersistentConfig();
+            config.cliPatterns[cliName] = analysis;
+            config.lastUpdated = new Date().toISOString();
+
+            // Remove from failed attempts if it was there
+            delete config.failedAttempts[cliName];
+
+            await this.savePersistentConfig(config);
+
+            // Also save last analysis timestamp
+            await fs.writeFile(
+                this.lastAnalysisFile,
+                JSON.stringify({ [cliName]: analysis.timestamp }, null, 2)
+            );
+
+        } catch (error) {
+            console.error(`Failed to cache analysis for ${cliName}:`, error.message);
+        }
+    }
+
+    /**
+     * Get cached analysis if available
+     */
+    async getCachedAnalysis(cliName) {
+        try {
+            const config = await this.loadPersistentConfig();
+            return config.cliPatterns[cliName] || null;
+        } catch (error) {
+            return null;
+        }
+    }
+
+    /**
+     * Check if cache is expired (24 hours)
+     */
+    isCacheExpired(timestamp) {
+        const cacheTime = new Date(timestamp);
+        const now = new Date();
+        const hoursDiff = (now - cacheTime) / (1000 * 60 * 60);
+        return hoursDiff > 24;
+    }
+
+    /**
+     * Record failed analysis attempt
+     */
+    async recordFailedAttempt(cliName, error) {
+        try {
+            const config = await this.loadPersistentConfig();
+            config.failedAttempts[cliName] = {
+                error: error.message,
+                timestamp: new Date().toISOString(),
+                attempts: (config.failedAttempts[cliName]?.attempts || 0) + 1
+            };
+            config.lastUpdated = new Date().toISOString();
+            await this.savePersistentConfig(config);
+        } catch (err) {
+            console.error('Failed to record failed attempt:', err.message);
+        }
+    }
+
+    /**
+     * Load persistent configuration
+     */
+    async loadPersistentConfig() {
+        try {
+            const data = await fs.readFile(this.persistentConfig, 'utf8');
+            return JSON.parse(data);
+        } catch (error) {
+            return {
+                version: '1.0.0',
+                lastUpdated: new Date().toISOString(),
+                cliPatterns: {},
+                failedAttempts: {}
+            };
+        }
+    }
+
+    /**
+     * Save persistent configuration
+     */
+    async savePersistentConfig(config) {
+        await fs.writeFile(this.persistentConfig, JSON.stringify(config, null, 2));
+    }
+
+    /**
+     * Check if file exists
+     */
+    async fileExists(filePath) {
+        try {
+            await fs.access(filePath);
+            return true;
+        } catch {
+            return false;
+        }
+    }
+
+    /**
+     * Get CLI pattern for specific tool
+     */
+    async getCLIPattern(cliName) {
+        const cached = await this.getCachedAnalysis(cliName);
+
+        if (cached && !this.isCacheExpired(cached.timestamp)) {
+            return cached;
+        }
+
+        // Re-analyze if cache expired or not available
+        return await this.analyzeCLI(cliName);
+    }
+
+    /**
+     * Update CLI pattern when call fails
+     */
+    async updatePatternOnFailure(cliName, error, attemptedCommand) {
+        console.log(`Updating pattern for ${cliName} due to failure:`, error.message);
+
+        try {
+            // Re-analyze the CLI
+            const newAnalysis = await this.analyzeCLI(cliName);
+
+            // Add failure context
+            newAnalysis.lastFailure = {
+                error: error.message,
+                attemptedCommand,
+                timestamp: new Date().toISOString()
+            };
+
+            return newAnalysis;
+        } catch (analysisError) {
+            console.error(`Failed to re-analyze ${cliName}:`, analysisError.message);
+            return null;
+        }
+    }
+}
+
+module.exports = CLIHelpAnalyzer;

package/src/index.js

@@ -1,12 +1,9 @@
-#!/usr/bin/env node
-
-/**
- * Stigmergy CLI - Main Entry Point
- * This file serves as the main entry point for the Stigmergy CLI system
- */
-
-// Import and export the main functionality from main.js
-import('./main.js').catch(error => {
-    console.error('❌ Error loading main module:', error.message);
-    process.exit(1);
-});
+#!/usr/bin/env node
+
+/**
+ * Stigmergy CLI - Entry Point
+ * International Version - Pure ANSI Characters Only
+ */
+
+// Import and export the main functionality from main.js
+require('./main.js');