pkg-track 1.0.0

package/src/open.js

@@ -0,0 +1,209 @@
+const chalk = require('chalk');
+const inquirer = require('inquirer');
+const open = require('open');
+const { getAllPackages } = require('./db');
+const { showBanner } = require('./banner');
+
+/**
+ * Get tracking URL for a carrier
+ */
+function getTrackingUrl(carrier, trackingNumber) {
+  const urls = {
+    'UPS': `https://www.ups.com/track?tracknum=${trackingNumber}`,
+    'FedEx': `https://www.fedex.com/fedextrack/?trknbr=${trackingNumber}`,
+    'USPS': `https://tools.usps.com/go/TrackConfirmAction?tLabels=${trackingNumber}`,
+    'Amazon Logistics': `https://track.amazon.com/tracking/${trackingNumber}`
+  };
+  return urls[carrier] || null;
+}
+
+/**
+ * Get status emoji and label
+ */
+function getStatusDisplay(status) {
+  const statusMap = {
+    'delivered': { emoji: '✅', label: 'Delivered' },
+    'in_transit': { emoji: '🚚', label: 'In Transit' },
+    'out_for_delivery': { emoji: '📦', label: 'Out for Delivery' },
+    'pending': { emoji: '⏳', label: 'Pending' },
+    'delayed': { emoji: '⚠️', label: 'Delayed' },
+  };
+  return statusMap[status] || { emoji: '❓', label: 'Unknown' };
+}
+
+/**
+ * Interactive package opener
+ */
+async function openPackages() {
+  // Show banner
+  showBanner();
+  
+  const SUPPORTED = ['UPS', 'FedEx', 'USPS', 'Amazon Logistics'];
+  const allPackages = getAllPackages(false); // Only non-delivered
+  
+  // Filter to supported carriers only
+  const packages = allPackages.filter(pkg => SUPPORTED.includes(pkg.carrier));
+  
+  if (packages.length === 0) {
+    console.log(chalk.yellow('\n📭 No packages to track'));
+    console.log(chalk.gray('Run `pkg sync` to scan for new packages\n'));
+    return;
+  }
+  
+  console.log(chalk.gray(`Showing ${packages.length} undelivered package(s) from your last sync`));
+  console.log(chalk.gray('💡 Tip: Run `pkg sync` again to get the latest updates from your email\n'));
+  
+  // Pagination settings
+  const PAGE_SIZE = 5;
+  let currentPage = 0;
+  const totalPages = Math.ceil(packages.length / PAGE_SIZE);
+  
+  while (true) {
+    // Get packages for current page
+    const startIdx = currentPage * PAGE_SIZE;
+    const endIdx = Math.min(startIdx + PAGE_SIZE, packages.length);
+    const pagePackages = packages.slice(startIdx, endIdx);
+    
+    // Build choices for current page
+    const choices = [];
+    
+    // Always show Open All at the top
+    choices.push({
+      name: chalk.bold('🌐 Open all packages in browser'),
+      value: 'ALL',
+      short: 'Open all'
+    });
+    
+    // Add separator if there are packages
+    if (pagePackages.length > 0) {
+      choices.push(new inquirer.Separator());
+    }
+    
+    // Add packages for this page
+    pagePackages.forEach(pkg => {
+      const description = pkg.description || 'Package';
+      const shortDesc = description.length > 35 ? description.substring(0, 32) + '...' : description;
+      const { emoji, label } = getStatusDisplay(pkg.status);
+      
+      // Format date
+      let dateStr = '';
+      if (pkg.last_email_date) {
+        const daysSince = Math.floor((Date.now() / 1000 - pkg.last_email_date) / 86400);
+        if (daysSince === 0) {
+          dateStr = 'today';
+        } else if (daysSince === 1) {
+          dateStr = 'yesterday';
+        } else if (daysSince < 7) {
+          dateStr = `${daysSince}d ago`;
+        } else {
+          const date = new Date(pkg.last_email_date * 1000);
+          dateStr = date.toLocaleDateString('en-US', { month: 'short', day: 'numeric' });
+        }
+      } else if (pkg.created_at) {
+        const date = new Date(pkg.created_at * 1000);
+        dateStr = date.toLocaleDateString('en-US', { month: 'short', day: 'numeric' });
+      }
+      
+      choices.push({
+        name: `${emoji} ${shortDesc} (${pkg.carrier} - ${label}) · ${dateStr}`,
+        value: pkg,
+        short: shortDesc
+      });
+    });
+    
+    // Add pagination controls if needed
+    if (totalPages > 1) {
+      choices.push(new inquirer.Separator());
+      
+      if (currentPage < totalPages - 1) {
+        choices.push({
+          name: chalk.cyan(`→ Next page (${currentPage + 2}/${totalPages})`),
+          value: 'NEXT_PAGE',
+          short: 'Next page'
+        });
+      }
+      
+      if (currentPage > 0) {
+        choices.push({
+          name: chalk.cyan(`← Previous page (${currentPage}/${totalPages})`),
+          value: 'PREV_PAGE',
+          short: 'Previous page'
+        });
+      }
+    }
+    
+    // Always show Exit at the very bottom
+    choices.push(new inquirer.Separator());
+    choices.push({
+      name: chalk.gray('❌ Exit'),
+      value: 'EXIT',
+      short: 'Exit'
+    });
+    
+    const { selected } = await inquirer.prompt([{
+      type: 'list',
+      name: 'selected',
+      message: `Page ${currentPage + 1}/${totalPages}:`,
+      choices,
+      pageSize: 12
+    }]);
+    
+    if (selected === 'EXIT') {
+      console.log(chalk.gray('\nGoodbye! 👋\n'));
+      break;
+    }
+    
+    if (selected === 'NEXT_PAGE') {
+      currentPage++;
+      continue;
+    }
+    
+    if (selected === 'PREV_PAGE') {
+      currentPage--;
+      continue;
+    }
+    
+    if (selected === 'ALL') {
+      console.log(chalk.blue('\n🌐 Opening all packages in browser...\n'));
+      for (const pkg of packages) {
+        const url = getTrackingUrl(pkg.carrier, pkg.tracking_number);
+        if (url) {
+          console.log(chalk.gray(`  Opening ${pkg.description}...`));
+          await open(url);
+          // Small delay to avoid overwhelming the browser
+          await new Promise(resolve => setTimeout(resolve, 500));
+        }
+      }
+      console.log(chalk.green('\n✓ Opened all packages\n'));
+      break;
+    }
+    
+    // Open individual package
+    const url = getTrackingUrl(selected.carrier, selected.tracking_number);
+    if (url) {
+      console.log(chalk.blue(`\n🌐 Opening ${selected.description} in browser...\n`));
+      await open(url);
+      
+      // Ask if they want to track another
+      const { another } = await inquirer.prompt([{
+        type: 'confirm',
+        name: 'another',
+        message: 'Track another package?',
+        default: false
+      }]);
+      
+      if (!another) {
+        console.log(chalk.gray('\nGoodbye! 👋\n'));
+        break;
+      }
+      
+      // Reset to first page when returning to menu
+      currentPage = 0;
+      console.log(); // Add spacing
+    }
+  }
+}
+
+module.exports = {
+  openPackages
+};

