stigmergy 1.0.64 → 1.0.66

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "stigmergy",
-  "version": "1.0.64",
+  "version": "1.0.66",
   "type": "module",
   "description": "Stigmergy CLI - Multi-Agents跨AI CLI工具协作系统",
   "main": "src/main.js",
@@ -79,4 +79,4 @@
   "bugs": {
     "url": "https://github.com/ptreezh/stigmergy-CLI-Multi-Agents/issues"
   }
-}
+}

package/src/core/cli_interaction_detector.js

@@ -0,0 +1,290 @@
+/**
+ * CLI协同检测器 - 轻量级拦截，增强现有适配器
+ * 增量设计，不影响现有系统
+ */
+
+import fs from 'fs/promises';
+import path from 'path';
+import { spawn, spawnSync } from 'child_process';
+import { EnvironmentStigmergySystem } from './environment_stigmergy_system.js';
+
+class CLIInteractionDetector {
+    constructor() {
+        this.stigmergySystem = new EnvironmentStigmergySystem();
+        this.interactionLogFile = path.join(process.cwd(), '.stigmergy-project', 'interactions.log');
+        
+        // 检测配置 - 轻量级，不修改现有CLI行为
+        this.detectionConfig = {
+            enableCollaborationDetection: true,
+            enableContextSharing: true,
+            enableSuggestion: true,
+            minimalLogging: true
+        };
+        
+        // CLI命令映射
+        this.cliCommands = {
+            'claude': ['claude', '@anthropic/claude-code'],
+            'gemini': ['gemini', '@google/gemini-cli'],
+            'qwen': ['qwen', 'qwencode'],
+            'iflow': ['iflow', '@iflow-ai/iflow-cli'],
+            'qoder': ['qodercli', 'qoder'],
+            'codebuddy': ['codebuddy', '@tencent-ai/codebuddy-code'],
+            'copilot': ['copilot', 'gh copilot'],
+            'codex': ['codex', 'openai-codex']
+        };
+    }
+
+    /**
+     * 初始化检测器 - 增量到现有系统
+     */
+    async initialize() {
+        try {
+            // 初始化环境线索系统
+            await this.stigmergySystem.initializeEnvironmentSystem();
+            
+            // 创建交互日志目录
+            const logDir = path.dirname(this.interactionLogFile);
+            await fs.mkdir(logDir, { recursive: true });
+            
+            console.log('✅ CLI协同检测器初始化完成');
+            return true;
+        } catch (error) {
+            console.error('❌ CLI协同检测器初始化失败:', error.message);
+            return false;
+        }
+    }
+
+    /**
+     * 检测CLI调用 - 轻量级监控
+     */
+    async detectCliInvocation(command, args, workingDir = process.cwd()) {
+        const cliName = this.detectCliFromCommand(command);
+        
+        if (!cliName) {
+            return null;
+        }
+
+        const userInput = args.join(' ');
+        
+        // 检测协作意图
+        const collaborationIntent = await this.stigmergySystem.writeEnvironmentSignal(
+            cliName, 
+            userInput, 
+            { workingDir, command }
+        );
+
+        // 记录交互
+        await this.logInteraction({
+            type: 'cli_invocation',
+            cliName,
+            command,
+            args: userInput,
+            workingDir,
+            collaborationIntent,
+            timestamp: new Date().toISOString()
+        });
+
+        // 读取环境线索
+        const environmentContext = await this.stigmergySystem.readEnvironmentSignals(cliName);
+
+        return {
+            cliName,
+            userInput,
+            collaborationIntent,
+            environmentContext,
+            suggestions: environmentContext.collaborationSuggestions
+        };
+    }
+
+    /**
+     * 从命令检测CLI名称
+     */
+    detectCliFromCommand(command) {
+        const cmd = command.toLowerCase();
+        
+        for (const [cliName, commands] of Object.entries(this.cliCommands)) {
+            if (commands.some(cmdStr => cmd.includes(cmdStr))) {
+                return cliName;
+            }
+        }
+
+        return null;
+    }
+
+    /**
+     * 生成上下文增强参数
+     */
+    async generateContextEnhancedArgs(cliName, originalArgs, context) {
+        const enhancedArgs = [...originalArgs];
+        
+        // 如果检测到协作意图，添加上下文
+        if (context.collaborationIntent && context.collaborationSuggestions.length > 0) {
+            // 生成上下文提示
+            const contextHint = this.generateContextHint(context);
+            if (contextHint) {
+                enhancedArgs.push(`[环境线索: ${contextHint}]`);
+            }
+        }
+
+        return enhancedArgs;
+    }
+
+    /**
+     * 生成上下文提示
+     */
+    generateContextHint(context) {
+        const suggestions = context.collaborationSuggestions;
+        
+        if (suggestions.length === 0) {
+            return '';
+        }
+
+        // 选择最相关的建议
+        const topSuggestion = suggestions[0];
+        
+        switch (topSuggestion.type) {
+            case 'frequent_collaboration':
+                return `最近频繁与${topSuggestion.cli}协作，考虑继续协作`;
+            case 'topic_based':
+                return `最近在处理"${topSuggestion.topic}"任务，可结合相关工具`;
+            default:
+                return topSuggestion.suggestion;
+        }
+    }
+
+    /**
+     * 记录交互日志
+     */
+    async logInteraction(interaction) {
+        try {
+            const logLine = JSON.stringify(interaction) + '\n';
+            await fs.appendFile(this.interactionLogFile, logLine);
+        } catch (error) {
+            console.error('❌ 记录交互日志失败:', error.message);
+        }
+    }
+
+    /**
+     * 创建CLI包装函数 - 最小化包装
+     */
+    createCliWrapper(cliName) {
+        return async (args, options = {}) => {
+            // 检测调用
+            const detection = await this.detectCliInvocation(cliName, args, options.cwd);
+            
+            // 生成增强参数
+            const enhancedArgs = detection 
+                ? await this.generateContextEnhancedArgs(cliName, args, detection.environmentContext)
+                : args;
+
+            // 执行原始命令
+            const command = this.cliCommands[cliName][0]; // 使用第一个命令
+            const result = spawnSync(command, enhancedArgs, {
+                stdio: 'inherit',
+                cwd: options.cwd || process.cwd(),
+                env: { ...process.env, ...options.env }
+            });
+
+            // 记录结果
+            if (detection) {
+                await this.logInteraction({
+                    type: 'cli_completion',
+                    cliName,
+                    args: args.join(' '),
+                    enhancedArgs: enhancedArgs.join(' '),
+                    exitCode: result.status,
+                    timestamp: new Date().toISOString()
+                });
+            }
+
+            return result;
+        };
+    }
+
+    /**
+     * 获取CLI建议
+     */
+    async getCliSuggestions(cliName) {
+        try {
+            const environmentContext = await this.stigmergySystem.getCliContext(cliName);
+            
+            return {
+                collaborationSuggestions: environmentContext.suggestions,
+                recentCollaborations: environmentContext.recentCollaborations,
+                contextHints: environmentContext.environmentContext,
+                sharedFiles: environmentContext.sharedFiles
+            };
+        } catch (error) {
+            console.error('❌ 获取CLI建议失败:', error.message);
+            return { suggestions: [], context: {}, sharedFiles: {} };
+        }
+    }
+
+    /**
+     * 共享文件到环境
+     */
+    async shareFileToEnvironment(cliName, filePath, metadata = {}) {
+        try {
+            const contextDir = path.join(process.cwd(), '.stigmergy-project', 'context-cache');
+            await fs.mkdir(contextDir, { recursive: true });
+
+            const shareData = {
+                cliName,
+                filePath,
+                fileName: path.basename(filePath),
+                content: await fs.readFile(filePath, 'utf8'),
+                metadata: {
+                    ...metadata,
+                    timestamp: new Date().toISOString(),
+                    size: (await fs.stat(filePath)).size
+                }
+            };
+
+            const shareFileName = `${cliName}_${path.basename(filePath)}_${Date.now()}.json`;
+            const shareFilePath = path.join(contextDir, shareFileName);
+
+            await fs.writeFile(shareFilePath, JSON.stringify(shareData, null, 2));
+
+            console.log(`✅ 文件已共享到环境: ${shareFileName}`);
+            return shareFilePath;
+        } catch (error) {
+            console.error('❌ 共享文件失败:', error.message);
+            return null;
+        }
+    }
+
+    /**
+     * 从环境获取共享文件
+     */
+    async getSharedFilesFromEnvironment(targetCli = null) {
+        try {
+            const contextDir = path.join(process.cwd(), '.stigmergy-project', 'context-cache');
+            const files = await fs.readdir(contextDir);
+            
+            const sharedFiles = [];
+            for (const file of files) {
+                if (file.endsWith('.json')) {
+                    const filePath = path.join(contextDir, file);
+                    const content = await fs.readFile(filePath, 'utf8');
+                    const shareData = JSON.parse(content);
+                    
+                    if (!targetCli || shareData.cliName === targetCli) {
+                        sharedFiles.push(shareData);
+                    }
+                }
+            }
+
+            // 按时间排序
+            sharedFiles.sort((a, b) => 
+                new Date(b.metadata.timestamp) - new Date(a.metadata.timestamp)
+            );
+
+            return sharedFiles;
+        } catch (error) {
+            console.error('❌ 获取共享文件失败:', error.message);
+            return [];
+        }
+    }
+}
+
+export { CLIInteractionDetector };

