stigmergy 1.2.6 → 1.2.8

package/src/weatherProcessor.js

@@ -1,228 +1,228 @@
-/**
- * Weather Data Processing Module
- *
- * This module provides functions for processing weather data from various sources
- * and converting it into standardized formats for analysis and display.
- */
-
-/**
- * Process raw weather data and generate standardized output
- * @param {Object} rawData - Raw weather data from API or sensor
- * @param {Object} options - Processing options
- * @param {string} options.unit - Temperature unit ('celsius', 'fahrenheit', 'kelvin')
- * @param {boolean} options.includeForecasts - Whether to include forecast data
- * @param {number} options.forecastDays - Number of forecast days to include (1-7)
- * @returns {Object} Processed weather data with standardized format
- * @throws {Error} If input data is invalid or missing required fields
- */
-function processWeatherData(rawData, options = {}) {
-  // Validate input
-  if (!rawData || typeof rawData !== 'object') {
-    throw new Error('Invalid weather data: must be an object');
-  }
-
-  // Default options
-  const opts = {
-    unit: 'celsius',
-    includeForecasts: false,
-    forecastDays: 5,
-    ...options,
-  };
-
-  // Validate options
-  if (!['celsius', 'fahrenheit', 'kelvin'].includes(opts.unit)) {
-    throw new Error(
-      'Invalid unit: must be "celsius", "fahrenheit", or "kelvin"',
-    );
-  }
-
-  if (opts.forecastDays < 1 || opts.forecastDays > 7) {
-    throw new Error('Invalid forecastDays: must be between 1 and 7');
-  }
-
-  // Process current weather data
-  const processedData = {
-    timestamp: new Date().toISOString(),
-    location: _extractLocation(rawData),
-    current: _processCurrentWeather(rawData.current || rawData, opts.unit),
-    forecasts: opts.includeForecasts
-      ? _processForecastData(rawData.forecast || [], opts)
-      : [],
-  };
-
-  return processedData;
-}
-
-/**
- * Extract location information from raw data
- * @param {Object} data - Raw weather data
- * @returns {Object} Location information
- */
-function _extractLocation(data) {
-  // Handle various location formats from different APIs
-  if (data.location) {
-    return {
-      name: data.location.name || data.location.city || 'Unknown',
-      country: data.location.country || '',
-      coordinates: {
-        lat: data.location.lat || data.location.latitude || 0,
-        lon: data.location.lon || data.location.longitude || 0,
-      },
-    };
-  }
-
-  if (data.city) {
-    return {
-      name: data.city.name || data.city,
-      country: data.city.country || '',
-      coordinates: {
-        lat: data.city.coord?.lat || data.city.latitude || 0,
-        lon: data.city.coord?.lon || data.city.longitude || 0,
-      },
-    };
-  }
-
-  return {
-    name: 'Unknown',
-    country: '',
-    coordinates: { lat: 0, lon: 0 },
-  };
-}
-
-/**
- * Process current weather data
- * @param {Object} current - Current weather data
- * @param {string} unit - Temperature unit
- * @returns {Object} Processed current weather data
- */
-function _processCurrentWeather(current, unit) {
-  if (!current) {
-    return null;
-  }
-
-  // Convert temperature to requested unit
-  const temp = _convertTemperature(
-    current.temp || current.temperature || 0,
-    'kelvin',
-    unit,
-  );
-  const feelsLike = _convertTemperature(
-    current.feels_like || current.feelsLike || temp,
-    'kelvin',
-    unit,
-  );
-
-  return {
-    temperature: {
-      value: temp,
-      unit: unit,
-      feelsLike: feelsLike,
-    },
-    humidity: current.humidity || current.humididy || 0,
-    pressure: current.pressure || 0,
-    wind: {
-      speed: current.wind_speed || current.windSpeed || 0,
-      direction: current.wind_deg || current.windDirection || 0,
-    },
-    visibility: current.visibility || 0,
-    cloudiness: current.clouds || current.cloudiness || 0,
-    description:
-      current.description || current.weather?.[0]?.description || 'Unknown',
-    icon: current.icon || current.weather?.[0]?.icon || '',
-  };
-}
-
-/**
- * Process forecast data
- * @param {Array} forecasts - Array of forecast data
- * @param {Object} options - Processing options
- * @returns {Array} Processed forecast data
- */
-function _processForecastData(forecasts, options) {
-  if (!Array.isArray(forecasts)) {
-    return [];
-  }
-
-  // Limit forecasts to requested number of days
-  const limitedForecasts = forecasts.slice(0, options.forecastDays);
-
-  return limitedForecasts.map((forecast) => {
-    const date = forecast.dt
-      ? new Date(forecast.dt * 1000).toISOString().split('T')[0]
-      : forecast.date || new Date().toISOString().split('T')[0];
-
-    return {
-      date: date,
-      temperature: {
-        min: _convertTemperature(
-          forecast.temp?.min || forecast.min_temp || 0,
-          'kelvin',
-          options.unit,
-        ),
-        max: _convertTemperature(
-          forecast.temp?.max || forecast.max_temp || 0,
-          'kelvin',
-          options.unit,
-        ),
-        unit: options.unit,
-      },
-      humidity: forecast.humidity || 0,
-      pressure: forecast.pressure || 0,
-      wind: {
-        speed: forecast.wind_speed || forecast.windSpeed || 0,
-        direction: forecast.wind_deg || forecast.windDirection || 0,
-      },
-      precipitation: {
-        probability: forecast.pop || forecast.precipitation_probability || 0,
-        amount: forecast.rain || forecast.snow || 0,
-      },
-      description:
-        forecast.weather?.[0]?.description || forecast.description || 'Unknown',
-    };
-  });
-}
-
-/**
- * Convert temperature between units
- * @param {number} value - Temperature value
- * @param {string} fromUnit - Source unit ('celsius', 'fahrenheit', 'kelvin')
- * @param {string} toUnit - Target unit ('celsius', 'fahrenheit', 'kelvin')
- * @returns {number} Converted temperature value
- */
-function _convertTemperature(value, fromUnit, toUnit) {
-  if (fromUnit === toUnit) {
-    return value;
-  }
-
-  // Convert to Celsius first
-  let celsius;
-  switch (fromUnit) {
-  case 'celsius':
-    celsius = value;
-    break;
-  case 'fahrenheit':
-    celsius = ((value - 32) * 5) / 9;
-    break;
-  case 'kelvin':
-    celsius = value - 273.15;
-    break;
-  default:
-    celsius = value;
-  }
-
-  // Convert from Celsius to target unit
-  switch (toUnit) {
-  case 'celsius':
-    return celsius;
-  case 'fahrenheit':
-    return (celsius * 9) / 5 + 32;
-  case 'kelvin':
-    return celsius + 273.15;
-  default:
-    return celsius;
-  }
-}
-
-module.exports = {
-  processWeatherData,
-};
+/**
+ * Weather Data Processing Module
+ *
+ * This module provides functions for processing weather data from various sources
+ * and converting it into standardized formats for analysis and display.
+ */
+
+/**
+ * Process raw weather data and generate standardized output
+ * @param {Object} rawData - Raw weather data from API or sensor
+ * @param {Object} options - Processing options
+ * @param {string} options.unit - Temperature unit ('celsius', 'fahrenheit', 'kelvin')
+ * @param {boolean} options.includeForecasts - Whether to include forecast data
+ * @param {number} options.forecastDays - Number of forecast days to include (1-7)
+ * @returns {Object} Processed weather data with standardized format
+ * @throws {Error} If input data is invalid or missing required fields
+ */
+function processWeatherData(rawData, options = {}) {
+  // Validate input
+  if (!rawData || typeof rawData !== 'object') {
+    throw new Error('Invalid weather data: must be an object');
+  }
+
+  // Default options
+  const opts = {
+    unit: 'celsius',
+    includeForecasts: false,
+    forecastDays: 5,
+    ...options,
+  };
+
+  // Validate options
+  if (!['celsius', 'fahrenheit', 'kelvin'].includes(opts.unit)) {
+    throw new Error(
+      'Invalid unit: must be "celsius", "fahrenheit", or "kelvin"',
+    );
+  }
+
+  if (opts.forecastDays < 1 || opts.forecastDays > 7) {
+    throw new Error('Invalid forecastDays: must be between 1 and 7');
+  }
+
+  // Process current weather data
+  const processedData = {
+    timestamp: new Date().toISOString(),
+    location: _extractLocation(rawData),
+    current: _processCurrentWeather(rawData.current || rawData, opts.unit),
+    forecasts: opts.includeForecasts
+      ? _processForecastData(rawData.forecast || [], opts)
+      : [],
+  };
+
+  return processedData;
+}
+
+/**
+ * Extract location information from raw data
+ * @param {Object} data - Raw weather data
+ * @returns {Object} Location information
+ */
+function _extractLocation(data) {
+  // Handle various location formats from different APIs
+  if (data.location) {
+    return {
+      name: data.location.name || data.location.city || 'Unknown',
+      country: data.location.country || '',
+      coordinates: {
+        lat: data.location.lat || data.location.latitude || 0,
+        lon: data.location.lon || data.location.longitude || 0,
+      },
+    };
+  }
+
+  if (data.city) {
+    return {
+      name: data.city.name || data.city,
+      country: data.city.country || '',
+      coordinates: {
+        lat: data.city.coord?.lat || data.city.latitude || 0,
+        lon: data.city.coord?.lon || data.city.longitude || 0,
+      },
+    };
+  }
+
+  return {
+    name: 'Unknown',
+    country: '',
+    coordinates: { lat: 0, lon: 0 },
+  };
+}
+
+/**
+ * Process current weather data
+ * @param {Object} current - Current weather data
+ * @param {string} unit - Temperature unit
+ * @returns {Object} Processed current weather data
+ */
+function _processCurrentWeather(current, unit) {
+  if (!current) {
+    return null;
+  }
+
+  // Convert temperature to requested unit
+  const temp = _convertTemperature(
+    current.temp || current.temperature || 0,
+    'kelvin',
+    unit,
+  );
+  const feelsLike = _convertTemperature(
+    current.feels_like || current.feelsLike || temp,
+    'kelvin',
+    unit,
+  );
+
+  return {
+    temperature: {
+      value: temp,
+      unit: unit,
+      feelsLike: feelsLike,
+    },
+    humidity: current.humidity || current.humididy || 0,
+    pressure: current.pressure || 0,
+    wind: {
+      speed: current.wind_speed || current.windSpeed || 0,
+      direction: current.wind_deg || current.windDirection || 0,
+    },
+    visibility: current.visibility || 0,
+    cloudiness: current.clouds || current.cloudiness || 0,
+    description:
+      current.description || current.weather?.[0]?.description || 'Unknown',
+    icon: current.icon || current.weather?.[0]?.icon || '',
+  };
+}
+
+/**
+ * Process forecast data
+ * @param {Array} forecasts - Array of forecast data
+ * @param {Object} options - Processing options
+ * @returns {Array} Processed forecast data
+ */
+function _processForecastData(forecasts, options) {
+  if (!Array.isArray(forecasts)) {
+    return [];
+  }
+
+  // Limit forecasts to requested number of days
+  const limitedForecasts = forecasts.slice(0, options.forecastDays);
+
+  return limitedForecasts.map((forecast) => {
+    const date = forecast.dt
+      ? new Date(forecast.dt * 1000).toISOString().split('T')[0]
+      : forecast.date || new Date().toISOString().split('T')[0];
+
+    return {
+      date: date,
+      temperature: {
+        min: _convertTemperature(
+          forecast.temp?.min || forecast.min_temp || 0,
+          'kelvin',
+          options.unit,
+        ),
+        max: _convertTemperature(
+          forecast.temp?.max || forecast.max_temp || 0,
+          'kelvin',
+          options.unit,
+        ),
+        unit: options.unit,
+      },
+      humidity: forecast.humidity || 0,
+      pressure: forecast.pressure || 0,
+      wind: {
+        speed: forecast.wind_speed || forecast.windSpeed || 0,
+        direction: forecast.wind_deg || forecast.windDirection || 0,
+      },
+      precipitation: {
+        probability: forecast.pop || forecast.precipitation_probability || 0,
+        amount: forecast.rain || forecast.snow || 0,
+      },
+      description:
+        forecast.weather?.[0]?.description || forecast.description || 'Unknown',
+    };
+  });
+}
+
+/**
+ * Convert temperature between units
+ * @param {number} value - Temperature value
+ * @param {string} fromUnit - Source unit ('celsius', 'fahrenheit', 'kelvin')
+ * @param {string} toUnit - Target unit ('celsius', 'fahrenheit', 'kelvin')
+ * @returns {number} Converted temperature value
+ */
+function _convertTemperature(value, fromUnit, toUnit) {
+  if (fromUnit === toUnit) {
+    return value;
+  }
+
+  // Convert to Celsius first
+  let celsius;
+  switch (fromUnit) {
+  case 'celsius':
+    celsius = value;
+    break;
+  case 'fahrenheit':
+    celsius = ((value - 32) * 5) / 9;
+    break;
+  case 'kelvin':
+    celsius = value - 273.15;
+    break;
+  default:
+    celsius = value;
+  }
+
+  // Convert from Celsius to target unit
+  switch (toUnit) {
+  case 'celsius':
+    return celsius;
+  case 'fahrenheit':
+    return (celsius * 9) / 5 + 32;
+  case 'kelvin':
+    return celsius + 273.15;
+  default:
+    return celsius;
+  }
+}
+
+module.exports = {
+  processWeatherData,
+};

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);
+  });
+});