stigmergy 1.0.94 → 1.0.97

package/docs/tdd_implementation_plan.md

@@ -0,0 +1,384 @@
+# Stigmergy CLI 测试驱动开发实施计划
+
+## 1. 测试策略
+
+### 1.1 测试类型
+- **单元测试**：针对各个模块的独立功能测试
+- **集成测试**：模块间协作和数据流测试
+- **端到端测试**：完整的用户场景测试
+- **性能测试**：关键路径性能验证
+
+### 1.2 测试工具
+- **测试框架**：Jest
+- **断言库**：内置Jest断言
+- **测试覆盖率**：nyc/istanbul
+- **模拟工具**：Jest Mock功能
+
+## 2. 测试计划
+
+### 2.1 智能路由模块测试
+
+#### 2.1.1 单元测试用例
+```javascript
+// tests/unit/smart_router.test.js
+
+describe('SmartRouter', () => {
+  let router;
+  
+  beforeEach(() => {
+    router = new SmartRouter();
+  });
+  
+  describe('smartRoute', () => {
+    test('should route to claude when claude keyword is detected', async () => {
+      const result = await router.smartRoute('用claude分析这段代码');
+      expect(result.tool).toBe('claude');
+      expect(result.prompt).toBe('分析这段代码');
+    });
+    
+    test('should route to qwen when qwen keyword is detected', async () => {
+      const result = await router.smartRoute('用qwen写一个hello world程序');
+      expect(result.tool).toBe('qwen');
+      expect(result.prompt).toBe('写一个hello world程序');
+    });
+    
+    test('should route to default tool when no keyword is detected', async () => {
+      const result = await router.smartRoute('分析项目架构');
+      expect(result.tool).toBe('claude');
+      expect(result.prompt).toBe('分析项目架构');
+    });
+  });
+  
+  describe('extractKeywords', () => {
+    test('should extract correct keywords for claude', () => {
+      const keywords = router.extractKeywords('claude');
+      expect(keywords).toContain('claude');
+      expect(keywords).toContain('anthropic');
+    });
+    
+    test('should extract correct keywords for qwen', () => {
+      const keywords = router.extractKeywords('qwen');
+      expect(keywords).toContain('qwen');
+      expect(keywords).toContain('alibaba');
+      expect(keywords).toContain('tongyi');
+    });
+  });
+});
+```
+
+#### 2.1.2 集成测试用例
+```javascript
+// tests/integration/routing_integration.test.js
+
+describe('Routing Integration', () => {
+  test('should successfully route and execute CLI command', async () => {
+    // 模拟CLI工具执行
+    const mockSpawn = jest.spyOn(require('child_process'), 'spawn');
+    mockSpawn.mockImplementation(() => {
+      return {
+        on: jest.fn().mockImplementation((event, callback) => {
+          if (event === 'close') {
+            setTimeout(() => callback(0), 10);
+          }
+        }),
+        stdout: { on: jest.fn() },
+        stderr: { on: jest.fn() }
+      };
+    });
+    
+    // 执行路由
+    const router = new SmartRouter();
+    const route = await router.smartRoute('用claude分析代码');
+    
+    // 验证路由结果
+    expect(route.tool).toBe('claude');
+    expect(route.prompt).toBe('分析代码');
+    
+    // 验证CLI执行
+    expect(mockSpawn).toHaveBeenCalledWith('claude', ['分析代码'], expect.any(Object));
+  });
+});
+```
+
+### 2.2 上下文管理模块测试
+
+#### 2.2.1 单元测试用例
+```javascript
+// tests/unit/memory_manager.test.js
+
+describe('MemoryManager', () => {
+  let memoryManager;
+  let tempDir;
+  
+  beforeEach(async () => {
+    tempDir = await fs.mkdtemp(path.join(os.tmpdir(), 'stigmergy-test-'));
+    memoryManager = new MemoryManager();
+    memoryManager.globalMemoryFile = path.join(tempDir, 'memory.json');
+  });
+  
+  afterEach(async () => {
+    await fs.rm(tempDir, { recursive: true, force: true });
+  });
+  
+  describe('getGlobalMemory', () => {
+    test('should return empty memory when file does not exist', async () => {
+      const memory = await memoryManager.getGlobalMemory();
+      expect(memory).toEqual({
+        interactions: [],
+        collaborations: []
+      });
+    });
+    
+    test('should return parsed memory when file exists', async () => {
+      const testData = {
+        interactions: [{ tool: 'claude', prompt: 'test' }],
+        collaborations: []
+      };
+      await fs.writeFile(memoryManager.globalMemoryFile, JSON.stringify(testData));
+      
+      const memory = await memoryManager.getGlobalMemory();
+      expect(memory).toEqual(testData);
+    });
+  });
+  
+  describe('updateGlobalMemory', () => {
+    test('should update memory and return updated data', async () => {
+      const updateFn = (memory) => {
+        memory.interactions.push({ tool: 'qwen', prompt: 'test' });
+        return memory;
+      };
+      
+      const updatedMemory = await memoryManager.updateGlobalMemory(updateFn);
+      
+      expect(updatedMemory.interactions).toHaveLength(1);
+      expect(updatedMemory.interactions[0].tool).toBe('qwen');
+    });
+  });
+});
+```
+
+### 2.3 CLI模式分析模块测试
+
+#### 2.3.1 单元测试用例
+```javascript
+// tests/unit/cli_help_analyzer.test.js
+
+describe('CLIHelpAnalyzer', () => {
+  let analyzer;
+  let tempDir;
+  
+  beforeEach(async () => {
+    tempDir = await fs.mkdtemp(path.join(os.tmpdir(), 'stigmergy-analyzer-test-'));
+    analyzer = new CLIHelpAnalyzer();
+    analyzer.configDir = tempDir;
+    analyzer.persistentConfig = path.join(tempDir, 'cli-patterns.json');
+  });
+  
+  afterEach(async () => {
+    await fs.rm(tempDir, { recursive: true, force: true });
+  });
+  
+  describe('initialize', () => {
+    test('should create config directory and initialize config file', async () => {
+      await analyzer.initialize();
+      
+      const configExists = await fs.access(analyzer.persistentConfig).then(() => true).catch(() => false);
+      expect(configExists).toBe(true);
+      
+      const config = JSON.parse(await fs.readFile(analyzer.persistentConfig, 'utf8'));
+      expect(config.version).toBe('1.0.0');
+      expect(config.cliPatterns).toEqual({});
+    });
+  });
+  
+  describe('analyzeCLI', () => {
+    test('should throw error when CLI is not configured', async () => {
+      await expect(analyzer.analyzeCLI('nonexistent-cli')).rejects.toThrow();
+    });
+    
+    test('should cache analysis results', async () => {
+      // 模拟CLI工具帮助信息
+      const mockSpawnSync = jest.spyOn(require('child_process'), 'spawnSync');
+      mockSpawnSync.mockReturnValue({
+        status: 0,
+        stdout: 'Usage: claude [options] [command]\n\nCommands:\n  analyze  Analyze code\n  generate Generate code',
+        stderr: ''
+      });
+      
+      const result = await analyzer.analyzeCLI('claude');
+      
+      expect(result.success).toBe(true);
+      expect(result.cliName).toBe('claude');
+      expect(result.patterns.commands).toHaveLength(2);
+      
+      // 验证缓存
+      const cached = await analyzer.getCachedAnalysis('claude');
+      expect(cached).toEqual(result);
+    });
+  });
+});
+```
+
+## 3. 实施路线图
+
+### 3.1 第一阶段：基础模块测试 (Week 1-2)
+- [ ] 智能路由模块单元测试
+- [ ] 上下文管理模块单元测试
+- [ ] CLI模式分析模块单元测试
+- [ ] 建立测试基础设施
+
+### 3.2 第二阶段：集成测试 (Week 3)
+- [ ] 模块间集成测试
+- [ ] 数据流测试
+- [ ] 错误处理测试
+
+### 3.3 第三阶段：端到端测试 (Week 4)
+- [ ] 完整用户场景测试
+- [ ] 性能测试
+- [ ] 兼容性测试
+
+### 3.4 第四阶段：测试优化 (Week 5)
+- [ ] 测试覆盖率分析
+- [ ] 测试稳定性优化
+- [ ] 自动化测试流程
+
+## 4. 质量门禁
+
+### 4.1 测试覆盖率要求
+- **行覆盖率**：≥ 80%
+- **函数覆盖率**：≥ 85%
+- **分支覆盖率**：≥ 75%
+
+### 4.2 代码质量要求
+- **ESLint**：无警告和错误
+- **代码复杂度**：函数圈复杂度 ≤ 10
+- **重复代码**：≤ 5%
+
+## 5. 持续集成配置
+
+### 5.1 GitHub Actions 配置
+```yaml
+# .github/workflows/test.yml
+name: Test
+on: [push, pull_request]
+jobs:
+  test:
+    runs-on: ubuntu-latest
+    strategy:
+      matrix:
+        node-version: [16.x, 18.x, 20.x]
+    steps:
+    - uses: actions/checkout@v3
+    - name: Use Node.js ${{ matrix.node-version }}
+      uses: actions/setup-node@v3
+      with:
+        node-version: ${{ matrix.node-version }}
+    - run: npm ci
+    - run: npm test
+    - run: npm run coverage
+```
+
+### 5.2 测试脚本配置
+```json
+// package.json
+{
+  "scripts": {
+    "test": "jest",
+    "test:unit": "jest tests/unit",
+    "test:integration": "jest tests/integration",
+    "test:e2e": "jest tests/e2e",
+    "coverage": "jest --coverage",
+    "test:watch": "jest --watch"
+  },
+  "jest": {
+    "testEnvironment": "node",
+    "collectCoverageFrom": [
+      "src/**/*.js",
+      "!src/index.js"
+    ],
+    "coverageThreshold": {
+      "global": {
+        "branches": 75,
+        "functions": 85,
+        "lines": 80,
+        "statements": 80
+      }
+    }
+  }
+}
+```
+
+## 6. 测试数据管理
+
+### 6.1 测试数据工厂
+```javascript
+// tests/factories/test_data_factory.js
+
+class TestDataFactory {
+  static createInteraction(tool = 'claude', prompt = 'test prompt') {
+    return {
+      timestamp: new Date().toISOString(),
+      tool,
+      prompt,
+      response: 'test response',
+      duration: 100
+    };
+  }
+  
+  static createCLIConfig(name = 'test-cli') {
+    return {
+      name: `${name} CLI`,
+      version: `${name} --version`,
+      install: `npm install -g ${name}-cli`,
+      hooksDir: path.join(os.homedir(), `.${name}`, 'hooks'),
+      config: path.join(os.homedir(), `.${name}`, 'config.json')
+    };
+  }
+}
+```
+
+### 6.2 测试环境配置
+```javascript
+// tests/test_setup.js
+
+// 设置测试环境
+process.env.NODE_ENV = 'test';
+process.env.STIGMERGY_TEST_MODE = 'true';
+
+// 创建测试临时目录
+const testTempDir = path.join(os.tmpdir(), 'stigmergy-tests');
+fs.mkdirSync(testTempDir, { recursive: true });
+
+// 清理测试环境
+afterAll(async () => {
+  await fs.rm(testTempDir, { recursive: true, force: true });
+});
+```
+
+## 7. 性能测试计划
+
+### 7.1 关键性能指标
+- 路由决策时间：< 100ms
+- 内存读写时间：< 50ms
+- CLI模式分析时间：< 5s
+
+### 7.2 性能测试用例
+```javascript
+// tests/performance/routing_performance.test.js
+
+describe('Routing Performance', () => {
+  test('should route decision time be less than 100ms', async () => {
+    const router = new SmartRouter();
+    const startTime = performance.now();
+    
+    await router.smartRoute('用claude分析项目架构');
+    
+    const endTime = performance.now();
+    const executionTime = endTime - startTime;
+    
+    expect(executionTime).toBeLessThan(100);
+  });
+});
+```
+
+通过以上TDD实施计划，我们可以确保Stigmergy CLI系统的质量和可靠性，同时保持开发效率。

