stigmergy 1.0.93 → 1.0.95

package/src/weatherProcessor.js

@@ -0,0 +1,205 @@
+/**
+ * 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/calculator.test.js

@@ -0,0 +1,215 @@
+/**
+ * Unit tests for Calculator class
+ */
+
+const Calculator = require('../src/calculator');
+
+console.log("Testing Calculator class...");
+
+// Test basic operations
+console.log("\n1. Testing basic arithmetic operations:");
+
+const calc = new Calculator();
+
+// Test addition
+console.log("\n1.1 Testing addition:");
+try {
+  const sum = calc.add(5, 3);
+  console.log(`calc.add(5, 3) = ${sum}`);
+  if (sum === 8) {
+    console.log("✅ Addition test passed");
+  } else {
+    console.log("❌ Addition test failed");
+  }
+} catch (error) {
+  console.log("❌ Addition test failed with error:", error.message);
+}
+
+// Test subtraction
+console.log("\n1.2 Testing subtraction:");
+try {
+  const difference = calc.subtract(10, 4);
+  console.log(`calc.subtract(10, 4) = ${difference}`);
+  if (difference === 6) {
+    console.log("✅ Subtraction test passed");
+  } else {
+    console.log("❌ Subtraction test failed");
+  }
+} catch (error) {
+  console.log("❌ Subtraction test failed with error:", error.message);
+}
+
+// Test multiplication
+console.log("\n1.3 Testing multiplication:");
+try {
+  const product = calc.multiply(6, 7);
+  console.log(`calc.multiply(6, 7) = ${product}`);
+  if (product === 42) {
+    console.log("✅ Multiplication test passed");
+  } else {
+    console.log("❌ Multiplication test failed");
+  }
+} catch (error) {
+  console.log("❌ Multiplication test failed with error:", error.message);
+}
+
+// Test division
+console.log("\n1.4 Testing division:");
+try {
+  const quotient = calc.divide(15, 3);
+  console.log(`calc.divide(15, 3) = ${quotient}`);
+  if (quotient === 5) {
+    console.log("✅ Division test passed");
+  } else {
+    console.log("❌ Division test failed");
+  }
+} catch (error) {
+  console.log("❌ Division test failed with error:", error.message);
+}
+
+// Test division by zero
+console.log("\n1.5 Testing division by zero:");
+try {
+  calc.divide(10, 0);
+  console.log("❌ Division by zero test failed - should have thrown an error");
+} catch (error) {
+  console.log("✅ Division by zero correctly threw error:", error.message);
+}
+
+// Test power function
+console.log("\n1.6 Testing power function:");
+try {
+  const powerResult = calc.power(2, 3);
+  console.log(`calc.power(2, 3) = ${powerResult}`);
+  if (powerResult === 8) {
+    console.log("✅ Power test passed");
+  } else {
+    console.log("❌ Power test failed");
+  }
+} catch (error) {
+  console.log("❌ Power test failed with error:", error.message);
+}
+
+// Test square root
+console.log("\n1.7 Testing square root:");
+try {
+  const sqrtResult = calc.sqrt(16);
+  console.log(`calc.sqrt(16) = ${sqrtResult}`);
+  if (sqrtResult === 4) {
+    console.log("✅ Square root test passed");
+  } else {
+    console.log("❌ Square root test failed");
+  }
+} catch (error) {
+  console.log("❌ Square root test failed with error:", error.message);
+}
+
+// Test square root of negative number
+console.log("\n1.8 Testing square root of negative number:");
+try {
+  calc.sqrt(-4);
+  console.log("❌ Square root of negative number test failed - should have thrown an error");
+} catch (error) {
+  console.log("✅ Square root of negative number correctly threw error:", error.message);
+}
+
+// Test factorial
+console.log("\n1.9 Testing factorial:");
+try {
+  const factorialResult = calc.factorial(5);
+  console.log(`calc.factorial(5) = ${factorialResult}`);
+  if (factorialResult === 120) {
+    console.log("✅ Factorial test passed");
+  } else {
+    console.log("❌ Factorial test failed");
+  }
+} catch (error) {
+  console.log("❌ Factorial test failed with error:", error.message);
+}
+
+// Test factorial of 0
+console.log("\n1.10 Testing factorial of 0:");
+try {
+  const factorialZero = calc.factorial(0);
+  console.log(`calc.factorial(0) = ${factorialZero}`);
+  if (factorialZero === 1) {
+    console.log("✅ Factorial of 0 test passed");
+  } else {
+    console.log("❌ Factorial of 0 test failed");
+  }
+} catch (error) {
+  console.log("❌ Factorial of 0 test failed with error:", error.message);
+}
+
+// Test factorial of negative number
+console.log("\n1.11 Testing factorial of negative number:");
+try {
+  calc.factorial(-5);
+  console.log("❌ Factorial of negative number test failed - should have thrown an error");
+} catch (error) {
+  console.log("✅ Factorial of negative number correctly threw error:", error.message);
+}
+
+// Test percentage
+console.log("\n1.12 Testing percentage:");
+try {
+  const percentageResult = calc.percentage(25, 100);
+  console.log(`calc.percentage(25, 100) = ${percentageResult}%`);
+  if (percentageResult === 25) {
+    console.log("✅ Percentage test passed");
+  } else {
+    console.log("❌ Percentage test failed");
+  }
+} catch (error) {
+  console.log("❌ Percentage test failed with error:", error.message);
+}
+
+// Test percentage with zero as whole
+console.log("\n1.13 Testing percentage with zero as whole:");
+try {
+  calc.percentage(50, 0);
+  console.log("❌ Percentage with zero as whole test failed - should have thrown an error");
+} catch (error) {
+  console.log("✅ Percentage with zero as whole correctly threw error:", error.message);
+}
+
+// Test calculation chain
+console.log("\n2. Testing calculation chain:");
+
+console.log("\n2.1 Testing chain operations:");
+try {
+  const chainResult = calc.chain(10).add(5).multiply(2).subtract(4).divide(2).equals();
+  console.log(`calc.chain(10).add(5).multiply(2).subtract(4).divide(2).equals() = ${chainResult}`);
+  // ((10 + 5) * 2 - 4) / 2 = (30 - 4) / 2 = 26 / 2 = 13
+  if (chainResult === 13) {
+    console.log("✅ Chain operations test passed");
+  } else {
+    console.log("❌ Chain operations test failed");
+  }
+} catch (error) {
+  console.log("❌ Chain operations test failed with error:", error.message);
+}
+
+console.log("\n2.2 Testing chain division by zero:");
+try {
+  calc.chain(10).divide(0);
+  console.log("❌ Chain division by zero test failed - should have thrown an error");
+} catch (error) {
+  console.log("✅ Chain division by zero correctly threw error:", error.message);
+}
+
+console.log("\n2.3 Testing chain value method:");
+try {
+  const chain = calc.chain(5).add(3);
+  const currentValue = chain.value();
+  console.log(`calc.chain(5).add(3).value() = ${currentValue}`);
+  if (currentValue === 8) {
+    console.log("✅ Chain value method test passed");
+  } else {
+    console.log("❌ Chain value method test failed");
+  }
+} catch (error) {
+  console.log("❌ Chain value method test failed with error:", error.message);
+}
+
+console.log("\n✅ All Calculator tests completed!");

