decharge-scout 4.0.2 → 4.0.4

package/index.js

@@ -33,7 +33,7 @@ dotenv.config({ path: path.join(process.cwd(), '.env') });
 // Import modules
 import { startWalletServer, openWalletConnection, waitForWalletConnection, getConnectedWallet } from './src/wallet-server.js';
 import { setConnectedWallet, getBalance, checkBalance, mockStake, refundStake } from './src/browser-wallet.js';
-import { getWeatherForLocation } from './src/weather-data.js';
+import { getWeatherForLocation, getFallbackCoordinates } from './src/weather-data.js';
 import { generateSmartPricing, getPricingInsights, getRegionalPricing } from './src/smart-pricing.js';
 import { findCheapestWindow, calculateSavings } from './src/optimizer.js';
 import { submitToOracle } from './src/oracle.js';
@@ -288,7 +288,38 @@ async function runQueryCycle(wallet, agentName, location, options) {
 
       } catch (error) {
         weatherSpinner.fail(chalk.red('Failed to fetch weather data'));
-        throw new Error(`Unable to generate pricing simulation: ${error.message}`);
+
+        // Check if we have fallback coordinates available
+        const fallbackCoords = getFallbackCoordinates(location);
+
+        console.log(chalk.yellow(`\n⚠️  Could not geocode location: "${location}"`));
+        console.log(chalk.yellow(`   Error: ${error.message}`));
+
+        if (fallbackCoords) {
+          console.log(chalk.blue(`\n💡 We have fallback coordinates for: ${fallbackCoords.name}, ${fallbackCoords.country}`));
+        }
+
+        console.log(chalk.blue(`\nOptions:`));
+        console.log(chalk.gray(`   1. Try a different location (e.g., just "Hyderabad" or "Hyderabad, India")`));
+        if (fallbackCoords) {
+          console.log(chalk.gray(`   2. Use fallback coordinates for ${fallbackCoords.name}`));
+        }
+        console.log(chalk.gray(`   3. Exit and restart\n`));
+
+        const userChoice = await question(chalk.blue('Enter new location (or press Enter to exit): '));
+
+        if (!userChoice.trim()) {
+          console.log(chalk.yellow('Exiting...'));
+          throw new Error('User chose to exit');
+        }
+
+        // Update location and retry this cycle
+        location = userChoice.trim();
+        console.log(chalk.green(`✓ Updated location to: ${location}`));
+        console.log(chalk.gray('Retrying...\n'));
+
+        // Retry with new location - this will loop back and try again
+        continue;
       }
 
       // Run optimization

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "decharge-scout",
-  "version": "4.0.2",
+  "version": "4.0.4",
   "description": "Global Energy Scout - Weather-powered intelligent energy price forecasting with Solana integration",
   "main": "index.js",
   "type": "module",

package/src/weather-data.js

@@ -12,34 +12,57 @@ import fetch from 'node-fetch';
 /**
  * Get coordinates from location string
  * Simple geocoding using Open-Meteo's geocoding API (also free!)
+ * Tries multiple search strategies for better success rate
  */
 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}`);
+  // Try multiple search strategies
+  const searchTerms = [
+    location, // Original: "Hyderabad, TS, IN"
+    location.split(',')[0].trim(), // Just city: "Hyderabad"
+    location.replace(/,\s*[A-Z]{2}\s*,/, ','), // Remove state: "Hyderabad, IN"
+  ];
+
+  // Remove duplicates
+  const uniqueSearchTerms = [...new Set(searchTerms)];
+
+  let lastError = null;
+
+  for (const searchTerm of uniqueSearchTerms) {
+    try {
+      const locationEncoded = encodeURIComponent(searchTerm);
+      const url = `https://geocoding-api.open-meteo.com/v1/search?name=${locationEncoded}&count=5&language=en&format=json`;
+
+      const response = await fetch(url);
+      if (!response.ok) {
+        lastError = new Error(`Geocoding failed: ${response.status}`);
+        continue;
+      }
+
+      const data = await response.json();
+
+      if (!data.results || data.results.length === 0) {
+        lastError = new Error(`Location "${searchTerm}" not found`);
+        continue;
+      }
+
+      // Use first result
+      const result = data.results[0];
+      console.log(`✓ Geocoded "${searchTerm}" → ${result.name}, ${result.country} (${result.latitude}, ${result.longitude})`);
+
+      return {
+        latitude: result.latitude,
+        longitude: result.longitude,
+        name: result.name,
+        country: result.country,
+        timezone: result.timezone || 'auto'
+      };
+    } catch (error) {
+      lastError = error;
+      continue;
     }
-
-    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}`);
   }
+
+  throw new Error(`Failed to geocode location after trying: ${uniqueSearchTerms.join(', ')}. Last error: ${lastError?.message}`);
 }
 
 /**
@@ -95,23 +118,47 @@ export async function fetchWeatherForecast(latitude, longitude, timezone = 'auto
   }
 }
 
+/**
+ * Known coordinates for common cities (fallback)
+ */
+const KNOWN_CITIES = {
+  'hyderabad': { latitude: 17.385, longitude: 78.487, name: 'Hyderabad', country: 'India', timezone: 'Asia/Kolkata' },
+  'mumbai': { latitude: 19.076, longitude: 72.877, name: 'Mumbai', country: 'India', timezone: 'Asia/Kolkata' },
+  'delhi': { latitude: 28.704, longitude: 77.102, name: 'Delhi', country: 'India', timezone: 'Asia/Kolkata' },
+  'bangalore': { latitude: 12.972, longitude: 77.594, name: 'Bangalore', country: 'India', timezone: 'Asia/Kolkata' },
+  'chennai': { latitude: 13.083, longitude: 80.270, name: 'Chennai', country: 'India', timezone: 'Asia/Kolkata' },
+  'lagos': { latitude: 6.524, longitude: 3.379, name: 'Lagos', country: 'Nigeria', timezone: 'Africa/Lagos' },
+  'london': { latitude: 51.509, longitude: -0.118, name: 'London', country: 'United Kingdom', timezone: 'Europe/London' },
+  'new york': { latitude: 40.713, longitude: -74.006, name: 'New York', country: 'United States', timezone: 'America/New_York' },
+  'los angeles': { latitude: 34.052, longitude: -118.244, name: 'Los Angeles', country: 'United States', timezone: 'America/Los_Angeles' },
+  'chicago': { latitude: 41.878, longitude: -87.630, name: 'Chicago', country: 'United States', timezone: 'America/Chicago' },
+  'houston': { latitude: 29.760, longitude: -95.369, name: 'Houston', country: 'United States', timezone: 'America/Chicago' },
+  'dallas': { latitude: 32.776, longitude: -96.797, name: 'Dallas', country: 'United States', timezone: 'America/Chicago' },
+};
+
 /**
  * Get weather data for a location
+ * Throws error if geocoding fails - caller should handle user interaction
  */
 export async function getWeatherForLocation(location) {
-  try {
-    // Get coordinates
-    const coords = await getCoordinatesFromLocation(location);
-    console.log(`📍 Location: ${coords.name}, ${coords.country} (${coords.latitude}, ${coords.longitude})`);
+  // Try geocoding - throw error if fails
+  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);
+  // 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}`);
-  }
+  return {
+    location: coords,
+    forecast
+  };
+}
+
+/**
+ * Get fallback coordinates for known cities
+ * Returns null if city not in database
+ */
+export function getFallbackCoordinates(location) {
+  const cityKey = location.split(',')[0].trim().toLowerCase();
+  return KNOWN_CITIES[cityKey] || null;
 }