stigmergy 1.0.68 → 1.0.70

package/test/unit/cli-scanner.test.js

@@ -0,0 +1,291 @@
+/**
+ * TDD: CLI Scanner Unit Tests
+ * 测试驱动开发 - 先写测试，再写实现
+ * 使用ANSI编码，无Unicode字符
+ */
+
+const assert = require('assert');
+const path = require('path');
+
+// 测试目标类 - 尚未实现
+class CLIScanner {
+    constructor() {
+        this.scanResults = new Map();
+    }
+
+    async scanForCLI(cliName) {
+        throw new Error('Not implemented yet - TDD approach');
+    }
+
+    async detectInstalledCLIs() {
+        throw new Error('Not implemented yet - TDD approach');
+    }
+
+    validateCLIExecutable(command) {
+        throw new Error('Not implemented yet - TDD approach');
+    }
+}
+
+describe('CLI Scanner Unit Tests - ANSI Encoding, Node.js First', () => {
+    let scanner;
+
+    beforeEach(() => {
+        scanner = new CLIScanner();
+    });
+
+    describe('Basic CLI Detection', () => {
+        it('should detect node command is available', async () => {
+            // 测试最基础的情况 - node命令应该可用
+            const result = await scanner.scanForCLI('node');
+
+            assert.strictEqual(result.cliName, 'node');
+            assert.strictEqual(result.available, true);
+            assert.ok(result.version);
+            assert.ok(result.path);
+        });
+
+        it('should detect npm command is available', async () => {
+            const result = await scanner.scanForCLI('npm');
+
+            assert.strictEqual(result.cliName, 'npm');
+            assert.strictEqual(result.available, true);
+            assert.ok(result.version);
+        });
+
+        it('should handle non-existent CLI gracefully', async () => {
+            const result = await scanner.scanForCLI('non-existent-cli-12345');
+
+            assert.strictEqual(result.cliName, 'non-existent-cli-12345');
+            assert.strictEqual(result.available, false);
+            assert.ok(result.error);
+        });
+    });
+
+    describe('AI CLI Detection', () => {
+        it('should detect Claude CLI if installed', async () => {
+            const result = await scanner.scanForCLI('claude');
+
+            assert.strictEqual(result.cliName, 'claude');
+            assert(typeof result.available === 'boolean');
+
+            if (result.available) {
+                assert.ok(result.version);
+                assert.ok(result.path);
+            }
+        });
+
+        it('should detect Gemini CLI if installed', async () => {
+            const result = await scanner.scanForCLI('gemini');
+
+            assert.strictEqual(result.cliName, 'gemini');
+            assert(typeof result.available === 'boolean');
+        });
+
+        it('should detect Qwen CLI if installed', async () => {
+            const result = await scanner.scanForCLI('qwen');
+
+            assert.strictEqual(result.cliName, 'qwen');
+            assert(typeof result.available === 'boolean');
+        });
+    });
+
+    describe('CLI Validation', () => {
+        it('should validate valid Windows commands', () => {
+            if (process.platform === 'win32') {
+                assert.ok(scanner.validateCLIExecutable('cmd'));
+                assert.ok(scanner.validateCLIExecutable('powershell'));
+                assert.ok(scanner.validateCLIExecutable('node'));
+            }
+        });
+
+        it('should validate valid Unix commands', () => {
+            if (process.platform !== 'win32') {
+                assert.ok(scanner.validateCLIExecutable('sh'));
+                assert.ok(scanner.validateCLIExecutable('ls'));
+                assert.ok(scanner.validateCLIExecutable('node'));
+            }
+        });
+
+        it('should reject invalid commands', () => {
+            assert.strictEqual(scanner.validateCLIExecutable(''), false);
+            assert.strictEqual(scanner.validateCLIExecutable('non-existent-command-12345'), false);
+        });
+    });
+
+    describe('Batch Detection', () => {
+        it('should detect all basic development tools', async () => {
+            const tools = ['node', 'npm', 'git'];
+            const results = await scanner.detectInstalledCLIs(tools);
+
+            assert.ok(results.size >= 2); // 至少node和npm应该可用
+            assert.ok(results.has('node'));
+            assert.ok(results.has('npm'));
+
+            // node和npm都应该可用
+            assert.strictEqual(results.get('node').available, true);
+            assert.strictEqual(results.get('npm').available, true);
+        });
+
+        it('should handle mixed available/unavailable tools', async () => {
+            const tools = ['node', 'non-existent-cli', 'npm'];
+            const results = await scanner.detectInstalledCLIs(tools);
+
+            assert.strictEqual(results.size, 3);
+            assert.ok(results.has('node'));
+            assert.ok(results.has('npm'));
+            assert.ok(results.has('non-existent-cli'));
+
+            assert.strictEqual(results.get('node').available, true);
+            assert.strictEqual(results.get('npm').available, true);
+            assert.strictEqual(results.get('non-existent-cli').available, false);
+        });
+    });
+
+    describe('Error Handling', () => {
+        it('should handle null input gracefully', async () => {
+            try {
+                await scanner.scanForCLI(null);
+                assert.fail('Should have thrown an error');
+            } catch (error) {
+                assert.ok(error.message.includes('Invalid CLI name'));
+            }
+        });
+
+        it('should handle empty string gracefully', async () => {
+            try {
+                await scanner.scanForCLI('');
+                assert.fail('Should have thrown an error');
+            } catch (error) {
+                assert.ok(error.message.includes('Invalid CLI name'));
+            }
+        });
+
+        it('should handle timeout during scanning', async () => {
+            // 测试超时处理
+            const timeoutMs = 1000;
+            const startTime = Date.now();
+
+            try {
+                await scanner.scanForCLI('sleep-command-that-does-not-exist', { timeout: timeoutMs });
+            } catch (error) {
+                const elapsed = Date.now() - startTime;
+                assert.ok(elapsed < timeoutMs + 1000); // 允许一些误差
+                assert.ok(error.message.includes('timeout') || error.message.includes('not found'));
+            }
+        });
+    });
+
+    describe('Platform Specific Tests', () => {
+        it('should work on Windows', async () => {
+            if (process.platform === 'win32') {
+                const result = await scanner.scanForCLI('node');
+                assert.strictEqual(result.available, true);
+                assert.ok(result.path.includes('.exe') || result.path.includes('node'));
+            }
+        });
+
+        it('should work on Unix-like systems', async () => {
+            if (process.platform !== 'win32') {
+                const result = await scanner.scanForCLI('node');
+                assert.strictEqual(result.available, true);
+            }
+        });
+    });
+
+    describe('Performance Tests', () => {
+        it('should scan multiple CLIs efficiently', async () => {
+            const tools = ['node', 'npm', 'git', 'code'];
+            const startTime = Date.now();
+
+            const results = await scanner.detectInstalledCLIs(tools);
+
+            const elapsed = Date.now() - startTime;
+            assert.ok(elapsed < 5000); // 应该在5秒内完成
+            assert.strictEqual(results.size, tools.length);
+        });
+
+        it('should cache scan results', async () => {
+            const cliName = 'node';
+
+            // 第一次扫描
+            const startTime1 = Date.now();
+            const result1 = await scanner.scanForCLI(cliName);
+            const time1 = Date.now() - startTime1;
+
+            // 第二次扫描（应该使用缓存）
+            const startTime2 = Date.now();
+            const result2 = await scanner.scanForCLI(cliName);
+            const time2 = Date.now() - startTime2;
+
+            assert.deepStrictEqual(result1, result2);
+            assert.ok(time2 <= time1); // 缓存应该更快或相等
+        });
+    });
+});
+
+// 运行测试
+if (require.main === module) {
+    console.log('Running CLI Scanner Unit Tests...');
+
+    // 简单的测试运行器
+    const testMethods = [
+        'should detect node command is available',
+        'should detect npm command is available',
+        'should handle non-existent CLI gracefully',
+        'should validate valid Windows commands',
+        'should reject invalid commands',
+        'should handle null input gracefully'
+    ];
+
+    (async () => {
+        const scanner = new CLIScanner();
+        let passed = 0;
+        let failed = 0;
+
+        for (const testName of testMethods) {
+            try {
+                console.log(`Testing: ${testName}`);
+
+                if (testName.includes('node')) {
+                    const result = await scanner.scanForCLI('node');
+                    if (result.available) {
+                        console.log(`[PASS] ${testName}`);
+                        passed++;
+                    } else {
+                        console.log(`[FAIL] ${testName} - Node not available`);
+                        failed++;
+                    }
+                } else if (testName.includes('npm')) {
+                    const result = await scanner.scanForCLI('npm');
+                    if (result.available) {
+                        console.log(`[PASS] ${testName}`);
+                        passed++;
+                    } else {
+                        console.log(`[FAIL] ${testName} - NPM not available`);
+                        failed++;
+                    }
+                } else if (testName.includes('non-existent')) {
+                    try {
+                        await scanner.scanForCLI('non-existent-cli-12345');
+                        console.log(`[FAIL] ${testName} - Should have thrown error`);
+                        failed++;
+                    } catch (error) {
+                        console.log(`[PASS] ${testName}`);
+                        passed++;
+                    }
+                } else {
+                    console.log(`[SKIP] ${testName} - Implementation needed`);
+                }
+
+            } catch (error) {
+                console.log(`[ERROR] ${testName} - ${error.message}`);
+                failed++;
+            }
+        }
+
+        console.log(`\nTest Results: ${passed} passed, ${failed} failed`);
+        console.log('Implementation needed for full TDD approach.');
+    })();
+}
+
+module.exports = CLIScanner;

