opensentinel 2.1.1 → 3.1.1

package/dist/chunk-SPPMCAKG.js

@@ -0,0 +1,777 @@
+import {
+  chat
+} from "./chunk-766ASQWE.js";
+
+// src/integrations/email/email-parser.ts
+function parseEmail(email) {
+  const isReply = email.subject.toLowerCase().startsWith("re:");
+  const isForward = email.subject.toLowerCase().startsWith("fwd:") || email.subject.toLowerCase().startsWith("fw:");
+  const attachments = email.attachments.map((att) => parseAttachment(att));
+  const totalAttachmentSize = attachments.reduce((sum, att) => sum + att.size, 0);
+  let importance = "normal";
+  const importanceHeader = email.headers.get("importance") || email.headers.get("x-priority");
+  if (importanceHeader) {
+    const lowerHeader = importanceHeader.toLowerCase();
+    if (lowerHeader.includes("high") || lowerHeader === "1" || lowerHeader === "2") {
+      importance = "high";
+    } else if (lowerHeader.includes("low") || lowerHeader === "5") {
+      importance = "low";
+    }
+  }
+  return {
+    id: email.id,
+    subject: email.subject,
+    from: email.from,
+    to: email.to,
+    cc: email.cc,
+    date: email.date,
+    body: {
+      text: email.text,
+      html: email.html,
+      snippet: email.snippet || email.text.substring(0, 200).replace(/\s+/g, " ").trim()
+    },
+    thread: {
+      id: email.threadId || email.messageId,
+      messageId: email.messageId,
+      inReplyTo: email.inReplyTo,
+      references: email.references,
+      position: email.references.length,
+      isReply,
+      isForward
+    },
+    attachments,
+    metadata: {
+      isRead: email.flags.includes("\\Seen"),
+      isFlagged: email.flags.includes("\\Flagged"),
+      isSpam: email.labels.includes("Spam") || email.labels.includes("Junk"),
+      isDraft: email.flags.includes("\\Draft"),
+      labels: email.labels,
+      importance,
+      hasAttachments: attachments.length > 0,
+      attachmentCount: attachments.length,
+      totalAttachmentSize
+    }
+  };
+}
+function parseAttachment(attachment) {
+  const extension = attachment.filename.includes(".") ? attachment.filename.split(".").pop()?.toLowerCase() || "" : "";
+  return {
+    filename: attachment.filename,
+    contentType: attachment.contentType,
+    size: attachment.size,
+    isInline: !!attachment.contentId,
+    cid: attachment.contentId,
+    content: attachment.content,
+    extension,
+    category: categorizeAttachment(attachment.contentType, extension)
+  };
+}
+function categorizeAttachment(contentType, extension) {
+  const lowerContentType = contentType.toLowerCase();
+  if (lowerContentType.startsWith("image/")) {
+    return "image";
+  }
+  const docExtensions = ["pdf", "doc", "docx", "xls", "xlsx", "ppt", "pptx", "txt", "rtf", "odt", "ods", "odp", "csv"];
+  const docMimeTypes = [
+    "application/pdf",
+    "application/msword",
+    "application/vnd.openxmlformats",
+    "application/vnd.ms-",
+    "text/plain",
+    "text/csv",
+    "application/vnd.oasis.opendocument"
+  ];
+  if (docExtensions.includes(extension) || docMimeTypes.some((m) => lowerContentType.includes(m))) {
+    return "document";
+  }
+  const archiveExtensions = ["zip", "rar", "7z", "tar", "gz", "bz2"];
+  const archiveMimeTypes = ["application/zip", "application/x-rar", "application/x-7z", "application/gzip"];
+  if (archiveExtensions.includes(extension) || archiveMimeTypes.some((m) => lowerContentType.includes(m))) {
+    return "archive";
+  }
+  if (lowerContentType.startsWith("audio/") || lowerContentType.startsWith("video/")) {
+    return "media";
+  }
+  return "other";
+}
+function groupIntoThreads(emails) {
+  const threadMap = /* @__PURE__ */ new Map();
+  for (const email of emails) {
+    let threadId = email.threadId || email.messageId;
+    if (email.references.length > 0) {
+      threadId = email.references[0];
+    }
+    if (!threadMap.has(threadId)) {
+      threadMap.set(threadId, []);
+    }
+    threadMap.get(threadId).push(email);
+  }
+  const threads = [];
+  for (const [threadId, messages] of threadMap) {
+    messages.sort((a, b) => a.date.getTime() - b.date.getTime());
+    const participantMap = /* @__PURE__ */ new Map();
+    for (const msg of messages) {
+      for (const addr of [...msg.from, ...msg.to, ...msg.cc]) {
+        if (!participantMap.has(addr.address)) {
+          participantMap.set(addr.address, addr);
+        }
+      }
+    }
+    const unreadCount = messages.filter((m) => !m.flags.includes("\\Seen")).length;
+    let subject = messages[0].subject;
+    for (const msg of messages) {
+      const cleaned = cleanSubject(msg.subject);
+      if (cleaned.length > 0 && !cleaned.toLowerCase().startsWith("re:")) {
+        subject = msg.subject;
+        break;
+      }
+    }
+    threads.push({
+      id: threadId,
+      subject: cleanSubject(subject),
+      participants: Array.from(participantMap.values()),
+      messageCount: messages.length,
+      unreadCount,
+      lastMessageDate: messages[messages.length - 1].date,
+      firstMessageDate: messages[0].date,
+      messages: messages.map(parseEmail),
+      snippet: messages[messages.length - 1].snippet || messages[messages.length - 1].text.substring(0, 200).replace(/\s+/g, " ").trim()
+    });
+  }
+  threads.sort((a, b) => b.lastMessageDate.getTime() - a.lastMessageDate.getTime());
+  return threads;
+}
+function cleanSubject(subject) {
+  return subject.replace(/^(Re|Fwd|Fw):\s*/gi, "").replace(/^\[.*?\]\s*/, "").trim();
+}
+function parseEmailBody(text) {
+  const lines = text.split("\n");
+  const newLines = [];
+  const quotedSections = [];
+  let currentQuote = null;
+  let signature;
+  let inSignature = false;
+  for (let i = 0; i < lines.length; i++) {
+    const line = lines[i];
+    if (line.trim() === "--" || line.trim() === "-- ") {
+      inSignature = true;
+      signature = lines.slice(i + 1).join("\n").trim();
+      break;
+    }
+    const quoteMatch = line.match(/^(>+)\s?/);
+    if (quoteMatch) {
+      const level = quoteMatch[1].length;
+      const content = line.substring(quoteMatch[0].length);
+      if (!currentQuote || currentQuote.level !== level) {
+        if (currentQuote) {
+          quotedSections.push({
+            level: currentQuote.level,
+            content: currentQuote.lines.join("\n"),
+            attribution: currentQuote.attribution
+          });
+        }
+        currentQuote = { level, lines: [content] };
+      } else {
+        currentQuote.lines.push(content);
+      }
+    } else if (isAttributionLine(line)) {
+      if (currentQuote) {
+        currentQuote.attribution = line;
+      } else {
+        currentQuote = { level: 1, lines: [], attribution: line };
+      }
+    } else {
+      if (currentQuote) {
+        quotedSections.push({
+          level: currentQuote.level,
+          content: currentQuote.lines.join("\n"),
+          attribution: currentQuote.attribution
+        });
+        currentQuote = null;
+      }
+      newLines.push(line);
+    }
+  }
+  if (currentQuote) {
+    quotedSections.push({
+      level: currentQuote.level,
+      content: currentQuote.lines.join("\n"),
+      attribution: currentQuote.attribution
+    });
+  }
+  return {
+    newContent: newLines.join("\n").trim(),
+    quotedContent: quotedSections,
+    signature
+  };
+}
+function isAttributionLine(line) {
+  const attributionPatterns = [
+    /^On .+ wrote:$/i,
+    /^On .+, .+ wrote:$/i,
+    /^.+ wrote:$/i,
+    /^-{3,}\s*Original Message\s*-{3,}$/i,
+    /^-{3,}\s*Forwarded message\s*-{3,}$/i,
+    /^From:\s*.+$/i,
+    /^Sent:\s*.+$/i
+  ];
+  return attributionPatterns.some((pattern) => pattern.test(line.trim()));
+}
+function extractEmailAddresses(text) {
+  const emailRegex = /[a-zA-Z0-9._%+-]+@[a-zA-Z0-9.-]+\.[a-zA-Z]{2,}/g;
+  const matches = text.match(emailRegex) || [];
+  return [...new Set(matches)];
+}
+function extractUrls(text) {
+  const urlRegex = /https?:\/\/[^\s<>"\)]+/gi;
+  const matches = text.match(urlRegex) || [];
+  return [...new Set(matches)];
+}
+function extractPhoneNumbers(text) {
+  const phoneRegex = /(?:\+\d{1,3}[-.\s]?)?\(?\d{3}\)?[-.\s]?\d{3}[-.\s]?\d{4}/g;
+  const matches = text.match(phoneRegex) || [];
+  return [...new Set(matches)];
+}
+function getEmailSummary(email) {
+  const fromAddr = email.from[0];
+  const fromDisplay = fromAddr ? fromAddr.name || fromAddr.address : "Unknown";
+  const snippet = "body" in email ? email.body.snippet : email.snippet || email.text.substring(0, 100);
+  const attachmentCount = "metadata" in email ? email.metadata.attachmentCount : email.attachments.length;
+  return {
+    from: fromDisplay,
+    subject: email.subject,
+    snippet,
+    date: formatEmailDate(email.date),
+    attachmentCount
+  };
+}
+function formatEmailDate(date) {
+  const now = /* @__PURE__ */ new Date();
+  const diff = now.getTime() - date.getTime();
+  const days = Math.floor(diff / (1e3 * 60 * 60 * 24));
+  if (days === 0) {
+    return date.toLocaleTimeString("en-US", {
+      hour: "numeric",
+      minute: "2-digit",
+      hour12: true
+    });
+  } else if (days === 1) {
+    return "Yesterday";
+  } else if (days < 7) {
+    return date.toLocaleDateString("en-US", { weekday: "short" });
+  } else if (date.getFullYear() === now.getFullYear()) {
+    return date.toLocaleDateString("en-US", { month: "short", day: "numeric" });
+  } else {
+    return date.toLocaleDateString("en-US", {
+      month: "short",
+      day: "numeric",
+      year: "numeric"
+    });
+  }
+}
+function calculateEmailSize(email) {
+  let size = 0;
+  size += new TextEncoder().encode(email.text).length;
+  size += new TextEncoder().encode(email.html).length;
+  size += new TextEncoder().encode(email.subject).length;
+  size += email.from.reduce((s, a) => s + (a.name?.length || 0) + a.address.length + 10, 0);
+  size += email.to.reduce((s, a) => s + (a.name?.length || 0) + a.address.length + 10, 0);
+  size += email.attachments.reduce((s, a) => s + a.size, 0);
+  return size;
+}
+function matchesFilter(email, filter) {
+  const parsed = "metadata" in email ? email : parseEmail(email);
+  if (filter.from) {
+    const fromMatch = parsed.from.some((addr) => {
+      const str = `${addr.name} ${addr.address}`;
+      return filter.from instanceof RegExp ? filter.from.test(str) : str.toLowerCase().includes(filter.from.toLowerCase());
+    });
+    if (!fromMatch) return false;
+  }
+  if (filter.to) {
+    const toMatch = parsed.to.some((addr) => {
+      const str = `${addr.name} ${addr.address}`;
+      return filter.to instanceof RegExp ? filter.to.test(str) : str.toLowerCase().includes(filter.to.toLowerCase());
+    });
+    if (!toMatch) return false;
+  }
+  if (filter.subject) {
+    const subjectMatch = filter.subject instanceof RegExp ? filter.subject.test(parsed.subject) : parsed.subject.toLowerCase().includes(filter.subject.toLowerCase());
+    if (!subjectMatch) return false;
+  }
+  if (filter.body) {
+    const bodyText = parsed.body.text;
+    const bodyMatch = filter.body instanceof RegExp ? filter.body.test(bodyText) : bodyText.toLowerCase().includes(filter.body.toLowerCase());
+    if (!bodyMatch) return false;
+  }
+  if (filter.hasAttachments !== void 0) {
+    if (parsed.metadata.hasAttachments !== filter.hasAttachments) return false;
+  }
+  if (filter.isUnread !== void 0) {
+    if (parsed.metadata.isRead === filter.isUnread) return false;
+  }
+  if (filter.isFlagged !== void 0) {
+    if (parsed.metadata.isFlagged !== filter.isFlagged) return false;
+  }
+  if (filter.dateAfter && parsed.date < filter.dateAfter) return false;
+  if (filter.dateBefore && parsed.date > filter.dateBefore) return false;
+  return true;
+}
+
+// src/integrations/email/inbox-summarizer.ts
+var CATEGORIZATION_PROMPT = `You are an email categorization assistant. Analyze the following email and categorize it.
+
+Categories:
+- urgent: Time-sensitive, requires immediate attention
+- action_required: Requires a response or action from the user
+- informational: FYI, newsletters, updates that don't require action
+- meeting: Calendar invites, meeting-related emails
+- financial: Invoices, receipts, financial statements
+- social: Personal emails, social notifications
+- marketing: Promotional emails, newsletters
+- support: Customer support, help desk emails
+- work: Work-related emails that aren't urgent
+- spam: Potential spam or unwanted emails
+
+Email:
+From: {{from}}
+Subject: {{subject}}
+Date: {{date}}
+Snippet: {{snippet}}
+
+Respond in JSON format:
+{
+  "category": "category_name",
+  "confidence": 0.0-1.0,
+  "reason": "brief explanation"
+}`;
+var ACTION_EXTRACTION_PROMPT = `You are an email assistant that extracts action items. Analyze the following email and identify any actions the recipient needs to take.
+
+Email:
+From: {{from}}
+Subject: {{subject}}
+Date: {{date}}
+Body: {{body}}
+
+For each action item found, provide:
+- action: A clear, concise description of what needs to be done
+- priority: high (urgent/deadline), medium (important but not urgent), or low (when convenient)
+- dueDate: If a specific date/time is mentioned (ISO format or null)
+- context: Brief context from the email
+
+Respond in JSON format:
+{
+  "actions": [
+    {
+      "action": "description",
+      "priority": "high|medium|low",
+      "dueDate": "ISO date or null",
+      "context": "brief context"
+    }
+  ]
+}
+
+If no actions are required, return: { "actions": [] }`;
+var INBOX_SUMMARY_PROMPT = `You are an email assistant providing a daily inbox summary. Based on the following email statistics and categories, provide a brief, helpful summary.
+
+Statistics:
+- Total emails: {{totalEmails}}
+- Unread: {{unreadCount}}
+- Important: {{importantCount}}
+
+Categories:
+{{categories}}
+
+Urgent items:
+{{urgentItems}}
+
+Provide a 2-3 sentence summary that:
+1. Highlights the most important items requiring attention
+2. Notes any patterns or notable senders
+3. Suggests prioritization if there are many items
+
+Keep it concise and actionable.`;
+var THREAD_SUMMARY_PROMPT = `You are an email assistant that summarizes email threads. Analyze the following email thread and provide a comprehensive summary.
+
+Thread: {{subject}}
+Participants: {{participants}}
+Messages: {{messageCount}}
+
+Messages (oldest to newest):
+{{messages}}
+
+Provide a summary including:
+1. Brief summary of the entire conversation (2-3 sentences)
+2. Current status of the discussion
+3. Key decisions made (if any)
+4. Open questions that need resolution
+5. Suggested next steps
+
+Respond in JSON format:
+{
+  "summary": "conversation summary",
+  "currentStatus": "status description",
+  "keyDecisions": ["decision 1", "decision 2"],
+  "openQuestions": ["question 1", "question 2"],
+  "nextSteps": ["step 1", "step 2"]
+}`;
+async function categorizeEmail(email) {
+  const parsed = "metadata" in email ? email : parseEmail(email);
+  const fromDisplay = parsed.from[0] ? `${parsed.from[0].name || ""} <${parsed.from[0].address}>`.trim() : "Unknown";
+  const prompt = CATEGORIZATION_PROMPT.replace("{{from}}", fromDisplay).replace("{{subject}}", parsed.subject).replace("{{date}}", parsed.date.toISOString()).replace("{{snippet}}", parsed.body.snippet);
+  try {
+    const response = await chat(
+      [{ role: "user", content: prompt }],
+      "You are a helpful email categorization assistant. Always respond with valid JSON."
+    );
+    const result = JSON.parse(response.content);
+    return {
+      category: result.category || "informational",
+      confidence: result.confidence || 0.5,
+      reason: result.reason || ""
+    };
+  } catch (err) {
+    console.error("Failed to categorize email:", err);
+    return {
+      category: "informational",
+      confidence: 0.5,
+      reason: "Failed to categorize"
+    };
+  }
+}
+async function extractActionItems(email) {
+  const parsed = "metadata" in email ? email : parseEmail(email);
+  const fromDisplay = parsed.from[0] ? `${parsed.from[0].name || ""} <${parsed.from[0].address}>`.trim() : "Unknown";
+  const bodyParts = parseEmailBody(parsed.body.text);
+  const relevantBody = bodyParts.newContent || parsed.body.text.substring(0, 2e3);
+  const prompt = ACTION_EXTRACTION_PROMPT.replace("{{from}}", fromDisplay).replace("{{subject}}", parsed.subject).replace("{{date}}", parsed.date.toISOString()).replace("{{body}}", relevantBody);
+  try {
+    const response = await chat(
+      [{ role: "user", content: prompt }],
+      "You are a helpful email assistant that extracts action items. Always respond with valid JSON."
+    );
+    const result = JSON.parse(response.content);
+    return (result.actions || []).map((action) => ({
+      emailId: parsed.id,
+      subject: parsed.subject,
+      from: fromDisplay,
+      action: action.action,
+      priority: ["high", "medium", "low"].includes(action.priority) ? action.priority : "medium",
+      dueDate: action.dueDate ? new Date(action.dueDate) : void 0,
+      context: action.context
+    }));
+  } catch (err) {
+    console.error("Failed to extract action items:", err);
+    return [];
+  }
+}
+async function summarizeThread(thread) {
+  const participants = thread.participants.map((p) => p.name || p.address).slice(0, 10).join(", ");
+  const messageContent = thread.messages.slice(-10).map((msg, idx) => {
+    const from = msg.from[0]?.name || msg.from[0]?.address || "Unknown";
+    const bodyParts = parseEmailBody(msg.body.text);
+    const content = (bodyParts.newContent || msg.body.snippet).substring(0, 500);
+    return `[${idx + 1}] From: ${from}
+Date: ${msg.date.toISOString()}
+${content}`;
+  }).join("\n\n---\n\n");
+  const prompt = THREAD_SUMMARY_PROMPT.replace("{{subject}}", thread.subject).replace("{{participants}}", participants).replace("{{messageCount}}", String(thread.messageCount)).replace("{{messages}}", messageContent);
+  try {
+    const response = await chat(
+      [{ role: "user", content: prompt }],
+      "You are a helpful email assistant that summarizes email threads. Always respond with valid JSON."
+    );
+    const result = JSON.parse(response.content);
+    return {
+      threadId: thread.id,
+      subject: thread.subject,
+      participantCount: thread.participants.length,
+      messageCount: thread.messageCount,
+      summary: result.summary || "No summary available",
+      currentStatus: result.currentStatus || "Unknown",
+      nextSteps: result.nextSteps || [],
+      keyDecisions: result.keyDecisions || [],
+      openQuestions: result.openQuestions || []
+    };
+  } catch (err) {
+    console.error("Failed to summarize thread:", err);
+    return {
+      threadId: thread.id,
+      subject: thread.subject,
+      participantCount: thread.participants.length,
+      messageCount: thread.messageCount,
+      summary: "Failed to generate summary",
+      currentStatus: "Unknown",
+      nextSteps: [],
+      keyDecisions: [],
+      openQuestions: []
+    };
+  }
+}
+async function summarizeInbox(emails) {
+  const parsedEmails = emails.map(parseEmail);
+  const categorizations = await Promise.all(
+    parsedEmails.slice(0, 100).map(async (email) => ({
+      email,
+      categorization: await categorizeEmail(email)
+    }))
+  );
+  const totalEmails = emails.length;
+  const unreadCount = parsedEmails.filter((e) => !e.metadata.isRead).length;
+  const importantCount = categorizations.filter(
+    (c) => c.categorization.category === "urgent" || c.categorization.category === "action_required"
+  ).length;
+  const categoryMap = /* @__PURE__ */ new Map();
+  for (const { email, categorization } of categorizations) {
+    const cat = categorization.category;
+    if (!categoryMap.has(cat)) {
+      categoryMap.set(cat, { emails: [], senders: /* @__PURE__ */ new Set() });
+    }
+    const entry = categoryMap.get(cat);
+    entry.emails.push(email);
+    if (email.from[0]) {
+      entry.senders.add(email.from[0].name || email.from[0].address);
+    }
+  }
+  const categories = [];
+  for (const [name, data] of categoryMap) {
+    categories.push({
+      name,
+      count: data.emails.length,
+      unreadCount: data.emails.filter((e) => !e.metadata.isRead).length,
+      topSenders: Array.from(data.senders).slice(0, 5),
+      description: getCategoryDescription(name)
+    });
+  }
+  categories.sort((a, b) => b.count - a.count);
+  const urgentItems = [];
+  for (const { email, categorization } of categorizations) {
+    if (categorization.category === "urgent") {
+      urgentItems.push({
+        emailId: email.id,
+        subject: email.subject,
+        from: email.from[0]?.name || email.from[0]?.address || "Unknown",
+        reason: categorization.reason,
+        suggestedAction: "Review and respond as soon as possible"
+      });
+    }
+  }
+  const actionItems = [];
+  const actionRequiredEmails = categorizations.filter((c) => c.categorization.category === "action_required").slice(0, 10);
+  for (const { email } of actionRequiredEmails) {
+    const items = await extractActionItems(email);
+    actionItems.push(...items);
+  }
+  actionItems.sort((a, b) => {
+    const priorityOrder = { high: 0, medium: 1, low: 2 };
+    return priorityOrder[a.priority] - priorityOrder[b.priority];
+  });
+  const categoriesText = categories.map((c) => `- ${c.name}: ${c.count} emails (${c.unreadCount} unread)`).join("\n");
+  const urgentText = urgentItems.length > 0 ? urgentItems.map((u) => `- "${u.subject}" from ${u.from}`).join("\n") : "None";
+  const summaryPrompt = INBOX_SUMMARY_PROMPT.replace("{{totalEmails}}", String(totalEmails)).replace("{{unreadCount}}", String(unreadCount)).replace("{{importantCount}}", String(importantCount)).replace("{{categories}}", categoriesText).replace("{{urgentItems}}", urgentText);
+  let summary = "";
+  try {
+    const response = await chat(
+      [{ role: "user", content: summaryPrompt }],
+      "You are a helpful email assistant providing inbox summaries. Be concise and actionable."
+    );
+    summary = response.content;
+  } catch (err) {
+    console.error("Failed to generate summary:", err);
+    summary = `You have ${totalEmails} emails, ${unreadCount} unread. ${importantCount} require attention.`;
+  }
+  return {
+    totalEmails,
+    unreadCount,
+    importantCount,
+    categories,
+    urgentItems,
+    actionItems: actionItems.slice(0, 20),
+    summary,
+    generatedAt: /* @__PURE__ */ new Date()
+  };
+}
+async function generateDailyDigest(emails) {
+  const summary = await summarizeInbox(emails);
+  let digest = `# Daily Email Digest
+
+`;
+  digest += `*Generated: ${summary.generatedAt.toLocaleString()}*
+
+`;
+  digest += `## Overview
+
+`;
+  digest += `${summary.summary}
+
+`;
+  digest += `- **Total Emails:** ${summary.totalEmails}
+`;
+  digest += `- **Unread:** ${summary.unreadCount}
+`;
+  digest += `- **Needs Attention:** ${summary.importantCount}
+
+`;
+  if (summary.urgentItems.length > 0) {
+    digest += `## Urgent
+
+`;
+    for (const item of summary.urgentItems) {
+      digest += `- **${item.subject}** from ${item.from}
+`;
+      digest += `  *${item.reason}*
+
+`;
+    }
+  }
+  if (summary.actionItems.length > 0) {
+    digest += `## Action Items
+
+`;
+    for (const item of summary.actionItems) {
+      const priority = item.priority === "high" ? "!!!" : item.priority === "medium" ? "!!" : "!";
+      digest += `- [${priority}] **${item.action}**
+`;
+      digest += `  From: ${item.from} | ${item.context}
+`;
+      if (item.dueDate) {
+        digest += `  Due: ${item.dueDate.toLocaleDateString()}
+`;
+      }
+      digest += "\n";
+    }
+  }
+  digest += `## By Category
+
+`;
+  for (const cat of summary.categories.slice(0, 8)) {
+    digest += `- **${cat.name}:** ${cat.count} emails`;
+    if (cat.unreadCount > 0) {
+      digest += ` (${cat.unreadCount} unread)`;
+    }
+    digest += "\n";
+    if (cat.topSenders.length > 0) {
+      digest += `  Top senders: ${cat.topSenders.slice(0, 3).join(", ")}
+`;
+    }
+  }
+  return digest;
+}
+async function suggestReplies(email) {
+  const parsed = "metadata" in email ? email : parseEmail(email);
+  const fromDisplay = parsed.from[0] ? `${parsed.from[0].name || ""} <${parsed.from[0].address}>`.trim() : "Unknown";
+  const bodyParts = parseEmailBody(parsed.body.text);
+  const relevantBody = (bodyParts.newContent || parsed.body.text).substring(0, 1500);
+  const prompt = `You are an email assistant suggesting reply options. Based on the following email, suggest 3 brief reply options ranging from formal to casual.
+
+Email:
+From: ${fromDisplay}
+Subject: ${parsed.subject}
+Body: ${relevantBody}
+
+Provide 3 reply suggestions:
+1. A brief, professional response
+2. A friendly but complete response
+3. A quick, informal response
+
+Respond in JSON format:
+{
+  "replies": ["reply 1", "reply 2", "reply 3"]
+}`;
+  try {
+    const response = await chat(
+      [{ role: "user", content: prompt }],
+      "You are a helpful email assistant. Always respond with valid JSON."
+    );
+    const result = JSON.parse(response.content);
+    return result.replies || [];
+  } catch (err) {
+    console.error("Failed to suggest replies:", err);
+    return [];
+  }
+}
+async function analyzeSentiment(email) {
+  const parsed = "metadata" in email ? email : parseEmail(email);
+  const bodyParts = parseEmailBody(parsed.body.text);
+  const relevantBody = (bodyParts.newContent || parsed.body.text).substring(0, 1500);
+  const prompt = `Analyze the sentiment and tone of this email:
+
+Subject: ${parsed.subject}
+Body: ${relevantBody}
+
+Respond in JSON format:
+{
+  "sentiment": "positive|negative|neutral",
+  "confidence": 0.0-1.0,
+  "tone": "brief description of tone (e.g., 'urgent', 'friendly', 'formal', 'frustrated')",
+  "keyPhrases": ["phrase1", "phrase2", "phrase3"]
+}`;
+  try {
+    const response = await chat(
+      [{ role: "user", content: prompt }],
+      "You are a helpful sentiment analysis assistant. Always respond with valid JSON."
+    );
+    const result = JSON.parse(response.content);
+    return {
+      sentiment: result.sentiment || "neutral",
+      confidence: result.confidence || 0.5,
+      tone: result.tone || "neutral",
+      keyPhrases: result.keyPhrases || []
+    };
+  } catch (err) {
+    console.error("Failed to analyze sentiment:", err);
+    return {
+      sentiment: "neutral",
+      confidence: 0.5,
+      tone: "neutral",
+      keyPhrases: []
+    };
+  }
+}
+function getCategoryDescription(category) {
+  const descriptions = {
+    urgent: "Time-sensitive emails requiring immediate attention",
+    action_required: "Emails that need your response or action",
+    informational: "FYI emails and updates",
+    meeting: "Calendar invites and meeting-related emails",
+    financial: "Invoices, receipts, and financial communications",
+    social: "Personal and social notifications",
+    marketing: "Promotional emails and newsletters",
+    support: "Customer support and help desk communications",
+    work: "Work-related emails",
+    spam: "Potentially unwanted emails"
+  };
+  return descriptions[category] || "Other emails";
+}
+var inbox_summarizer_default = {
+  categorizeEmail,
+  extractActionItems,
+  summarizeThread,
+  summarizeInbox,
+  generateDailyDigest,
+  suggestReplies,
+  analyzeSentiment
+};
+
+export {
+  parseEmail,
+  parseAttachment,
+  groupIntoThreads,
+  cleanSubject,
+  parseEmailBody,
+  extractEmailAddresses,
+  extractUrls,
+  extractPhoneNumbers,
+  getEmailSummary,
+  calculateEmailSize,
+  matchesFilter,
+  categorizeEmail,
+  extractActionItems,
+  summarizeThread,
+  summarizeInbox,
+  generateDailyDigest,
+  suggestReplies,
+  analyzeSentiment,
+  inbox_summarizer_default
+};
+//# sourceMappingURL=chunk-SPPMCAKG.js.map