stigmergy 1.2.0 → 1.2.8

package/src/test/test-environment.js

@@ -0,0 +1,289 @@
+/**
+ * Test Environment Isolation
+ * Creates isolated environment for testing without affecting user setup
+ */
+
+const fs = require('fs');
+const path = require('path');
+const os = require('os');
+const { spawn } = require('child_process');
+
+class TestEnvironment {
+  constructor(name = 'stigmergy-test') {
+    this.name = name;
+    this.baseDir = path.join(os.tmpdir(), name);
+    this.originalEnv = { ...process.env };
+    this.isSetup = false;
+  }
+
+  /**
+   * Setup isolated test environment
+   * @param {Object} options - Setup options
+   */
+  async setup(options = {}) {
+    const { clean = true } = options;
+
+    // Create base directory
+    if (clean && fs.existsSync(this.baseDir)) {
+      await this.cleanup();
+    }
+    fs.mkdirSync(this.baseDir, { recursive: true });
+
+    // Setup home directory
+    this.testHome = path.join(this.baseDir, 'home');
+    fs.mkdirSync(this.testHome, { recursive: true });
+
+    // Setup test configuration directories
+    this.configDirs = {
+      stigmergy: path.join(this.testHome, '.stigmergy'),
+      claude: path.join(this.testHome, '.claude'),
+      gemini: path.join(this.testHome, '.gemini'),
+      qwen: path.join(this.testHome, '.qwen'),
+      // Add more as needed
+    };
+
+    Object.values(this.configDirs).forEach(dir => {
+      fs.mkdirSync(dir, { recursive: true });
+    });
+
+    // Modify environment variables
+    process.env.HOME = this.testHome;
+    process.env.USERPROFILE = this.testHome; // Windows
+    process.env.PATH = this.createSafePath();
+
+    this.isSetup = true;
+  }
+
+  /**
+   * Create safe PATH with essential tools only
+   * @returns {string} Safe PATH
+   */
+  createSafePath() {
+    const essentialPaths = [
+      '/usr/bin',
+      '/usr/local/bin',
+      path.join(process.env.ProgramFiles || '', 'Git', 'bin'),
+      path.join(process.env.ProgramFiles || '', 'nodejs'),
+    ].filter(p => p && fs.existsSync(p));
+
+    return essentialPaths.join(path.delimiter);
+  }
+
+  /**
+   * Setup mock CLI tools for testing
+   * @param {Object} mockTools - Map of tool name to mock implementation
+   */
+  async setupMockCLIs(mockTools = {}) {
+    const mockBinDir = path.join(this.testHome, 'bin');
+    fs.mkdirSync(mockBinDir, { recursive: true });
+
+    // Add mock bin directory to PATH
+    process.env.PATH = `${mockBinDir}${path.delimiter}${process.env.PATH}`;
+
+    for (const [toolName, behavior] of Object.entries(mockTools)) {
+      await this.createMockCLI(toolName, behavior, mockBinDir);
+    }
+  }
+
+  /**
+   * Create a mock CLI tool
+   * @param {string} name - Tool name
+   * @param {Object} behavior - Mock behavior
+   * @param {string} binDir - Binary directory
+   */
+  async createMockCLI(name, behavior, binDir) {
+    const script = this.generateMockScript(name, behavior);
+    const scriptPath = path.join(binDir, name);
+
+    if (process.platform === 'win32') {
+      // Windows batch file
+      const batPath = scriptPath + '.cmd';
+      fs.writeFileSync(batPath, `@echo off\n${script}\n`, 'utf8');
+      // Make executable
+      fs.chmodSync(batPath, '755');
+    } else {
+      // Unix shell script
+      fs.writeFileSync(scriptPath, `#!/bin/bash\n${script}\n`, 'utf8');
+      // Make executable
+      fs.chmodSync(scriptPath, '755');
+    }
+  }
+
+  /**
+   * Generate mock script content
+   * @param {string} toolName - Tool name
+   * @param {Object} behavior - Mock behavior definition
+   * @returns {string} Script content
+   */
+  generateMockScript(toolName, behavior) {
+    const defaultBehavior = {
+      version: `${toolName} version 1.0.0-mock`,
+      success: true,
+      delay: 0,
+      output: `Mock ${toolName} executed successfully`
+    };
+
+    const config = { ...defaultBehavior, ...behavior };
+
+    let script = '';
+    if (config.delay > 0) {
+      script += `sleep ${config.delay}\n`;
+    }
+
+    // Handle version command
+    script += 'if echo "$*" | grep -q "\\-\\-version\\|-v"; then\n';
+    script += `  echo "${config.version}"\n`;
+    script += '  exit 0\n';
+    script += 'fi\n';
+
+    // Handle help command
+    script += 'if echo "$*" | grep -q "\\-\\-help\\|-h"; then\n';
+    script += `  echo "Mock ${toolName} help"\n`;
+    script += `  echo "Usage: ${toolName} [options]"\n`;
+    script += '  exit 0\n';
+    script += 'fi\n';
+
+    // Handle prompt flag
+    script += 'PROMPT=""\n';
+    script += 'for arg in "$@"; do\n';
+    script += '  if [[ "$arg" == "-p" ]]; then\n';
+    script += '    PROMPT="$1"\n';
+    script += '    shift\n';
+    script += '  fi\n';
+    script += '  shift\n';
+    script += 'done\n';
+
+    // Generate response
+    script += 'if [ -n "$PROMPT" ]; then\n';
+    script += '  echo "Mock response for: $PROMPT"\n';
+    script += `  echo "${config.output}"\n`;
+    script += 'else\n';
+    script += `  echo "${config.output}"\n`;
+    script += 'fi\n';
+
+    // Handle success/failure
+    script += config.success ? 'exit 0\n' : 'exit 1\n';
+
+    return script;
+  }
+
+  /**
+   * Execute command in isolated environment
+   * @param {string} command - Command to execute
+   * @param {Array} args - Command arguments
+   * @param {Object} options - Execution options
+   * @returns {Promise<Object>} Execution result
+   */
+  async execute(command, args = [], options = {}) {
+    if (!this.isSetup) {
+      throw new Error('Test environment not setup. Call setup() first.');
+    }
+
+    return new Promise((resolve) => {
+      let stdout = '';
+      let stderr = '';
+
+      const child = spawn(command, args, {
+        stdio: ['ignore', 'pipe', 'pipe'],
+        shell: true,
+        env: process.env, // Use modified environment
+        ...options
+      });
+
+      child.stdout?.on('data', (data) => {
+        stdout += data.toString();
+      });
+
+      child.stderr?.on('data', (data) => {
+        stderr += data.toString();
+      });
+
+      child.on('close', (code) => {
+        resolve({
+          success: code === 0,
+          stdout,
+          stderr,
+          exitCode: code
+        });
+      });
+
+      child.on('error', (error) => {
+        resolve({
+          success: false,
+          stdout,
+          stderr,
+          error: error.message
+        });
+      });
+    });
+  }
+
+  /**
+   * Create test data in environment
+   * @param {Object} testData - Test data structure
+   */
+  createTestData(testData = {}) {
+    for (const [filePath, content] of Object.entries(testData)) {
+      const fullPath = path.join(this.testHome, filePath);
+      const dir = path.dirname(fullPath);
+
+      // Create directory if it doesn't exist
+      if (!fs.existsSync(dir)) {
+        fs.mkdirSync(dir, { recursive: true });
+      }
+
+      // Write file
+      if (typeof content === 'object') {
+        fs.writeFileSync(fullPath, JSON.stringify(content, null, 2), 'utf8');
+      } else {
+        fs.writeFileSync(fullPath, content, 'utf8');
+      }
+    }
+  }
+
+  /**
+   * Restore original environment
+   */
+  restore() {
+    if (!this.isSetup) return;
+
+    // Restore environment variables
+    Object.keys(this.originalEnv).forEach(key => {
+      process.env[key] = this.originalEnv[key];
+    });
+
+    // Remove any additions
+    const addedKeys = Object.keys(process.env).filter(key => !this.originalEnv.hasOwnProperty(key));
+    addedKeys.forEach(key => {
+      delete process.env[key];
+    });
+
+    this.isSetup = false;
+  }
+
+  /**
+   * Cleanup test environment
+   */
+  async cleanup() {
+    this.restore();
+
+    try {
+      if (fs.existsSync(this.baseDir)) {
+        fs.rmSync(this.baseDir, { recursive: true, force: true });
+      }
+    } catch (error) {
+      console.warn(`Warning: Could not cleanup test directory: ${error.message}`);
+    }
+  }
+
+  /**
+   * Get path in test environment
+   * @param {...string} parts - Path parts
+   * @returns {string} Full path in test environment
+   */
+  getPath(...parts) {
+    return path.join(this.testHome, ...parts);
+  }
+}
+
+module.exports = TestEnvironment;