package/docs/test_report.md

@@ -0,0 +1,49 @@
+# Stigmergy CLI - 测试报告
+
+## 概述
+本次测试验证了Stigmergy CLI系统的核心模块，包括智能路由、CLI帮助分析和内存管理模块。
+
+## 测试结果
+
+### 测试套件执行情况
+- **通过**: 3/3 测试套件
+- **失败**: 0/3 测试套件
+- **总测试数**: 20个测试用例
+- **通过率**: 100%
+
+### 详细测试结果
+
+#### 1. SmartRouter 测试套件
+- **总测试数**: 11个测试用例
+- **通过**: 11/11
+- **测试内容**:
+  - 构造函数测试
+  - 关键字提取功能测试
+  - 智能路由决策测试
+
+#### 2. CLIHelpAnalyzer 测试套件
+- **总测试数**: 6个测试用例
+- **通过**: 6/6
+- **测试内容**:
+  - 构造函数测试
+  - 初始化功能测试
+  - 缓存过期检查测试
+  - 文件存在性检查测试
+
+#### 3. MemoryManager 测试套件
+- **总测试数**: 3个测试用例
+- **通过**: 3/3
+- **测试内容**:
+  - 构造函数测试
+  - 全局内存获取测试
+  - 内存文件读写测试
+
+## 代码覆盖率
+当前测试覆盖率尚未达到预设阈值：
+- **语句覆盖率**: 7.51% (目标: 80%)
+- **分支覆盖率**: 7.84% (目标: 75%)
+- **函数覆盖率**: 12.39% (目标: 85%)
+- **行覆盖率**: 7.6% (目标: 80%)
+
+## 结论
+所有单元测试均已通过，验证了核心模块的基本功能。下一步需要增加更多测试用例以提高代码覆盖率。

