@realtimex/email-automator 2.23.10 → 2.24.0

package/api/src/middleware/validation.ts

@@ -88,14 +88,23 @@ export const schemas = {
 
     // Rule schemas - supports both single action (legacy) and actions array
     // Now includes description and intent for context-aware AI matching
+    // Actions support: 'delete', 'archive', 'draft', 'star', 'read', or 'label:*' (e.g., 'label:Financial')
     createRule: z.object({
         name: z.string().min(1).max(100),
         description: z.string().max(500).optional(),
         intent: z.string().max(200).optional(),
         priority: z.number().int().min(0).max(100).optional(),
         condition: z.record(z.unknown()),
-        action: z.enum(['delete', 'archive', 'draft', 'star', 'read']).optional(),
-        actions: z.array(z.enum(['delete', 'archive', 'draft', 'star', 'read'])).optional(),
+        negative_condition: z.record(z.unknown()).optional(),
+        min_confidence: z.number().min(0).max(1).optional().default(0.7),
+        action: z.union([
+            z.enum(['delete', 'archive', 'draft', 'star', 'read']),
+            z.string().regex(/^label:.+/, 'Label actions must start with "label:"')
+        ]).optional(),
+        actions: z.array(z.union([
+            z.enum(['delete', 'archive', 'draft', 'star', 'read']),
+            z.string().regex(/^label:.+/, 'Label actions must start with "label:"')
+        ])).optional(),
         instructions: z.string().optional(),
         is_enabled: z.boolean().default(true),
     }).refine(data => data.action || (data.actions && data.actions.length > 0), {
@@ -108,8 +117,16 @@ export const schemas = {
         intent: z.string().max(200).optional(),
         priority: z.number().int().min(0).max(100).optional(),
         condition: z.record(z.unknown()).optional(),
-        action: z.enum(['delete', 'archive', 'draft', 'star', 'read']).optional(),
-        actions: z.array(z.enum(['delete', 'archive', 'draft', 'star', 'read'])).optional(),
+        negative_condition: z.record(z.unknown()).optional(),
+        min_confidence: z.number().min(0).max(1).optional(),
+        action: z.union([
+            z.enum(['delete', 'archive', 'draft', 'star', 'read']),
+            z.string().regex(/^label:.+/, 'Label actions must start with "label:"')
+        ]).optional(),
+        actions: z.array(z.union([
+            z.enum(['delete', 'archive', 'draft', 'star', 'read']),
+            z.string().regex(/^label:.+/, 'Label actions must start with "label:"')
+        ])).optional(),
         instructions: z.string().optional(),
         is_enabled: z.boolean().optional(),
     }),

package/api/src/routes/index.ts

@@ -12,6 +12,7 @@ import ttsRoutes from './tts.js';
 import agentRoutes from './agent.js';
 import draftsRoutes from './drafts.js';
 import attachmentsRoutes from './attachments.js';
+import learningRoutes from './learning.js';
 
 
 const router = Router();
@@ -30,6 +31,7 @@ router.use('/tts', ttsRoutes);
 router.use('/agent', agentRoutes);
 router.use('/drafts', draftsRoutes);
 router.use('/drafts', attachmentsRoutes);
+router.use('/learning', learningRoutes);
 
 
 export default router;

package/api/src/routes/learning.ts

@@ -0,0 +1,99 @@
+import { Router, Request, Response } from 'express';
+import { authMiddleware } from '../middleware/auth.js';
+import { asyncHandler } from '../middleware/errorHandler.js';
+import { createLogger } from '../utils/logger.js';
+
+const router = Router();
+const logger = createLogger('LearningRoutes');
+
+/**
+ * POST /api/learning/feedback
+ * Submit user feedback and immediately update metrics
+ */
+router.post('/feedback', authMiddleware, asyncHandler(async (req: Request, res: Response) => {
+    const supabase = req.supabase;
+    const user = req.user;
+
+    if (!supabase) {
+        return res.status(503).json({ error: 'Supabase client not configured' });
+    }
+
+    if (!user) {
+        return res.status(401).json({ error: 'Not authenticated' });
+    }
+
+    const { email_id, feedback_type, original_state, corrected_state, reasoning } = req.body;
+
+    if (!email_id || !feedback_type) {
+        return res.status(400).json({ error: 'Missing required fields' });
+    }
+
+    // Get account_id from email
+    const { data: email, error: emailError } = await supabase
+        .from('emails')
+        .select('account_id')
+        .eq('id', email_id)
+        .single();
+
+    if (emailError) {
+        logger.warn('Failed to get email account_id', { email_id, error: emailError });
+    }
+
+    // 1. Insert feedback record
+    const { error: feedbackError } = await supabase
+        .from('user_feedback')
+        .insert({
+            user_id: user.id,
+            email_id,
+            account_id: email?.account_id || null,  // Populate account_id
+            feedback_type,
+            original_data: original_state,
+            corrected_data: corrected_state,
+            reasoning: reasoning || null
+        });
+
+    if (feedbackError) {
+        logger.error('Failed to insert feedback', feedbackError);
+        return res.status(500).json({ error: 'Failed to submit feedback' });
+    }
+
+    // 2. Immediately update metrics if positive feedback
+    if (feedback_type === 'analysis' && corrected_state?.is_correct === true) {
+        const { data: metrics, error: fetchError } = await supabase
+            .from('learning_metrics')
+            .select('*')
+            .eq('user_id', user.id)
+            .maybeSingle();
+
+        if (fetchError && fetchError.code !== 'PGRST116') {
+            logger.error('Failed to fetch metrics', fetchError);
+        } else {
+            if (metrics) {
+                // Update existing
+                await supabase
+                    .from('learning_metrics')
+                    .update({
+                        total_classifications: (metrics.total_classifications || 0) + 1,
+                        correct_classifications: (metrics.correct_classifications || 0) + 1,
+                        updated_at: new Date().toISOString()
+                    })
+                    .eq('user_id', user.id);
+            } else {
+                // Create new
+                await supabase
+                    .from('learning_metrics')
+                    .insert({
+                        user_id: user.id,
+                        total_classifications: 1,
+                        correct_classifications: 1
+                    });
+            }
+
+            logger.info('Updated metrics for positive feedback', { user_id: user.id });
+        }
+    }
+
+    res.json({ success: true });
+}));
+
+export default router;

package/api/src/services/defaultRules/emailOrg.ts

@@ -59,7 +59,7 @@ export const EMAIL_ORG_RULES: DefaultRule[] = [
     actions: ['label:Sales/Cold Outreach', 'draft'],
     instructions: 'Politely acknowledge the outreach. If not interested, thank them and decline. If potentially interested, ask for more details.',
     priority: 20,
-    is_enabled_by_default: true
+    is_enabled_by_default: true  // ← RE-ENABLED: recipient_type now implemented!
   },
 
   // Rule 3: CC Organizer

package/api/src/services/defaultRules/types.ts

@@ -59,6 +59,11 @@ export interface EnhancedRuleCondition {
   recipient_count_gt?: number;       // Number of recipients threshold
   is_first_contact?: boolean;        // No prior thread with sender
 
+  // Email header metadata (parsed during sync)
+  is_automated?: boolean;            // Detected from List-Unsubscribe, Precedence:bulk, X-Mailer
+  has_unsubscribe?: boolean;         // Contains List-Unsubscribe header
+  is_reply?: boolean;                // Part of a reply thread (In-Reply-To/References headers)
+
   // Content matching
   contains_keywords?: string[];      // Any of these words (case-insensitive)
   matches_pattern?: string;          // Regex pattern

package/api/src/services/intelligence.ts

@@ -69,6 +69,8 @@ export interface RuleContext {
     intent?: string;
     actions: string[];
     draft_instructions?: string;
+    condition?: any; // Positive condition
+    negative_condition?: any; // Negative condition (exclusion logic)
 }
 
 export interface EmailContext {
@@ -76,10 +78,18 @@ export interface EmailContext {
     sender: string;
     date: string;
     metadata?: {
+        // Original metadata fields (deprecated but kept for compatibility)
         importance?: string;
         listUnsubscribe?: string;
         autoSubmitted?: string;
         mailer?: string;
+        // Enhanced header metadata for better LLM analysis
+        recipient_type?: 'to' | 'cc' | 'bcc';
+        is_automated?: boolean;
+        has_unsubscribe?: boolean;
+        is_reply?: boolean;
+        sender_priority?: 'high' | 'normal' | 'low';
+        thread_id?: string;
     };
     userPreferences?: {
         autoTrashSpam?: boolean;
@@ -158,7 +168,37 @@ export class IntelligenceService {
         const cleanedContent = ContentCleaner.cleanEmailBody(content).substring(0, 2500);
 
         const metadataSignals = [];
-        if (context.metadata?.listUnsubscribe) metadataSignals.push('- Contains Unsubscribe header');
+
+        // Email age signal (objective time context only)
+        if (context.date) {
+            const emailDate = new Date(context.date);
+            const now = new Date();
+            const ageMs = now.getTime() - emailDate.getTime();
+            const ageDays = Math.floor(ageMs / (1000 * 60 * 60 * 24));
+            const ageHours = Math.floor(ageMs / (1000 * 60 * 60));
+
+            if (ageDays === 0 && ageHours < 1) {
+                metadataSignals.push('- Email age: Less than 1 hour old');
+            } else if (ageDays === 0) {
+                metadataSignals.push(`- Email age: ${ageHours} hours old`);
+            } else if (ageDays === 1) {
+                metadataSignals.push('- Email age: 1 day old');
+            } else {
+                metadataSignals.push(`- Email age: ${ageDays} days old`);
+            }
+        }
+
+        // Header-based signals (enhanced)
+        if (context.metadata?.recipient_type === 'cc') metadataSignals.push('- Recipient: CC (not directly addressed)');
+        if (context.metadata?.recipient_type === 'bcc') metadataSignals.push('- Recipient: BCC (bulk/mass email)');
+        if (context.metadata?.is_automated) metadataSignals.push('- Automated/Bulk email detected (List-Unsubscribe or Precedence:bulk)');
+        if (context.metadata?.has_unsubscribe) metadataSignals.push('- Contains Unsubscribe header (likely newsletter/marketing)');
+        if (context.metadata?.is_reply) metadataSignals.push('- Part of reply thread (ongoing conversation)');
+        if (context.metadata?.sender_priority === 'high') metadataSignals.push('- Sender Priority: HIGH (marked as urgent)');
+        if (context.metadata?.sender_priority === 'low') metadataSignals.push('- Sender Priority: LOW');
+        if (context.metadata?.mailer) metadataSignals.push(`- Sent via: ${context.metadata.mailer}`);
+        // Legacy metadata (deprecated but kept for compatibility)
+        if (context.metadata?.listUnsubscribe && !context.metadata?.has_unsubscribe) metadataSignals.push('- Contains Unsubscribe header');
         if (context.metadata?.autoSubmitted && context.metadata.autoSubmitted !== 'no') metadataSignals.push(`- Auto-Submitted: ${context.metadata.autoSubmitted}`);
         if (context.metadata?.importance) metadataSignals.push(`- Priority: ${context.metadata.importance}`);
 
@@ -191,11 +231,12 @@ CATEGORY DEFINITIONS:
 
 CRITICAL RULES:
 1. Platform notifications (linkedin.com, github.com) are ALWAYS "notification" or "social", never "personal"
-2. Emails from noreply@, no-reply@ are likely "transactional" or "notification"
+2. Automated sender addresses (noreply@, no-reply@, donotreply@, alerts@, notifications@, updates@, newsletter@, etc.) are ALWAYS "transactional", "notification", or "newsletter" - NEVER "personal"
 3. Weekly/Monthly digests are "newsletter"
 4. If "List-Unsubscribe" header is present, it is likely "newsletter" or "promotional"
 5. Follow "LEARNED PATTERN" signals strictly if present
 6. VIP Senders must be "High" priority unless irrelevant (e.g. OOO auto-reply)
+7. Google Alerts (googlealerts-noreply@google.com) are ALWAYS "news" category, NEVER "personal" or "promotional"
 
 FEW-SHOT EXAMPLES:
 
@@ -520,11 +561,86 @@ REQUIRED JSON STRUCTURE:
         });
         const cleanedContent = ContentCleaner.cleanEmailBody(content).substring(0, 2500);
 
+        // Build metadata signals (same as analyzeEmail)
+        const metadataSignals = [];
+
+        // Email age signal (objective time context only)
+        if (context.date) {
+            const emailDate = new Date(context.date);
+            const now = new Date();
+            const ageMs = now.getTime() - emailDate.getTime();
+            const ageDays = Math.floor(ageMs / (1000 * 60 * 60 * 24));
+            const ageHours = Math.floor(ageMs / (1000 * 60 * 60));
+
+            if (ageDays === 0 && ageHours < 1) {
+                metadataSignals.push('- Email age: Less than 1 hour old');
+            } else if (ageDays === 0) {
+                metadataSignals.push(`- Email age: ${ageHours} hours old`);
+            } else if (ageDays === 1) {
+                metadataSignals.push('- Email age: 1 day old');
+            } else {
+                metadataSignals.push(`- Email age: ${ageDays} days old`);
+            }
+        }
+
+        // Header-based signals (enhanced)
+        if (context.metadata?.recipient_type === 'cc') metadataSignals.push('- Recipient: CC (not directly addressed)');
+        if (context.metadata?.recipient_type === 'bcc') metadataSignals.push('- Recipient: BCC (bulk/mass email)');
+        if (context.metadata?.is_automated) metadataSignals.push('- Automated/Bulk email detected (likely newsletter/marketing)');
+        if (context.metadata?.has_unsubscribe) metadataSignals.push('- Contains Unsubscribe header (newsletter indicator)');
+        if (context.metadata?.is_reply) metadataSignals.push('- Part of reply thread (ongoing conversation)');
+        if (context.metadata?.sender_priority === 'high') metadataSignals.push('- Sender Priority: HIGH (marked as urgent)');
+        if (context.metadata?.sender_priority === 'low') metadataSignals.push('- Sender Priority: LOW');
+        if (context.metadata?.mailer) metadataSignals.push(`- Sent via: ${context.metadata.mailer}`);
+        // Legacy metadata (deprecated but kept for compatibility)
+        if (context.metadata?.listUnsubscribe && !context.metadata?.has_unsubscribe) metadataSignals.push('- Contains Unsubscribe header');
+        if (context.metadata?.autoSubmitted && context.metadata.autoSubmitted !== 'no') metadataSignals.push(`- Auto-Submitted: ${context.metadata.autoSubmitted}`);
+        if (context.metadata?.importance) metadataSignals.push(`- Priority: ${context.metadata.importance}`);
+
+        // Adaptive Learning Signals
+        if (context.userPreferences?.vipSenders?.includes(context.sender)) {
+            metadataSignals.push('- SENDER IS VIP (High Priority Required)');
+        }
+
+        const senderDomain = context.sender.split('@')[1];
+        if (senderDomain && context.userPreferences?.categoryPatterns?.[senderDomain]) {
+            const learnedCategory = context.userPreferences.categoryPatterns[senderDomain];
+            metadataSignals.push(`- LEARNED PATTERN: Sender domain '${senderDomain}' is strictly category '${learnedCategory}'`);
+        }
+
+        // Format rules with positive and negative conditions
+        const formatCondition = (cond: any): string => {
+            if (!cond) return '';
+            if (cond.and) return `(${cond.and.map(formatCondition).join(' AND ')})`;
+            if (cond.or) return `(${cond.or.map(formatCondition).join(' OR ')})`;
+            if (cond.not) return `NOT ${formatCondition(cond.not)}`;
+
+            const parts = [];
+            for (const [key, value] of Object.entries(cond)) {
+                if (key === 'category') parts.push(`category=${value}`);
+                else if (key === 'is_automated') parts.push(`is_automated=${value}`);
+                else if (key === 'has_unsubscribe') parts.push(`has_unsubscribe=${value}`);
+                else if (key === 'recipient_type') parts.push(`recipient_type=${value}`);
+                else if (key === 'sender_domain') parts.push(`sender_domain=${value}`);
+                else parts.push(`${key}=${value}`);
+            }
+            return parts.join(', ');
+        };
+
         let rulesContext: string;
         if (typeof compiledRulesContext === 'string') {
             rulesContext = compiledRulesContext;
         } else {
-            rulesContext = compiledRulesContext.map(r => `- ${r.name}: ${r.intent}`).join('\n');
+            rulesContext = compiledRulesContext.map(r => {
+                let ruleText = `- ${r.name}: ${r.intent || r.description || 'No description'}`;
+                if (r.condition) {
+                    ruleText += `\n  Match when: ${formatCondition(r.condition)}`;
+                }
+                if (r.negative_condition) {
+                    ruleText += `\n  EXCLUDE when: ${formatCondition(r.negative_condition)}`;
+                }
+                return ruleText;
+            }).join('\n');
         }
 
         const systemPrompt = `You are an AI Automation Agent. Analyze the email and identify ALL rules that apply.
@@ -543,6 +659,11 @@ CATEGORY DEFINITIONS:
 - notification: Platform alerts/notifications (Github, Linear, etc) - distinct from social
 - other: Anything that doesn't fit above categories
 
+Email Context:
+- Subject: ${context.subject}
+- From: ${context.sender}
+${metadataSignals.join('\n')}
+
 Rules Context:
 ${rulesContext}
 
@@ -571,7 +692,8 @@ CRITICAL INSTRUCTIONS:
 - Actions will be merged by the system - you don't need to resolve conflicts
 - Use "draft" action only if a rule explicitly requests it
 - Platform notifications (linkedin, github) are ALWAYS "notification" or "social"
-- Emails from noreply@ are likely "transactional" or "notification"`;
+- Automated sender addresses (noreply@, no-reply@, donotreply@, alerts@, notifications@, updates@, newsletter@, etc.) are ALWAYS "transactional", "notification", or "newsletter" - NEVER "personal"
+- Google Alerts (googlealerts-noreply@google.com) are ALWAYS "news" category`;
 
         if (eventLogger) {
             await eventLogger.info('Thinking', `Context-aware analysis: ${context.subject}`, {

package/api/src/services/learning.ts

@@ -226,8 +226,13 @@ export class LearningService {
 
     private async updateMetrics(userId: string, items: UserFeedback[]): Promise<void> {
         try {
-            // Simple counters for now
-            const corrections = items.filter(i => i.feedback_type === 'analysis').length;
+            // Separate positive feedback (correct) from corrections (incorrect)
+            const positiveFeedback = items.filter(i =>
+                i.feedback_type === 'analysis' && i.corrected_data?.is_correct === true
+            );
+            const corrections = items.filter(i =>
+                i.feedback_type === 'analysis' && i.corrected_data?.is_correct !== true
+            );
             const draftEdits = items.filter(i => i.feedback_type === 'draft_edit').length;
 
             // Fetch existing or create
@@ -247,8 +252,7 @@ export class LearningService {
                     .from('learning_metrics')
                     .update({
                         total_classifications: (existing.total_classifications || 0) + items.length,
-                        // If it's a correction, it wasn't correct. If it's pure positive feedback... (not impl yet)
-                        // For now, this is just activity tracking
+                        correct_classifications: (existing.correct_classifications || 0) + positiveFeedback.length,
                         drafts_edited: (existing.drafts_edited || 0) + draftEdits,
                         updated_at: new Date().toISOString()
                     })
@@ -261,11 +265,19 @@ export class LearningService {
                     .insert({
                         user_id: userId,
                         total_classifications: items.length,
+                        correct_classifications: positiveFeedback.length,
                         drafts_edited: draftEdits
                     });
 
                 if (insertError) throw insertError;
             }
+
+            logger.info('Updated learning metrics', {
+                userId,
+                positive: positiveFeedback.length,
+                corrections: corrections.length,
+                total: items.length
+            });
         } catch (error) {
             logger.error('Failed to update learning metrics', error as Error);
         }