package/src/utils/helpers.js

@@ -31,5 +31,5 @@ function isAuthenticated() {
 
 module.exports = {
   maxOfTwo,
-  isAuthenticated
-};
+  isAuthenticated,
+};

package/src/utils.js

@@ -678,6 +678,12 @@ async function executeCommand(command, args = [], options = {}) {
 
       const child = spawn(command, args, opts);
 
+      // Add debug logging for Windows command execution
+      if (process.platform === 'win32' && process.env.DEBUG === 'true') {
+        console.log(`[DEBUG] Spawned process with command: ${command}`);
+        console.log(`[DEBUG] Spawned process with args: ${JSON.stringify(args)}`);
+      }
+
       let stdout = '';
       let stderr = '';
 
@@ -912,4 +918,4 @@ module.exports = {
   encryptData,
   decryptData,
   generateKey,
-};
+};

package/test/multilingual/hook-deployment.test.js

@@ -0,0 +1,91 @@
+// test/multilingual/hook-deployment.test.js
+
+const fs = require('fs');
+const path = require('path');
+const os = require('os');
+const HookDeploymentManager = require('../../src/core/coordination/nodejs/HookDeploymentManager');
+
+describe('HookDeploymentManager Multilingual Support', () => {
+  let deploymentManager;
+  let tempDir;
+
+  beforeAll(() => {
+    // Create a temporary directory for testing
+    tempDir = fs.mkdtempSync(path.join(os.tmpdir(), 'stigmergy-test-'));
+    deploymentManager = new HookDeploymentManager();
+    deploymentManager.deploymentDir = tempDir;
+  });
+
+  afterAll(() => {
+    // Clean up temporary directory
+    if (fs.existsSync(tempDir)) {
+      fs.rmSync(tempDir, { recursive: true, force: true });
+    }
+  });
+
+  test('should initialize deployment manager', async () => {
+    await expect(deploymentManager.initialize()).resolves.toBeUndefined();
+    expect(fs.existsSync(tempDir)).toBe(true);
+  });
+
+  test('should deploy hooks with multilingual support', async () => {
+    const cliName = 'claude';
+    const result = await deploymentManager.deployHooksForCLI(cliName);
+    expect(result).toBe(true);
+    
+    // Check that the hook file was created
+    const hookDir = path.join(tempDir, cliName);
+    const hookFile = path.join(hookDir, `${cliName}_nodejs_hook.js`);
+    const configFile = path.join(hookDir, 'config.json');
+    
+    expect(fs.existsSync(hookDir)).toBe(true);
+    expect(fs.existsSync(hookFile)).toBe(true);
+    expect(fs.existsSync(configFile)).toBe(true);
+    
+    // Check that the hook file contains multilingual support
+    const hookContent = fs.readFileSync(hookFile, 'utf8');
+    expect(hookContent).toContain('LanguagePatternManager');
+    expect(hookContent).toContain('detectCrossCLIRequest');
+    
+    // Check that the hook file contains patterns for multiple languages
+    expect(hookContent).toContain('请用');
+    expect(hookContent).toContain('使って');
+    expect(hookContent).toContain('benutze');
+    expect(hookContent).toContain('utilise');
+    expect(hookContent).toContain('usa');
+    expect(hookContent).toContain('usa'); // Italian
+    expect(hookContent).toContain('use'); // Portuguese
+    expect(hookContent).toContain('используй'); // Russian
+    expect(hookContent).toContain('استخدم'); // Arabic
+    expect(hookContent).toContain('kullanarak'); // Turkish
+    expect(hookContent).toContain('utiliser'); // French
+    expect(hookContent).toContain('usar'); // Spanish
+    expect(hookContent).toContain('utilizzare'); // Italian
+    expect(hookContent).toContain('verwenden'); // German
+    expect(hookContent).toContain('使う'); // Japanese
+  });
+
+  test('should validate hook deployment', async () => {
+    const cliName = 'gemini';
+    await deploymentManager.deployHooksForCLI(cliName);
+    
+    const validationResult = await deploymentManager.validateHookDeployment(cliName);
+    expect(validationResult.valid).toBe(true);
+    expect(validationResult.message).toBe('Hook deployment is valid');
+  });
+
+  test('should list deployed hooks', async () => {
+    const hooks = await deploymentManager.listDeployedHooks();
+    expect(Array.isArray(hooks)).toBe(true);
+    expect(hooks.length).toBeGreaterThanOrEqual(1);
+  });
+
+  test('should undeploy hooks', async () => {
+    const cliName = 'claude';
+    const result = await deploymentManager.undeployHooksForCLI(cliName);
+    expect(result).toBe(true);
+    
+    const hookDir = path.join(tempDir, cliName);
+    expect(fs.existsSync(hookDir)).toBe(false);
+  });
+});

