decharge-scout 4.0.0 → 4.0.4

package/dashboard/api/alpha.js

@@ -0,0 +1,167 @@
+/**
+ * Vercel API Endpoint - Alpha Contributions
+ *
+ * GET /api/alpha - Get verified alpha contributions
+ * POST /api/alpha - Submit new alpha contribution
+ */
+
+import { createClient } from '@supabase/supabase-js';
+
+export const config = {
+  runtime: 'edge',
+};
+
+export default async function handler(req) {
+  // CORS headers
+  const headers = {
+    'Access-Control-Allow-Origin': '*',
+    'Access-Control-Allow-Methods': 'GET, POST, OPTIONS',
+    'Access-Control-Allow-Headers': 'Content-Type',
+    'Content-Type': 'application/json',
+  };
+
+  // Handle OPTIONS request for CORS
+  if (req.method === 'OPTIONS') {
+    return new Response(null, { status: 200, headers });
+  }
+
+  // Initialize Supabase client
+  const supabase = createClient(
+    process.env.SUPABASE_URL,
+    process.env.SUPABASE_ANON_KEY
+  );
+
+  // GET - Retrieve alpha contributions
+  if (req.method === 'GET') {
+    try {
+      const url = new URL(req.url);
+      const location = url.searchParams.get('location');
+      const verified = url.searchParams.get('verified') === 'true';
+      const minConfidence = parseFloat(url.searchParams.get('min_confidence') || '0');
+
+      let query = supabase
+        .from('alpha_contributions')
+        .select('*')
+        .order('created_at', { ascending: false })
+        .limit(100);
+
+      // Apply filters
+      if (location) {
+        query = query.ilike('location', `%${location}%`);
+      }
+
+      if (verified) {
+        query = query.eq('verified', true);
+      }
+
+      if (minConfidence > 0) {
+        query = query.gte('confidence', minConfidence);
+      }
+
+      const { data, error } = await query;
+
+      if (error) throw error;
+
+      // Get statistics
+      const { data: stats } = await supabase
+        .from('alpha_by_location')
+        .select('*')
+        .order('verified_count', { ascending: false })
+        .limit(10);
+
+      return new Response(
+        JSON.stringify({
+          contributions: data || [],
+          statistics: stats || [],
+          total: data?.length || 0,
+          timestamp: new Date().toISOString(),
+        }),
+        { status: 200, headers }
+      );
+    } catch (error) {
+      console.error('Alpha GET error:', error);
+      return new Response(
+        JSON.stringify({
+          error: 'Failed to fetch alpha contributions',
+          message: error.message,
+        }),
+        { status: 500, headers }
+      );
+    }
+  }
+
+  // POST - Submit alpha contribution
+  if (req.method === 'POST') {
+    try {
+      const data = await req.json();
+
+      // Validate required fields
+      if (!data.agent_name || !data.location || !data.contribution) {
+        return new Response(
+          JSON.stringify({ error: 'Missing required fields' }),
+          { status: 400, headers }
+        );
+      }
+
+      const { contribution } = data;
+
+      // Validate contribution structure
+      if (
+        typeof contribution.startHour !== 'number' ||
+        typeof contribution.endHour !== 'number' ||
+        !contribution.type ||
+        contribution.startHour < 0 ||
+        contribution.startHour > 23 ||
+        contribution.endHour < 0 ||
+        contribution.endHour > 23
+      ) {
+        return new Response(
+          JSON.stringify({ error: 'Invalid contribution data' }),
+          { status: 400, headers }
+        );
+      }
+
+      // Insert alpha contribution
+      const { data: insertedData, error: insertError } = await supabase
+        .from('alpha_contributions')
+        .insert({
+          agent_name: data.agent_name,
+          location: data.location,
+          contribution_type: contribution.type,
+          start_hour: contribution.startHour,
+          end_hour: contribution.endHour,
+          verified: data.verified || false,
+          confidence: data.confidence || 0.5,
+          verification_reasons: data.verificationReasons || [],
+          timestamp: new Date(data.timestamp || Date.now()).toISOString(),
+        })
+        .select()
+        .single();
+
+      if (insertError) throw insertError;
+
+      return new Response(
+        JSON.stringify({
+          success: true,
+          message: 'Alpha contribution submitted successfully',
+          contribution: insertedData,
+        }),
+        { status: 200, headers }
+      );
+    } catch (error) {
+      console.error('Alpha POST error:', error);
+      return new Response(
+        JSON.stringify({
+          error: 'Failed to submit alpha contribution',
+          message: error.message,
+        }),
+        { status: 500, headers }
+      );
+    }
+  }
+
+  return new Response(
+    JSON.stringify({ error: 'Method not allowed' }),
+    { status: 405, headers }
+  );
+}