package/src/parser.js

@@ -0,0 +1,223 @@
+/**
+ * Regex patterns for supported shipping carriers
+ * UPS, FedEx, USPS, Amazon Logistics
+ */
+const TRACKING_PATTERNS = {
+  ups: {
+    pattern: /\b(1Z[A-Z0-9]{16})\b/gi,
+    carrier: 'UPS'
+  },
+  usps: {
+    pattern: /\b(9[0-9]{21}|92[0-9]{18}|94[0-9]{20}|82[0-9]{8})\b/gi,
+    carrier: 'USPS'
+  },
+  amazon: {
+    pattern: /\b(TBA\d{12})\b/gi,
+    carrier: 'Amazon Logistics'
+  },
+  fedex: {
+    // FedEx is tricky - only match if we see FedEx keywords nearby
+    pattern: /\b(\d{12}|\d{15}|\d{20})\b/g,
+    carrier: 'FedEx',
+    requiresContext: true // Needs "fedex" in surrounding text
+  }
+};
+
+/**
+ * Extract tracking numbers from email text
+ * @param {string} text - Email body or subject
+ * @returns {Array} Array of { trackingNumber, carrier } objects
+ */
+function extractTrackingNumbers(text) {
+  const found = [];
+  const seen = new Set(); // Avoid duplicates
+  const lowerText = text.toLowerCase();
+
+  // Try each carrier pattern
+  for (const [key, config] of Object.entries(TRACKING_PATTERNS)) {
+    const { pattern, carrier, requiresContext } = config;
+    
+    // For FedEx, only match if "fedex" appears in text
+    if (requiresContext && !lowerText.includes('fedex')) {
+      continue;
+    }
+    
+    const matches = text.matchAll(pattern);
+    
+    for (const match of matches) {
+      const trackingNumber = match[1];
+      
+      // Basic validation to reduce false positives
+      if (isValidTrackingNumber(trackingNumber, key) && !seen.has(trackingNumber)) {
+        found.push({ trackingNumber, carrier });
+        seen.add(trackingNumber);
+      }
+    }
+  }
+
+  return found;
+}
+
+/**
+ * Additional validation to reduce false positives
+ */
+function isValidTrackingNumber(number, carrierKey) {
+  // UPS: Always starts with 1Z
+  if (carrierKey === 'ups') {
+    return number.startsWith('1Z');
+  }
+  
+  // USPS: Specific prefixes
+  if (carrierKey === 'usps') {
+    return /^(9[0-9]|92|94|82)/.test(number);
+  }
+  
+  // Amazon: TBA prefix + exactly 12 digits after
+  if (carrierKey === 'amazon') {
+    return number.startsWith('TBA') && number.length === 15;
+  }
+  
+  // FedEx: Length-based validation (very strict to avoid false positives)
+  if (carrierKey === 'fedex') {
+    const len = number.length;
+    // Only accept if exactly 12, 15, or 20 digits
+    return (len === 12 || len === 15 || len === 20) && /^\d+$/.test(number);
+  }
+  
+  return true;
+}
+
+/**
+ * Detect retailer from email headers and body
+ */
+function detectRetailer(emailData) {
+  const from = emailData.from.toLowerCase();
+  const subject = emailData.subject.toLowerCase();
+  
+  const retailers = {
+    'Amazon': ['amazon.com', 'amazon'],
+    'Target': ['target.com', 'target'],
+    'Walmart': ['walmart.com', 'walmart'],
+    'Etsy': ['etsy.com', 'etsy'],
+    'eBay': ['ebay.com', 'ebay'],
+    'Best Buy': ['bestbuy.com', 'best buy'],
+    'Apple': ['apple.com', 'apple'],
+    'Nike': ['nike.com', 'nike'],
+    'Adidas': ['adidas.com', 'adidas'],
+  };
+  
+  for (const [retailer, keywords] of Object.entries(retailers)) {
+    if (keywords.some(kw => from.includes(kw) || subject.includes(kw))) {
+      return retailer;
+    }
+  }
+  
+  return 'Unknown';
+}
+
+/**
+ * Extract shipped date from email
+ */
+function extractShippedDate(emailData) {
+  const { subject, body, date } = emailData;
+  const text = `${subject} ${body}`;
+  
+  // Look for common date patterns in shipping emails
+  const datePatterns = [
+    /shipped on ([A-Z][a-z]+\s+\d{1,2},?\s+\d{4})/i,
+    /ship date:?\s*([A-Z][a-z]+\s+\d{1,2},?\s+\d{4})/i,
+    /estimated ship date:?\s*([A-Z][a-z]+\s+\d{1,2},?\s+\d{4})/i,
+    /(\d{1,2}\/\d{1,2}\/\d{4})/g, // MM/DD/YYYY
+    /(\d{4}-\d{2}-\d{2})/g, // YYYY-MM-DD
+  ];
+  
+  for (const pattern of datePatterns) {
+    const match = text.match(pattern);
+    if (match) {
+      try {
+        const parsedDate = new Date(match[1] || match[0]);
+        if (!isNaN(parsedDate.getTime())) {
+          return Math.floor(parsedDate.getTime() / 1000);
+        }
+      } catch (e) {
+        // Continue trying other patterns
+      }
+    }
+  }
+  
+  // Fallback to email date (when email was received)
+  if (date) {
+    try {
+      const parsedDate = new Date(date);
+      if (!isNaN(parsedDate.getTime())) {
+        return Math.floor(parsedDate.getTime() / 1000);
+      }
+    } catch (e) {
+      // ignore
+    }
+  }
+  
+  // Last resort: use current time
+  return Math.floor(Date.now() / 1000);
+}
+
+/**
+ * Extract product/order details from email body
+ */
+function extractProductDetails(emailData) {
+  const { subject, body } = emailData;
+  
+  // Try to extract product name from subject first
+  const subjectPatterns = [
+    /shipped:?\s*(.+?)(?:\s*-\s*tracking|$)/i,
+    /order.*?:\s*(.+?)(?:\s*has shipped|$)/i,
+    /your\s+(.+?)\s+(?:has|have) shipped/i,
+  ];
+  
+  for (const pattern of subjectPatterns) {
+    const match = subject.match(pattern);
+    if (match && match[1]) {
+      const cleaned = match[1].trim();
+      if (cleaned.length > 3 && cleaned.length < 100) {
+        return cleaned;
+      }
+    }
+  }
+  
+  // Try to extract from body
+  const bodyPatterns = [
+    /item:?\s*(.+?)(?:\n|quantity|price|tracking)/i,
+    /product:?\s*(.+?)(?:\n|quantity|price|tracking)/i,
+    /order summary:?\s*(.+?)(?:\n\n|quantity|price|tracking)/i,
+  ];
+  
+  for (const pattern of bodyPatterns) {
+    const match = body.match(pattern);
+    if (match && match[1]) {
+      const cleaned = match[1].trim().replace(/\s+/g, ' ');
+      if (cleaned.length > 3 && cleaned.length < 100) {
+        return cleaned;
+      }
+    }
+  }
+  
+  // Fallback to a cleaned-up subject line
+  const cleanedSubject = subject
+    .replace(/^(re:|fwd?:)\s*/gi, '')
+    .replace(/shipped|tracking|delivered|order confirmation/gi, '')
+    .replace(/\s+/g, ' ')
+    .trim();
+  
+  if (cleanedSubject.length > 3 && cleanedSubject.length < 100) {
+    return cleanedSubject;
+  }
+  
+  return 'Package';
+}
+
+module.exports = {
+  extractTrackingNumbers,
+  detectRetailer,
+  extractShippedDate,
+  extractProductDetails
+};