package/examples/calculator-example.js

@@ -0,0 +1,72 @@
+/**
+ * Example usage of the Calculator class
+ */
+
+const Calculator = require('../src/calculator');
+
+// Create a new calculator instance
+const calc = new Calculator();
+
+// Basic operations
+console.log('=== Basic Operations ===');
+console.log(`Addition: 5 + 3 = ${calc.add(5, 3)}`);
+console.log(`Subtraction: 10 - 4 = ${calc.subtract(10, 4)}`);
+console.log(`Multiplication: 6 * 7 = ${calc.multiply(6, 7)}`);
+console.log(`Division: 15 / 3 = ${calc.divide(15, 3)}`);
+console.log(`Power: 2^8 = ${calc.power(2, 8)}`);
+console.log(`Square Root: √64 = ${calc.sqrt(64)}`);
+console.log(`Factorial: 5! = ${calc.factorial(5)}`);
+console.log(`Percentage: 25 is what percent of 200 = ${calc.percentage(25, 200)}%`);
+
+// Chained calculations
+console.log('\n=== Chained Calculations ===');
+const result1 = calc.chain(10)
+  .add(5)
+  .multiply(2)
+  .subtract(10)
+  .divide(4)
+  .equals();
+
+console.log(`((10 + 5) * 2 - 10) / 4 = ${result1}`);
+
+// More complex chained calculation
+const result2 = calc.chain(2)
+  .power(3)
+  .add(1)
+  .multiply(2)
+  .sqrt()
+  .equals();
+
+console.log(`√(((2^3) + 1) * 2) = ${result2}`);
+
+// Getting intermediate values
+console.log('\n=== Intermediate Values ===');
+const chain = calc.chain(100)
+  .subtract(20)  // 80
+  .divide(4)     // 20
+  .add(5);       // 25
+
+console.log(`Intermediate result: ${chain.value()}`);
+
+const finalResult = chain.multiply(2).equals(); // 50
+console.log(`Final result: ${finalResult}`);
+
+// Error handling examples
+console.log('\n=== Error Handling ===');
+try {
+  calc.divide(10, 0);
+} catch (error) {
+  console.log(`Error caught: ${error.message}`);
+}
+
+try {
+  calc.sqrt(-1);
+} catch (error) {
+  console.log(`Error caught: ${error.message}`);
+}
+
+try {
+  calc.chain(10).divide(0);
+} catch (error) {
+  console.log(`Error caught: ${error.message}`);
+}