package/dashboard/api/submit.js

@@ -65,6 +65,29 @@ export default async function handler(req) {
 
     if (submissionError) throw submissionError;
 
+    // Handle alpha contribution if present
+    if (data.alpha_contribution) {
+      const alpha = data.alpha_contribution;
+      const { error: alphaError } = await supabase
+        .from('alpha_contributions')
+        .insert({
+          agent_name: data.agent_name,
+          location: data.location,
+          contribution_type: alpha.type,
+          start_hour: alpha.startHour,
+          end_hour: alpha.endHour,
+          verified: alpha.verified || false,
+          confidence: alpha.confidence || 0.5,
+          verification_reasons: alpha.verificationReasons || [],
+          timestamp: new Date(data.timestamp).toISOString(),
+        });
+
+      // Don't fail the entire request if alpha submission fails
+      if (alphaError) {
+        console.warn('Alpha contribution failed:', alphaError);
+      }
+    }
+
     // Update agent heartbeat (upsert)
     const { error: heartbeatError } = await supabase
       .from('agent_heartbeat')

package/dashboard/lib/migration-alpha-contributions.sql

@@ -0,0 +1,185 @@
+-- DeCharge Scout Dashboard - Alpha Contributions Migration
+-- Add this to your Supabase database to support verified local alpha contributions
+
+-- ============================================================================
+-- TABLE: alpha_contributions
+-- Stores verified local knowledge contributions from agents
+-- ============================================================================
+CREATE TABLE IF NOT EXISTS alpha_contributions (
+  id SERIAL PRIMARY KEY,
+  agent_name VARCHAR(255) NOT NULL,
+  location VARCHAR(255) NOT NULL,
+  contribution_type VARCHAR(20) NOT NULL CHECK (contribution_type IN ('peak', 'cheap', 'general')),
+  start_hour INTEGER NOT NULL CHECK (start_hour >= 0 AND start_hour <= 23),
+  end_hour INTEGER NOT NULL CHECK (end_hour >= 0 AND end_hour <= 23),
+
+  -- Verification fields
+  verified BOOLEAN DEFAULT FALSE,
+  confidence DECIMAL(4, 3) CHECK (confidence >= 0 AND confidence <= 1),
+  verification_reasons TEXT[],
+
+  -- Metadata
+  timestamp TIMESTAMP NOT NULL,
+  created_at TIMESTAMP DEFAULT NOW(),
+
+  -- Indexes for performance
+  CONSTRAINT valid_hour_range CHECK (start_hour <= end_hour)
+);
+
+-- Indexes for efficient querying
+CREATE INDEX idx_alpha_location ON alpha_contributions(location);
+CREATE INDEX idx_alpha_verified ON alpha_contributions(verified);
+CREATE INDEX idx_alpha_confidence ON alpha_contributions(confidence DESC);
+CREATE INDEX idx_alpha_created_at ON alpha_contributions(created_at DESC);
+CREATE INDEX idx_alpha_type ON alpha_contributions(contribution_type);
+
+-- ============================================================================
+-- VIEW: Verified Alpha Contributions (high confidence only)
+-- ============================================================================
+CREATE OR REPLACE VIEW verified_alpha_contributions AS
+SELECT
+  id,
+  agent_name,
+  location,
+  contribution_type,
+  start_hour,
+  end_hour,
+  confidence,
+  verification_reasons,
+  timestamp,
+  created_at
+FROM alpha_contributions
+WHERE verified = TRUE AND confidence >= 0.6
+ORDER BY confidence DESC, created_at DESC;
+
+-- ============================================================================
+-- VIEW: Alpha Contributions Summary by Location
+-- ============================================================================
+CREATE OR REPLACE VIEW alpha_by_location AS
+SELECT
+  location,
+  COUNT(*) as total_contributions,
+  COUNT(CASE WHEN verified = TRUE THEN 1 END) as verified_count,
+  AVG(confidence) as avg_confidence,
+  MAX(created_at) as latest_contribution
+FROM alpha_contributions
+WHERE created_at > NOW() - INTERVAL '30 days'
+GROUP BY location
+ORDER BY verified_count DESC, total_contributions DESC;
+
+-- ============================================================================
+-- VIEW: Peak Hours Analysis (most commonly reported)
+-- ============================================================================
+CREATE OR REPLACE VIEW peak_hours_analysis AS
+WITH hour_counts AS (
+  SELECT
+    location,
+    generate_series(start_hour, end_hour) as hour,
+    confidence,
+    contribution_type
+  FROM alpha_contributions
+  WHERE contribution_type = 'peak'
+    AND verified = TRUE
+    AND created_at > NOW() - INTERVAL '30 days'
+)
+SELECT
+  location,
+  hour,
+  COUNT(*) as report_count,
+  AVG(confidence) as avg_confidence,
+  COUNT(*) * AVG(confidence) as weighted_score
+FROM hour_counts
+GROUP BY location, hour
+HAVING COUNT(*) >= 2  -- At least 2 reports
+ORDER BY location, weighted_score DESC;
+
+-- ============================================================================
+-- FUNCTION: Get Alpha Insights for Location
+-- ============================================================================
+CREATE OR REPLACE FUNCTION get_alpha_insights(
+  p_location VARCHAR(255),
+  p_min_confidence DECIMAL DEFAULT 0.6
+)
+RETURNS TABLE (
+  contribution_type VARCHAR(20),
+  start_hour INTEGER,
+  end_hour INTEGER,
+  confidence DECIMAL(4, 3),
+  report_count BIGINT,
+  latest_report TIMESTAMP
+) AS $$
+BEGIN
+  RETURN QUERY
+  SELECT
+    ac.contribution_type,
+    ac.start_hour,
+    ac.end_hour,
+    AVG(ac.confidence)::DECIMAL(4, 3) as confidence,
+    COUNT(*) as report_count,
+    MAX(ac.created_at) as latest_report
+  FROM alpha_contributions ac
+  WHERE ac.location ILIKE '%' || p_location || '%'
+    AND ac.verified = TRUE
+    AND ac.confidence >= p_min_confidence
+    AND ac.created_at > NOW() - INTERVAL '30 days'
+  GROUP BY ac.contribution_type, ac.start_hour, ac.end_hour
+  ORDER BY report_count DESC, confidence DESC
+  LIMIT 10;
+END;
+$$ LANGUAGE plpgsql;
+
+-- ============================================================================
+-- FUNCTION: Calculate Contribution Quality Score
+-- ============================================================================
+CREATE OR REPLACE FUNCTION calculate_contribution_quality(
+  p_agent_name VARCHAR(255)
+)
+RETURNS TABLE (
+  agent_name VARCHAR(255),
+  total_contributions BIGINT,
+  verified_contributions BIGINT,
+  avg_confidence DECIMAL(4, 3),
+  quality_score DECIMAL(6, 2)
+) AS $$
+BEGIN
+  RETURN QUERY
+  SELECT
+    p_agent_name::VARCHAR(255),
+    COUNT(*)::BIGINT as total_contributions,
+    COUNT(CASE WHEN verified = TRUE THEN 1 END)::BIGINT as verified_contributions,
+    AVG(confidence)::DECIMAL(4, 3) as avg_confidence,
+    (
+      (COUNT(CASE WHEN verified = TRUE THEN 1 END)::DECIMAL / NULLIF(COUNT(*), 0)) * 100 +
+      (AVG(confidence) * 100)
+    )::DECIMAL(6, 2) as quality_score
+  FROM alpha_contributions
+  WHERE agent_name = p_agent_name;
+END;
+$$ LANGUAGE plpgsql;
+
+-- ============================================================================
+-- COMMENTS for documentation
+-- ============================================================================
+COMMENT ON TABLE alpha_contributions IS 'Stores verified local energy pricing knowledge from agents';
+COMMENT ON COLUMN alpha_contributions.verified IS 'TRUE if contribution matches actual pricing data';
+COMMENT ON COLUMN alpha_contributions.confidence IS 'Confidence score 0-1, higher means better match with actual data';
+COMMENT ON COLUMN alpha_contributions.verification_reasons IS 'Array of reasons explaining verification result';
+
+-- ============================================================================
+-- Sample queries for testing
+-- ============================================================================
+
+-- Get all verified contributions for a location
+-- SELECT * FROM verified_alpha_contributions WHERE location ILIKE '%mumbai%';
+
+-- Get alpha insights for a specific location
+-- SELECT * FROM get_alpha_insights('Mumbai', 0.7);
+
+-- Get contribution quality for an agent
+-- SELECT * FROM calculate_contribution_quality('Agent-X8DOAO');
+
+-- Get peak hours analysis
+-- SELECT * FROM peak_hours_analysis WHERE location ILIKE '%india%';
+
+-- Get alpha summary by location
+-- SELECT * FROM alpha_by_location ORDER BY verified_count DESC LIMIT 10;

package/dashboard/public/index.html

@@ -213,6 +213,132 @@
       font-weight: bold;
       color: #667eea;
     }
