decharge-scout 2.5.6 → 4.0.2

package/src/smart-pricing.js

@@ -0,0 +1,251 @@
+/**
+ * Smart Pricing Simulation Engine
+ *
+ * Simulates realistic energy grid pricing based on:
+ * - Real weather data (temperature, wind, solar radiation)
+ * - Regional base pricing
+ * - Time-of-day patterns
+ * - Seasonal adjustments
+ * - Local grid characteristics
+ */
+
+/**
+ * Regional Base Pricing Map (USD/kWh)
+ * Based on real-world average electricity prices
+ */
+const REGIONAL_BASE_PRICES = {
+  // North America
+  US: { base: 0.14, currency: 'USD', name: 'United States' },
+  CA: { base: 0.12, currency: 'CAD', name: 'Canada' },
+  MX: { base: 0.09, currency: 'MXN', name: 'Mexico' },
+
+  // Europe
+  DE: { base: 0.32, currency: 'EUR', name: 'Germany' },
+  FR: { base: 0.19, currency: 'EUR', name: 'France' },
+  GB: { base: 0.28, currency: 'GBP', name: 'United Kingdom' },
+  ES: { base: 0.24, currency: 'EUR', name: 'Spain' },
+  IT: { base: 0.26, currency: 'EUR', name: 'Italy' },
+  PL: { base: 0.16, currency: 'EUR', name: 'Poland' },
+  NL: { base: 0.27, currency: 'EUR', name: 'Netherlands' },
+
+  // Asia
+  IN: { base: 0.08, currency: 'INR', name: 'India' },
+  CN: { base: 0.08, currency: 'CNY', name: 'China' },
+  JP: { base: 0.26, currency: 'JPY', name: 'Japan' },
+  KR: { base: 0.10, currency: 'KRW', name: 'South Korea' },
+  SG: { base: 0.19, currency: 'SGD', name: 'Singapore' },
+
+  // South America
+  BR: { base: 0.11, currency: 'BRL', name: 'Brazil' },
+  AR: { base: 0.06, currency: 'ARS', name: 'Argentina' },
+  CL: { base: 0.14, currency: 'CLP', name: 'Chile' },
+
+  // Oceania
+  AU: { base: 0.21, currency: 'AUD', name: 'Australia' },
+  NZ: { base: 0.18, currency: 'NZD', name: 'New Zealand' },
+
+  // Africa
+  ZA: { base: 0.09, currency: 'ZAR', name: 'South Africa' },
+  NG: { base: 0.05, currency: 'NGN', name: 'Nigeria' },
+  KE: { base: 0.12, currency: 'KES', name: 'Kenya' },
+
+  // Default
+  DEFAULT: { base: 0.12, currency: 'USD', name: 'Global Average' }
+};
+
+/**
+ * Regional Peak Hour Patterns
+ * Different regions have different typical peak hours
+ */
+const REGIONAL_PEAK_PATTERNS = {
+  US: { morning: [7, 9], evening: [17, 21], offPeak: [22, 6] },
+  EU: { morning: [7, 9], evening: [18, 21], offPeak: [23, 6] },
+  IN: { morning: [6, 9], evening: [19, 23], offPeak: [0, 5] }, // India peaks later due to heat
+  BR: { morning: [7, 10], evening: [18, 22], offPeak: [23, 6] },
+  JP: { morning: [8, 10], evening: [18, 20], offPeak: [22, 6] },
+  DEFAULT: { morning: [7, 9], evening: [17, 21], offPeak: [22, 6] }
+};
+
+/**
+ * Get regional pricing info from country code
+ */
+export function getRegionalPricing(countryCode) {
+  const code = countryCode ? countryCode.toUpperCase() : 'DEFAULT';
+  return REGIONAL_BASE_PRICES[code] || REGIONAL_BASE_PRICES.DEFAULT;
+}
+
+/**
+ * Get regional peak pattern
+ */
+function getRegionalPeakPattern(countryCode) {
+  // Map country code to region
+  const regionMap = {
+    US: 'US', CA: 'US', MX: 'US',
+    DE: 'EU', FR: 'EU', GB: 'EU', ES: 'EU', IT: 'EU', PL: 'EU', NL: 'EU',
+    IN: 'IN',
+    BR: 'BR', AR: 'BR', CL: 'BR',
+    JP: 'JP', KR: 'JP', CN: 'JP',
+  };
+
+  const region = regionMap[countryCode] || 'DEFAULT';
+  return REGIONAL_PEAK_PATTERNS[region] || REGIONAL_PEAK_PATTERNS.DEFAULT;
+}
+
+/**
+ * Check if hour is in peak period
+ */
+function isPeakHour(hour, pattern) {
+  const morningPeak = hour >= pattern.morning[0] && hour <= pattern.morning[1];
+  const eveningPeak = hour >= pattern.evening[0] && hour <= pattern.evening[1];
+  return morningPeak || eveningPeak;
+}
+
+/**
+ * Check if hour is off-peak
+ */
+function isOffPeakHour(hour, pattern) {
+  if (pattern.offPeak[0] > pattern.offPeak[1]) {
+    // Wraps around midnight (e.g., 22-6)
+    return hour >= pattern.offPeak[0] || hour <= pattern.offPeak[1];
+  }
+  return hour >= pattern.offPeak[0] && hour <= pattern.offPeak[1];
+}
+
+/**
+ * Calculate price multiplier based on weather conditions
+ */
+function calculateWeatherMultiplier(weather) {
+  let multiplier = 1.0;
+  const reasons = [];
+
+  // Temperature impact (AC/heating demand)
+  if (weather.temperature > 28) {
+    const tempImpact = 1 + ((weather.temperature - 28) * 0.03); // +3% per degree above 28°C
+    multiplier *= tempImpact;
+    reasons.push(`🌡️ High temp (${weather.temperature.toFixed(1)}°C) +${((tempImpact - 1) * 100).toFixed(0)}% AC demand`);
+  } else if (weather.temperature < 5) {
+    const tempImpact = 1 + ((5 - weather.temperature) * 0.02); // +2% per degree below 5°C
+    multiplier *= tempImpact;
+    reasons.push(`❄️ Low temp (${weather.temperature.toFixed(1)}°C) +${((tempImpact - 1) * 100).toFixed(0)}% heating demand`);
+  }
+
+  // Wind impact (wind energy generation)
+  if (weather.windSpeed > 8) {
+    const windImpact = 0.75; // -25% when windy
+    multiplier *= windImpact;
+    reasons.push(`💨 High wind (${weather.windSpeed.toFixed(1)} m/s) -25% renewable energy`);
+  }
+
+  // Solar radiation impact (solar energy generation)
+  // Only during daytime hours (6-18)
+  if (weather.hour >= 6 && weather.hour <= 18 && weather.solarRadiation > 200) {
+    const solarImpact = Math.max(0.8, 1 - (weather.solarRadiation / 1000) * 0.2); // Up to -20%
+    multiplier *= solarImpact;
+    reasons.push(`☀️ High solar (${weather.solarRadiation.toFixed(0)} W/m²) -${((1 - solarImpact) * 100).toFixed(0)}% solar energy`);
+  }
+
+  return { multiplier, reasons };
+}
+
+/**
+ * Calculate time-of-day multiplier
+ */
+function calculateTimeMultiplier(hour, pattern) {
+  const reasons = [];
+  let multiplier = 1.0;
+
+  if (isPeakHour(hour, pattern)) {
+    multiplier = 1.4; // +40% during peak
+    const peakType = hour >= pattern.morning[0] && hour <= pattern.morning[1] ? 'morning' : 'evening';
+    reasons.push(`⚡ ${peakType.charAt(0).toUpperCase() + peakType.slice(1)} peak hours +40%`);
+  } else if (isOffPeakHour(hour, pattern)) {
+    multiplier = 0.7; // -30% during off-peak
+    reasons.push(`🌙 Off-peak hours -30%`);
+  } else {
+    reasons.push(`📊 Standard hours`);
+  }
+
+  return { multiplier, reasons };
+}
+
+/**
+ * Generate smart pricing data based on weather forecast
+ */
+export function generateSmartPricing(weatherData, countryCode = 'DEFAULT') {
+  const regionalPricing = getRegionalPricing(countryCode);
+  const peakPattern = getRegionalPeakPattern(countryCode);
+  const basePrice = regionalPricing.base;
+
+  console.log(`💰 Base price: $${basePrice.toFixed(4)}/kWh (${regionalPricing.name})`);
+
+  const pricingData = [];
+
+  for (const weather of weatherData.forecast) {
+    // Calculate multipliers
+    const weatherMultiplier = calculateWeatherMultiplier(weather);
+    const timeMultiplier = calculateTimeMultiplier(weather.hour, peakPattern);
+
+    // Calculate final price
+    const finalMultiplier = weatherMultiplier.multiplier * timeMultiplier.multiplier;
+    const price = basePrice * finalMultiplier;
+
+    // Calculate simulated demand (inversely related to price for renewable-heavy grids)
+    const baseDemand = 40000;
+    const demandMultiplier = 1 + (finalMultiplier - 1) * 0.5; // Demand follows price but not as strongly
+    const demand = baseDemand * demandMultiplier;
+
+    pricingData.push({
+      timestamp: weather.timestamp,
+      hour: weather.hour,
+      price: Math.max(basePrice * 0.5, Math.min(basePrice * 2.0, price)), // Cap at 50%-200% of base
+      demand,
+      weather: {
+        temperature: weather.temperature,
+        windSpeed: weather.windSpeed,
+        solarRadiation: weather.solarRadiation,
+        humidity: weather.humidity
+      },
+      reasons: [...timeMultiplier.reasons, ...weatherMultiplier.reasons],
+      source: 'Smart-Simulation-Weather'
+    });
+  }
+
+  return pricingData;
+}
+
+/**
+ * Get insights about pricing patterns
+ */
+export function getPricingInsights(pricingData, countryCode) {
+  const prices = pricingData.map(d => d.price);
+  const minPrice = Math.min(...prices);
+  const maxPrice = Math.max(...prices);
+  const avgPrice = prices.reduce((a, b) => a + b, 0) / prices.length;
+
+  const cheapestHour = pricingData.find(d => d.price === minPrice);
+  const expensiveHour = pricingData.find(d => d.price === maxPrice);
+
+  const regionalPricing = getRegionalPricing(countryCode);
+
+  return {
+    region: regionalPricing.name,
+    baseCurrency: regionalPricing.currency,
+    avgPrice: avgPrice.toFixed(4),
+    minPrice: minPrice.toFixed(4),
+    maxPrice: maxPrice.toFixed(4),
+    priceRange: ((maxPrice - minPrice) / avgPrice * 100).toFixed(1),
+    cheapestTime: {
+      hour: cheapestHour.hour,
+      timestamp: cheapestHour.timestamp,
+      price: cheapestHour.price.toFixed(4),
+      reasons: cheapestHour.reasons
+    },
+    expensiveTime: {
+      hour: expensiveHour.hour,
+      timestamp: expensiveHour.timestamp,
+      price: expensiveHour.price.toFixed(4),
+      reasons: expensiveHour.reasons
+    },
+    savingsPotential: (((maxPrice - minPrice) / maxPrice) * 100).toFixed(1)
+  };
+}