package/test/multilingual/language-pattern-manager.test.js

@@ -0,0 +1,140 @@
+// test/multilingual/language-pattern-manager.test.js
+
+const LanguagePatternManager = require('../../src/core/multilingual/language-pattern-manager');
+
+describe('LanguagePatternManager', () => {
+  let manager;
+
+  beforeEach(() => {
+    manager = new LanguagePatternManager();
+  });
+
+  test('should load language patterns correctly', () => {
+    expect(manager.languagePatterns).toBeDefined();
+    expect(Object.keys(manager.languagePatterns).length).toBeGreaterThan(0);
+  });
+
+  test('should detect English patterns', () => {
+    const result = manager.detectCrossCLIRequest('use claude to write code');
+    expect(result).toBeDefined();
+    expect(result.targetCLI).toBe('claude');
+    expect(result.task).toBe('write code');
+    expect(result.language).toBe('en');
+  });
+
+  test('should detect Chinese patterns', () => {
+    const result = manager.detectCrossCLIRequest('请用copilot帮我创建React组件');
+    expect(result).toBeDefined();
+    expect(result.targetCLI).toBe('copilot');
+    expect(result.task).toBe('创建React组件');
+    expect(result.language).toBe('zh');
+  });
+
+  test('should detect Japanese patterns', () => {
+    const result = manager.detectCrossCLIRequest('claudeを使ってコードを書いて関数を作成');
+    expect(result).toBeDefined();
+    expect(result.targetCLI).toBe('claude');
+    expect(result.task).toBe('関数を作成');
+    expect(result.language).toBe('ja');
+  });
+
+  test('should detect Korean patterns', () => {
+    const result = manager.detectCrossCLIRequest('claude로 코드 작성해 줘함수를 만들어');
+    expect(result).toBeDefined();
+    expect(result.targetCLI).toBe('claude');
+    expect(result.task).toBe('함수를 만들어');
+    expect(result.language).toBe('ko');
+  });
+
+  test('should detect German patterns', () => {
+    const result = manager.detectCrossCLIRequest('benutze claude um code zu schreiben');
+    expect(result).toBeDefined();
+    expect(result.targetCLI).toBe('claude');
+    expect(result.task).toBe('code zu schreiben');
+    expect(result.language).toBe('de');
+  });
+
+  test('should detect French patterns', () => {
+    const result = manager.detectCrossCLIRequest('utilise claude pour écrire du code');
+    expect(result).toBeDefined();
+    expect(result.targetCLI).toBe('claude');
+    expect(result.task).toBe('écrire du code');
+    expect(result.language).toBe('fr');
+  });
+
+  test('should detect Spanish patterns', () => {
+    const result = manager.detectCrossCLIRequest('usa claude para escribir código');
+    expect(result).toBeDefined();
+    expect(result.targetCLI).toBe('claude');
+    expect(result.task).toBe('escribir código');
+    expect(result.language).toBe('es');
+  });
+
+  test('should detect Italian patterns', () => {
+    const result = manager.detectCrossCLIRequest('usa claude per scrivere codice');
+    expect(result).toBeDefined();
+    expect(result.targetCLI).toBe('claude');
+    expect(result.task).toBe('scrivere codice');
+    expect(result.language).toBe('it');
+  });
+
+  test('should detect Portuguese patterns', () => {
+    const result = manager.detectCrossCLIRequest('use claude para escrever código');
+    expect(result).toBeDefined();
+    expect(result.targetCLI).toBe('claude');
+    expect(result.task).toBe('escrever código');
+    expect(result.language).toBe('pt');
+  });
+
+  test('should detect Russian patterns', () => {
+    const result = manager.detectCrossCLIRequest('используй claude чтобы написать код');
+    expect(result).toBeDefined();
+    expect(result.targetCLI).toBe('claude');
+    expect(result.task).toBe('написать код');
+    expect(result.language).toBe('ru');
+  });
+
+  test('should detect Arabic patterns', () => {
+    const result = manager.detectCrossCLIRequest('استخدم claude لكتابة الكود');
+    expect(result).toBeDefined();
+    expect(result.targetCLI).toBe('claude');
+    expect(result.task).toBe('كتابة الكود');
+    expect(result.language).toBe('ar');
+  });
+
+  test('should detect Turkish patterns', () => {
+    const result = manager.detectCrossCLIRequest('claude kullanarak kod yaz bir fonksiyon');
+    expect(result).toBeDefined();
+    expect(result.targetCLI).toBe('claude');
+    expect(result.task).toBe('kod yaz bir fonksiyon');
+    expect(result.language).toBe('tr');
+  });
+
+  test('should return null for unsupported CLI tools', () => {
+    const result = manager.detectCrossCLIRequest('use nonexistenttool to do something');
+    expect(result).toBeNull();
+  });
+
+  test('should return null for non-cross-CLI requests', () => {
+    const result = manager.detectCrossCLIRequest('just a regular prompt');
+    expect(result).toBeNull();
+  });
+
+  test('should get patterns for specific language', () => {
+    const patterns = manager.getPatterns('en');
+    expect(Array.isArray(patterns)).toBe(true);
+    expect(patterns.length).toBeGreaterThan(0);
+  });
+
+  test('should get all patterns', () => {
+    const allPatterns = manager.getAllPatterns();
+    expect(allPatterns).toBeDefined();
+    expect(Object.keys(allPatterns).length).toBeGreaterThan(0);
+  });
+
+  test('should detect language from environment', () => {
+    const language = manager.detectLanguage();
+    expect(typeof language).toBe('string');
+    expect(language.length).toBeGreaterThan(0);
+  });
+});