package/test/collision-test.js

@@ -0,0 +1,26 @@
+const { HashTable } = require('../src/utils');
+
+console.log("=== Hash Table Collision Handling Demo ===");
+
+// Create a hash table with a small size to force collisions
+const ht = new HashTable(4); // Small size to demonstrate collisions
+
+// Add several key-value pairs that will cause collisions
+ht.set("key1", "value1");
+ht.set("key2", "value2");
+ht.set("key3", "value3");
+ht.set("key4", "value4");
+ht.set("key5", "value5"); // This will collide with one of the above
+
+console.log("Values retrieved:");
+console.log("key1:", ht.get("key1"));
+console.log("key2:", ht.get("key2"));
+console.log("key3:", ht.get("key3"));
+console.log("key4:", ht.get("key4"));
+console.log("key5:", ht.get("key5"));
+console.log("nonexistent_key:", ht.get("nonexistent_key"));
+
+console.log("\nAll keys:", ht.keys());
+console.log("All values:", ht.values());
+
+console.log("\n=== Test completed successfully! ===");

package/test/csv-processing-test.js

@@ -0,0 +1,36 @@
+const { processCSV } = require('../src/utils');
+
+// Test basic CSV processing
+console.log('Testing basic CSV processing...');
+
+const csvData = `name,age,city
+John,25,New York
+Jane,30,Boston
+Bob,35,Chicago
+Alice,28,Los Angeles`;
+
+const stats = processCSV(csvData);
+console.log('Basic CSV Stats:', JSON.stringify(stats, null, 2));
+
+// Test CSV without headers
+console.log('\nTesting CSV without headers...');
+
+const csvWithoutHeaders = `John,25,New York
+Jane,30,Boston
+Bob,35,Chicago`;
+
+const statsNoHeaders = processCSV(csvWithoutHeaders, { hasHeader: false });
+console.log('CSV without headers Stats:', JSON.stringify(statsNoHeaders, null, 2));
+
+// Test CSV with numeric data
+console.log('\nTesting CSV with numeric data...');
+
+const csvNumeric = `product,price,quantity
+Apple,1.20,100
+Banana,0.50,200
+Orange,0.80,150`;
+
+const statsNumeric = processCSV(csvNumeric);
+console.log('Numeric CSV Stats:', JSON.stringify(statsNumeric, null, 2));
+
+console.log('\nCSV processing tests completed successfully!');