package/test/unit/cross-cli-executor.test.js

@@ -0,0 +1,399 @@
+/**
+ * TDD: Cross-CLI Executor Unit Tests
+ * 测试驱动开发 - 先写测试，再写实现
+ * 使用ANSI编码，无Unicode字符，Node.js优先
+ */
+
+const assert = require('assert');
+const EventEmitter = require('events');
+
+// 测试目标类 - 尚未实现
+class CrossCLIExecutor extends EventEmitter {
+    constructor() {
+        super();
+        this.executionHistory = [];
+        this.activeExecutions = new Map();
+    }
+
+    async executeCrossCLI(sourceCLI, targetCLI, task, options = {}) {
+        throw new Error('Not implemented yet - TDD approach');
+    }
+
+    async executeCommand(command, args, options = {}) {
+        throw new Error('Not implemented yet - TDD approach');
+    }
+
+    validateExecutionParams(sourceCLI, targetCLI, task) {
+        throw new Error('Not implemented yet - TDD approach');
+    }
+
+    getExecutionHistory() {
+        return this.executionHistory;
+    }
+
+    getActiveExecutions() {
+        return Array.from(this.activeExecutions.values());
+    }
+}
+
+describe('Cross-CLI Executor Unit Tests - ANSI Encoding', () => {
+    let executor;
+
+    beforeEach(() => {
+        executor = new CrossCLIExecutor();
+    });
+
+    describe('Parameter Validation', () => {
+        it('should validate correct execution parameters', () => {
+            const result = executor.validateExecutionParams('claude', 'gemini', 'translate this text');
+
+            assert.strictEqual(result.valid, true);
+            assert.strictEqual(result.sourceCLI, 'claude');
+            assert.strictEqual(result.targetCLI, 'gemini');
+            assert.strictEqual(result.task, 'translate this text');
+        });
+
+        it('should reject empty source CLI', () => {
+            const result = executor.validateExecutionParams('', 'gemini', 'test task');
+
+            assert.strictEqual(result.valid, false);
+            assert.ok(result.error.includes('source CLI'));
+        });
+
+        it('should reject empty target CLI', () => {
+            const result = executor.validateExecutionParams('claude', '', 'test task');
+
+            assert.strictEqual(result.valid, false);
+            assert.ok(result.error.includes('target CLI'));
+        });
+
+        it('should reject empty task', () => {
+            const result = executor.validateExecutionParams('claude', 'gemini', '');
+
+            assert.strictEqual(result.valid, false);
+            assert.ok(result.error.includes('task'));
+        });
+
+        it('should reject same source and target CLI', () => {
+            const result = executor.validateExecutionParams('claude', 'claude', 'test task');
+
+            assert.strictEqual(result.valid, false);
+            assert.ok(result.error.includes('same'));
+        });
+    });
+
+    describe('Command Execution', () => {
+        it('should execute node --version successfully', async () => {
+            const result = await executor.executeCommand('node', ['--version'], {
+                timeout: 5000
+            });
+
+            assert.strictEqual(result.success, true);
+            assert.ok(result.stdout);
+            assert.strictEqual(result.exitCode, 0);
+        });
+
+        it('should execute npm --version successfully', async () => {
+            const result = await executor.executeCommand('npm', ['--version'], {
+                timeout: 5000
+            });
+
+            assert.strictEqual(result.success, true);
+            assert.ok(result.stdout);
+            assert.strictEqual(result.exitCode, 0);
+        });
+
+        it('should handle non-existent command gracefully', async () => {
+            const result = await executor.executeCommand('non-existent-command-12345', [], {
+                timeout: 3000
+            });
+
+            assert.strictEqual(result.success, false);
+            assert.ok(result.error);
+            assert.ok(result.error.includes('not found') || result.error.includes('ENOENT'));
+        });
+
+        it('should handle command timeout', async () => {
+            const startTime = Date.now();
+            const result = await executor.executeCommand('node', ['-e', 'setTimeout(() => {}, 10000)'], {
+                timeout: 2000
+            });
+            const elapsed = Date.now() - startTime;
+
+            assert.strictEqual(result.success, false);
+            assert.ok(elapsed < 5000); // 应该在超时时间内返回
+            assert.ok(result.error.includes('timeout') || result.error.includes('killed'));
+        });
+
+        it('should capture stderr output', async () => {
+            const result = await executor.executeCommand('node', ['-e', 'console.error("error message")'], {
+                timeout: 5000
+            });
+
+            assert.strictEqual(result.success, true);
+            assert.ok(result.stderr.includes('error message'));
+        });
+    });
+
+    describe('Cross-CLI Execution', () => {
+        it('should execute simple claude to gemini translation', async () => {
+            // Mock实际调用，因为真实CLI可能未安装
+            const result = await executor.executeCrossCLI('claude', 'gemini', 'translate "hello world" to chinese', {
+                dryRun: true, // 干运行模式
+                timeout: 5000
+            });
+
+            assert.strictEqual(result.success, true);
+            assert.strictEqual(result.sourceCLI, 'claude');
+            assert.strictEqual(result.targetCLI, 'gemini');
+            assert.ok(result.executionId);
+            assert.ok(typeof result.executionTime === 'number');
+        });
+
+        it('should handle execution errors gracefully', async () => {
+            const result = await executor.executeCrossCLI('non-existent', 'gemini', 'test task', {
+                timeout: 3000
+            });
+
+            assert.strictEqual(result.success, false);
+            assert.ok(result.error);
+        });
+
+        it('should prevent duplicate executions', async () => {
+            const task = 'test duplicate task';
+            const options = {
+                preventDuplicate: true,
+                timeout: 5000
+            };
+
+            const result1 = await executor.executeCrossCLI('claude', 'gemini', task, options);
+            const result2 = await executor.executeCrossCLI('claude', 'gemini', task, options);
+
+            assert.strictEqual(result1.success, true);
+            assert.strictEqual(result2.duplicate, true);
+            assert.strictEqual(result2.executionId, result1.executionId);
+        });
+    });
+
+    describe('Execution History Management', () => {
+        it('should track execution history', async () => {
+            await executor.executeCommand('node', ['--version']);
+
+            const history = executor.getExecutionHistory();
+            assert.ok(history.length > 0);
+
+            const lastExecution = history[history.length - 1];
+            assert.strictEqual(lastExecution.command, 'node');
+            assert.strictEqual(lastExecution.success, true);
+            assert.ok(lastExecution.timestamp);
+        });
+
+        it('should track both successful and failed executions', async () => {
+            await executor.executeCommand('node', ['--version']);
+            await executor.executeCommand('non-existent-command', []);
+
+            const history = executor.getExecutionHistory();
+            assert.ok(history.length >= 2);
+
+            const results = history.map(h => h.success);
+            assert.ok(results.includes(true));
+            assert.ok(results.includes(false));
+        });
+
+        it('should limit history size', async () => {
+            // 执行多个命令
+            for (let i = 0; i < 150; i++) {
+                await executor.executeCommand('node', ['--version']);
+            }
+
+            const history = executor.getExecutionHistory();
+            assert.ok(history.length <= 100); // 应该有历史大小限制
+        });
+    });
+
+    describe('Active Execution Tracking', () => {
+        it('should track active executions', async () => {
+            const executionPromise = executor.executeCommand('node', ['-e', 'setTimeout(() => {}, 2000)'], {
+                timeout: 5000
+            });
+
+            // 立即检查活跃执行
+            const activeExecutions = executor.getActiveExecutions();
+            assert.ok(activeExecutions.length > 0);
+
+            const execution = activeExecutions[0];
+            assert.strictEqual(execution.command, 'node');
+            assert.strictEqual(execution.status, 'running');
+
+            await executionPromise;
+        });
+
+        it('should clean up completed executions', async () => {
+            await executor.executeCommand('node', ['--version']);
+
+            const activeExecutions = executor.getActiveExecutions();
+            const completedExecutions = activeExecutions.filter(e => e.status === 'completed');
+            assert.strictEqual(completedExecutions.length, 0);
+        });
+    });
+
+    describe('Event Emission', () => {
+        it('should emit execution start event', (done) => {
+            executor.on('execution:start', (data) => {
+                assert.strictEqual(data.command, 'node');
+                assert.ok(data.executionId);
+                done();
+            });
+
+            executor.executeCommand('node', ['--version']);
+        });
+
+        it('should emit execution complete event', (done) => {
+            executor.on('execution:complete', (data) => {
+                assert.strictEqual(data.command, 'node');
+                assert.strictEqual(data.success, true);
+                done();
+            });
+
+            executor.executeCommand('node', ['--version']);
+        });
+
+        it('should emit execution error event', (done) => {
+            executor.on('execution:error', (data) => {
+                assert.strictEqual(data.command, 'non-existent-command');
+                assert.strictEqual(data.success, false);
+                done();
+            });
+
+            executor.executeCommand('non-existent-command', []);
+        });
+    });
+
+    describe('Performance Tests', () => {
+        it('should execute multiple commands concurrently', async () => {
+            const commands = [
+                ['node', ['--version']],
+                ['npm', ['--version']],
+                ['node', ['-e', 'console.log("test")']]
+            ];
+
+            const startTime = Date.now();
+            const results = await Promise.all(
+                commands.map(([cmd, args]) => executor.executeCommand(cmd, args))
+            );
+            const elapsed = Date.now() - startTime;
+
+            assert.strictEqual(results.length, 3);
+            assert.ok(results.every(r => r.success));
+            assert.ok(elapsed < 10000); // 应该在10秒内完成并发执行
+        });
+
+        it('should handle memory usage efficiently', async () => {
+            const initialMemory = process.memoryUsage();
+
+            // 执行多个命令
+            for (let i = 0; i < 50; i++) {
+                await executor.executeCommand('node', ['--version']);
+            }
+
+            const finalMemory = process.memoryUsage();
+            const memoryIncrease = finalMemory.heapUsed - initialMemory.heapUsed;
+
+            // 内存增长应该控制在合理范围内
+            assert.ok(memoryIncrease < 50 * 1024 * 1024); // 小于50MB
+        });
+    });
+
+    describe('Platform Specific Tests', () => {
+        it('should work on Windows platform', async () => {
+            if (process.platform === 'win32') {
+                const result = await executor.executeCommand('cmd', ['/c', 'echo test'], {
+                    timeout: 5000
+                });
+
+                assert.strictEqual(result.success, true);
+                assert.ok(result.stdout.includes('test'));
+            }
+        });
+
+        it('should work on Unix-like platforms', async () => {
+            if (process.platform !== 'win32') {
+                const result = await executor.executeCommand('echo', ['test'], {
+                    timeout: 5000
+                });
+
+                assert.strictEqual(result.success, true);
+                assert.ok(result.stdout.includes('test'));
+            }
+        });
+    });
+});
+
+// 运行测试
+if (require.main === module) {
+    console.log('Running Cross-CLI Executor Unit Tests...');
+
+    (async () => {
+        const executor = new CrossCLIExecutor();
+        let passed = 0;
+        let failed = 0;
+
+        const tests = [
+            async () => {
+                console.log('Testing parameter validation...');
+                const result = executor.validateExecutionParams('claude', 'gemini', 'test task');
+                if (result.valid) {
+                    console.log('[PASS] Parameter validation');
+                    return true;
+                }
+                return false;
+            },
+            async () => {
+                console.log('Testing command execution...');
+                try {
+                    const result = await executor.executeCommand('node', ['--version'], { timeout: 3000 });
+                    if (result.success) {
+                        console.log('[PASS] Command execution');
+                        return true;
+                    }
+                } catch (error) {
+                    console.log(`[FAIL] Command execution: ${error.message}`);
+                }
+                return false;
+            },
+            async () => {
+                console.log('Testing error handling...');
+                try {
+                    const result = await executor.executeCommand('non-existent-command-12345', [], { timeout: 2000 });
+                    if (!result.success) {
+                        console.log('[PASS] Error handling');
+                        return true;
+                    }
+                } catch (error) {
+                    console.log('[PASS] Error handling (exception thrown)');
+                    return true;
+                }
+                return false;
+            }
+        ];
+
+        for (const test of tests) {
+            try {
+                const result = await test();
+                if (result) {
+                    passed++;
+                } else {
+                    failed++;
+                }
+            } catch (error) {
+                console.log(`[ERROR] Test failed: ${error.message}`);
+                failed++;
+            }
+        }
+
+        console.log(`\nTest Results: ${passed} passed, ${failed} failed`);
+        console.log('Implementation needed for full TDD approach.');
+    })();
+}
+
+module.exports = CrossCLIExecutor;

package/src/adapters/claude/__init__.py

@@ -1,13 +0,0 @@
-"""
-Claude CLI 适配器包
-
-基于 Claude CLI 官方 Hook 系统的原生集成
-支持多种实现方式，全部无抽象层
-"""
-
-from .standalone_claude_adapter import get_standalone_claude_adapter, StandaloneClaudeAdapter
-
-# 向后兼容的别名
-ClaudeHookAdapter = StandaloneClaudeAdapter
-
-__all__ = ['StandaloneClaudeAdapter', 'get_standalone_claude_adapter', 'ClaudeHookAdapter']