avocavo 1.0.4 → 1.1.1

package/CHANGELOG.md

@@ -2,6 +2,46 @@
 
 All notable changes to the Avocavo CLI will be documented in this file.
 
+## [1.1.1] - 2025-08-21
+
+### ✨ UPC/Barcode Search Support
+- **NEW**: Complete UPC/barcode search functionality with `upc` and `upc-batch` commands
+- **NEW**: Access to 4.4M+ product database from USDA Branded Foods + Open Food Facts
+- **NEW**: Product information display with brand, ingredients, and nutrition data
+- **NEW**: UPC health check with `upc-health` command
+
+### 🔧 UPC Command Features
+- **ADDED**: `avocavo upc "041196912395"` - Single UPC lookup
+- **ADDED**: `avocavo upc-batch -u "041196912395" "123456789012"` - Batch UPC processing
+- **ADDED**: `avocavo upc-batch -f upcs.txt` - UPC search from file
+- **IMPROVED**: Comprehensive product display with nutritional information
+- **ENHANCED**: Response time reporting for UPC searches
+
+### 📚 API Integration
+- **UPDATED**: NutritionAPI class with `searchUPC()` and `searchUPCBatch()` methods
+- **IMPROVED**: Error handling for UPC service unavailability
+- **ADDED**: UPC health monitoring and status reporting
+
+## [1.0.5] - 2025-08-04
+
+### 🎯 Login Logic Improvements
+- **ENHANCED**: Improved login flow to always check server for all user API keys
+- **FIXED**: Better handling of invalid selected API keys - shows specific "invalid key" message
+- **ACCURATE**: Login now correctly identifies invalid keys vs missing keys vs multiple keys
+- **SMART**: More intelligent key validation and user guidance after login
+
+### 🔧 Key Selection Logic
+- **IMPROVED**: Always validates currently selected API key before showing account info
+- **FALLBACK**: If selected key is invalid and user has 1 key, auto-selects the working key
+- **GUIDANCE**: Clear differentiation between "invalid key" and "no keys" scenarios
+- **ROBUST**: Better error handling for key validation failures
+
+### 🛠️ Technical Enhancements
+- Consolidated login key detection into single comprehensive flow
+- Added key validation testing before displaying account information
+- Enhanced error messaging with specific guidance for each scenario
+- Improved fallback handling for API key enumeration failures
+
 ## [1.0.4] - 2025-08-04
 
 ### 🔧 Login Experience Fixes

package/bin/avocavo.js

@@ -5,7 +5,7 @@ const chalk = require('chalk');
 const path = require('path');
 const fs = require('fs');
 const axios = require('axios');
-const { NutritionAPI } = require('../lib/api');
+const { NutritionAPI, formatResponseTime } = require('../lib/api');
 const { AuthManager } = require('../lib/auth');
 const { formatNutrition, formatPerformanceMetrics, formatUSDAMatch, formatTable } = require('../lib/formatters');
 const { version } = require('../package.json');