package/test/e2e/claude-cli-test.js

@@ -0,0 +1,128 @@
+// Claude CLI Integration Tests
+const { executeCommand, recordTestResult } = require('./test-utils');
+
+async function testClaudeCLIIntegration() {
+  console.log('Starting Claude CLI integration testing...\n');
+  
+  // Test 1: Simple code generation
+  console.log('--- Test 1: Simple code generation ---');
+  try {
+    const result = await executeCommand('node src/main_english.js call "claude write a simple Python function to add two numbers"', 45000);
+    
+    const passed = result.success && 
+                   result.stdout.length > 100 && 
+                   result.stdout.includes('def') && 
+                   result.stdout.includes('return') &&
+                   !result.stdout.includes('Error') &&
+                   !result.stdout.includes('error');
+                   
+    recordTestResult('Claude CLI - Simple Code Generation', passed, {
+      command: result.command,
+      executionTime: result.executionTime,
+      outputLength: result.stdout.length,
+      hasError: !result.success || result.stderr.length > 0
+    });
+    
+    console.log(`  Result: ${passed ? 'PASS' : 'FAIL'}`);
+    console.log(`  Execution time: ${result.executionTime}ms`);
+    console.log(`  Output length: ${result.stdout.length} characters`);
+    
+  } catch (error) {
+    recordTestResult('Claude CLI - Simple Code Generation', false, {
+      error: error.message
+    });
+    console.log(`  Result: FAIL - ${error.message}`);
+  }
+  
+  // Test 2: Complex algorithm implementation
+  console.log('\n--- Test 2: Complex algorithm implementation ---');
+  try {
+    const result = await executeCommand('node src/main_english.js call "claude implement a binary search algorithm in Python with proper error handling"', 60000);
+    
+    const passed = result.success && 
+                   result.stdout.length > 200 && 
+                   (result.stdout.includes('def') || result.stdout.includes('class')) &&
+                   result.stdout.includes('binary') &&
+                   !result.stdout.includes('Error') &&
+                   !result.stdout.includes('error');
+                   
+    recordTestResult('Claude CLI - Complex Algorithm Implementation', passed, {
+      command: result.command,
+      executionTime: result.executionTime,
+      outputLength: result.stdout.length,
+      hasError: !result.success || result.stderr.length > 0
+    });
+    
+    console.log(`  Result: ${passed ? 'PASS' : 'FAIL'}`);
+    console.log(`  Execution time: ${result.executionTime}ms`);
+    console.log(`  Output length: ${result.stdout.length} characters`);
+    
+  } catch (error) {
+    recordTestResult('Claude CLI - Complex Algorithm Implementation', false, {
+      error: error.message
+    });
+    console.log(`  Result: FAIL - ${error.message}`);
+  }
+  
+  // Test 3: Code analysis and review
+  console.log('\n--- Test 3: Code analysis and review ---');
+  try {
+    const result = await executeCommand('node src/main_english.js call "claude analyze this Python code for potential security vulnerabilities: def login(user, password): if user == \"admin\" and password == \"123456\": return True"', 45000);
+    
+    const passed = result.success && 
+                   result.stdout.length > 100 && 
+                   (result.stdout.includes('security') || result.stdout.includes('vulnerab')) &&
+                   !result.stdout.includes('Error') &&
+                   !result.stdout.includes('error');
+                   
+    recordTestResult('Claude CLI - Code Analysis and Review', passed, {
+      command: result.command,
+      executionTime: result.executionTime,
+      outputLength: result.stdout.length,
+      hasError: !result.success || result.stderr.length > 0
+    });
+    
+    console.log(`  Result: ${passed ? 'PASS' : 'FAIL'}`);
+    console.log(`  Execution time: ${result.executionTime}ms`);
+    console.log(`  Output length: ${result.stdout.length} characters`);
+    
+  } catch (error) {
+    recordTestResult('Claude CLI - Code Analysis and Review', false, {
+      error: error.message
+    });
+    console.log(`  Result: FAIL - ${error.message}`);
+  }
+  
+  // Test 4: Documentation generation
+  console.log('\n--- Test 4: Documentation generation ---');
+  try {
+    const result = await executeCommand('node src/main_english.js call "claude generate documentation for a Python function that sorts arrays"', 45000);
+    
+    const passed = result.success && 
+                   result.stdout.length > 100 && 
+                   (result.stdout.includes('def') || result.stdout.includes('function') || result.stdout.includes('doc')) &&
+                   !result.stdout.includes('Error') &&
+                   !result.stdout.includes('error');
+                   
+    recordTestResult('Claude CLI - Documentation Generation', passed, {
+      command: result.command,
+      executionTime: result.executionTime,
+      outputLength: result.stdout.length,
+      hasError: !result.success || result.stderr.length > 0
+    });
+    
+    console.log(`  Result: ${passed ? 'PASS' : 'FAIL'}`);
+    console.log(`  Execution time: ${result.executionTime}ms`);
+    console.log(`  Output length: ${result.stdout.length} characters`);
+    
+  } catch (error) {
+    recordTestResult('Claude CLI - Documentation Generation', false, {
+      error: error.message
+    });
+    console.log(`  Result: FAIL - ${error.message}`);
+  }
+  
+  console.log('\n--- Claude CLI integration testing completed ---\n');
+}
+
+module.exports = testClaudeCLIIntegration;