+
+    .alpha-grid {
+      display: grid;
+      grid-template-columns: repeat(auto-fill, minmax(300px, 1fr));
+      gap: 20px;
+      margin-top: 20px;
+    }
+
+    .alpha-card {
+      background: #f8f9fa;
+      padding: 20px;
+      border-radius: 8px;
+      border-left: 4px solid #4caf50;
+      transition: transform 0.2s;
+    }
+
+    .alpha-card:hover {
+      transform: translateY(-2px);
+      box-shadow: 0 4px 12px rgba(0, 0, 0, 0.1);
+    }
+
+    .alpha-card.unverified {
+      border-left-color: #ff9800;
+      opacity: 0.8;
+    }
+
+    .alpha-header {
+      display: flex;
+      justify-content: space-between;
+      align-items: center;
+      margin-bottom: 12px;
+    }
+
+    .alpha-type {
+      display: inline-block;
+      padding: 4px 10px;
+      background: #4caf50;
+      color: white;
+      border-radius: 12px;
+      font-size: 0.75em;
+      font-weight: 600;
+      text-transform: uppercase;
+    }
+
+    .alpha-type.cheap {
+      background: #2196f3;
+    }
+
+    .confidence-badge {
+      display: inline-block;
+      padding: 4px 10px;
+      border-radius: 12px;
+      font-size: 0.75em;
+      font-weight: 600;
+    }
+
+    .confidence-high {
+      background: #c8e6c9;
+      color: #2e7d32;
+    }
+
+    .confidence-medium {
+      background: #fff9c4;
+      color: #f57f17;
+    }
+
+    .confidence-low {
+      background: #ffccbc;
+      color: #d84315;
+    }
+
+    .alpha-hours {
+      font-size: 1.5em;
+      font-weight: bold;
+      color: #333;
+      margin: 10px 0;
+    }
+
+    .alpha-location {
+      color: #666;
+      font-size: 0.9em;
+      margin-bottom: 8px;
+    }
+
+    .alpha-agent {
+      color: #999;
+      font-size: 0.8em;
+    }
+
+    .verification-reason {
+      background: white;
+      padding: 8px;
+      border-radius: 4px;
+      margin-top: 10px;
+      font-size: 0.85em;
+      color: #666;
+      border-left: 3px solid #4caf50;
+    }
+
+    .verification-reason.warning {
+      border-left-color: #ff9800;
+    }
+
+    .verified-badge {
+      display: inline-flex;
+      align-items: center;
+      gap: 4px;
+      padding: 4px 8px;
+      background: #c8e6c9;
+      color: #2e7d32;
+      border-radius: 12px;
+      font-size: 0.75em;
+      font-weight: 600;
+    }
+
+    .unverified-badge {
+      display: inline-flex;
+      align-items: center;
+      gap: 4px;
+      padding: 4px 8px;
+      background: #ffccbc;
+      color: #d84315;
+      border-radius: 12px;
+      font-size: 0.75em;
+      font-weight: 600;
+    }
   </style>
 </head>
 <body>