package/src/core/environment_stigmergy_system.js

@@ -0,0 +1,454 @@
+/**
+ * 环境线索式协同系统 - 增量设计
+ * 不影响现有系统功能，增强环境共享机制
+ */
+
+import fs from 'fs/promises';
+import path from 'path';
+import { homedir } from 'os';
+import { createHash } from 'crypto';
+
+class EnvironmentStigmergySystem {
+    constructor() {
+        // 现有系统路径保持不变
+        this.projectRoot = process.cwd();
+        this.stigmergyDir = path.join(this.projectRoot, '.stigmergy-project');
+        this.contextDir = path.join(this.stigmergyDir, 'context-cache');
+        this.collaborationLog = path.join(this.stigmergyDir, 'collaboration.log');
+        this.environmentCache = path.join(this.stigmergyDir, 'environment-cache.json');
+        
+        // CLI工具配置映射
+        this.cliConfig = {
+            'claude': {
+                configFile: '~/.config/claude/config.json',
+                historyFile: '~/.config/claude/history.json',
+                contextPatterns: ['claude', 'anthropic']
+            },
+            'gemini': {
+                configFile: '~/.config/gemini/config.json',
+                historyFile: '~/.config/gemini/history.json', 
+                contextPatterns: ['gemini', 'google', 'bard']
+            },
+            'qwen': {
+                configFile: '~/.config/qwen/config.json',
+                historyFile: '~/.config/qwen/history.json',
+                contextPatterns: ['qwen', 'qwencode', 'alibaba']
+            },
+            'iflow': {
+                configFile: '~/.config/iflow/config.json',
+                historyFile: '~/.config/iflow/history.json',
+                contextPatterns: ['iflow', 'flow', 'mindflow']
+            },
+            'qoder': {
+                configFile: '~/.config/qoder/config.json',
+                historyFile: '~/.config/qoder/history.json',
+                contextPatterns: ['qoder', 'code-assistant']
+            },
+            'codebuddy': {
+                configFile: '~/.config/codebuddy/config.json',
+                historyFile: '~/.config/codebuddy/history.json',
+                contextPatterns: ['codebuddy', 'tencent', 'buddy']
+            },
+            'copilot': {
+                configFile: '~/.config/copilot/config.json',
+                historyFile: '~/.config/copilot/history.json',
+                contextPatterns: ['copilot', 'github', 'gh']
+            },
+            'codex': {
+                configFile: '~/.config/codex/config.json',
+                historyFile: '~/.config/codex/history.json',
+                contextPatterns: ['codex', 'openai', 'gpt']
+            }
+        };
+    }
+
+    /**
+     * 初始化环境线索系统 - 增量创建
+     */
+    async initializeEnvironmentSystem() {
+        try {
+            // 创建必要的目录（不影响现有结构）
+            await fs.mkdir(this.contextDir, { recursive: true });
+            
+            // 初始化环境缓存文件
+            await this.initializeEnvironmentCache();
+            
+            console.log('✅ 环境线索协同系统初始化完成');
+            return true;
+        } catch (error) {
+            console.error('❌ 环境线索系统初始化失败:', error.message);
+            return false;
+        }
+    }
+
+    /**
+     * 初始化环境缓存
+     */
+    async initializeEnvironmentCache() {
+        const cacheExists = await fs.access(this.environmentCache)
+            .then(() => true)
+            .catch(() => false);
+
+        if (!cacheExists) {
+            const initialCache = {
+                version: '1.0.0',
+                createdAt: new Date().toISOString(),
+                lastUpdate: new Date().toISOString(),
+                sharedContext: {},
+                collaborationHistory: [],
+                environmentSignals: {}
+            };
+
+            await fs.writeFile(this.environmentCache, JSON.stringify(initialCache, null, 2));
+        }
+    }
+
+    /**
+     * 写入环境线索 - CLI调用时自动调用
+     */
+    async writeEnvironmentSignal(cliName, userInput, context = {}) {
+        try {
+            const signal = {
+                timestamp: new Date().toISOString(),
+                cliName,
+                userInput,
+                context,
+                intent: this.detectCollaborationIntent(userInput),
+                sessionId: this.generateSessionId()
+            };
+
+            // 更新环境缓存
+            await this.updateEnvironmentCache('signal', signal);
+            
+            // 记录协作日志
+            await this.logCollaboration(signal);
+            
+            return signal;
+        } catch (error) {
+            console.error('❌ 写入环境线索失败:', error.message);
+            return null;
+        }
+    }
+
+    /**
+     * 读取环境线索 - CLI启动时自动调用
+     */
+    async readEnvironmentSignals(cliName) {
+        try {
+            const cache = await this.loadEnvironmentCache();
+            const signals = cache.environmentSignals || {};
+            
+            // 获取最近的协作信号
+            const recentSignals = this.getRecentCollaborationSignals(signals, cliName);
+            
+            // 分析环境上下文
+            const context = this.analyzeEnvironmentContext(signals, cliName);
+            
+            return {
+                signals: recentSignals,
+                context,
+                collaborationSuggestions: this.generateCollaborationSuggestions(signals, cliName)
+            };
+        } catch (error) {
+            console.error('❌ 读取环境线索失败:', error.message);
+            return { signals: [], context: {}, suggestions: [] };
+        }
+    }
+
+    /**
+     * 检测协作意图
+     */
+    detectCollaborationIntent(userInput) {
+        const patterns = [
+            /(?:call|invoke|use|run|execute|ask|tell|request)\s+(?:the\s+)?([a-z]+)\s+(?:cli|tool|assistant|ai)/i,
+            /(?:with|using|via|through)\s+([a-z]+)/i,
+            /(?:let|have|can|should)\s+([a-z]+)\s+(?:help|assist|process|handle|deal)/i,
+            /(?:switch|change|switch to)\s+([a-z]+)/i,
+            /(?:in|using)\s+([a-z]+)\s+(?:mode|context)/i
+        ];
+
+        for (const pattern of patterns) {
+            const match = userInput.match(pattern);
+            if (match) {
+                const targetCli = match[1].toLowerCase();
+                // 映射到标准CLI名称
+                return this.mapToStandardCliName(targetCli);
+            }
+        }
+
+        return null;
+    }
+
+    /**
+     * 映射到标准CLI名称
+     */
+    mapToStandardCliName(cliName) {
+        const mapping = {
+            'anthropic': 'claude',
+            'google': 'gemini',
+            'bard': 'gemini',
+            'qwencode': 'qwen',
+            'alibaba': 'qwen',
+            'flow': 'iflow',
+            'mindflow': 'iflow',
+            'tencent': 'codebuddy',
+            'buddy': 'codebuddy',
+            'github': 'copilot',
+            'gh': 'copilot',
+            'openai': 'codex',
+            'gpt': 'codex'
+        };
+
+        return mapping[cliName] || cliName;
+    }
+
+    /**
+     * 获取最近的协作信号
+     */
+    getRecentCollaborationSignals(signals, currentCli) {
+        const allSignals = Object.values(signals).flat();
+        const collaborationSignals = allSignals.filter(signal => 
+            signal.intent && signal.intent !== currentCli
+        );
+
+        // 按时间排序，返回最近的5个
+        return collaborationSignals
+            .sort((a, b) => new Date(b.timestamp) - new Date(a.timestamp))
+            .slice(0, 5);
+    }
+
+    /**
+     * 分析环境上下文
+     */
+    analyzeEnvironmentContext(signals, currentCli) {
+        const allSignals = Object.values(signals).flat();
+        const recentSignals = allSignals
+            .sort((a, b) => new Date(b.timestamp) - new Date(a.timestamp))
+            .slice(0, 10);
+
+        // 分析模式
+        const patterns = {
+            frequentCollaboration: {},
+            commonTopics: [],
+            projectContext: {},
+            workflowHints: []
+        };
+
+        // 分析协作频率
+        recentSignals.forEach(signal => {
+            const target = signal.intent;
+            if (target && target !== currentCli) {
+                patterns.frequentCollaboration[target] = 
+                    (patterns.frequentCollaboration[target] || 0) + 1;
+            }
+        });
+
+        // 分析常见主题
+        const topics = recentSignals
+            .map(signal => this.extractTopics(signal.userInput))
+            .flat();
+        patterns.commonTopics = this.getMostFrequent(topics, 3);
+
+        return patterns;
+    }
+
+    /**
+     * 生成协作建议
+     */
+    generateCollaborationSuggestions(signals, currentCli) {
+        const context = this.analyzeEnvironmentContext(signals, currentCli);
+        const suggestions = [];
+
+        // 基于协作频率的建议
+        Object.entries(context.frequentCollaboration).forEach(([cli, count]) => {
+            if (count >= 2) {
+                suggestions.push({
+                    type: 'frequent_collaboration',
+                    cli,
+                    reason: `最近频繁与${cli}协作 (${count}次)`,
+                    suggestion: `考虑使用${cli}继续当前任务`
+                });
+            }
+        });
+
+        // 基于主题的建议
+        context.commonTopics.forEach(topic => {
+            suggestions.push({
+                type: 'topic_based',
+                topic,
+                reason: `最近在处理"${topic}"相关任务`,
+                suggestion: `考虑使用专门的工具处理${topic}任务`
+            });
+        });
+
+        return suggestions;
+    }
+
+    /**
+     * 更新环境缓存
+     */
+    async updateEnvironmentCache(type, data) {
+        try {
+            const cache = await this.loadEnvironmentCache();
+            const timestamp = new Date().toISOString();
+
+            if (type === 'signal') {
+                if (!cache.environmentSignals) {
+                    cache.environmentSignals = {};
+                }
+                
+                const cliKey = data.cliName;
+                if (!cache.environmentSignals[cliKey]) {
+                    cache.environmentSignals[cliKey] = [];
+                }
+                
+                cache.environmentSignals[cliKey].push(data);
+                
+                // 保持每个CLI最多100个信号
+                if (cache.environmentSignals[cliKey].length > 100) {
+                    cache.environmentSignals[cliKey] = cache.environmentSignals[cliKey].slice(-100);
+                }
+            }
+
+            cache.lastUpdate = timestamp;
+            await fs.writeFile(this.environmentCache, JSON.stringify(cache, null, 2));
+        } catch (error) {
+            console.error('❌ 更新环境缓存失败:', error.message);
+        }
+    }
+
+    /**
+     * 加载环境缓存
+     */
+    async loadEnvironmentCache() {
+        try {
+            const data = await fs.readFile(this.environmentCache, 'utf8');
+            return JSON.parse(data);
+        } catch (error) {
+            console.error('❌ 加载环境缓存失败:', error.message);
+            return {};
+        }
+    }
+
+    /**
+     * 记录协作日志
+     */
+    async logCollaboration(signal) {
+        const logEntry = {
+            timestamp: signal.timestamp,
+            type: 'collaboration_signal',
+            cli: signal.cliName,
+            intent: signal.intent,
+            userInput: signal.userInput,
+            sessionId: signal.sessionId
+        };
+
+        const logLine = JSON.stringify(logEntry) + '\n';
+        await fs.appendFile(this.collaborationLog, logLine);
+    }
+
+    /**
+     * 生成会话ID
+     */
+    generateSessionId() {
+        return createHash('md5')
+            .update(`${Date.now()}-${Math.random()}`)
+            .digest('hex')
+            .substring(0, 16);
+    }
+
+    /**
+     * 提取主题
+     */
+    extractTopics(userInput) {
+        const topics = [];
+        const topicPatterns = {
+            '代码生成': ['generate', 'create', 'write', 'build', 'implement', 'code'],
+            '代码分析': ['analyze', 'review', 'check', 'examine', 'audit'],
+            '调试': ['debug', 'fix', 'error', 'issue', 'problem'],
+            '文档': ['document', 'explain', 'comment', 'readme'],
+            '测试': ['test', 'spec', 'validate', 'verify'],
+            '部署': ['deploy', 'build', 'release', 'publish'],
+            'API': ['api', 'endpoint', 'route', 'service'],
+            '数据库': ['database', 'db', 'sql', 'query', 'schema'],
+            '前端': ['frontend', 'ui', 'component', 'react', 'vue'],
+            '后端': ['backend', 'server', 'service', 'microservice']
+        };
+
+        const input = userInput.toLowerCase();
+        Object.entries(topicPatterns).forEach(([topic, keywords]) => {
+            if (keywords.some(keyword => input.includes(keyword))) {
+                topics.push(topic);
+            }
+        });
+
+        return topics;
+    }
+
+    /**
+     * 获取最频繁的元素
+     */
+    getMostFrequent(arr, count) {
+        const frequency = {};
+        arr.forEach(item => {
+            frequency[item] = (frequency[item] || 0) + 1;
+        });
+
+        return Object.entries(frequency)
+            .sort(([,a], [,b]) => b - a)
+            .slice(0, count)
+            .map(([item]) => item);
+    }
+
+    /**
+     * 为CLI提供环境上下文
+     */
+    async getCliContext(cliName) {
+        const signals = await this.readEnvironmentSignals(cliName);
+        return {
+            currentSession: this.generateSessionId(),
+            recentCollaborations: signals.signals,
+            environmentContext: signals.context,
+            suggestions: signals.collaborationSuggestions,
+            sharedFiles: await this.getSharedFiles(),
+            projectSpec: await this.getProjectSpec()
+        };
+    }
+
+    /**
+     * 获取共享文件
+     */
+    async getSharedFiles() {
+        try {
+            const files = await fs.readdir(this.contextDir);
+            const sharedFiles = {};
+
+            for (const file of files) {
+                if (file.endsWith('.json')) {
+                    const filePath = path.join(this.contextDir, file);
+                    const content = await fs.readFile(filePath, 'utf8');
+                    sharedFiles[file] = JSON.parse(content);
+                }
+            }
+
+            return sharedFiles;
+        } catch (error) {
+            return {};
+        }
+    }
+
+    /**
+     * 获取项目规格
+     */
+    async getProjectSpec() {
+        try {
+            const specFile = path.join(this.projectRoot, '.stigmergy-project', 'stigmergy-config.json');
+            const content = await fs.readFile(specFile, 'utf8');
+            return JSON.parse(content);
+        } catch (error) {
+            return {};
+        }
+    }
+}
+
+export { EnvironmentStigmergySystem };