package/src/weather-data.js

@@ -0,0 +1,117 @@
+/**
+ * Weather Data Module - Open-Meteo API Integration
+ *
+ * Fetches real-time weather forecasts to simulate energy grid pricing.
+ * Uses FREE Open-Meteo API (no key needed!)
+ *
+ * API Docs: https://open-meteo.com/en/docs
+ */
+
+import fetch from 'node-fetch';
+
+/**
+ * Get coordinates from location string
+ * Simple geocoding using Open-Meteo's geocoding API (also free!)
+ */
+export async function getCoordinatesFromLocation(location) {
+  try {
+    const locationEncoded = encodeURIComponent(location);
+    const url = `https://geocoding-api.open-meteo.com/v1/search?name=${locationEncoded}&count=1&language=en&format=json`;
+
+    const response = await fetch(url);
+    if (!response.ok) {
+      throw new Error(`Geocoding failed: ${response.status}`);
+    }
+
+    const data = await response.json();
+
+    if (!data.results || data.results.length === 0) {
+      throw new Error('Location not found');
+    }
+
+    const result = data.results[0];
+    return {
+      latitude: result.latitude,
+      longitude: result.longitude,
+      name: result.name,
+      country: result.country,
+      timezone: result.timezone || 'UTC'
+    };
+  } catch (error) {
+    throw new Error(`Failed to geocode location: ${error.message}`);
+  }
+}
+
+/**
+ * Fetch weather forecast from Open-Meteo API (FREE!)
+ * Returns 24-hour forecast with temperature, wind, humidity, and solar radiation
+ */
+export async function fetchWeatherForecast(latitude, longitude, timezone = 'auto') {
+  try {
+    const url = `https://api.open-meteo.com/v1/forecast?` +
+      `latitude=${latitude}` +
+      `&longitude=${longitude}` +
+      `&hourly=temperature_2m,relative_humidity_2m,wind_speed_10m,shortwave_radiation` +
+      `&timezone=${timezone}` +
+      `&forecast_days=2`; // Get 2 days for full 24h coverage
+
+    console.log(`🌤️  Fetching weather from Open-Meteo API (FREE!)...`);
+
+    const response = await fetch(url);
+
+    if (!response.ok) {
+      throw new Error(`Open-Meteo API error: ${response.status}`);
+    }
+
+    const data = await response.json();
+
+    if (!data.hourly) {
+      throw new Error('No hourly forecast data available');
+    }
+
+    // Parse hourly data
+    const hourlyData = [];
+    const currentHour = new Date().getHours();
+
+    for (let i = 0; i < Math.min(48, data.hourly.time.length); i++) {
+      const timestamp = data.hourly.time[i];
+      const hour = new Date(timestamp).getHours();
+
+      hourlyData.push({
+        timestamp,
+        hour,
+        temperature: data.hourly.temperature_2m[i] || 20, // Celsius
+        humidity: data.hourly.relative_humidity_2m[i] || 50, // %
+        windSpeed: data.hourly.wind_speed_10m[i] || 0, // m/s
+        solarRadiation: data.hourly.shortwave_radiation[i] || 0, // W/m²
+      });
+    }
+
+    console.log(`✓ Fetched ${hourlyData.length} hours of weather forecast`);
+    return hourlyData;
+
+  } catch (error) {
+    throw new Error(`Failed to fetch weather data: ${error.message}`);
+  }
+}
+
+/**
+ * Get weather data for a location
+ */
+export async function getWeatherForLocation(location) {
+  try {
+    // Get coordinates
+    const coords = await getCoordinatesFromLocation(location);
+    console.log(`📍 Location: ${coords.name}, ${coords.country} (${coords.latitude}, ${coords.longitude})`);
+
+    // Get weather forecast
+    const forecast = await fetchWeatherForecast(coords.latitude, coords.longitude, coords.timezone);
+
+    return {
+      location: coords,
+      forecast
+    };
+  } catch (error) {
+    throw new Error(`Failed to get weather for location: ${error.message}`);
+  }
+}