package/src/tracker.js

@@ -0,0 +1,103 @@
+const { upsertPackage } = require('./db');
+const { extractTrackingNumbers } = require('./parser');
+const inquirer = require('inquirer');
+const chalk = require('chalk');
+
+const CARRIERS = [
+  'UPS',
+  'FedEx',
+  'USPS',
+  'Amazon Logistics'
+];
+
+/**
+ * Manually add a package with interactive prompts
+ */
+async function addPackage(trackingNumber, options = {}) {
+  console.log(chalk.blue('\n📦 Manual Package Entry\n'));
+  console.log(chalk.gray('Add a tracking number that wasn\'t found in your email'));
+  console.log(chalk.gray('Supports: UPS, FedEx, USPS, Amazon Logistics\n'));
+  
+  // Sanitize input - remove whitespace and ensure alphanumeric
+  trackingNumber = trackingNumber.trim().toUpperCase();
+  
+  // Basic security check - only allow alphanumeric tracking numbers
+  if (!/^[A-Z0-9]+$/.test(trackingNumber)) {
+    throw new Error('Invalid tracking number format. Only letters and numbers allowed.');
+  }
+  
+  // Length check - tracking numbers are typically 10-22 characters
+  if (trackingNumber.length < 10 || trackingNumber.length > 22) {
+    throw new Error('Invalid tracking number length. Must be between 10-22 characters.');
+  }
+  
+  // Validate and auto-detect carrier from tracking number
+  const extracted = extractTrackingNumbers(trackingNumber);
+  
+  let detectedCarrier = null;
+  let validNumber = trackingNumber;
+  
+  if (extracted.length > 0) {
+    detectedCarrier = extracted[0].carrier;
+    validNumber = extracted[0].trackingNumber;
+    console.log(chalk.green(`✓ Valid tracking number detected`));
+    if (detectedCarrier) {
+      console.log(chalk.gray(`  Carrier: ${detectedCarrier}`));
+    }
+  } else {
+    console.log(chalk.yellow('⚠️  Could not auto-detect carrier from tracking number'));
+  }
+  
+  console.log(chalk.gray(`  Tracking: ${validNumber}\n`));
+  
+  // Interactive prompts
+  const answers = await inquirer.prompt([
+    {
+      type: 'input',
+      name: 'description',
+      message: 'What is this package?',
+      default: options.name || 'Package',
+      validate: (input) => input.trim().length > 0 || 'Description is required'
+    },
+    {
+      type: 'list',
+      name: 'carrier',
+      message: 'Select carrier:',
+      choices: detectedCarrier 
+        ? [
+            { name: `${detectedCarrier} (detected)`, value: detectedCarrier },
+            new inquirer.Separator(),
+            ...CARRIERS.filter(c => c !== detectedCarrier)
+          ]
+        : CARRIERS,
+      default: detectedCarrier
+    },
+    {
+      type: 'input',
+      name: 'retailer',
+      message: 'Where did you order from? (optional)',
+      default: 'Manual'
+    }
+  ]);
+  
+  // Add the package
+  const pkg = upsertPackage({
+    trackingNumber: validNumber,
+    carrier: answers.carrier,
+    retailer: answers.retailer || 'Manual',
+    description: answers.description,
+    emailId: null,
+    shippedDate: Math.floor(Date.now() / 1000), // Use current time as shipped date
+    lastEmailDate: Math.floor(Date.now() / 1000),
+  });
+  
+  console.log(chalk.green('\n✓ Package added successfully!'));
+  console.log(chalk.gray(`  ${answers.description}`));
+  console.log(chalk.gray(`  ${answers.carrier} · ${validNumber}\n`));
+  
+  return pkg;
+}
+
+module.exports = {
+  addPackage,
+};