package/src/core/lightweight_cli_enhancer.js

@@ -0,0 +1,282 @@
+/**
+ * 轻量级CLI增强器 - 增量到现有CLI
+ * 不修改CLI原生行为，增加协同能力
+ */
+
+import fs from 'fs/promises';
+import path from 'path';
+import { spawn, spawnSync } from 'child_process';
+import { CLIInteractionDetector } from './cli_interaction_detector.js';
+
+class LightweightCLIEnhancer {
+    constructor() {
+        this.detector = new CLIInteractionDetector();
+        this.enhancementConfig = {
+            enableContextSharing: true,
+            enableCollaborationHints: true,
+            enableAutomaticFileSharing: true,
+            minimalIntervention: true
+        };
+    }
+
+    /**
+     * 增强CLI命令 - 最小化介入
+     */
+    async enhanceCliCommand(cliName, args, options = {}) {
+        // 初始化检测器
+        await this.detector.initialize();
+
+        // 检测CLI调用
+        const detection = await this.detector.detectCliInvocation(cliName, args, options.cwd);
+
+        if (!detection) {
+            // 如果没有检测到特殊意图，直接执行原命令
+            return this.executeOriginalCommand(cliName, args, options);
+        }
+
+        // 生成增强参数
+        const enhancedArgs = await this.generateEnhancedArgs(detection);
+
+        // 执行增强命令
+        return this.executeEnhancedCommand(cliName, enhancedArgs, options, detection);
+    }
+
+    /**
+     * 执行原始命令 - 完全不改变行为
+     */
+    async executeOriginalCommand(cliName, args, options = {}) {
+        const cliCommands = {
+            'claude': ['claude', '@anthropic/claude-code'],
+            'gemini': ['gemini', '@google/gemini-cli'],
+            'qwen': ['qwen', 'qwencode'],
+            'iflow': ['iflow', '@iflow-ai/iflow-cli'],
+            'qoder': ['qodercli', 'qoder'],
+            'codebuddy': ['codebuddy', '@tencent-ai/codebuddy-code'],
+            'copilot': ['copilot', 'gh copilot'],
+            'codex': ['codex', 'openai-codex']
+        };
+
+        const command = cliCommands[cliName]?.[0] || cliName;
+        
+        return spawnSync(command, args, {
+            stdio: 'inherit',
+            cwd: options.cwd || process.cwd(),
+            env: { ...process.env, ...options.env }
+        });
+    }
+
+    /**
+     * 生成增强参数
+     */
+    async generateEnhancedArgs(detection) {
+        const enhancedArgs = [...detection.userInput.split(' ')];
+        
+        // 添加上下文线索
+        if (this.enhancementConfig.enableContextSharing && detection.environmentContext) {
+            const contextHint = this.generateContextHint(detection);
+            if (contextHint) {
+                enhancedArgs.push(`[上下文: ${contextHint}]`);
+            }
+        }
+
+        // 添加协作提示
+        if (this.enhancementConfig.enableCollaborationHints && detection.suggestions.length > 0) {
+            const collaborationHint = this.generateCollaborationHint(detection.suggestions[0]);
+            if (collaborationHint) {
+                enhancedArgs.push(`[协作提示: ${collaborationHint}]`);
+            }
+        }
+
+        return enhancedArgs;
+    }
+
+    /**
+     * 生成上下文提示
+     */
+    generateContextHint(detection) {
+        const context = detection.environmentContext;
+        
+        if (context.frequentCollaboration && Object.keys(context.frequentCollaboration).length > 0) {
+            const frequentCli = Object.keys(context.frequentCollaboration)[0];
+            return `最近经常与${frequentCli}协作`;
+        }
+
+        if (context.commonTopics && context.commonTopics.length > 0) {
+            return `最近在处理${context.commonTopics[0]}相关任务`;
+        }
+
+        return '';
+    }
+
+    /**
+     * 生成协作提示
+     */
+    generateCollaborationHint(suggestion) {
+        switch (suggestion.type) {
+            case 'frequent_collaboration':
+                return `建议后续可使用${suggestion.cli}继续`;
+            case 'topic_based':
+                return `建议使用专门工具处理${suggestion.topic}任务`;
+            default:
+                return suggestion.suggestion;
+        }
+    }
+
+    /**
+     * 执行增强命令
+     */
+    async executeEnhancedCommand(cliName, enhancedArgs, options, detection) {
+        // 先执行原始命令
+        const result = await this.executeOriginalCommand(cliName, enhancedArgs, options);
+
+        // 后台处理协作逻辑
+        if (this.enhancementConfig.enableAutomaticFileSharing) {
+            await this.handleAutomaticFileSharing(detection);
+        }
+
+        // 记录协作结果
+        await this.logCollaborationResult(detection, result);
+
+        return result;
+    }
+
+    /**
+     * 处理自动文件共享
+     */
+    async handleAutomaticFileSharing(detection) {
+        if (!detection.collaborationIntent) {
+            return;
+        }
+
+        try {
+            // 检测当前目录中的重要文件
+            const importantFiles = await this.detectImportantFiles();
+            
+            // 自动共享相关文件到环境
+            for (const file of importantFiles) {
+                await this.detector.shareFileToEnvironment(
+                    detection.cliName,
+                    file.filePath,
+                    { 
+                        autoShared: true,
+                        collaborationIntent: detection.collaborationIntent,
+                        relevanceScore: file.relevanceScore
+                    }
+                );
+            }
+        } catch (error) {
+            console.error('❌ 自动文件共享失败:', error.message);
+        }
+    }
+
+    /**
+     * 检测重要文件
+     */
+    async detectImportantFiles() {
+        const workingDir = process.cwd();
+        const files = await fs.readdir(workingDir);
+        
+        const importantPatterns = {
+            'README': ['README.md', 'README.txt', 'readme.md'],
+            'Config': ['package.json', 'requirements.txt', 'pyproject.toml', 'Cargo.toml'],
+            'Code': ['src/', 'lib/', 'app/', 'main.py', 'main.js', 'index.js', 'index.py'],
+            'Project': ['project.json', 'project.toml', '.stigmergy-project/']
+        };
+
+        const importantFiles = [];
+        
+        for (const file of files) {
+            let relevanceScore = 0;
+            let fileType = '';
+            
+            for (const [type, patterns] of Object.entries(importantPatterns)) {
+                if (patterns.some(pattern => file.includes(pattern) || file.startsWith(pattern))) {
+                    relevanceScore += 2;
+                    fileType = type;
+                }
+            }
+
+            if (relevanceScore > 0) {
+                const filePath = path.join(workingDir, file);
+                try {
+                    const stats = await fs.stat(filePath);
+                    importantFiles.push({
+                        fileName: file,
+                        filePath,
+                        fileType,
+                        relevanceScore,
+                        size: stats.size,
+                        modified: stats.mtime
+                    });
+                } catch (error) {
+                    // 忽略无法访问的文件
+                }
+            }
+        }
+
+        // 按相关性排序
+        return importantFiles
+            .sort((a, b) => b.relevanceScore - a.relevanceScore)
+            .slice(0, 5); // 最多共享5个文件
+    }
+
+    /**
+     * 记录协作结果
+     */
+    async logCollaborationResult(detection, result) {
+        try {
+            const logEntry = {
+                timestamp: new Date().toISOString(),
+                type: 'collaboration_result',
+                cliName: detection.cliName,
+                userInput: detection.userInput,
+                collaborationIntent: detection.collaborationIntent,
+                exitCode: result.status,
+                success: result.status === 0,
+                enhanced: true
+            };
+
+            const logFile = path.join(process.cwd(), '.stigmergy-project', 'collaboration_results.log');
+            await fs.mkdir(path.dirname(logFile), { recursive: true });
+            
+            const logLine = JSON.stringify(logEntry) + '\n';
+            await fs.appendFile(logFile, logLine);
+        } catch (error) {
+            console.error('❌ 记录协作结果失败:', error.message);
+        }
+    }
+
+    /**
+     * 创建CLI命令包装器
+     */
+    createCliWrapper(cliName) {
+        return async (...args) => {
+            return await this.enhanceCliCommand(cliName, args);
+        };
+    }
+
+    /**
+     * 获取当前环境状态
+     */
+    async getEnvironmentStatus() {
+        try {
+            const suggestions = await this.detector.getCliSuggestions('claude'); // 以claude为例
+            const sharedFiles = await this.detector.getSharedFilesFromEnvironment();
+            
+            return {
+                systemInitialized: true,
+                featuresEnabled: this.enhancementConfig,
+                availableSuggestions: suggestions.collaborationSuggestions.length,
+                sharedFilesCount: sharedFiles.length,
+                recentCollaborations: suggestions.recentCollaborations.length
+            };
+        } catch (error) {
+            return {
+                systemInitialized: false,
+                error: error.message
+            };
+        }
+    }
+}
+
+export { LightweightCLIEnhancer };

