inboxd 1.0.12 → 1.1.0

package/src/deletion-log.js

@@ -95,10 +95,111 @@ function removeLogEntries(ids) {
   }
 }
 
+/**
+ * Extracts domain from email address
+ * @param {string} from - From field like "Name <email@domain.com>" or "email@domain.com"
+ * @returns {string} Domain or 'unknown'
+ */
+function extractDomain(from) {
+  const match = from.match(/@([a-zA-Z0-9.-]+)/);
+  return match ? match[1].toLowerCase() : 'unknown';
+}
+
+/**
+ * Gets deletion statistics for the specified period
+ * @param {number} days - Number of days to look back (default: 30)
+ * @returns {Object} Statistics object with counts and breakdowns
+ */
+function getStats(days = 30) {
+  const deletions = getRecentDeletions(days);
+
+  // Count by account
+  const byAccount = {};
+  deletions.forEach(d => {
+    const account = d.account || 'default';
+    byAccount[account] = (byAccount[account] || 0) + 1;
+  });
+
+  // Count by sender domain
+  const bySender = {};
+  deletions.forEach(d => {
+    const domain = extractDomain(d.from || '');
+    bySender[domain] = (bySender[domain] || 0) + 1;
+  });
+
+  // Sort senders by count (descending)
+  const topSenders = Object.entries(bySender)
+    .sort((a, b) => b[1] - a[1])
+    .slice(0, 10)
+    .map(([domain, count]) => ({ domain, count }));
+
+  return {
+    total: deletions.length,
+    byAccount,
+    topSenders,
+  };
+}
+
+/**
+ * Analyzes deletion patterns to suggest cleanup actions
+ * @param {number} days - Number of days to analyze (default: 30)
+ * @returns {Object} Analysis with suggestions
+ */
+function analyzePatterns(days = 30) {
+  const deletions = getRecentDeletions(days);
+
+  // Group by sender domain with details
+  const senderStats = {};
+  deletions.forEach(d => {
+    const domain = extractDomain(d.from || '');
+    if (!senderStats[domain]) {
+      senderStats[domain] = { count: 0, unreadCount: 0, subjects: new Set() };
+    }
+    senderStats[domain].count++;
+    // Check if it was unread when deleted (labelIds contains UNREAD)
+    if (d.labelIds && d.labelIds.includes('UNREAD')) {
+      senderStats[domain].unreadCount++;
+    }
+    // Store unique subject patterns (first 30 chars)
+    if (d.subject) {
+      senderStats[domain].subjects.add(d.subject.substring(0, 30));
+    }
+  });
+
+  // Find frequent deleters (deleted 3+ times)
+  const frequentDeleters = Object.entries(senderStats)
+    .filter(([_, stats]) => stats.count >= 3)
+    .sort((a, b) => b[1].count - a[1].count)
+    .map(([domain, stats]) => ({
+      domain,
+      deletedCount: stats.count,
+      suggestion: 'Consider unsubscribing',
+    }));
+
+  // Find never-read senders (all deleted emails were unread)
+  const neverReadSenders = Object.entries(senderStats)
+    .filter(([_, stats]) => stats.count >= 2 && stats.unreadCount === stats.count)
+    .sort((a, b) => b[1].count - a[1].count)
+    .map(([domain, stats]) => ({
+      domain,
+      deletedCount: stats.count,
+      suggestion: 'You never read these - consider bulk cleanup',
+    }));
+
+  return {
+    period: days,
+    totalDeleted: deletions.length,
+    frequentDeleters,
+    neverReadSenders,
+  };
+}
+
 module.exports = {
   logDeletions,
   getRecentDeletions,
   getLogPath,
   readLog,
   removeLogEntries,
+  getStats,
+  analyzePatterns,
 };

package/src/gmail-monitor.js

@@ -209,6 +209,34 @@ async function markAsRead(account, messageIds) {
   return results;
 }
 
