@realtimex/email-automator 2.11.2 → 2.12.0

package/api/src/services/processor.ts

@@ -9,6 +9,7 @@ import { getStorageService } from './storage.js';
 import { generateEmailFilename } from '../utils/filename.js';
 import { EmailAccount, Email, Rule, ProcessingLog } from './supabase.js';
 import { EventLogger } from './eventLogger.js';
+import { RulePackService } from './RulePackService.js';
 
 const logger = createLogger('Processor');
 
@@ -32,6 +33,18 @@ export class EmailProcessorService {
     async syncAccount(accountId: string, userId: string): Promise<ProcessingResult> {
         const result: ProcessingResult = { processed: 0, deleted: 0, drafted: 0, errors: 0 };
 
+        // Zero-Config UX: Auto-install Universal Pack for new users (self-healing)
+        try {
+            const rulePackService = new RulePackService(this.supabase);
+            const { installed } = await rulePackService.ensureUniversalPack(userId);
+            if (installed) {
+                logger.info(`Auto-installed Universal Pack for user ${userId}`);
+            }
+        } catch (error) {
+            // Don't fail sync if pack installation fails
+            logger.error('Failed to auto-install Universal Pack', error);
+        }
+
         // Create processing log
         const { data: log } = await this.supabase
             .from('processing_logs')
@@ -651,7 +664,11 @@ export class EmailProcessorService {
                 },
                 compiledContext || '',  // Pre-compiled context (fast path)
                 eventLogger || undefined,
-                email.id
+                email.id,
+                {
+                    llm_provider: settings?.llm_provider,
+                    llm_model: settings?.llm_model
+                }
             );
 
             if (!analysis) {
@@ -789,7 +806,10 @@ export class EmailProcessorService {
                             subject: email.subject || '',
                             sender: email.sender || '',
                             body: email.body_snippet || ''
-                        }, rule.instructions);
+                        }, rule.instructions, {
+                            llm_provider: settings?.llm_provider,
+                            llm_model: settings?.llm_model
+                        });
 
                         if (customizedDraft) {
                             draftContent = customizedDraft;
@@ -805,50 +825,92 @@ export class EmailProcessorService {
         }
     }
 
