stigmergy 1.0.94 → 1.0.95

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/json-validation-example.js

@@ -0,0 +1,64 @@
+// Example usage of parseAndValidateJSON function
+
+const { parseAndValidateJSON } = require('../src/utils');
+
+// Example 1: Basic JSON parsing
+console.log('=== Example 1: Basic JSON Parsing ===');
+try {
+  const jsonData = '{"name": "Alice", "age": 25, "city": "New York"}';
+  const parsed = parseAndValidateJSON(jsonData);
+  console.log('Parsed data:', parsed);
+} 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 jsonData = '{"id": 123, "name": "Bob", "email": "bob@example.com", "active": true}';
+  
+  // Define a schema for validation
+  const userSchema = {
+    required: ['id', 'name', 'email'],
+    properties: {
+      id: { type: 'number' },
+      name: { type: 'string' },
+      email: { type: 'string' },
+      active: { type: 'boolean' }
+    }
+  };
+  
+  const validatedData = parseAndValidateJSON(jsonData, userSchema);
+  console.log('Validated data:', validatedData);
+} catch (error) {
+  console.error('Error:', error.message);
+}
+
+// Example 3: Handling invalid JSON
+console.log('\n=== Example 3: Handling Invalid JSON ===');
+try {
+  const invalidJson = '{"name": "Charlie", "age":}';
+  const result = parseAndValidateJSON(invalidJson);
+  console.log('Result:', result);
+} catch (error) {
+  console.error('Error:', error.message);
+}
+
+// Example 4: Handling schema validation errors
+console.log('\n=== Example 4: Handling Schema Validation Errors ===');
+try {
+  const jsonData = '{"name": "David", "age": "thirty"}'; // age should be a number
+  
+  const schema = {
+    required: ['name', 'age'],
+    properties: {
+      name: { type: 'string' },
+      age: { type: 'number' }
+    }
+  };
+  
+  const result = parseAndValidateJSON(jsonData, schema);
+  console.log('Result:', result);
+} catch (error) {
+  console.error('Error:', error.message);
+}

package/examples/rest-client-example.js