+/**
+ * Marks emails as unread by adding the UNREAD label
+ * @param {string} account - Account name
+ * @param {Array<string>} messageIds - Array of message IDs to mark as unread
+ * @returns {Array<{id: string, success: boolean, error?: string}>} Results for each message
+ */
+async function markAsUnread(account, messageIds) {
+  const gmail = await getGmailClient(account);
+  const results = [];
+
+  for (const id of messageIds) {
+    try {
+      await withRetry(() => gmail.users.messages.modify({
+        userId: 'me',
+        id: id,
+        requestBody: {
+          addLabelIds: ['UNREAD'],
+        },
+      }));
+      results.push({ id, success: true });
+    } catch (err) {
+      results.push({ id, success: false, error: err.message });
+    }
+  }
+
+  return results;
+}
+
 /**
  * Archives emails by removing the INBOX label
  * @param {string} account - Account name
@@ -237,6 +265,34 @@ async function archiveEmails(account, messageIds) {
   return results;
 }
 
+/**
+ * Unarchives emails by adding the INBOX label back
+ * @param {string} account - Account name
+ * @param {Array<string>} messageIds - Array of message IDs to unarchive
+ * @returns {Array<{id: string, success: boolean, error?: string}>} Results for each message
+ */
+async function unarchiveEmails(account, messageIds) {
+  const gmail = await getGmailClient(account);
+  const results = [];
+
+  for (const id of messageIds) {
+    try {
+      await withRetry(() => gmail.users.messages.modify({
+        userId: 'me',
+        id: id,
+        requestBody: {
+          addLabelIds: ['INBOX'],
+        },
+      }));
+      results.push({ id, success: true });
+    } catch (err) {
+      results.push({ id, success: false, error: err.message });
+    }
+  }
+
+  return results;
+}
+
 /**
  * Extracts the domain from a From header value
  * @param {string} from - e.g., "Sender Name <sender@example.com>" or "sender@example.com"
@@ -646,7 +702,9 @@ module.exports = {
   getEmailById,
   untrashEmails,
   markAsRead,
+  markAsUnread,
   archiveEmails,
+  unarchiveEmails,
   extractSenderDomain,
   groupEmailsBySender,
   getEmailContent,

package/src/sent-log.js

@@ -79,9 +79,44 @@ function getSentLogPath() {
   return LOG_FILE;
 }
 
+/**
+ * Gets sent email statistics for the specified period
+ * @param {number} days - Number of days to look back (default: 30)
+ * @returns {Object} Statistics object with counts and breakdowns
+ */
+function getSentStats(days = 30) {
+  const sent = getRecentSent(days);
+
+  // Count replies vs new emails
+  let replies = 0;
+  let newEmails = 0;
+  sent.forEach(s => {
+    if (s.replyToId) {
+      replies++;
+    } else {
+      newEmails++;
+    }
+  });
+
+  // Count by account
+  const byAccount = {};
+  sent.forEach(s => {
+    const account = s.account || 'default';
+    byAccount[account] = (byAccount[account] || 0) + 1;
+  });
+
+  return {
+    total: sent.length,
+    replies,
+    newEmails,
+    byAccount,
+  };
+}
+
 module.exports = {
   logSentEmail,
   getRecentSent,
   getSentLogPath,
   readSentLog,
+  getSentStats,
 };

package/tests/archive-log.test.js