package/src/core/verified_cross_cli_system.py

@@ -17,7 +17,7 @@ import re
 
 # 导入编码安全模块
 sys.path.append(str(Path(__file__).parent))
-from cross_platform_encoding import safe_file_write, safe_file_read
+from cross_platform_encoding import SafeFileWriter, SafeFileReader
 
 @dataclass 
 class RealCLISpecs:
@@ -198,14 +198,9 @@ class VerifiedCrossCLISystem:
             )
         }
         
-        # 内存系统
-        self.memory_dir = Path.home() / '.verified_cross_cli'
-        self.memory_dir.mkdir(exist_ok=True)
-        self.context_dir = self.memory_dir / 'context_files'
-        self.context_dir.mkdir(exist_ok=True)
-        
-        self.call_history_file = self.memory_dir / 'verified_call_history.json'
-        self.context_cache_file = self.memory_dir / 'context_cache.json'
+        # 初始化文件操作工具
+        self.file_writer = SafeFileWriter()
+        self.file_reader = SafeFileReader()
     
     def check_cli_availability(self, cli_name: str) -> Dict[str, Any]:
         """检查CLI可用性 - 基于真实规范"""
@@ -740,11 +735,7 @@ export {status['api_env']}='your-api-key-here'
 """
         for i, method in enumerate(status['available_methods']):
             cmd = self._build_verified_command(method, spec, request, context_file, True)
-            manual_guidance += f"#### 方法 {i+1}:
-```bash
-{cmd}
-```
-\\n"
+            manual_guidance += f"#### 方法 {i+1}:\n```bash\n{cmd}\n```\n"
         
         manual_guidance += f"""
 ### 原始错误信息:

