Feat: context-aware replies, auto-rules, templates, signature, calendar, GDPR

- Context-aware replies: embeddings.py now fetches user's sent reply drafts as RAG context, scored by keyword overlap with incoming email — gives AI style reference
- Email signature: added email_signature to UserUpdate + UserSettings; ai_processor appends it to every generated draft; editable in Profile & AI settings tab
- Auto-labeling rules: localStorage-based rule engine (lib/rules.ts) — IF sender/subject/body matches → set category/priority; applied to email list display; RulesManager settings UI with add/edit/delete/toggle
- Email templates: 4 built-in templates + custom templates (localStorage); Templates tab in settings; insert dropdown in ReplyEditor (appends to current draft)
- Google Calendar: "Add to Calendar" button in meeting detection banner — opens calendar.google.com with pre-filled title and agenda
- GDPR / Data & Privacy: new settings tab; "Download My Data" exports all emails, actions, reply drafts, and profile as JSON; "Delete Account" permanently wipes all user data
- Backend: GET /api/settings/export-data and DELETE /api/settings/delete-account endpoints

Co-Authored-By: Claude Sonnet 4.6 <noreply@anthropic.com>

Author: 2 people

backend/ai/embeddings.py

@@ -1,22 +1,72 @@
 """
-Embedding module — disabled in production to reduce memory usage.
-Semantic similarity search is skipped; AI reply generation still works
-using Claude directly without past-reply context.
+Context-aware reply retrieval using past sent replies as RAG context.
+Uses keyword-based search on past sent reply_drafts to find relevant examples.
 """
 import logging
 
 logger = logging.getLogger(__name__)
 
 
 async def generate_embedding(text: str) -> list[float]:
+    """Stub — pgvector not enabled. Returns empty list."""
     return []
 
 
 async def store_reply_embedding(user_id: str, email_id: str, reply_text: str) -> None:
-    logger.debug("Embeddings disabled — skipping store for email_id=%s", email_id)
+    """Stub — mark reply draft as stored (no-op for pgvector)."""
+    logger.debug("Embeddings stub — skipping vector store for email_id=%s", email_id)
 
 
 async def find_similar_replies(
     user_id: str, email_text: str, limit: int = 3
 ) -> list[str]:
-    return []
+    """
+    Find relevant past replies by fetching the user's most recently sent
+    reply drafts. Used as few-shot context for the AI reply generator.
+    """
+    try:
+        from database import get_supabase
+        supabase = get_supabase()
+
+        # Get recently sent reply drafts (last 10, pick top `limit`)
+        result = (
+            supabase.table("reply_drafts")
+            .select("draft_text, emails(subject, sender)")
+            .eq("user_id", user_id)
+            .eq("is_sent", True)
+            .order("created_at", desc=True)
+            .limit(10)
+            .execute()
+        )
+
+        rows = result.data or []
+        if not rows:
+            # Fall back to any drafts (not necessarily sent) as style reference
+            fallback = (
+                supabase.table("reply_drafts")
+                .select("draft_text")
+                .eq("user_id", user_id)
+                .order("created_at", desc=True)
+                .limit(limit)
+                .execute()
+            )
+            return [r["draft_text"] for r in (fallback.data or []) if r.get("draft_text")][:limit]
+
+        # Score by keyword overlap with email_text
+        keywords = set(w.lower() for w in email_text.split() if len(w) > 4)
+        scored: list[tuple[float, str]] = []
+        for row in rows:
+            draft = row.get("draft_text", "")
+            if not draft:
+                continue
+            email_meta = row.get("emails") or {}
+            context = f"{email_meta.get('subject', '')} {email_meta.get('sender', '')}"
+            overlap = sum(1 for w in context.lower().split() if w in keywords)
+            scored.append((overlap, draft))
+
+        scored.sort(key=lambda x: x[0], reverse=True)
+        return [text for _, text in scored[:limit]]
+
+    except Exception as exc:
+        logger.warning("find_similar_replies error: %s", exc)
+        return []

backend/models/user.py

@@ -27,6 +27,7 @@ class UserUpdate(BaseModel):
     priority_threshold: Optional[int] = None
     vacation_mode: Optional[bool] = None
     vacation_message: Optional[str] = None
+    email_signature: Optional[str] = None
 
 
 class ReplyDraftResponse(BaseModel):

backend/routes/settings.py