@@ -78,79 +78,77 @@ program
       if (success) {
         console.log(chalk.green('✅ Successfully logged in!'));
         
-        // Check for API keys - first check if user has a selected key
-        let apiKey = await auth.getApiKey();
-        
-        if (apiKey) {
-          // User has a selected API key, test it
-          if (program.opts().verbose) {
-            console.log(chalk.gray(`Debug: Using selected API key: ${apiKey.substring(0, 12)}...`));
-          }
-          const api = new NutritionAPI(apiKey, program.opts().baseUrl, 30000, auth);
-          try {
-            const account = await api.getAccountUsage();
-            console.log(chalk.cyan(`📊 Account: ${account.email} (${account.api_tier} tier)`));
-            console.log(chalk.cyan(`📈 Usage: ${account.usage.current_month}/${account.usage.monthly_limit || 'unlimited'}`));
-          } catch (err) {
-            console.log(chalk.yellow('⚠️  Selected API key appears invalid'));
-            console.log(chalk.cyan('💡 Try selecting a different key with: avocavo keys switch'));
-            if (program.opts().verbose) {
-              console.log(chalk.gray(`Debug: ${err.message}`));
-            }
-          }
-        } else {
-          // No selected API key, check if user has any keys at all
-          try {
-            const KeyManager = require('../lib/keys');
-            const keyManager = new KeyManager(auth, program.opts().baseUrl);
+        // Check for API keys - always check server for all keys
+        try {
+          const KeyManager = require('../lib/keys');
+          const keyManager = new KeyManager(auth, program.opts().baseUrl);
+          
+          // Get user's API keys from server
+          const headers = await keyManager.getAuthHeaders();
+          const response = await axios.get(`${program.opts().baseUrl}/api/keys`, { headers });
+          
+          if (response.data.keys && response.data.keys.length > 0) {
+            const keyCount = response.data.keys.length;
             
-            // Get user's API keys from server
-            const headers = await keyManager.getAuthHeaders();
-            const response = await axios.get(`${program.opts().baseUrl}/api/keys`, { headers });
+            // Check if user already has a selected key
+            let currentKey = await auth.getApiKey();
+            let keyWorked = false;
             
-            if (response.data.keys && response.data.keys.length > 0) {
-              const keyCount = response.data.keys.length;
-              
-              if (keyCount === 1) {
-                // Auto-select the single key
-                console.log(chalk.cyan('🔄 You have 1 API key. Auto-selecting it...'));
-                const singleKey = response.data.keys[0];
-                
-                // Store the key as selected (simplified approach)
-                await auth.storeApiKeySecurely(auth.getUserInfo().email, singleKey.api_key);
-                
-                // Test the auto-selected key
-                const api = new NutritionAPI(singleKey.api_key, program.opts().baseUrl, 30000, auth);
-                try {
-                  const account = await api.getAccountUsage();
-                  console.log(chalk.green('✅ API key activated!'));
-                  console.log(chalk.cyan(`📊 Account: ${account.email} (${account.api_tier} tier)`));
-                  console.log(chalk.cyan(`📈 Usage: ${account.usage.current_month}/${account.usage.monthly_limit || 'unlimited'}`));
-                } catch (err) {
-                  console.log(chalk.yellow('⚠️  Auto-selected API key appears invalid'));
-                  console.log(chalk.cyan('💡 Check your keys with: avocavo keys list'));
+            if (currentKey) {
+              // Test the current selected key
+              const api = new NutritionAPI(currentKey, program.opts().baseUrl, 30000, auth);
+              try {
+                const account = await api.getAccountUsage();
+                console.log(chalk.cyan(`📊 Account: ${account.email} (${account.api_tier} tier)`));
+                console.log(chalk.cyan(`📈 Usage: ${account.usage.current_month}/${account.usage.monthly_limit || 'unlimited'}`));
+                keyWorked = true;
+              } catch (err) {
+                console.log(chalk.yellow('⚠️  Currently selected API key appears invalid'));
+                if (program.opts().verbose) {
+                  console.log(chalk.gray(`Debug: ${err.message}`));
                 }
-              } else {
-                // Multiple keys - prompt user to select one
-                console.log(chalk.cyan(`💡 You have ${keyCount} API keys but none selected. Choose one to activate:`));
-                console.log(chalk.cyan('   avocavo keys switch'));
-                console.log(chalk.gray('   or'));
-                console.log(chalk.cyan('   avocavo keys list'));
               }
-            } else {
-              // No API keys at all
-              console.log(chalk.yellow('⚠️  You don\'t have any API keys yet'));
-              console.log(chalk.cyan('💡 Create your first API key to start using the nutrition API:'));
-              console.log(chalk.cyan('   avocavo keys create'));
             }
-          } catch (keyCheckError) {
-            // Fallback to create message if we can't check existing keys
-            console.log(chalk.yellow('⚠️  Unable to check for existing API keys'));
-            console.log(chalk.cyan('💡 Create an API key to start using the nutrition API:'));
-            console.log(chalk.cyan('   avocavo keys create'));
-            if (program.opts().verbose) {
-              console.log(chalk.gray(`Debug: ${keyCheckError.message}`));
+            
+            // If no working key and user has exactly 1 key, auto-select it
+            if (!keyWorked && keyCount === 1) {
+              console.log(chalk.cyan('🔄 Auto-selecting your API key...'));
+              const singleKey = response.data.keys[0];
+              
+              // Store the key as selected
+              await auth.storeApiKeySecurely(auth.getUserInfo().email, singleKey.api_key);
+              
+              // Test the auto-selected key
+              const api = new NutritionAPI(singleKey.api_key, program.opts().baseUrl, 30000, auth);
+              try {
+                const account = await api.getAccountUsage();
+                console.log(chalk.green('✅ API key activated!'));
+                console.log(chalk.cyan(`📊 Account: ${account.email} (${account.api_tier} tier)`));
+                console.log(chalk.cyan(`📈 Usage: ${account.usage.current_month}/${account.usage.monthly_limit || 'unlimited'}`));
+              } catch (err) {
+                console.log(chalk.yellow('⚠️  Auto-selected API key appears invalid'));
+                console.log(chalk.cyan('💡 Check your keys with: avocavo keys list'));
+              }
+            } else if (!keyWorked && keyCount > 1) {
+              // Multiple keys - prompt user to select one
+              console.log(chalk.cyan(`💡 You have ${keyCount} API keys. Choose one to activate:`));
+              console.log(chalk.cyan('   avocavo keys switch'));
+              console.log(chalk.gray('   or'));
+              console.log(chalk.cyan('   avocavo keys list'));
             }
+          } else {
+            // No API keys at all
+            console.log(chalk.yellow('⚠️  You don\'t have any API keys yet'));
+            console.log(chalk.cyan('💡 Create your first API key to start using the nutrition API:'));
+            console.log(chalk.cyan('   avocavo keys create'));
+          }
+        } catch (keyCheckError) {
+          // Fallback to create message if we can't check existing keys
+          console.log(chalk.yellow('⚠️  Unable to check for existing API keys'));
+          console.log(chalk.cyan('💡 Create an API key to start using the nutrition API:'));
+          console.log(chalk.cyan('   avocavo keys create'));
+          if (program.opts().verbose) {
+            console.log(chalk.gray(`Debug: ${keyCheckError.message}`));
           }
         }
       } else {
@@ -665,6 +663,246 @@ program
     }
   });
 
+// UPC/Barcode search command
+program
+  .command('upc <upc>')
+  .description('Search for product information by UPC/barcode')
+  .option('--verbose', 'Show detailed product information')
+  .action(async (upc, options) => {
+    try {
+      const api = await getApiClient();
+      const globalOpts = program.opts();
+      const verbose = options.verbose || globalOpts.verbose;
+      
+      console.log(chalk.cyan(`🔍 Searching UPC: ${upc}...`));
+      
+      const result = await api.searchUPC(upc);
+      
+      if (program.opts().json) {
+        console.log(JSON.stringify(result, null, 2));
+        return;
+      }
+
+      if (result.success && result.product) {
+        const product = result.product;
+        console.log(chalk.green(`✅ Product Found!`));
+        console.log('');
+        
+        // Basic product info
+        if (product.product_name) {
+          console.log(`📦 ${chalk.bold('Product:')} ${chalk.cyan(product.product_name)}`);
+        }
+        if (product.brand) {
+          console.log(`🏷️  ${chalk.bold('Brand:')} ${chalk.yellow(product.brand)}`);
+        }
+        if (product.manufacturer) {
+          console.log(`🏭 ${chalk.bold('Manufacturer:')} ${chalk.gray(product.manufacturer)}`);
+        }
+        
+        // Data sources
+        if (product.sources && product.sources.length > 0) {
+          console.log(`📊 ${chalk.bold('Sources:')} ${chalk.magenta(product.sources.join(', '))}`);
+        }
+        
+        // Categories
+        if (product.categories && product.categories.length > 0) {
+          const categoryDisplay = product.categories.slice(0, 3).join(', ');
+          const moreCategories = product.categories.length > 3 ? ` (+${product.categories.length - 3} more)` : '';
+          console.log(`📋 ${chalk.bold('Categories:')} ${chalk.blue(categoryDisplay)}${chalk.gray(moreCategories)}`);
+        }
+        
+        // Serving info
+        if (product.serving_size) {
+          console.log(`🥄 ${chalk.bold('Serving Size:')} ${chalk.cyan(product.serving_size)}`);
+        }
+        if (product.servings_per_container) {
+          console.log(`📦 ${chalk.bold('Servings Per Container:')} ${chalk.cyan(product.servings_per_container)}`);
+        }
+        
+        // Nutrition data sample (if available)
+        if (product.nutrition && typeof product.nutrition === 'object' && Object.keys(product.nutrition).length > 0) {
+          console.log('');
+          console.log(chalk.bold('🍎 Nutrition Data Available:'));
+          
+          // Show sample from merged nutrition if available
+          const nutritionData = product.nutrition.merged || product.nutrition.usda || product.nutrition.openfoodfacts || product.nutrition;
+          if (nutritionData && typeof nutritionData === 'object') {
+            const sampleNutrients = Object.entries(nutritionData)
+              .slice(0, 5)
+              .filter(([key, value]) => value !== null && value !== undefined);
+            
+            sampleNutrients.forEach(([nutrient, value]) => {
+              console.log(`  ${chalk.gray(nutrient.replace(/_/g, ' ').toUpperCase())}:`, chalk.green(value));
+            });
+            
+            const totalNutrients = Object.keys(nutritionData).length;
+            if (totalNutrients > 5) {
+              console.log(`  ${chalk.gray(`... and ${totalNutrients - 5} more nutrients`)}`);
+            }
+          }
+        }
+        
+        // Verbose information
+        if (verbose) {
+          console.log('');
+          console.log(chalk.bold('📝 Additional Details:'));
+          
+          if (product.ingredients_text) {
+            const ingredientsPreview = product.ingredients_text.length > 100 ? 
+              product.ingredients_text.substring(0, 100) + '...' : product.ingredients_text;
+            console.log(`  ${chalk.bold('Ingredients:')} ${chalk.gray(ingredientsPreview)}`);
+          }
+          
+          if (product.packaging) {
+            console.log(`  ${chalk.bold('Packaging:')} ${chalk.gray(product.packaging)}`);
+          }
+          
+          if (product.countries && product.countries.length > 0) {
+            console.log(`  ${chalk.bold('Countries:')} ${chalk.gray(product.countries.join(', '))}`);
+          }
+          
+          if (product.quality_score) {
+            console.log(`  ${chalk.bold('Quality Score:')} ${chalk.cyan(product.quality_score)}`);
+          }
+          
+          if (product.images && product.images.length > 0) {
+            console.log(`  ${chalk.bold('Images:')} ${chalk.cyan(product.images.length)} available`);
+          }
+        }
+        
+        // Performance info
+        if (result.processing_time_ms) {
+          console.log('');
+          console.log(`⏱️  ${chalk.gray('Processing Time:')} ${formatResponseTime(result.processing_time_ms)}`);
+        }
+        if (result.from_cache) {
+          console.log(`💾 ${chalk.gray('Source:')} ${chalk.green('Cache (fast response)')}`);
+        }
+        
+      } else {
+        console.log(chalk.yellow(`❌ Product not found for UPC: ${upc}`));
+        if (result.error) {
+          console.log(chalk.gray(`Error: ${result.error}`));
+        }
+        console.log('');
+        console.log(chalk.cyan('💡 Tips:'));
+        console.log(chalk.gray('  • Check that the UPC is correct (12-13 digits)'));
+        console.log(chalk.gray('  • Try removing any leading zeros'));
+        console.log(chalk.gray('  • Some products may not be in our 4.4M+ product database'));
+      }
+    } catch (error) {
+      console.error(chalk.red(`❌ UPC search error: ${error.message}`));
+      process.exit(1);
+    }
+  });
+
+// UPC batch search command
+program
+  .command('upc-batch')
+  .description('Search multiple UPCs/barcodes efficiently')
+  .option('-u, --upcs <upcs...>', 'UPCs to search')
+  .option('-f, --file <file>', 'Read UPCs from file (one per line)')
+  .option('--verbose', 'Show detailed results')
+  .action(async (options) => {
+    try {
+      let upcs = [];
+      
+      if (options.file) {
+        const content = secureReadFile(options.file);
+        upcs = content.split('\n').map(line => line.trim()).filter(line => line);
+      } else if (options.upcs) {
+        upcs = options.upcs;
+      } else {
+        console.log(chalk.red('❌ Please provide UPCs via --upcs or --file'));
+        process.exit(1);
+      }
+
+      if (upcs.length === 0) {
+        console.log(chalk.red('❌ No UPCs provided'));
+        process.exit(1);
+      }
+
+      const api = await getApiClient();
+      const globalOpts = program.opts();
+      const verbose = options.verbose || globalOpts.verbose;
+      
+      console.log(chalk.cyan(`🔍 Batch searching ${upcs.length} UPCs...`));
+      
+      const result = await api.searchUPCBatch(upcs);
+      
+      if (program.opts().json) {
+        console.log(JSON.stringify(result, null, 2));
+        return;
+      }
+
+      if (result.success) {
+        console.log(chalk.green(`✅ Batch search complete!`));
+        console.log(chalk.cyan(`📊 Found: ${result.summary.found}/${result.summary.total} products`));
+        console.log('');
+        
+        // Results table
+        const tableData = result.results.map(item => [
+          item.success ? '✅' : '❌',
+          item.upc,
+          item.success && item.product ? (item.product.product_name || 'Unknown Product') : 'Not Found',
+          item.success && item.product ? (item.product.brand || 'Unknown Brand') : 'N/A',
+          item.success && item.product ? item.product.sources.join(', ') : 'N/A'
+        ]);
+        
+        console.log(formatTable([
+          ['Status', 'UPC', 'Product Name', 'Brand', 'Sources'],
+          ...tableData
+        ]));
+        
+        // Detailed results for found products (verbose mode)
+        if (verbose) {
+          const foundProducts = result.results.filter(r => r.success && r.product);
+          if (foundProducts.length > 0) {
+            console.log('');
+            console.log(chalk.bold('📦 Product Details:'));
+            foundProducts.forEach((item, index) => {
+              const product = item.product;
+              console.log(`\n${index + 1}. ${chalk.cyan(product.product_name || 'Unknown Product')} (${item.upc})`);
+              
+              if (product.brand) {
+                console.log(`   Brand: ${chalk.yellow(product.brand)}`);
+              }
+              if (product.categories && product.categories.length > 0) {
+                console.log(`   Categories: ${chalk.blue(product.categories.slice(0, 2).join(', '))}`);
+              }
+              if (product.serving_size) {
+                console.log(`   Serving: ${chalk.gray(product.serving_size)}`);
+              }
+              
+              // Nutrition sample
+              if (product.nutrition) {
+                const nutritionData = product.nutrition.merged || product.nutrition.usda || product.nutrition.openfoodfacts || product.nutrition;
+                if (nutritionData && typeof nutritionData === 'object') {
+                  const calories = nutritionData.energy_kcal || nutritionData.calories;
+                  const protein = nutritionData.protein;
+                  if (calories) console.log(`   Calories: ${chalk.green(calories)}`);
+                  if (protein) console.log(`   Protein: ${chalk.green(protein)}g`);
+                }
+              }
+            });
+          }
+        }
+        
+        // Performance summary
+        if (result.processing_time_ms) {
+          console.log(`\n⏱️  ${chalk.gray('Total Processing Time:')} ${formatResponseTime(result.processing_time_ms)}`);
+        }
+        
+      } else {
+        console.log(chalk.red(`❌ ${result.error || 'Batch search failed'}`));
+        process.exit(1);
+      }
+    } catch (error) {
+      console.error(chalk.red(`❌ UPC batch search error: ${error.message}`));
+      process.exit(1);
+    }
+  });
+
 // Health check command
 program
   .command('health')
@@ -750,6 +988,8 @@ async function getApiClient(requireAuth = true) {
   return new NutritionAPI(apiKey, globalOpts.baseUrl, 30000, auth);
 }
 
+// Helper function already imported from api.js
+
 // Handle unknown commands
 program.on('command:*', () => {
   console.error(chalk.red(`❌ Unknown command: ${program.args.join(' ')}`));
@@ -774,6 +1014,10 @@ Examples:
   $ avocavo ingredient "1 cup rice" -v     # Include USDA verification URL
   $ avocavo recipe -i "2 cups flour" "1 cup milk" -s 8  # Analyze recipe
   $ avocavo batch -i "1 cup rice" "2 tbsp oil" "4 oz chicken"  # Batch analysis
+  $ avocavo upc "041196912395"             # Search UPC/barcode
+  $ avocavo upc "041196912395" --verbose   # Detailed UPC product info
+  $ avocavo upc-batch -u "041196912395" "123456789012"  # Batch UPC search
+  $ avocavo upc-batch -f upcs.txt          # UPC search from file
   $ avocavo health                         # Check API health
 
 Authentication:

package/lib/api.js

@@ -1,262 +1,197 @@
 const axios = require('axios');
 const chalk = require('chalk');
 
-class ApiError extends Error {
-  constructor(message, statusCode = null, response = null) {
-    super(message);
-    this.name = 'ApiError';
-    this.statusCode = statusCode;
-    this.response = response;
-  }
-}
-
 class NutritionAPI {
-  constructor(apiKey, baseUrl = 'https://app.avocavo.app', timeout = 30000, authManager = null) {
+  constructor(apiKey, baseUrl = 'https://app.avocavo.app', timeout = 30000, auth = null) {
     this.apiKey = apiKey;
-    this.baseUrl = baseUrl.replace(/\/$/, '');
+    this.baseUrl = baseUrl.replace(/\/$/, ''); // Remove trailing slash
     this.timeout = timeout;
-    this.authManager = authManager;
+    this.auth = auth;
     
-    // Create axios instance
+    // Create axios instance with default configuration
     this.client = axios.create({
-      baseURL: this.baseUrl,
       timeout: this.timeout,
       headers: {
         'Content-Type': 'application/json',
-        'User-Agent': 'avocavo-nutrition-cli/1.8.0'
-      }
-    });
-    
-    // Add API key to requests if provided
-    if (this.apiKey) {
-      this.client.defaults.headers['X-API-Key'] = this.apiKey;
-    }
-    
-    // Add request interceptor to handle authentication
-    this.client.interceptors.request.use(async (config) => {
-      // Determine authentication method based on endpoint
-      const endpoint = config.url;
-      
-      if (process.env.NODE_ENV === 'development' || process.env.AVOCAVO_DEBUG) {
-        console.log(`[DEBUG] Request to ${endpoint} with API key: ${this.apiKey ? '[REDACTED]' : 'none'}`);
-        // Sanitize headers before logging
-        const sanitizedHeaders = { ...config.headers };
-        if (sanitizedHeaders['X-API-Key']) sanitizedHeaders['X-API-Key'] = '[REDACTED]';
-        if (sanitizedHeaders['Authorization']) sanitizedHeaders['Authorization'] = '[REDACTED]';
-        console.log(`[DEBUG] Request headers:`, JSON.stringify(sanitizedHeaders, null, 2));
+        'User-Agent': 'avocavo-cli/1.1.0'
       }
-      
-      if (endpoint.startsWith('/api/auth/')) {
-        // JWT authentication for key management endpoints
-        if (this.authManager) {
-          const jwt = await this.authManager.getJwtToken();
-          if (jwt) {
-            config.headers['Authorization'] = `Bearer ${jwt}`;
-            // Remove API key header for JWT endpoints
-            delete config.headers['X-API-Key'];
-          }
-        }
-      } else if (endpoint.startsWith('/api/v2/nutrition/') || endpoint.startsWith('/api/v1/nutrition/')) {
-        // API key authentication for nutrition endpoints
-        if (this.apiKey) {
-          // Use API key from constructor (command line or direct)
-          config.headers['X-API-Key'] = this.apiKey;
-        } else if (this.authManager) {
-          // Try to get selected API key from auth manager
-          const apiKey = await this.authManager.getApiKey();
-          if (apiKey) {
-            config.headers['X-API-Key'] = apiKey;
-          }
-        }
-      }
-      
-      return config;
     });
-    
-    // Response interceptor for error handling
-    this.client.interceptors.response.use(
-      response => response,
-      error => {
-        if (error.response) {
-          const status = error.response.status;
-          const data = error.response.data;
-          
-          let message = data?.error || `HTTP ${status}`;
-          
-          if (status === 401) {
-            message = 'Invalid API key or authentication required';
-            if (process.env.NODE_ENV === 'development' || process.env.AVOCAVO_DEBUG) {
-              console.log(`[DEBUG] 401 Response:`, JSON.stringify(data, null, 2));
-            }
-          } else if (status === 402) {
-            message = 'Trial expired or payment required';
-          } else if (status === 403) {
-            message = 'Feature not available on your plan';
-          } else if (status === 429) {
-            message = 'Rate limit exceeded';
-          } else if (status >= 500) {
-            message = 'Server error - please try again later';
-          }
-          
-          throw new ApiError(message, status, data);
-        } else if (error.request) {
-          throw new ApiError('Connection error. Check your internet connection.');
-        } else {
-          throw new ApiError(`Request failed: ${error.message}`);
-        }
-      }
-    );
-  }
 
-  async analyze(input, servings = null) {
-    try {
-      // Smart routing to proper structured endpoints based on input type
-      if (typeof input === 'string') {
-        // Single ingredient - use bulletproof V2 ingredient endpoint
-        return await this.analyzeIngredient(input);
-      } else if (Array.isArray(input)) {
-        if (servings && servings > 1) {
-          // Recipe with servings - use bulletproof V2 recipe endpoint
-          return await this.analyzeRecipe(input, servings);
-        } else {
-          // Multiple ingredients without servings - use bulletproof V2 batch endpoint
-          return await this.analyzeBatch(input);
-        }
+    // Set authentication headers
+    if (this.apiKey) {
+      if (this.apiKey.startsWith('eyJ') || this.apiKey.includes('.')) {
+        // JWT token
+        this.client.defaults.headers['Authorization'] = `Bearer ${this.apiKey}`;
       } else {
-        throw new Error('Input must be a string (ingredient) or array (recipe/batch)');
+        // API key
+        this.client.defaults.headers['X-API-Key'] = this.apiKey;
       }
-    } catch (error) {
-      throw error;
     }
   }
 
-  async analyzeIngredient(ingredient, includeVerification = false, verbose = false) {
+  async analyzeIngredient(ingredient, verify = false, verbose = false) {
     try {
-      const requestData = {
+      const response = await this.client.post(`${this.baseUrl}/api/v2/nutrition/ingredient`, {
         ingredient: ingredient
-      };
-      
-      // Add verbose parameter if requested
-      if (verbose) {
-        requestData.verbose = true;
-      }
-      
-      const response = await this.client.post('/api/v2/nutrition/ingredient', requestData);
-      
-      const result = response.data;
-      
-      // For backward compatibility, ensure verification URL is included if requested
-      if (includeVerification && result.success && result.nutrition?.fdc_id) {
-        result.verification_url = `https://fdc.nal.usda.gov/fdc-app.html#/food-details/${result.nutrition.fdc_id}`;
-      }
-      
-      return result;
+      });
+
+      return response.data;
     } catch (error) {
-      throw error;
+      throw this.handleError(error);
     }
   }
 
   async analyzeRecipe(ingredients, servings = 1, verbose = false) {
     try {
-      const requestData = {
+      const response = await this.client.post(`${this.baseUrl}/api/v2/nutrition/recipe`, {
         ingredients: ingredients,
         servings: servings
-      };
-      
-      // Add verbose parameter if requested
-      if (verbose) {
-        requestData.verbose = true;
-      }
-      
-      const response = await this.client.post('/api/v2/nutrition/recipe', requestData);
-      
+      });
+
       return response.data;
     } catch (error) {
-      throw error;
+      throw this.handleError(error);
     }
   }
 
   async analyzeBatch(ingredients, verbose = false) {
     try {
-      // The batch endpoint now supports both array of strings and array of objects
-      const requestData = {
-        ingredients: ingredients
-      };
-      
-      // Add verbose parameter if requested
-      if (verbose) {
-        requestData.verbose = true;
-      }
-      
-      const response = await this.client.post('/api/v2/nutrition/batch', requestData);
-      
+      // Transform array of strings to array of objects expected by batch endpoint
+      const ingredientObjects = ingredients.map((ingredient, index) => ({
+        ingredient: ingredient,
+        id: `item_${index + 1}`
+      }));
+
+      const response = await this.client.post(`${this.baseUrl}/api/v2/nutrition/batch`, {
+        ingredients: ingredientObjects
+      });
+
       return response.data;
     } catch (error) {
-      throw error;
+      throw this.handleError(error);
     }
   }
 
   async getAccountUsage() {
     try {
-      const response = await this.client.get('/api/v2/nutrition/account/usage');
-      
-      // V2 endpoint returns correct format
-      const data = response.data;
-      return {
-        email: data.account?.email || 'Unknown',
-        api_tier: data.account?.api_tier || 'Unknown',
-        subscription_status: data.account?.subscription_status || 'Unknown',
-        usage: data.usage || {
-          current_month: 0,
-          monthly_limit: 1000,
-          remaining: 1000,
-          percentage_used: 0,
-          reset_date: new Date().toISOString(),
-          days_until_reset: 30
-        },
-        // Include detailed credit information
-        credits: {
-          total: data.usage?.total_credits || 0,
-          trial: data.usage?.trial_credits || 0,
-          monthly: data.usage?.monthly_credits || 0,
-          paid: data.usage?.paid_credits || 0
-        }
-      };
+      const response = await this.client.get(`${this.baseUrl}/api/v2/nutrition/account/usage`);
+      return response.data;
+    } catch (error) {
+      throw this.handleError(error);
+    }
+  }
+
+  async healthCheck() {
+    try {
+      // Remove auth headers for health check
+      const headers = { ...this.client.defaults.headers };
+      delete headers['X-API-Key'];
+      delete headers['Authorization'];
+
+      const response = await this.client.get(`${this.baseUrl}/api/v2/nutrition/health`, {
+        headers: headers
+      });
+
+      return response.data;
     } catch (error) {
-      throw error;
+      throw this.handleError(error);
     }
   }
 
-  async verifyFdcId(fdcId) {
+  // NEW UPC FUNCTIONALITY
+  async searchUPC(upc) {
     try {
-      const response = await this.client.get(`/api/v2/nutrition/nutrition/verify/${fdcId}`);
+      const response = await this.client.post(`${this.baseUrl}/api/v2/upc/ingredient`, {
+        upc: upc
+      });
+
       return response.data;
     } catch (error) {
-      throw error;
+      throw this.handleError(error);
     }
   }
 
-  async healthCheck() {
+  async searchUPCBatch(upcs) {
     try {
-      // Basic health check (no auth required)
-      const tempHeaders = { ...this.client.defaults.headers };
-      delete this.client.defaults.headers['X-API-Key'];
-      
-      const response = await this.client.get('/health');
-      
-      // Restore headers
-      this.client.defaults.headers = tempHeaders;
-      
+      const response = await this.client.post(`${this.baseUrl}/api/v2/upc/batch`, {
+        upcs: upcs
+      });
+
       return response.data;
     } catch (error) {
-      // Restore headers even on error
-      if (this.apiKey) {
-        this.client.defaults.headers['X-API-Key'] = this.apiKey;
+      throw this.handleError(error);
+    }
+  }
+
+  async upcHealthCheck() {
+    try {
+      // Remove auth headers for health check
+      const headers = { ...this.client.defaults.headers };
+      delete headers['X-API-Key'];
+      delete headers['Authorization'];
+
+      const response = await this.client.get(`${this.baseUrl}/api/upc/health`, {
+        headers: headers
+      });
+
+      return response.data;
+    } catch (error) {
+      throw this.handleError(error);
+    }
+  }
+
+  handleError(error) {
+    if (error.response) {
+      const status = error.response.status;
+      const data = error.response.data;
+
+      // Extract error message
+      let message = data?.error || data?.message || `HTTP ${status} Error`;
+
+      // Handle specific status codes
+      switch (status) {
+        case 401:
+          message = 'Invalid API key or authentication failed';
+          break;
+        case 402:
+          message = 'Payment required - upgrade your plan or add credits';
+          break;
+        case 403:
+          message = data?.error || 'Access denied - feature not available on your plan';
+          break;
+        case 429:
+          const limit = data?.limit;
+          const usage = data?.usage;
+          message = `Rate limit exceeded${limit ? ` (${usage}/${limit})` : ''}`;
+          break;
+        case 500:
+        case 502:
+        case 503:
+          message = 'Server error - please try again later';
+          break;
       }
-      throw error;
+
+      const apiError = new Error(message);
+      apiError.status = status;
+      apiError.response = data;
+      return apiError;
+    } else if (error.request) {
+      return new Error('Network error - please check your connection');
+    } else {
+      return new Error(error.message || 'Unknown error occurred');
     }
   }
+}
 
+// Helper function to format response time
+function formatResponseTime(ms) {
+  if (ms < 1000) {
+    return chalk.green(`${ms}ms`);
+  } else if (ms < 3000) {
+    return chalk.yellow(`${ms}ms`);
+  } else {
+    return chalk.red(`${ms}ms`);
+  }
 }
 
-module.exports = { NutritionAPI, ApiError };
+module.exports = { NutritionAPI, formatResponseTime };

package/lib/auth-supabase.js

@@ -74,7 +74,7 @@ try {
 }
 
 class SupabaseAuthManager {
-  constructor(baseUrl = 'https://app.avocavo.app') {
+  constructor(baseUrl = 'https://nutrition.avocavo.app') {
     this.baseUrl = baseUrl.replace(/\/$/, '');
     this.serviceName = 'avocavo-nutrition';
     this.keytarAvailable = keytarAvailable;

package/lib/auth.js

@@ -17,7 +17,7 @@ try {
 }
 
 class AuthManager {
-  constructor(baseUrl = 'https://app.avocavo.app') {
+  constructor(baseUrl = 'https://nutrition.avocavo.app') {
     this.baseUrl = baseUrl.replace(/\/$/, '');
     this.serviceName = 'avocavo-nutrition';
     this.keytarAvailable = keytarAvailable;

package/lib/keys.js

@@ -5,7 +5,7 @@ const Table = require('cli-table3');
 const inquirer = require('inquirer');
 
 class KeyManager {
-  constructor(auth, baseUrl = 'https://app.avocavo.app') {
+  constructor(auth, baseUrl = 'https://nutrition.avocavo.app') {
     this.auth = auth;
     this.baseUrl = baseUrl;
   }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "avocavo",
-  "version": "1.0.4",
+  "version": "1.1.1",
   "description": "Avocavo CLI - Nutrition analysis made simple. Get accurate USDA nutrition data with secure authentication.",
   "main": "index.js",
   "bin": {