@@ -0,0 +1,196 @@
+import { describe, it, expect } from 'vitest';
+import path from 'path';
+import os from 'os';
+
+// Test archive-log logic patterns without importing the real module
+// This mirrors the structure of deletion-log.test.js
+
+describe('Archive Log', () => {
+  const LOG_DIR = path.join(os.homedir(), '.config', 'inboxd');
+  const LOG_FILE = path.join(LOG_DIR, 'archive-log.json');
+
+  describe('Log entry structure', () => {
+    it('should have required fields for recovery', () => {
+      const logEntry = {
+        archivedAt: '2026-01-03T15:45:00.000Z',
+        account: 'personal@gmail.com',
+        id: '19b84376ff5f5ed2',
+        threadId: '19b84376ff5f5ed2',
+        from: 'Newsletter <news@example.com>',
+        subject: 'Weekly Digest',
+        snippet: 'This week in tech...',
+      };
+
+      expect(logEntry).toHaveProperty('archivedAt');
+      expect(logEntry).toHaveProperty('account');
+      expect(logEntry).toHaveProperty('id');
+      expect(logEntry).toHaveProperty('threadId');
+      expect(logEntry).toHaveProperty('from');
+      expect(logEntry).toHaveProperty('subject');
+      expect(logEntry).toHaveProperty('snippet');
+    });
+
+    it('should include ISO timestamp', () => {
+      const timestamp = new Date().toISOString();
+      expect(timestamp).toMatch(/^\d{4}-\d{2}-\d{2}T\d{2}:\d{2}:\d{2}/);
+    });
+  });
+
+  describe('Log filtering by date', () => {
+    it('should filter entries within date range', () => {
+      const now = new Date();
+      const tenDaysAgo = new Date(now);
+      tenDaysAgo.setDate(tenDaysAgo.getDate() - 10);
+      const fortyDaysAgo = new Date(now);
+      fortyDaysAgo.setDate(fortyDaysAgo.getDate() - 40);
+
+      const entries = [
+        { archivedAt: now.toISOString(), id: 'recent' },
+        { archivedAt: tenDaysAgo.toISOString(), id: 'ten-days' },
+        { archivedAt: fortyDaysAgo.toISOString(), id: 'forty-days' },
+      ];
+
+      const cutoff = new Date();
+      cutoff.setDate(cutoff.getDate() - 30);
+
+      const recentEntries = entries.filter((e) => new Date(e.archivedAt) >= cutoff);
+
+      expect(recentEntries).toHaveLength(2);
+      expect(recentEntries.map(e => e.id)).toContain('recent');
+      expect(recentEntries.map(e => e.id)).toContain('ten-days');
+      expect(recentEntries.map(e => e.id)).not.toContain('forty-days');
+    });
+  });
+
+  describe('Log path', () => {
+    it('should use correct log directory path', () => {
+      expect(LOG_DIR).toContain('.config');
+      expect(LOG_DIR).toContain('inboxd');
+    });
+
+    it('should use correct log file name', () => {
+      expect(LOG_FILE).toContain('archive-log.json');
+    });
+  });
+
+  describe('Batch archiving', () => {
+    it('should handle multiple emails in one log operation', () => {
+      const emails = [
+        { id: '1', account: 'test', from: 'a@b.com', subject: 'A', snippet: 'a', threadId: '1' },
+        { id: '2', account: 'test', from: 'c@d.com', subject: 'B', snippet: 'b', threadId: '2' },
+        { id: '3', account: 'test', from: 'e@f.com', subject: 'C', snippet: 'c', threadId: '3' },
+      ];
+
+      const timestamp = new Date().toISOString();
+      const logEntries = emails.map(email => ({
+        archivedAt: timestamp,
+        ...email,
+      }));
+
+      expect(logEntries).toHaveLength(3);
+      expect(logEntries[0].id).toBe('1');
+      expect(logEntries[2].id).toBe('3');
+      // All should have same timestamp (batch operation)
+      expect(logEntries[0].archivedAt).toBe(logEntries[1].archivedAt);
+    });
+  });
+
+  describe('Empty log handling', () => {
+    it('should return empty array for empty log', () => {
+      const emptyLog = [];
+      expect(emptyLog).toHaveLength(0);
+      expect(Array.isArray(emptyLog)).toBe(true);
+    });
+
+    it('should handle missing log file gracefully', () => {
+      const readLogSafe = (fileExists, fileContent) => {
+        if (!fileExists) return [];
+        try {
+          return JSON.parse(fileContent);
+        } catch {
+          return [];
+        }
+      };
+
+      expect(readLogSafe(false, '')).toEqual([]);
+      expect(readLogSafe(true, 'invalid json')).toEqual([]);
+      expect(readLogSafe(true, '[]')).toEqual([]);
+    });
+  });
+
+  describe('Log removal for unarchive', () => {
+    it('should remove entries by id after unarchiving', () => {
+      const log = [
+        { id: '1', account: 'test' },
+        { id: '2', account: 'test' },
+        { id: '3', account: 'test' },
+      ];
+
+      const idsToRemove = ['2'];
+      const newLog = log.filter(entry => !idsToRemove.includes(entry.id));
+
+      expect(newLog).toHaveLength(2);
+      expect(newLog.find(e => e.id === '2')).toBeUndefined();
+      expect(newLog.find(e => e.id === '1')).toBeDefined();
+      expect(newLog.find(e => e.id === '3')).toBeDefined();
+    });
+
+    it('should handle removing multiple entries', () => {
+      const log = [
+        { id: '1' },
+        { id: '2' },
+        { id: '3' },
+        { id: '4' },
+      ];
+
+      const idsToRemove = ['1', '3'];
+      const newLog = log.filter(entry => !idsToRemove.includes(entry.id));
+
+      expect(newLog).toHaveLength(2);
+      expect(newLog.map(e => e.id)).toEqual(['2', '4']);
+    });
+
+    it('should detect when entries were removed', () => {
+      const log = [{ id: '1' }, { id: '2' }];
+      const idsToRemove = ['2'];
+      const newLog = log.filter(entry => !idsToRemove.includes(entry.id));
+
+      const entriesWereRemoved = log.length !== newLog.length;
+      expect(entriesWereRemoved).toBe(true);
+    });
+  });
+
+  describe('Sorting for --last N', () => {
+    it('should sort by archivedAt descending for --last retrieval', () => {
+      const now = new Date();
+      const oneHourAgo = new Date(now.getTime() - 60 * 60 * 1000);
+      const twoHoursAgo = new Date(now.getTime() - 2 * 60 * 60 * 1000);
+
+      const archives = [
+        { id: '1', archivedAt: twoHoursAgo.toISOString() },
+        { id: '2', archivedAt: now.toISOString() },
+        { id: '3', archivedAt: oneHourAgo.toISOString() },
+      ];
+
+      archives.sort((a, b) => new Date(b.archivedAt) - new Date(a.archivedAt));
+
+      expect(archives[0].id).toBe('2'); // most recent
+      expect(archives[1].id).toBe('3');
+      expect(archives[2].id).toBe('1'); // oldest
+    });
+
+    it('should slice correct number for --last N', () => {
+      const archives = [
+        { id: '1' },
+        { id: '2' },
+        { id: '3' },
+        { id: '4' },
+        { id: '5' },
+      ];
+
+      const lastThree = archives.slice(0, 3);
+      expect(lastThree).toHaveLength(3);
+      expect(lastThree.map(e => e.id)).toEqual(['1', '2', '3']);
+    });
+  });
+});