package/test/multilingual/system-test.js

@@ -0,0 +1,85 @@
+#!/usr/bin/env node
+
+/**
+ * Simple test to verify the multilingual hook system works
+ */
+
+const fs = require('fs');
+const path = require('path');
+
+console.log('Testing Multilingual Hook System...\n');
+
+// Check if required files exist
+const requiredFiles = [
+  '../../src/core/multilingual/language-pattern-manager.js',
+  '../../.qoder/specs/multilingual-hook-system/language-patterns/english.js',
+  '../../.qoder/specs/multilingual-hook-system/language-patterns/chinese.js',
+  '../../.qoder/specs/multilingual-hook-system/language-patterns/japanese.js',
+  '../../.qoder/specs/multilingual-hook-system/language-patterns/korean.js',
+  '../../.qoder/specs/multilingual-hook-system/language-patterns/german.js',
+  '../../.qoder/specs/multilingual-hook-system/language-patterns/french.js',
+  '../../.qoder/specs/multilingual-hook-system/language-patterns/spanish.js',
+  '../../.qoder/specs/multilingual-hook-system/language-patterns/italian.js',
+  '../../.qoder/specs/multilingual-hook-system/language-patterns/portuguese.js',
+  '../../.qoder/specs/multilingual-hook-system/language-patterns/russian.js',
+  '../../.qoder/specs/multilingual-hook-system/language-patterns/arabic.js',
+  '../../.qoder/specs/multilingual-hook-system/language-patterns/turkish.js'
+];
+
+let allFilesExist = true;
+
+requiredFiles.forEach(file => {
+  const fullPath = path.join(__dirname, file);
+  if (fs.existsSync(fullPath)) {
+    console.log(`✓ ${file} exists`);
+  } else {
+    console.log(`✗ ${file} missing`);
+    allFilesExist = false;
+  }
+});
+
+if (allFilesExist) {
+  console.log('\n✓ All required files are present');
+  
+  // Try to load the LanguagePatternManager
+  try {
+    const LanguagePatternManager = require('../../src/core/multilingual/language-pattern-manager');
+    const manager = new LanguagePatternManager();
+    
+    console.log('✓ LanguagePatternManager loaded successfully');
+    
+    // Test English pattern matching
+    const englishResult = manager.detectCrossCLIRequest('use claude to write code');
+    if (englishResult && englishResult.targetCLI === 'claude') {
+      console.log('✓ English pattern matching works');
+    } else {
+      console.log('✗ English pattern matching failed');
+    }
+    
+    // Test Chinese pattern matching
+    const chineseResult = manager.detectCrossCLIRequest('请用copilot帮我创建React组件');
+    if (chineseResult && chineseResult.targetCLI === 'copilot') {
+      console.log('✓ Chinese pattern matching works');
+    } else {
+      console.log('✗ Chinese pattern matching failed');
+    }
+    
+    // Test Japanese pattern matching
+    const japaneseResult = manager.detectCrossCLIRequest('claudeを使ってコードを書いて関数を作成');
+    if (japaneseResult && japaneseResult.targetCLI === 'claude') {
+      console.log('✓ Japanese pattern matching works');
+    } else {
+      console.log('✗ Japanese pattern matching failed');
+    }
+    
+    console.log('\n🎉 Multilingual Hook System is ready!');
+    console.log('\nTo deploy multilingual hooks, run:');
+    console.log('  stigmergy deploy');
+    
+  } catch (error) {
+    console.log(`✗ Failed to load LanguagePatternManager: ${error.message}`);
+  }
+} else {
+  console.log('\n✗ Some required files are missing');
+  process.exit(1);
+}