@@ -0,0 +1,52 @@
+// Example usage of the RESTClient class
+
+const { RESTClient } = require('../src/utils');
+
+// Create a new REST client instance
+const client = new RESTClient('https://jsonplaceholder.typicode.com');
+
+// Example 1: GET request
+async function getPost() {
+  try {
+    const response = await client.get('/posts/1');
+    console.log('Post Title:', response.data.title);
+  } catch (error) {
+    console.error('Error fetching post:', error.message);
+  }
+}
+
+// Example 2: POST request
+async function createPost() {
+  try {
+    const newPost = {
+      title: 'My New Post',
+      body: 'This is the content of my new post',
+      userId: 1
+    };
+    
+    const response = await client.post('/posts', newPost);
+    console.log('Created Post ID:', response.data.id);
+  } catch (error) {
+    console.error('Error creating post:', error.message);
+  }
+}
+
+// Example 3: Using custom headers
+async function getRequestWithHeaders() {
+  try {
+    const clientWithAuth = new RESTClient('https://jsonplaceholder.typicode.com', {
+      'Authorization': 'Bearer your-token-here',
+      'X-Custom-Header': 'custom-value'
+    });
+    
+    const response = await clientWithAuth.get('/users/1');
+    console.log('User Name:', response.data.name);
+  } catch (error) {
+    console.error('Error fetching user:', error.message);
+  }
+}
+
+// Run the examples
+getPost();
+createPost();
+getRequestWithHeaders();

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "stigmergy",
-  "version": "1.0.94",
+  "version": "1.0.95",
   "description": "Stigmergy CLI - Multi-Agents Cross-AI CLI Tools Collaboration System",
   "main": "src/main_english.js",
   "bin": {
@@ -8,9 +8,12 @@
   },
   "scripts": {
     "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",
+    "test": "jest",
+    "test:unit": "jest tests/unit",
+    "test:integration": "jest tests/integration",
+    "test:e2e": "jest tests/e2e",
+    "coverage": "jest --coverage",
+    "test:watch": "jest --watch",
     "build": "node scripts/build.js",
     "deploy": "node src/deploy.js",
     "status": "node src/index.js status",
@@ -69,29 +72,30 @@
     "node": ">=16.0.0"
   },
   "dependencies": {
+    "chalk": "^4.1.2",
+    "child_process": "^1.0.2",
+    "chokidar": "^3.5.3",
     "commander": "^12.0.0",
+    "crypto": "^1.0.1",
+    "events": "^3.3.0",
+    "figures": "^3.2.0",
+    "fs-extra": "^11.1.1",
+    "glob": "^10.3.10",
     "inquirer": "^8.2.6",
-    "chalk": "^4.1.2",
     "js-yaml": "^4.1.0",
     "node-fetch": "^2.6.7",
-    "child_process": "^1.0.2",
-    "fs-extra": "^11.1.1",
-    "path": "^0.12.7",
+    "ora": "^5.4.1",
     "os": "^0.1.2",
-    "crypto": "^1.0.1",
-    "events": "^3.3.0",
-    "util": "^0.12.5",
+    "path": "^0.12.7",
     "semver": "^7.5.4",
-    "glob": "^10.3.10",
-    "chokidar": "^3.5.3",
     "table": "^6.8.1",
-    "figures": "^3.2.0",
-    "ora": "^5.4.1"
+    "util": "^0.12.5"
   },
   "devDependencies": {
     "eslint": "^8.50.0",
-    "prettier": "^3.0.3",
-    "nodemon": "^3.0.1"
+    "jest": "^30.2.0",
+    "nodemon": "^3.0.1",
+    "prettier": "^3.0.3"
   },
   "config": {
     "encoding": "ansi",

package/scripts/post-deployment-config.js

@@ -63,9 +63,16 @@ class PostDeploymentConfigurer {
     // Check if an installation script exists
     async checkInstallScript(toolName) {
         const tool = CLI_TOOLS[toolName];
-        if (!tool) return false;
+        if (!tool) return { exists: false, path: '' };
+        
+        // Mapping for tool names that don't match their adapter directory names
+        const toolNameToAdapterDir = {
+            'qodercli': 'qoder',
+            'qwencode': 'qwen'
+        };
+        const adapterDirName = toolNameToAdapterDir[toolName] || toolName;
+        const scriptPath = path.join(this.stigmergyAssetsDir, adapterDirName, tool.installScript);
         
-        const scriptPath = path.join(this.stigmergyAssetsDir, toolName, tool.installScript);
         try {
             await fs.access(scriptPath);
             return { exists: true, path: scriptPath };

package/src/auth.js

@@ -0,0 +1,171 @@
+/**
+ * Authentication module for the Stigmergy CLI system.
+ * Provides user authentication functionality including password hashing and token management.
+ */
+
+const crypto = require('crypto');
+
+/**
+ * Custom exception for authentication failures.
+ */
+class AuthenticationError extends Error {
+  constructor(message) {
+    super(message);
+    this.name = 'AuthenticationError';
+  }
+}
+
+/**
+ * Handles user authentication operations including registration, login, and session management.
+ */
+class UserAuthenticator {
+  /**
+   * Create a new UserAuthenticator instance.
+   */
+  constructor() {
+    // In production, this would be stored in a secure database
+    this._users = new Map();
+    this._sessions = new Map();
+  }
+
+  /**
+   * Register a new user with the provided username and password.
+   * 
+   * @param {string} username - The user's username
+   * @param {string} password - The user's password
+   * @returns {boolean} True if registration successful, false if username already exists
+   * @throws {Error} If username or password is invalid
+   */
+  registerUser(username, password) {
+    if (!username || !password) {
+      throw new Error('Username and password cannot be empty');
+    }
+
+    if (username.length < 3) {
+      throw new Error('Username must be at least 3 characters long');
+    }
+
+    if (password.length < 8) {
+      throw new Error('Password must be at least 8 characters long');
+    }
+
+    if (this._users.has(username)) {
+      return false;
+    }
+
+    // Hash the password with a salt
+    const salt = crypto.randomBytes(16).toString('hex');
+    const passwordHash = this._hashPassword(password, salt);
+
+    this._users.set(username, {
+      passwordHash: passwordHash,
+      salt: salt
+    });
+
+    return true;
+  }
+
+  /**
+   * Authenticate a user with the provided credentials.
+   * 
+   * @param {string} username - The user's username
+   * @param {string} password - The user's password
+   * @returns {string} Session token if authentication is successful
+   * @throws {AuthenticationError} If authentication fails
+   */
+  authenticateUser(username, password) {
+    if (!this._users.has(username)) {
+      throw new AuthenticationError('Invalid username or password');
+    }
+
+    const userData = this._users.get(username);
+    const passwordHash = this._hashPassword(password, userData.salt);
+
+    if (passwordHash !== userData.passwordHash) {
+      throw new AuthenticationError('Invalid username or password');
+    }
+
+    // Generate session token
+    const sessionToken = crypto.randomBytes(32).toString('base64url');
+    this._sessions.set(sessionToken, {
+      username: username,
+      createdAt: Date.now()
+    });
+
+    return sessionToken;
+  }
+
+  /**
+   * Validate a session token and return the associated username.
+   * 
+   * @param {string} sessionToken - The session token to validate
+   * @returns {string|null} Username if session is valid, null otherwise
+   */
+  validateSession(sessionToken) {
+    if (!this._sessions.has(sessionToken)) {
+      return null;
+    }
+
+    // In production, you would check session expiration here
+    return this._sessions.get(sessionToken).username;
+  }
+
+  /**
+   * Invalidate a session token.
+   * 
+   * @param {string} sessionToken - The session token to invalidate
+   * @returns {boolean} True if session was invalidated, false if token was not found
+   */
+  logout(sessionToken) {
+    if (this._sessions.has(sessionToken)) {
+      this._sessions.delete(sessionToken);
+      return true;
+    }
+    return false;
+  }
+
+  /**
+   * Hash a password with the provided salt using PBKDF2.
+   * 
+   * @param {string} password - The password to hash
+   * @param {string} salt - The salt to use for hashing
+   * @returns {string} The hashed password
+   * @private
+   */
+  _hashPassword(password, salt) {
+    return crypto.pbkdf2Sync(
+      password,
+      salt,
+      100000, // iterations
+      32, // key length
+      'sha256' // digest
+    ).toString('hex');
+  }
+}
+
+/**
+ * Helper function to authenticate a user and return a session token.
+ * 
+ * @param {UserAuthenticator} authenticator - The authenticator instance
+ * @param {string} username - The user's username
+ * @param {string} password - The user's password
+ * @returns {[boolean, string]} A tuple containing success status and message/token
+ */
+function authenticateAndGetToken(authenticator, username, password) {
+  try {
+    const token = authenticator.authenticateUser(username, password);
+    return [true, token];
+  } catch (error) {
+    if (error instanceof AuthenticationError) {
+      return [false, error.message];
+    } else {
+      return [false, `Authentication error: ${error.message}`];
+    }
+  }
+}
+
+module.exports = {
+  UserAuthenticator,
+  AuthenticationError,
+  authenticateAndGetToken
+};

package/src/auth_command.js

@@ -0,0 +1,195 @@
+/**
+ * Authentication command handler for the Stigmergy CLI.
+ * Provides CLI commands for user registration, login, and session management.
+ */
+
+const fs = require('fs');
+const path = require('path');
+const { UserAuthenticator, authenticateAndGetToken } = require('./auth');
+
+/**
+ * Get the path to the authentication data file.
+ * @returns {string} Path to the auth data file
+ */
+function getAuthDataPath() {
+  const homeDir = process.env.HOME || process.env.USERPROFILE;
+  const configDir = path.join(homeDir, '.stigmergy');
+  
+  // Create config directory if it doesn't exist
+  if (!fs.existsSync(configDir)) {
+    fs.mkdirSync(configDir, { recursive: true });
+  }
+  
+  return path.join(configDir, 'auth.json');
+}
+
+/**
+ * Load authentication data from file.
+ * @param {UserAuthenticator} authenticator - The authenticator instance
+ */
+function loadAuthData(authenticator) {
+  try {
+    const authFile = getAuthDataPath();
+    if (fs.existsSync(authFile)) {
+      const data = JSON.parse(fs.readFileSync(authFile, 'utf8'));
+      
+      // Load users
+      if (data.users) {
+        for (const [username, userData] of Object.entries(data.users)) {
+          authenticator._users.set(username, userData);
+        }
+      }
+      
+      // Load sessions
+      if (data.sessions) {
+        for (const [token, sessionData] of Object.entries(data.sessions)) {
+          authenticator._sessions.set(token, sessionData);
+        }
+      }
+    }
+  } catch (error) {
+    console.warn('[WARN] Could not load authentication data:', error.message);
+  }
+}
+
+/**
+ * Save authentication data to file.
+ * @param {UserAuthenticator} authenticator - The authenticator instance
+ */
+function saveAuthData(authenticator) {
+  try {
+    const authFile = getAuthDataPath();
+    
+    // Convert Maps to objects for JSON serialization
+    const users = {};
+    for (const [username, userData] of authenticator._users.entries()) {
+      users[username] = userData;
+    }
+    
+    const sessions = {};
+    for (const [token, sessionData] of authenticator._sessions.entries()) {
+      sessions[token] = sessionData;
+    }
+    
+    const data = {
+      users,
+      sessions
+    };
+    
+    fs.writeFileSync(authFile, JSON.stringify(data, null, 2));
+  } catch (error) {
+    console.warn('[WARN] Could not save authentication data:', error.message);
+  }
+}
+
+/**
+ * Handle user registration.
+ * @param {string} username - The username to register
+ * @param {string} password - The password for the user
+ */
+function handleRegister(username, password) {
+  const authenticator = new UserAuthenticator();
+  loadAuthData(authenticator);
+  
+  try {
+    const success = authenticator.registerUser(username, password);
+    if (success) {
+      saveAuthData(authenticator);
+      console.log(`[SUCCESS] User '${username}' registered successfully`);
+    } else {
+      console.log(`[ERROR] Username '${username}' already exists`);
+      process.exit(1);
+    }
+  } catch (error) {
+    console.log(`[ERROR] Registration failed: ${error.message}`);
+    process.exit(1);
+  }
+}
+
+/**
+ * Handle user login.
+ * @param {string} username - The username to login
+ * @param {string} password - The password for the user
+ */
+function handleLogin(username, password) {
+  const authenticator = new UserAuthenticator();
+  loadAuthData(authenticator);
+  
+  const [success, result] = authenticateAndGetToken(authenticator, username, password);
+  
+  if (success) {
+    const token = result;
+    saveAuthData(authenticator);
+    
+    // Also save the token to a session file for easy access
+    const sessionFile = path.join(path.dirname(getAuthDataPath()), 'session.token');
+    fs.writeFileSync(sessionFile, token);
+    
+    console.log(`[SUCCESS] Login successful`);
+    console.log(`Session token: ${token}`);
+  } else {
+    console.log(`[ERROR] Login failed: ${result}`);
+    process.exit(1);
+  }
+}
+
+/**
+ * Handle user logout.
+ */
+function handleLogout() {
+  const authenticator = new UserAuthenticator();
+  loadAuthData(authenticator);
+  
+  // Read the current session token
+  const sessionFile = path.join(path.dirname(getAuthDataPath()), 'session.token');
+  
+  if (!fs.existsSync(sessionFile)) {
+    console.log(`[ERROR] No active session found`);
+    process.exit(1);
+  }
+  
+  const token = fs.readFileSync(sessionFile, 'utf8').trim();
+  
+  const success = authenticator.logout(token);
+  if (success) {
+    saveAuthData(authenticator);
+    fs.unlinkSync(sessionFile); // Remove the session file
+    console.log(`[SUCCESS] Logged out successfully`);
+  } else {
+    console.log(`[ERROR] Logout failed: Invalid session`);
+    process.exit(1);
+  }
+}
+
+/**
+ * Check if user is authenticated.
+ */
+function handleStatus() {
+  const authenticator = new UserAuthenticator();
+  loadAuthData(authenticator);
+  
+  // Read the current session token
+  const sessionFile = path.join(path.dirname(getAuthDataPath()), 'session.token');
+  
+  if (!fs.existsSync(sessionFile)) {
+    console.log(`[INFO] No active session`);
+    return;
+  }
+  
+  const token = fs.readFileSync(sessionFile, 'utf8').trim();
+  const username = authenticator.validateSession(token);
+  
+  if (username) {
+    console.log(`[INFO] Authenticated as: ${username}`);
+  } else {
+    console.log(`[INFO] Session expired or invalid`);
+    fs.unlinkSync(sessionFile); // Remove the invalid session file
+  }
+}
+
+module.exports = {
+  handleRegister,
+  handleLogin,
+  handleLogout,
+  handleStatus
+};