-    private matchesCondition(email: Partial<Email>, analysis: EmailAnalysis, condition: Record<string, unknown>): boolean {
-        if (!analysis) return false;
+    /**
+     * Enhanced condition matching with support for AI-powered rules
+     * Supports logical operators (AND/OR/NOT) and new condition types
+     */
+    private matchesCondition(email: Partial<Email>, analysis: EmailAnalysis | null, condition: Record<string, unknown>): boolean {
+        // Logical operators (evaluated recursively)
+        if ('and' in condition) {
+            const subConditions = condition.and as Record<string, unknown>[];
+            return subConditions.every(subCond => this.matchesCondition(email, analysis, subCond));
+        }
+
+        if ('or' in condition) {
+            const subConditions = condition.or as Record<string, unknown>[];
+            return subConditions.some(subCond => this.matchesCondition(email, analysis, subCond));
+        }
+
+        if ('not' in condition) {
+            const subCondition = condition.not as Record<string, unknown>;
+            return !this.matchesCondition(email, analysis, subCondition);
+        }
 
+        // Standard condition matching
         for (const [key, value] of Object.entries(condition)) {
             const val = value as string;
 
             switch (key) {
+                // === Legacy field-based matching ===
                 case 'sender_email':
                     if (email.sender?.toLowerCase() !== val.toLowerCase()) return false;
                     break;
+
                 case 'sender_domain':
-                    // Check if sender ends with domain (e.g. @gmail.com)
+                    // Support both "gmail.com" and "@gmail.com" formats
                     const domain = val.startsWith('@') ? val : `@${val}`;
                     if (!email.sender?.toLowerCase().endsWith(domain.toLowerCase())) return false;
                     break;
+
                 case 'sender_contains':
                     if (!email.sender?.toLowerCase().includes(val.toLowerCase())) return false;
                     break;
+
                 case 'subject_contains':
                     if (!email.subject?.toLowerCase().includes(val.toLowerCase())) return false;
                     break;
+
                 case 'body_contains':
                     if (!email.body_snippet?.toLowerCase().includes(val.toLowerCase())) return false;
                     break;
+
                 case 'older_than_days':
                     if (!email.date) return false;
                     const ageInMs = Date.now() - new Date(email.date).getTime();
                     const ageInDays = ageInMs / (1000 * 60 * 60 * 24);
                     if (ageInDays < (value as number)) return false;
                     break;
+
+                // === AI-powered conditions ===
                 case 'category':
-                    if (analysis.category !== value) return false;
+                    if (!analysis || analysis.category !== value) return false;
                     break;
+
                 case 'priority':
-                    if (analysis.priority !== value) return false;
+                    if (!analysis || analysis.priority !== value) return false;
                     break;
+
+                case 'ai_priority':  // Alias for priority
+                    if (!analysis || analysis.priority !== value) return false;
+                    break;
+
                 case 'sentiment':
-                    if (analysis.sentiment !== value) return false;
+                    if (!analysis || analysis.sentiment !== value) return false;
                     break;
+
                 case 'is_useless':
-                    if (analysis.is_useless !== value) return false;
+                    if (!analysis || analysis.is_useless !== value) return false;
+                    break;
+
+                case 'confidence_gt':
+                    // Check if AI confidence is above threshold
+                    // Note: We'd need to store confidence in analysis, for now skip
+                    // TODO: Add confidence tracking to EmailAnalysis
                     break;
+
                 case 'suggested_actions':
-                    // Handle array membership check (e.g. if condition expects "reply" to be in actions)
+                    if (!analysis) return false;
+                    // Handle array membership check
                     const requiredActions = Array.isArray(value) ? value : [value];
                     const actualActions = analysis.suggested_actions || [];
                     const hasAllActions = requiredActions.every(req =>
@@ -856,6 +918,61 @@ export class EmailProcessorService {
                     );
                     if (!hasAllActions) return false;
                     break;
+
+                // === Content matching ===
+                case 'contains_keywords':
+                    if (!Array.isArray(value)) return false;
+                    const keywords = value as string[];
+                    const searchText = `${email.subject || ''} ${email.body_snippet || ''}`.toLowerCase();
+                    // Match if ANY keyword is found
+                    const hasKeyword = keywords.some(kw => searchText.includes(kw.toLowerCase()));
+                    if (!hasKeyword) return false;
+                    break;
+
+                case 'matches_pattern':
+                    if (typeof value !== 'string') return false;
+                    try {
+                        const regex = new RegExp(value, 'i');
+                        const searchText = `${email.subject || ''} ${email.body_snippet || ''}`;
+                        if (!regex.test(searchText)) return false;
+                    } catch (e) {
+                        // Invalid regex, treat as no match
+                        return false;
+                    }
+                    break;
+
+                // === Recipient analysis ===
+                case 'recipient_type':
+                    // Check if user is in to/cc/bcc
+                    // Note: This requires parsing the recipient field
+                    // For now, simple heuristic: if recipient field exists and matches pattern
+                    // TODO: Implement proper recipient parsing
+                    break;
+
+                case 'recipient_count_gt':
+                    // Count number of recipients
+                    // Note: This requires parsing recipient lists
+                    // TODO: Implement recipient counting
+                    break;
+
+                case 'is_first_contact':
+                    // Check if no prior thread with sender
+                    // Note: This requires thread tracking
+                    // TODO: Implement thread tracking
+                    break;
+
+                // === Sender analysis ===
+                case 'sender_is_vip':
+                    // Check against VIP list
+                    // Note: This requires VIP management feature
+                    // TODO: Implement VIP list
+                    break;
+
+                case 'sender_in_contacts':
+                    // Check if sender is in contacts
+                    // Note: This requires contact list integration
+                    // TODO: Implement contact list
+                    break;
                 default:
                     // Fallback for any other keys that might be in analysis
                     if ((analysis as any)[key] !== value) return false;
@@ -918,7 +1035,7 @@ export class EmailProcessorService {
     private async executeAction(
         account: EmailAccount,
         email: Email,
-        action: 'delete' | 'archive' | 'draft' | 'read' | 'star',
+        action: string,  // Changed to string to support 'label:*' and other future actions
         draftContent?: string,
         eventLogger?: EventLogger | null,
         reason?: string,
@@ -929,6 +1046,19 @@ export class EmailProcessorService {
                 await eventLogger.info('Acting', `Executing action: ${action}`, { reason, hasAttachments: !!attachments?.length }, email.id);
             }
 
+            // Parse label actions (e.g., "label:Finance/Receipts")
+            if (action.startsWith('label:')) {
+                const labelName = action.substring(6); // Remove "label:" prefix
+                if (account.provider === 'gmail') {
+                    await this.gmailService.applyLabelByName(account, email.external_id, labelName);
+                } else if (account.provider === 'outlook') {
+                    await this.microsoftService.moveToFolderByPath(account, email.external_id, labelName);
+                }
+                logger.debug('Label/folder action executed', { emailId: email.id, labelName });
+                return;
+            }
+
+            // Standard actions
             if (account.provider === 'gmail') {
                 if (action === 'delete') {
                     await this.gmailService.trashMessage(account, email.external_id);
@@ -946,6 +1076,10 @@ export class EmailProcessorService {
                     await this.gmailService.markAsRead(account, email.external_id);
                 } else if (action === 'star') {
                     await this.gmailService.starMessage(account, email.external_id);
+                } else if (action === 'important') {
+                    await this.gmailService.addLabel(account, email.external_id, ['IMPORTANT']);
+                } else if (action === 'unstar') {
+                    await this.gmailService.removeLabel(account, email.external_id, ['STARRED']);
                 }
             } else if (account.provider === 'outlook') {
                 if (action === 'delete') {
@@ -959,7 +1093,7 @@ export class EmailProcessorService {
                     await this.microsoftService.createDraft(account, email.external_id, draftContent);
                 } else if (action === 'read') {
                     await this.microsoftService.markAsRead(account, email.external_id);
-                } else if (action === 'star') {
+                } else if (action === 'star' || action === 'important') {
                     await this.microsoftService.flagMessage(account, email.external_id);
                 }
             }

package/api/src/services/rulePacks/developer.ts

@@ -0,0 +1,179 @@
+/**
+ * Developer Pack - Engineering & Technical Workflows
+ *
+ * Designed for software engineers, DevOps, and technical teams who need to:
+ * - Surface critical system alerts
+ * - Filter project management noise
+ * - Organize meeting recordings and docs
+ * - Focus on code reviews and incidents
+ */
+
+import { RulePack } from './types.js';
+
+export const DEVELOPER_PACK: RulePack = {
+  id: 'developer',
+  name: 'Developer Pack',
+  description: 'Surface critical alerts and filter tool noise',
+  icon: '💻',
+  enabled_by_default: false,
+  target_roles: ['developer'],
+  rules: [
+    {
+      id: 'dev-system-alerts',
+      name: '🚨 System Alerts Prioritizer',
+      intent: 'Prioritize critical system alerts and incidents',
+      description: 'Stars critical alerts from AWS, Datadog, Sentry, PagerDuty while archiving info-level notifications',
+      condition: {
+        or: [
+          {
+            sender_domain: 'aws.amazon.com',
+            contains_keywords: ['critical', 'down', 'outage', 'incident']
+          },
+          {
+            sender_domain: 'datadoghq.com',
+            contains_keywords: ['alert', 'critical', 'error rate']
+          },
+          {
+            sender_domain: 'sentry.io',
+            contains_keywords: ['new issue', 'regression', 'error']
+          },
+          {
+            sender_domain: 'pagerduty.com',
+            contains_keywords: ['triggered', 'incident']
+          }
+        ]
+      },
+      actions: ['star', 'important', 'pin'],
+      priority: 100,
+      is_enabled_by_default: true
+    },
+    {
+      id: 'dev-system-info',
+      name: '⚠️ System Info Organizer',
+      intent: 'Archive non-critical system notifications',
+      description: 'Archives info and warning level alerts from monitoring tools',
+      condition: {
+        or: [
+          {
+            sender_domain: 'aws.amazon.com',
+            not: {
+              contains_keywords: ['critical', 'down', 'outage']
+            }
+          },
+          {
+            sender_domain: 'datadoghq.com',
+            contains_keywords: ['info', 'warning', 'recovered']
+          },
+          {
+            sender_domain: 'circleci.com'
+          },
+          {
+            sender_domain: 'github.com',
+            contains_keywords: ['build', 'workflow']
+          }
+        ]
+      },
+      actions: ['label:Logs', 'archive', 'read'],
+      priority: 20,
+      is_enabled_by_default: true
+    },
+    {
+      id: 'dev-project-management',
+      name: '🔨 Project Management Organizer',
+      intent: 'Organize Jira, GitHub, and project management notifications',
+      description: 'Archives project management notifications unless you\'re directly assigned',
+      condition: {
+        or: [
+          {
+            sender_domain: 'atlassian.net',
+            not: {
+              contains_keywords: ['assigned to you', 'mentioned you']
+            }
+          },
+          {
+            sender_domain: 'github.com',
+            not: {
+              contains_keywords: ['assigned', 'review requested', '@']
+            }
+          },
+          {
+            sender_domain: 'asana.com',
+            not: {
+              contains_keywords: ['assigned to you']
+            }
+          },
+          {
+            sender_domain: 'trello.com'
+          },
+          {
+            sender_domain: 'monday.com'
+          }
+        ]
+      },
+      actions: ['label:Tools', 'archive'],
+      priority: 15,
+      is_enabled_by_default: true
+    },
+    {
+      id: 'dev-code-reviews',
+      name: '👀 Code Review Highlighter',
+      intent: 'Highlight pull request reviews and assignments',
+      description: 'Stars GitHub/GitLab notifications where your review is requested',
+      condition: {
+        or: [
+          {
+            sender_domain: 'github.com',
+            contains_keywords: ['review requested', 'requested your review']
+          },
+          {
+            sender_domain: 'gitlab.com',
+            contains_keywords: ['review', 'merge request']
+          }
+        ]
+      },
+      actions: ['star'],
+      priority: 80,
+      is_enabled_by_default: true
+    },
+    {
+      id: 'dev-meeting-recordings',
+      name: '📹 Meeting Recording Archiver',
+      intent: 'Archive meeting recordings and transcripts',
+      description: 'Automatically archives Zoom, Teams, and AI note-taker recordings',
+      condition: {
+        or: [
+          {
+            sender_domain: 'zoom.us',
+            contains_keywords: ['recording', 'cloud recording']
+          },
+          {
+            sender_domain: 'microsoft.com',
+            contains_keywords: ['recording', 'teams recording']
+          },
+          {
+            sender_domain: 'fireflies.ai'
+          },
+          {
+            sender_domain: 'otter.ai'
+          }
+        ]
+      },
+      actions: ['label:Recordings', 'archive'],
+      priority: 10,
+      is_enabled_by_default: true
+    },
+    {
+      id: 'dev-drive-shares',
+      name: '📂 Drive Share Organizer',
+      intent: 'Archive Google Drive/Docs share notifications',
+      description: 'Archives notifications about shared documents (usually redundant)',
+      condition: {
+        sender_domain: 'google.com',
+        contains_keywords: ['shared', 'document', 'commented on', 'mentioned you in']
+      },
+      actions: ['label:Drive', 'archive'],
+      priority: 5,
+      is_enabled_by_default: true
+    }
+  ]
+};

package/api/src/services/rulePacks/executive.ts

@@ -0,0 +1,143 @@
+/**
+ * Executive Pack - Leadership & Strategic Communications
+ *
+ * Designed for executives, C-suite, and leadership who need to:
+ * - Focus on VIP communications
+ * - Prioritize strategic decisions
+ * - Filter operational noise
+ * - Manage travel and legal documents
+ */
+
+import { RulePack } from './types.js';
+
+export const EXECUTIVE_PACK: RulePack = {
+  id: 'executive',
+  name: 'Executive Pack',
+  description: 'Focus on high-priority communications and strategic matters',
+  icon: '👔',
+  enabled_by_default: false,
+  target_roles: ['executive'],
+  rules: [
+    {
+      id: 'exec-vip-clients',
+      name: '⭐ VIP Client Prioritizer',
+      intent: 'Star and prioritize emails from key clients and partners',
+      description: 'Automatically highlights emails from VIP contacts and important clients',
+      condition: {
+        or: [
+          {
+            sender_is_vip: true  // From VIP list (requires VIP management feature)
+          },
+          {
+            category: 'client',
+            ai_priority: 'High'
+          }
+        ]
+      },
+      actions: ['star', 'important'],
+      priority: 100,
+      is_enabled_by_default: true
+    },
+    {
+      id: 'exec-direct-questions',
+      name: '⚡ Direct Questions Highlighter',
+      intent: 'Highlight emails that require your direct input',
+      description: 'Identifies emails where you\'re the only recipient and a response is clearly needed',
+      condition: {
+        recipient_type: 'to',
+        recipient_count_gt: 0,  // Only sent to you
+        contains_keywords: ['?', 'your input', 'your thoughts', 'need your', 'awaiting your'],
+        not: {
+          category: 'newsletter'  // Exclude automated newsletters
+        }
+      },
+      actions: ['important'],
+      priority: 90,
+      is_enabled_by_default: true
+    },
+    {
+      id: 'exec-travel-itineraries',
+      name: '✈️ Travel Organizer',
+      intent: 'Organize flight confirmations, hotel bookings, and itineraries',
+      description: 'Labels travel-related emails for easy access before trips',
+      condition: {
+        or: [
+          {
+            sender_domain: 'delta.com'
+          },
+          {
+            sender_domain: 'united.com'
+          },
+          {
+            sender_domain: 'aa.com'
+          },
+          {
+            sender_domain: 'hilton.com'
+          },
+          {
+            sender_domain: 'marriott.com'
+          },
+          {
+            contains_keywords: ['itinerary', 'flight confirmation', 'booking confirmation', 'reservation confirmed']
+          }
+        ]
+      },
+      actions: ['label:Travel', 'star'],
+      priority: 70,
+      is_enabled_by_default: true
+    },
+    {
+      id: 'exec-legal-contracts',
+      name: '⚖️ Legal & Contracts Highlighter',
+      intent: 'Highlight important legal documents and contracts',
+      description: 'Stars emails containing contracts, NDAs, and legal documents requiring signature',
+      condition: {
+        or: [
+          {
+            sender_domain: 'docusign.com'
+          },
+          {
+            sender_domain: 'hellosign.com'
+          },
+          {
+            sender_domain: 'pandadoc.com'
+          },
+          {
+            contains_keywords: ['nda', 'agreement', 'contract', 'sign', 'signature required']
+          }
+        ]
+      },
+      actions: ['label:Legal', 'star'],
+      priority: 95,
+      is_enabled_by_default: true
+    },
+    {
+      id: 'exec-social-notifications',
+      name: '🔔 Social Media Archiver',
+      intent: 'Archive social media notifications',
+      description: 'Automatically archives LinkedIn, Twitter, and other social notifications',
+      condition: {
+        category: 'social',
+        confidence_gt: 0.8
+      },
+      actions: ['archive', 'read'],
+      priority: 5,
+      is_enabled_by_default: true
+    },
+    {
+      id: 'exec-calendar-responses',
+      name: '📅 Calendar Response Cleaner',
+      intent: 'Clean up calendar accept/decline notifications',
+      description: 'Deletes automatic calendar responses that don\'t contain custom messages',
+      condition: {
+        contains_keywords: ['accepted:', 'declined:', 'tentative:'],
+        not: {
+          recipient_type: 'to'  // Don't delete if you're the only recipient
+        }
+      },
+      actions: ['delete'],
+      priority: 10,
+      is_enabled_by_default: false  // Disabled by default - deletion is aggressive
+    }
+  ]
+};

package/api/src/services/rulePacks/index.ts

@@ -0,0 +1,63 @@
+/**
+ * Rule Packs - Zero-Configuration Email Automation
+ *
+ * This module provides pre-configured rule packs for different user roles.
+ * Rule packs enable zero-configuration UX by providing smart defaults that
+ * work out of the box.
+ */
+
+export * from './types.js';
+export { UNIVERSAL_PACK } from './universal.js';
+export { EXECUTIVE_PACK } from './executive.js';
+export { DEVELOPER_PACK } from './developer.js';
+export { SALES_PACK } from './sales.js';
+export { OPERATIONS_PACK } from './operations.js';
+
+import { UNIVERSAL_PACK } from './universal.js';
+import { EXECUTIVE_PACK } from './executive.js';
+import { DEVELOPER_PACK } from './developer.js';
+import { SALES_PACK } from './sales.js';
+import { OPERATIONS_PACK } from './operations.js';
+import { RulePack, UserRole } from './types.js';
+
+/**
+ * All available rule packs
+ */
+export const ALL_PACKS: Record<string, RulePack> = {
+  universal: UNIVERSAL_PACK,
+  executive: EXECUTIVE_PACK,
+  developer: DEVELOPER_PACK,
+  sales: SALES_PACK,
+  operations: OPERATIONS_PACK,
+};
+
+/**
+ * Get packs that should be installed for a specific user role
+ */
+export function getPacksForRole(role?: UserRole | string): RulePack[] {
+  const packs: RulePack[] = [
+    UNIVERSAL_PACK  // Always include universal pack
+  ];
+
+  // Add role-specific pack
+  if (role === 'executive') packs.push(EXECUTIVE_PACK);
+  if (role === 'developer') packs.push(DEVELOPER_PACK);
+  if (role === 'sales') packs.push(SALES_PACK);
+  if (role === 'operations') packs.push(OPERATIONS_PACK);
+
+  return packs;
+}
+
+/**
+ * Get a specific pack by ID
+ */
+export function getPackById(packId: string): RulePack | undefined {
+  return ALL_PACKS[packId];
+}
+
+/**
+ * Get all available packs
+ */
+export function getAllPacks(): RulePack[] {
+  return Object.values(ALL_PACKS);
+}