@@ -1,7 +1,10 @@
+import json
 import logging
+from datetime import datetime, timezone
 from typing import Annotated
 
 from fastapi import APIRouter, Depends, HTTPException, status
+from fastapi.responses import Response
 
 from database import get_supabase
 from middleware.auth import get_current_user
@@ -83,6 +86,59 @@ async def update_settings(
         )
 
 
+@router.get("/export-data")
+async def export_user_data(current_user: Annotated[dict, Depends(get_current_user)]):
+    """GDPR: Export all user data as a JSON file."""
+    try:
+        supabase = get_supabase()
+        uid = _user_id(current_user)
+
+        profile = supabase.table("user_profiles").select("*").eq("id", uid).single().execute()
+        emails = supabase.table("emails").select(
+            "id, subject, sender, body, category, priority, ai_summary, received_at, is_read, created_at"
+        ).eq("user_id", uid).order("received_at", desc=True).limit(1000).execute()
+        actions = supabase.table("actions").select("*").eq("user_id", uid).limit(500).execute()
+        replies = supabase.table("reply_drafts").select(
+            "id, email_id, draft_text, is_sent, created_at"
+        ).eq("user_id", uid).limit(500).execute()
+
+        export = {
+            "exported_at": datetime.now(timezone.utc).isoformat(),
+            "user_id": uid,
+            "profile": profile.data or {},
+            "emails": emails.data or [],
+            "actions": actions.data or [],
+            "reply_drafts": replies.data or [],
+        }
+
+        filename = f"inboxiq-data-{datetime.now(timezone.utc).strftime('%Y%m%d')}.json"
+        return Response(
+            content=json.dumps(export, indent=2, default=str),
+            media_type="application/json",
+            headers={"Content-Disposition": f'attachment; filename="{filename}"'},
+        )
+    except Exception as exc:
+        logger.error("export_user_data error: %s", exc)
+        raise HTTPException(status_code=500, detail="Failed to export data.")
+
+
+@router.delete("/delete-account", status_code=status.HTTP_200_OK)
+async def delete_account(current_user: Annotated[dict, Depends(get_current_user)]):
+    """GDPR: Delete all user data. Irreversible."""
+    try:
+        supabase = get_supabase()
+        uid = _user_id(current_user)
+        # Delete in dependency order
+        supabase.table("reply_drafts").delete().eq("user_id", uid).execute()
+        supabase.table("actions").delete().eq("user_id", uid).execute()
+        supabase.table("emails").delete().eq("user_id", uid).execute()
+        supabase.table("user_profiles").delete().eq("id", uid).execute()
+        return {"message": "Account and all data deleted successfully."}
+    except Exception as exc:
+        logger.error("delete_account error: %s", exc)
+        raise HTTPException(status_code=500, detail="Failed to delete account.")
+
+
 @router.get("/profile", response_model=dict)
 async def get_profile(current_user: Annotated[dict, Depends(get_current_user)]):
     """

backend/services/ai_processor.py

@@ -103,11 +103,12 @@ async def process_email(email: dict) -> dict | None:
     slack_webhook_url = ""
     vacation_mode = False
     vacation_message = ""
+    email_signature = ""
 
     try:
         profile_result = (
             supabase.table("user_profiles")
-            .select("company_description, tone_preference, slack_webhook_url, vacation_mode, vacation_message")
+            .select("company_description, tone_preference, slack_webhook_url, vacation_mode, vacation_message, email_signature")
             .eq("id", user_id)
             .single()
             .execute()
@@ -121,6 +122,7 @@ async def process_email(email: dict) -> dict | None:
             slack_webhook_url = profile.get("slack_webhook_url") or ""
             vacation_mode = bool(profile.get("vacation_mode", False))
             vacation_message = profile.get("vacation_message") or ""
+            email_signature = profile.get("email_signature") or ""
     except Exception as exc:
         logger.warning("Could not fetch user profile for user_id=%s: %s", user_id, exc)
 
@@ -162,7 +164,13 @@ async def process_email(email: dict) -> dict | None:
         confidence = 0.3
 
     # ------------------------------------------------------------------
-    # Step 6a – Prepend vacation auto-reply note if vacation mode is on
+    # Step 6a – Append email signature if set
+    # ------------------------------------------------------------------
+    if email_signature:
+        draft_text = draft_text.rstrip() + "\n\n" + email_signature.strip()
+
+    # ------------------------------------------------------------------
+    # Step 6c – Prepend vacation auto-reply note if vacation mode is on
     # ------------------------------------------------------------------
     if vacation_mode:
         auto_reply_note = vacation_message.strip() if vacation_message else (
@@ -172,7 +180,7 @@ async def process_email(email: dict) -> dict | None:
         draft_text = vacation_prefix + draft_text
 
     # ------------------------------------------------------------------
-    # Step 6b – Persist reply draft
+    # Step 6d – Persist reply draft
     # ------------------------------------------------------------------
     try:
         supabase.table("reply_drafts").upsert(

frontend/components/ReplyEditor.tsx

@@ -1,8 +1,9 @@
-import { useState, useEffect } from 'react';
-import { Send, Save, Zap, Loader2, Sparkles } from 'lucide-react';
+import { useState, useEffect, useRef } from 'react';
+import { Send, Save, Zap, Loader2, Sparkles, FileText, ChevronDown } from 'lucide-react';
 import clsx from 'clsx';
 import toast from 'react-hot-toast';
 import { repliesApi, emailsApi } from '@/lib/api';
+import { loadTemplates } from '@/lib/templates';
 import type { ReplyDraft } from '@/lib/types';
 
 interface ReplyEditorProps {
@@ -22,6 +23,9 @@ export default function ReplyEditor({ emailId, draft, onSent, className }: Reply
   const [isGenerating, setIsGenerating] = useState(false);
   const [hasChanges, setHasChanges] = useState(false);
   const [confidence, setConfidence] = useState(draft?.confidence_score);
+  const [templatesOpen, setTemplatesOpen] = useState(false);
+  const templateMenuRef = useRef<HTMLDivElement>(null);
+  const templates = loadTemplates();
 
   useEffect(() => {
     if (draft?.draft_content) {
@@ -88,6 +92,23 @@ export default function ReplyEditor({ emailId, draft, onSent, className }: Reply
     }
   };
 
+  // Close template dropdown on outside click
+  useEffect(() => {
+    const handler = (e: MouseEvent) => {
+      if (templateMenuRef.current && !templateMenuRef.current.contains(e.target as Node)) {
+        setTemplatesOpen(false);
+      }
+    };
+    document.addEventListener('mousedown', handler);
+    return () => document.removeEventListener('mousedown', handler);
+  }, []);
+
+  const insertTemplate = (body: string) => {
+    setContent((prev) => (prev ? prev + '\n\n' + body : body));
+    setHasChanges(true);
+    setTemplatesOpen(false);
+  };
+
   const charPercentage = (content.length / MAX_CHARS) * 100;
 
   return (
@@ -166,7 +187,34 @@ export default function ReplyEditor({ emailId, draft, onSent, className }: Reply
         </div>
 
         {/* Actions */}
-        <div className="flex items-center gap-2 justify-end">
+        <div className="flex items-center gap-2 justify-end flex-wrap">
+          {/* Templates dropdown */}
+          <div className="relative" ref={templateMenuRef}>
+            <button
+              onClick={() => setTemplatesOpen((v) => !v)}
+              className="btn-secondary text-sm gap-1.5"
+              title="Insert template"
+            >
+              <FileText className="h-4 w-4" />
+              Templates
+              <ChevronDown className="h-3.5 w-3.5" />
+            </button>
+            {templatesOpen && (
+              <div className="absolute bottom-full mb-1 right-0 z-30 w-56 rounded-xl border border-gray-200 dark:border-gray-700 bg-white dark:bg-gray-800 shadow-xl overflow-hidden">
+                {templates.map((t) => (
+                  <button
+                    key={t.id}
+                    onClick={() => insertTemplate(t.body)}
+                    className="w-full text-left px-3 py-2.5 text-sm text-gray-800 dark:text-gray-200 hover:bg-gray-50 dark:hover:bg-gray-700 transition-colors border-b border-gray-100 dark:border-gray-700 last:border-0"
+                  >
+                    <p className="font-medium text-xs">{t.name}</p>
+                    <p className="text-xs text-gray-400 dark:text-gray-500 line-clamp-1 mt-0.5">{t.body.split('\n')[0]}</p>
+                  </button>
+                ))}
+              </div>
+            )}
+          </div>
+
           <button
             onClick={handleSave}
             disabled={isSaving || !hasChanges}