package/src/postinstall.js

@@ -276,6 +276,39 @@ async function copyPluginExtensions(availableCLIs) {
     console.log('✅ 插件扩展复制完成');
 }
 
+// 生成全局配置文件
+async function generateGlobalConfig(availableCLIs) {
+    console.log('\n📝 生成全局配置文件...');
+    
+    const globalConfigDir = join(homedir(), '.stigmergy-cli');
+    const globalConfigPath = join(globalConfigDir, 'global-config.json');
+    
+    const timestamp = new Date().toISOString();
+    const config = {
+        version: '1.0.0',
+        generatedAt: timestamp,
+        platform: process.platform,
+        nodeVersion: process.version,
+        availableTools: availableCLIs.filter(cli => cli.available).map(cli => ({
+            name: cli.name,
+            displayName: cli.displayName,
+            path: cli.path.replace(/\r$/, ''), // 清理路径中的回车符
+            description: cli.description,
+            required: cli.required
+        })),
+        scanResults: availableCLIs
+    };
+    
+    try {
+        await fs.writeFile(globalConfigPath, JSON.stringify(config, null, 2), 'utf8');
+        console.log(`✅ 全局配置文件已生成: ${globalConfigPath}`);
+        return true;
+    } catch (error) {
+        console.log(`⚠️ 无法生成全局配置文件: ${error.message}`);
+        return false;
+    }
+}
+
 // 生成全局记忆配置MD文件
 async function generateGlobalMemoryConfigMD(availableCLIs) {
     console.log('\n📝 生成全局记忆配置MD文件...');
@@ -356,12 +389,18 @@ async function main() {
             // 5. 复制各个CLI工具所必须的插件扩展到各个CLI安装的路径中
             await copyPluginExtensions(updatedAvailableCLIs);
             
-            // 6. 生成全局记忆配置MD文件
-            await generateGlobalMemoryConfigMD(updatedAvailableCLIs);
+            // 6. 生成全局配置文件和全局记忆配置MD文件
+            const configGenerated = await generateGlobalConfig(updatedAvailableCLIs);
+            if (configGenerated) {
+                await generateGlobalMemoryConfigMD(updatedAvailableCLIs);
+            }
         } else {
             // 如果没有安装新工具，直接处理已有的工具
-            await copyPluginExtensions(availableCLIs);
-            await generateGlobalMemoryConfigMD(availableCLIs);
+            const configGenerated = await generateGlobalConfig(availableCLIs);
+            if (configGenerated) {
+                await copyPluginExtensions(availableCLIs);
+                await generateGlobalMemoryConfigMD(availableCLIs);
+            }
         }
         
         console.log('\n🎉 Stigmergy CLI 安装后设置完成！');
@@ -377,9 +416,7 @@ async function main() {
 }
 
 // 运行主函数
-if (import.meta.url === `file://${process.argv[1]}`) {
-    main().catch(error => {
-        console.error(`❌ 脚本执行失败: ${error.message}`);
-        process.exit(1);
-    });
-}
+main().catch(error => {
+    console.error(`❌ 脚本执行失败: ${error.message}`);
+    process.exit(1);
+});