package/tests/cleanup-suggest.test.js

@@ -0,0 +1,239 @@
+import { describe, it, expect } from 'vitest';
+
+// Test cleanup-suggest / analyzePatterns logic
+// Mirrors the analyzePatterns function in deletion-log.js
+
+describe('Cleanup Suggestions', () => {
+  // Helper to extract domain from email address
+  function extractDomain(from) {
+    const match = from.match(/@([a-zA-Z0-9.-]+)/);
+    return match ? match[1].toLowerCase() : 'unknown';
+  }
+
+  // Mirrors analyzePatterns() from deletion-log.js
+  function analyzePatterns(deletions) {
+    const senderStats = {};
+    deletions.forEach(d => {
+      const domain = extractDomain(d.from || '');
+      if (!senderStats[domain]) {
+        senderStats[domain] = { count: 0, unreadCount: 0, subjects: new Set() };
+      }
+      senderStats[domain].count++;
+      if (d.labelIds && d.labelIds.includes('UNREAD')) {
+        senderStats[domain].unreadCount++;
+      }
+      if (d.subject) {
+        senderStats[domain].subjects.add(d.subject.substring(0, 30));
+      }
+    });
+
+    const frequentDeleters = Object.entries(senderStats)
+      .filter(([_, stats]) => stats.count >= 3)
+      .sort((a, b) => b[1].count - a[1].count)
+      .map(([domain, stats]) => ({
+        domain,
+        deletedCount: stats.count,
+        suggestion: 'Consider unsubscribing',
+      }));
+
+    const neverReadSenders = Object.entries(senderStats)
+      .filter(([_, stats]) => stats.count >= 2 && stats.unreadCount === stats.count)
+      .sort((a, b) => b[1].count - a[1].count)
+      .map(([domain, stats]) => ({
+        domain,
+        deletedCount: stats.count,
+        suggestion: 'You never read these - consider bulk cleanup',
+      }));
+
+    return {
+      period: 30,
+      totalDeleted: deletions.length,
+      frequentDeleters,
+      neverReadSenders,
+    };
+  }
+
+  describe('Frequent Deleters Detection', () => {
+    it('should identify senders with 3+ deletions', () => {
+      const deletions = [
+        { id: '1', from: 'a@linkedin.com' },
+        { id: '2', from: 'b@linkedin.com' },
+        { id: '3', from: 'c@linkedin.com' },
+        { id: '4', from: 'd@amazon.com' },
+        { id: '5', from: 'e@amazon.com' },
+      ];
+
+      const analysis = analyzePatterns(deletions);
+
+      expect(analysis.frequentDeleters).toHaveLength(1);
+      expect(analysis.frequentDeleters[0].domain).toBe('linkedin.com');
+      expect(analysis.frequentDeleters[0].deletedCount).toBe(3);
+    });
+
+    it('should not include senders with less than 3 deletions', () => {
+      const deletions = [
+        { id: '1', from: 'a@example.com' },
+        { id: '2', from: 'b@example.com' },
+      ];
+
+      const analysis = analyzePatterns(deletions);
+      expect(analysis.frequentDeleters).toHaveLength(0);
+    });
+
+    it('should sort frequent deleters by count descending', () => {
+      const deletions = [
+        { id: '1', from: 'a@linkedin.com' },
+        { id: '2', from: 'b@linkedin.com' },
+        { id: '3', from: 'c@linkedin.com' },
+        { id: '4', from: 'd@amazon.com' },
+        { id: '5', from: 'e@amazon.com' },
+        { id: '6', from: 'f@amazon.com' },
+        { id: '7', from: 'g@amazon.com' },
+        { id: '8', from: 'h@github.com' },
+        { id: '9', from: 'i@github.com' },
+        { id: '10', from: 'j@github.com' },
+      ];
+
+      const analysis = analyzePatterns(deletions);
+
+      expect(analysis.frequentDeleters[0].domain).toBe('amazon.com');
+      expect(analysis.frequentDeleters[0].deletedCount).toBe(4);
+      expect(analysis.frequentDeleters[1].deletedCount).toBe(3);
+    });
+  });
+
+  describe('Never-Read Senders Detection', () => {
+    it('should identify senders whose emails were always deleted unread', () => {
+      const deletions = [
+        { id: '1', from: 'promo@store.com', labelIds: ['UNREAD'] },
+        { id: '2', from: 'promo@store.com', labelIds: ['UNREAD'] },
+        { id: '3', from: 'promo@store.com', labelIds: ['UNREAD'] },
+      ];
+
+      const analysis = analyzePatterns(deletions);
+
+      expect(analysis.neverReadSenders).toHaveLength(1);
+      expect(analysis.neverReadSenders[0].domain).toBe('store.com');
+      expect(analysis.neverReadSenders[0].deletedCount).toBe(3);
+    });
+
+    it('should not include senders with some read emails', () => {
+      const deletions = [
+        { id: '1', from: 'news@example.com', labelIds: ['UNREAD'] },
+        { id: '2', from: 'news@example.com', labelIds: [] }, // was read
+        { id: '3', from: 'news@example.com', labelIds: ['UNREAD'] },
+      ];
+
+      const analysis = analyzePatterns(deletions);
+      expect(analysis.neverReadSenders).toHaveLength(0);
+    });
+
+    it('should require at least 2 deletions for never-read', () => {
+      const deletions = [
+        { id: '1', from: 'one@example.com', labelIds: ['UNREAD'] },
+      ];
+
+      const analysis = analyzePatterns(deletions);
+      expect(analysis.neverReadSenders).toHaveLength(0);
+    });
+
+    it('should handle missing labelIds gracefully', () => {
+      const deletions = [
+        { id: '1', from: 'a@test.com' },
+        { id: '2', from: 'b@test.com' },
+      ];
+
+      // Should not throw
+      const analysis = analyzePatterns(deletions);
+      expect(analysis.neverReadSenders).toHaveLength(0);
+    });
+  });
+
+  describe('Analysis Output Structure', () => {
+    it('should include period and total', () => {
+      const analysis = analyzePatterns([]);
+      expect(analysis).toHaveProperty('period');
+      expect(analysis).toHaveProperty('totalDeleted');
+      expect(analysis.totalDeleted).toBe(0);
+    });
+
+    it('should provide suggestions for frequent deleters', () => {
+      const deletions = [
+        { id: '1', from: 'a@spam.com' },
+        { id: '2', from: 'b@spam.com' },
+        { id: '3', from: 'c@spam.com' },
+      ];
+
+      const analysis = analyzePatterns(deletions);
+      expect(analysis.frequentDeleters[0]).toHaveProperty('suggestion');
+      expect(analysis.frequentDeleters[0].suggestion).toContain('unsubscribing');
+    });
+
+    it('should provide suggestions for never-read senders', () => {
+      const deletions = [
+        { id: '1', from: 'a@junk.com', labelIds: ['UNREAD'] },
+        { id: '2', from: 'b@junk.com', labelIds: ['UNREAD'] },
+      ];
+
+      const analysis = analyzePatterns(deletions);
+      expect(analysis.neverReadSenders[0]).toHaveProperty('suggestion');
+      expect(analysis.neverReadSenders[0].suggestion).toContain('bulk cleanup');
+    });
+  });
+
+  describe('JSON output structure', () => {
+    it('should have correct structure for JSON output', () => {
+      const jsonOutput = {
+        period: 30,
+        totalDeleted: 15,
+        frequentDeleters: [
+          { domain: 'linkedin.com', deletedCount: 8, suggestion: 'Consider unsubscribing' }
+        ],
+        neverReadSenders: [
+          { domain: 'promo.com', deletedCount: 5, suggestion: 'You never read these...' }
+        ],
+      };
+
+      expect(jsonOutput).toHaveProperty('period');
+      expect(jsonOutput).toHaveProperty('totalDeleted');
+      expect(jsonOutput).toHaveProperty('frequentDeleters');
+      expect(jsonOutput).toHaveProperty('neverReadSenders');
+      expect(Array.isArray(jsonOutput.frequentDeleters)).toBe(true);
+      expect(Array.isArray(jsonOutput.neverReadSenders)).toBe(true);
+    });
+  });
+
+  describe('Edge Cases', () => {
+    it('should handle empty deletions list', () => {
+      const analysis = analyzePatterns([]);
+      expect(analysis.totalDeleted).toBe(0);
+      expect(analysis.frequentDeleters).toEqual([]);
+      expect(analysis.neverReadSenders).toEqual([]);
+    });
+
+    it('should handle emails with missing from field', () => {
+      const deletions = [
+        { id: '1' },
+        { id: '2', from: '' },
+        { id: '3', from: null },
+      ];
+
+      // Should not throw
+      const analysis = analyzePatterns(deletions);
+      expect(analysis.totalDeleted).toBe(3);
+    });
+
+    it('should group same sender with different display names', () => {
+      const deletions = [
+        { id: '1', from: 'LinkedIn Jobs <jobs@linkedin.com>' },
+        { id: '2', from: 'LinkedIn Connections <connect@linkedin.com>' },
+        { id: '3', from: 'noreply@linkedin.com' },
+      ];
+
+      const analysis = analyzePatterns(deletions);
+      expect(analysis.frequentDeleters).toHaveLength(1);
+      expect(analysis.frequentDeleters[0].domain).toBe('linkedin.com');
+      expect(analysis.frequentDeleters[0].deletedCount).toBe(3);
+    });
+  });
+});