package/examples/encryption-example.js

@@ -0,0 +1,67 @@
+/**
+ * Example usage of the encryption functions
+ */
+
+const { encryptData, decryptData, generateKey } = require('../src/utils');
+
+// Generate a secure key (in production, use a proper key management system)
+const secretKey = generateKey();
+
+console.log('Data Encryption Example');
+console.log('=====================');
+
+// Data to encrypt
+const plaintext = "This is confidential information that needs to be protected.";
+
+console.log('Original data:', plaintext);
+
+try {
+  // Encrypt the data
+  const encryptedObj = encryptData(plaintext, secretKey);
+  console.log('\nEncrypted data:');
+  console.log('Encrypted:', encryptedObj.encryptedData);
+  console.log('IV:', encryptedObj.iv);
+  console.log('Auth Tag:', encryptedObj.authTag);
+
+  // Decrypt the data
+  const decrypted = decryptData(encryptedObj, secretKey);
+  console.log('\nDecrypted data:', decrypted);
+  
+  // Verify data integrity
+  console.log('\nData integrity check:', plaintext === decrypted ? 'PASS' : 'FAIL');
+  
+} catch (error) {
+  console.error('Encryption/decryption failed:', error.message);
+}
+
+// Example with different data types
+console.log('\n\nExample with different data types:');
+console.log('---------------------------------');
+
+// Working with buffers
+const bufferData = Buffer.from('Binary data to encrypt', 'utf8');
+console.log('Buffer data to encrypt:', bufferData.toString('utf8'));
+
+try {
+  const encryptedBuffer = encryptData(bufferData, secretKey);
+  const decryptedBuffer = decryptData(encryptedBuffer, secretKey);
+  console.log('Decrypted buffer data:', decryptedBuffer);
+} catch (error) {
+  console.error('Buffer encryption failed:', error.message);
+}
+
+// Working with Unicode characters
+console.log('\nUnicode example:');
+const unicodeData = "Hello, 世界! 🌍 Welcome to 数据加密!";
+console.log('Unicode data to encrypt:', unicodeData);
+
+try {
+  const encryptedUnicode = encryptData(unicodeData, secretKey);
+  const decryptedUnicode = decryptData(encryptedUnicode, secretKey);
+  console.log('Decrypted unicode data:', decryptedUnicode);
+  console.log('Unicode integrity check:', unicodeData === decryptedUnicode ? 'PASS' : 'FAIL');
+} catch (error) {
+  console.error('Unicode encryption failed:', error.message);
+}
+
+console.log('\nExample completed.');