@@ -255,6 +381,11 @@
       <div id="locations-map" class="map-grid"></div>
     </div>
 
+    <div class="section">
+      <h2>💡 Verified Local Alpha (Community Knowledge)</h2>
+      <div id="alpha-container"></div>
+    </div>
+
     <div class="section">
       <h2>📊 Recent Submissions</h2>
       <button class="refresh-btn" onclick="loadData()">Refresh Data</button>
@@ -295,6 +426,9 @@
         // Render submissions table
         renderSubmissionsTable(data.recentSubmissions || []);
 
+        // Load alpha contributions
+        await loadAlphaContributions();
+
         // Update timestamp
         document.getElementById('last-updated').textContent =
           `Last updated: ${new Date().toLocaleTimeString()}`;
@@ -308,6 +442,24 @@
       }
     }
 
+    async function loadAlphaContributions() {
+      try {
+        const response = await fetch(`${API_BASE}/api/alpha?verified=true&min_confidence=0.6`);
+
+        if (!response.ok) {
+          console.warn('Alpha API not available yet');
+          return;
+        }
+
+        const data = await response.json();
+        renderAlphaContributions(data.contributions || [], data.statistics || []);
+      } catch (error) {
+        console.warn('Error loading alpha contributions:', error);
+        document.getElementById('alpha-container').innerHTML =
+          '<div class="loading">Alpha contributions will appear here once the database is migrated</div>';
+      }
+    }
+
     function renderLocationsMap(locations) {
       const container = document.getElementById('locations-map');
 
@@ -325,6 +477,90 @@
       `).join('');
     }
 
+    function renderAlphaContributions(contributions, statistics) {
+      const container = document.getElementById('alpha-container');
+
+      if (contributions.length === 0) {
+        container.innerHTML = '<div class="loading">No verified alpha contributions yet. Share your local knowledge to be the first!</div>';
+        return;
+      }
+
+      // Show top locations first
+      let statsHtml = '';
+      if (statistics.length > 0) {
+        statsHtml = `
+          <div class="map-grid" style="margin-bottom: 20px;">
+            ${statistics.slice(0, 5).map(stat => `
+              <div class="location-card">
+                <h4>${escapeHtml(stat.location)}</h4>
+                <div class="count">${stat.verified_count}</div>
+                <div class="label">verified contributions</div>
+                <div style="margin-top: 8px; color: #666; font-size: 0.85em;">
+                  Avg confidence: ${(stat.avg_confidence * 100).toFixed(0)}%
+                </div>
+              </div>
+            `).join('')}
+          </div>
+        `;
+      }
+
+      container.innerHTML = statsHtml + `
+        <div class="alpha-grid">
+          ${contributions.slice(0, 12).map(alpha => {
+            const confidence = parseFloat(alpha.confidence);
+            const confidenceClass = confidence >= 0.8 ? 'confidence-high' :
+                                   confidence >= 0.6 ? 'confidence-medium' : 'confidence-low';
+            const confidenceLabel = confidence >= 0.8 ? 'High' :
+                                   confidence >= 0.6 ? 'Medium' : 'Low';
+
+            const formatHour = (h) => {
+              const hour = parseInt(h);
+              if (hour === 0) return '12 AM';
+              if (hour < 12) return `${hour} AM`;
+              if (hour === 12) return '12 PM';
+              return `${hour - 12} PM`;
+            };
+
+            const typeClass = alpha.contribution_type === 'peak' ? 'alpha-type' : 'alpha-type cheap';
+
+            return `
+              <div class="alpha-card ${alpha.verified ? '' : 'unverified'}">
+                <div class="alpha-header">
+                  <span class="${typeClass}">${alpha.contribution_type}</span>
+                  ${alpha.verified
+                    ? `<span class="verified-badge">✓ Verified</span>`
+                    : `<span class="unverified-badge">⚠ Unverified</span>`
+                  }
+                </div>
+
+                <div class="alpha-hours">
+                  ${formatHour(alpha.start_hour)} - ${formatHour(alpha.end_hour)}
+                </div>
+
+                <div class="alpha-location">📍 ${escapeHtml(alpha.location)}</div>
+
+                <div class="alpha-agent">
+                  By ${escapeHtml(alpha.agent_name)} • ${new Date(alpha.created_at).toLocaleDateString()}
+                </div>
+
+                <div style="margin-top: 12px;">
+                  <span class="confidence-badge ${confidenceClass}">
+                    ${confidenceLabel} Confidence (${(confidence * 100).toFixed(0)}%)
+                  </span>
+                </div>
+
+                ${alpha.verification_reasons && alpha.verification_reasons.length > 0 ? `
+                  <div class="verification-reason ${confidence < 0.6 ? 'warning' : ''}">
+                    ${escapeHtml(alpha.verification_reasons[0])}
+                  </div>
+                ` : ''}
+              </div>
+            `;
+          }).join('')}
+        </div>
+      `;
+    }
+
     function renderSubmissionsTable(submissions) {
       const container = document.getElementById('submissions-container');
 

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';
@@ -53,6 +53,7 @@ const CYCLE_INTERVAL_MS = 15 * 60 * 1000; // 15 minutes
 let isRunning = true;
 let totalRuns = 0;
 let stakeTransactionSignature = null;
+let pendingAlphaContribution = null; // Store alpha contribution for next submission
 
 // Readline interface for prompts
 const rl = createInterface({
@@ -172,16 +173,26 @@ async function main(options) {
       const detectedLocation = await getLocation();
       locationSpinner.succeed(chalk.green(`📍 Detected Location: ${detectedLocation}`));
 
-      // Ask user to confirm or override (no timeout - wait for input)
+      // Ask user to confirm or override with 10 second timeout
       console.log(chalk.blue('\nYou can use this location or enter a custom one.'));
       console.log(chalk.gray('(Press Enter to use detected location, or type a custom location like "Dallas,TX,USA")'));
+      console.log(chalk.gray('(Will auto-proceed in 10 seconds if no input)\n'));
 
       try {
-        const customLocation = await question('Enter location (or press Enter for auto-detected): ');
+        // Create a promise race between user input and timeout
+        const customLocation = await Promise.race([
+          question('Enter location (or press Enter for auto-detected): '),
+          new Promise((resolve) => {
+            setTimeout(() => {
+              console.log(chalk.yellow('\n⏱️  Timeout - using detected location'));
+              resolve('');
+            }, 10000); // 10 second timeout
+          })
+        ]);
 
         // Use custom location if provided, otherwise use detected
-        location = customLocation.trim() || detectedLocation;
-        if (customLocation.trim()) {
+        location = (customLocation || '').trim() || detectedLocation;
+        if ((customLocation || '').trim()) {
           console.log(chalk.green(`✓ Using custom location: ${location}`));
         } else {
           console.log(chalk.green(`✓ Using detected location: ${location}`));
@@ -277,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
@@ -341,14 +383,22 @@ async function runQueryCycle(wallet, agentName, location, options) {
         console.log(chalk.blue(`\n🌐 Dashboard API URL: ${apiUrl}`));
         console.log(chalk.gray(`📤 Submitting data...`));
 
+        const dashboardPayload = {
+          ...submissionData,
+          wallet: wallet, // wallet parameter from runQueryCycle
+          run_number: totalRuns
+        };
+
+        // Include alpha contribution if available
+        if (pendingAlphaContribution) {
+          dashboardPayload.alpha_contribution = pendingAlphaContribution;
+          console.log(chalk.blue(`📊 Including verified alpha contribution (${(pendingAlphaContribution.confidence * 100).toFixed(0)}% confidence)`));
+        }
+
         const response = await fetch(apiUrl, {
           method: 'POST',
           headers: { 'Content-Type': 'application/json' },
-          body: JSON.stringify({
-            ...submissionData,
-            wallet: wallet, // wallet parameter from runQueryCycle
-            run_number: totalRuns
-          })
+          body: JSON.stringify(dashboardPayload)
         });
 
         const responseText = await response.text();
@@ -358,6 +408,12 @@ async function runQueryCycle(wallet, agentName, location, options) {
           dashboardSpinner.succeed(chalk.green('✅ Dashboard submission successful!'));
           console.log(chalk.green(`🎉 Data should now appear at: https://decharge-scout.vercel.app/agentone`));
           console.log(chalk.gray(`Response: ${responseText}`));
+
+          // Clear pending alpha contribution after successful submission
+          if (pendingAlphaContribution) {
+            console.log(chalk.green(`   ✓ Alpha contribution synced to dashboard`));
+            pendingAlphaContribution = null;
+          }
         } else {
           dashboardSpinner.warn(chalk.yellow(`⚠️  Dashboard API returned: ${response.status}`));
           console.log(chalk.yellow(`Response: ${responseText}`));
@@ -420,6 +476,17 @@ async function runQueryCycle(wallet, agentName, location, options) {
             // Save contribution with verification status
             const contribution = saveAlphaContribution(parsed, agentName, location, verification);
 
+            // Store for dashboard submission
+            pendingAlphaContribution = {
+              type: parsed.type,
+              startHour: parsed.startHour,
+              endHour: parsed.endHour,
+              location: parsed.location,
+              verified: verification.verified,
+              confidence: verification.confidence,
+              verificationReasons: verification.reasons
+            };
+
             // Calculate bonus (higher for verified contributions)
             const alphaBonus = calculateAlphaBonus(parsed, verification);
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "decharge-scout",
-  "version": "4.0.0",
+  "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;
 }