package/test/e2e/collaboration-test.js

@@ -0,0 +1,75 @@
+// Collaboration functionality testing
+const { executeCommand, recordTestResult, wait } = require('./test-utils');
+const testData = require('./test-data');
+
+async function testCollaboration() {
+  console.log('Starting collaboration functionality testing...\n');
+  
+  // Test each collaboration scenario
+  for (const scenario of testData.collaborationScenarios) {
+    console.log(`\n--- Testing ${scenario.name} ---`);
+    
+    let allStepsPassed = true;
+    const stepResults = [];
+    
+    // Execute each step in the scenario
+    for (let i = 0; i < scenario.steps.length; i++) {
+      const step = scenario.steps[i];
+      console.log(`  Step ${i + 1}: ${step}`);
+      
+      try {
+        const result = await executeCommand(`stigmergy call "${step}"`, 60000);
+        
+        // Check if the command executed successfully
+        const stepPassed = result.success && 
+                           result.stdout.length > 30 &&
+                           !result.stdout.includes('Error') &&
+                           !result.stdout.includes('error');
+                           
+        stepResults.push({
+          step: i + 1,
+          command: step,
+          passed: stepPassed,
+          executionTime: result.executionTime,
+          outputLength: result.stdout.length
+        });
+        
+        if (!stepPassed) {
+          allStepsPassed = false;
+        }
+        
+        // Log result summary
+        console.log(`    Result: ${stepPassed ? 'PASS' : 'FAIL'}`);
+        console.log(`    Execution time: ${result.executionTime}ms`);
+        console.log(`    Output length: ${result.stdout.length} characters`);
+        
+        // Wait a bit between steps to avoid overwhelming the system
+        await wait(2000);
+        
+      } catch (error) {
+        stepResults.push({
+          step: i + 1,
+          command: step,
+          passed: false,
+          error: error.message
+        });
+        
+        allStepsPassed = false;
+        console.log(`    Result: FAIL - ${error.message}`);
+      }
+    }
+    
+    // Record overall scenario result
+    recordTestResult(`Collaboration - ${scenario.name}`, allStepsPassed, {
+      steps: stepResults,
+      totalSteps: scenario.steps.length,
+      passedSteps: stepResults.filter(s => s.passed).length
+    });
+    
+    console.log(`  Overall: ${allStepsPassed ? 'PASS' : 'FAIL'}`);
+  }
+  
+  console.log('\n--- Collaboration testing completed ---\n');
+}
+
+module.exports = testCollaboration;