package/examples/json-parser-example.js

@@ -0,0 +1,120 @@
+/**
+ * Example usage of the parseAndValidateJSON function
+ */
+
+const { parseAndValidateJSON } = require('../src/utils');
+
+// Example 1: Simple JSON parsing without validation
+console.log('=== Example 1: Simple JSON parsing ===');
+try {
+  const jsonString = '{"name": "Alice", "age": 25, "city": "Boston"}';
+  const data = parseAndValidateJSON(jsonString);
+  console.log('Parsed data:', data);
+} catch (error) {
+  console.error('Error:', error.message);
+}
+
+// Example 2: JSON parsing with schema validation
+console.log('\n=== Example 2: JSON parsing with schema validation ===');
+try {
+  const jsonString = '{"username": "bob", "email": "bob@example.com", "age": 30}';
+  
+  // Define a schema for validation
+  const userSchema = {
+    required: ["username", "email"],
+    properties: {
+      username: { 
+        type: "string",
+        minLength: 3,
+        maxLength: 20
+      },
+      email: { 
+        type: "string" 
+      },
+      age: { 
+        type: "number", 
+        minimum: 0, 
+        maximum: 120 
+      }
+    }
+  };
+  
+  const data = parseAndValidateJSON(jsonString, userSchema);
+  console.log('Validated data:', data);
+} catch (error) {
+  console.error('Error:', error.message);
+}
+
+// Example 3: Handling validation errors
+console.log('\n=== Example 3: Handling validation errors ===');
+try {
+  const invalidJsonString = '{"username": "c", "email": "charlie@", "age": -5}';
+  
+  const userSchema = {
+    required: ["username", "email", "age"],
+    properties: {
+      username: { 
+        type: "string",
+        minLength: 3,  // This will fail since "c" has length 1
+        maxLength: 20
+      },
+      email: { 
+        type: "string" 
+      },
+      age: { 
+        type: "number", 
+        minimum: 0,  // This will fail since -5 < 0
+        maximum: 120 
+      }
+    }
+  };
+  
+  const data = parseAndValidateJSON(invalidJsonString, userSchema);
+  console.log('Validated data:', data);
+} catch (error) {
+  console.error('Validation Error:', error.message);
+}
+
+// Example 4: Working with arrays and nested objects
+console.log('\n=== Example 4: Arrays and nested objects ===');
+try {
+  const jsonString = `{
+    "id": 1,
+    "name": "Product A",
+    "tags": ["electronics", "gadgets"],
+    "metadata": {
+      "createdBy": "admin",
+      "createdAt": "2023-01-01"
+    }
+  }`;
+  
+  const productSchema = {
+    required: ["id", "name"],
+    properties: {
+      id: { 
+        type: "number" 
+      },
+      name: { 
+        type: "string" 
+      },
+      tags: { 
+        type: "array", 
+        items: { type: "string" },
+        minItems: 1
+      },
+      metadata: {
+        type: "object",
+        properties: {
+          createdBy: { type: "string" },
+          createdAt: { type: "string" }
+        },
+        required: ["createdBy", "createdAt"]
+      }
+    }
+  };
+  
+  const data = parseAndValidateJSON(jsonString, productSchema);
+  console.log('Complex validated data:', data);
+} catch (error) {
+  console.error('Error:', error.message);
+}