feat: implement archive functionality with retention period management and UI updates

Author: mberrishdev

src/main/clipboardManager.ts

@@ -28,7 +28,7 @@ export class ClipboardManager {
     this.loadHistoryFromDB();
   }
 
-  private loadHistoryFromDB() {
+  public loadHistoryFromDB() {
     try {
       const stats = this.db.getStats();
       log.info(`Database stats:`, stats);

src/main/configManager.ts

@@ -7,12 +7,14 @@ export interface AppConfig {
   globalShortcut: string;
   transparency: boolean;
   openaiApiKey?: string;
+  retentionPeriodDays: number;
 }
 
 const DEFAULT_CONFIG: AppConfig = {
   globalShortcut: "CommandOrControl+Shift+V",
   transparency: true,
   openaiApiKey: undefined,
+  retentionPeriodDays: 30,
 };
 
 export class ConfigManager {
@@ -80,4 +82,17 @@ export class ConfigManager {
     this.config.openaiApiKey = apiKey.trim();
     this.saveConfig();
   }
+
+  getRetentionPeriodDays(): number {
+    return this.config.retentionPeriodDays;
+  }
+
+  setRetentionPeriodDays(days: number): void {
+    // Validate: minimum 1 day, maximum 365 days
+    if (days < 1 || days > 365) {
+      throw new Error("Retention period must be between 1 and 365 days");
+    }
+    this.config.retentionPeriodDays = days;
+    this.saveConfig();
+  }
 }

src/main/database.ts

@@ -64,6 +64,22 @@ export class DatabaseManager {
 
       CREATE INDEX IF NOT EXISTS idx_timestamp ON clipboard_items(timestamp DESC);
       CREATE INDEX IF NOT EXISTS idx_type ON clipboard_items(type);
+
+      CREATE TABLE IF NOT EXISTS archived_items (
+        id INTEGER PRIMARY KEY AUTOINCREMENT,
+        original_id INTEGER NOT NULL,
+        type TEXT NOT NULL,
+        text TEXT,
+        image TEXT,
+        timestamp INTEGER NOT NULL,
+        embedding BLOB,
+        archived_at DATETIME DEFAULT CURRENT_TIMESTAMP,
+        created_at DATETIME
+      );
+
+      CREATE INDEX IF NOT EXISTS idx_archived_timestamp ON archived_items(timestamp DESC);
+      CREATE INDEX IF NOT EXISTS idx_archived_at ON archived_items(archived_at DESC);
+      CREATE INDEX IF NOT EXISTS idx_archived_type ON archived_items(type);
     `);
     log.info("Database tables initialized");
   }
@@ -192,6 +208,115 @@ export class DatabaseManager {
     return stmt.all(JSON.stringify(queryEmbedding), limit) as ClipboardItem[];
   }
 
+  archiveOldItems(retentionDays: number): number {
+    const cutoffTimestamp = Date.now() - retentionDays * 24 * 60 * 60 * 1000;
+
+    const insertStmt = this.db.prepare(`
+      INSERT INTO archived_items (original_id, type, text, image, timestamp, embedding, created_at)
+      SELECT id, type, text, image, timestamp, embedding, created_at
+      FROM clipboard_items
+      WHERE timestamp < ?
+    `);
+
+    const result = insertStmt.run(cutoffTimestamp);
+
+    if (result.changes > 0) {
+      const deleteStmt = this.db.prepare(`
+        DELETE FROM clipboard_items WHERE timestamp < ?
+      `);
+      deleteStmt.run(cutoffTimestamp);
+    }
+
+    log.info(
+      `Archived ${result.changes} items older than ${retentionDays} days`
+    );
+    return result.changes;
+  }
+
+  getArchivedItems(limit: number = 1000, offset: number = 0): ClipboardItem[] {
+    const stmt = this.db.prepare(`
+      SELECT id, type, text, image, timestamp
+      FROM archived_items
+      ORDER BY timestamp DESC
+      LIMIT ? OFFSET ?
+    `);
+
+    return stmt.all(limit, offset) as ClipboardItem[];
+  }
+
+  unarchiveItem(id: number): boolean {
+    const insertStmt = this.db.prepare(`
+      INSERT INTO clipboard_items (type, text, image, timestamp, embedding)
+      SELECT type, text, image, timestamp, embedding
+      FROM archived_items
+      WHERE id = ?
+    `);
+
+    const result = insertStmt.run(id);
+
+    if (result.changes > 0) {
+      const deleteStmt = this.db.prepare(`
+        DELETE FROM archived_items WHERE id = ?
+      `);
+      deleteStmt.run(id);
+      log.info(`Unarchived item ${id}`);
+      return true;
+    }
+
+    return false;
+  }
+
+  deleteArchivedItem(id: number): boolean {
+    const stmt = this.db.prepare("DELETE FROM archived_items WHERE id = ?");
+    const result = stmt.run(id);
+    if (result.changes > 0) {
+      log.info(`Permanently deleted archived item ${id}`);
+    }
+    return result.changes > 0;
+  }
+
+  clearArchive(): void {
+    this.db.exec("DELETE FROM archived_items");
+    log.info("All archived items cleared");
+  }
+
+  getArchiveStats(): { total: number; text: number; image: number } {
+    const result = this.db
+      .prepare(
+        `
+        SELECT
+          COUNT(*) as total,
+          SUM(CASE WHEN type = 'text' THEN 1 ELSE 0 END) as text,
+          SUM(CASE WHEN type = 'image' THEN 1 ELSE 0 END) as image
+        FROM archived_items
+      `
+      )
+      .get() as { total: number; text: number; image: number };
+
+    return result;
+  }
+
+  semanticSearchArchive(
+    queryEmbedding: number[],
+    limit: number = 10
+  ): ClipboardItem[] {
+    const stmt = this.db.prepare(`
+      SELECT
+        id,
+        type,
+        text,
+        image,
+        timestamp,
+        vec_distance_cosine(embedding, vec_f32(?)) as distance
+      FROM archived_items
+      WHERE embedding IS NOT NULL
+      ORDER BY distance ASC
+      LIMIT ?
+    `);
+
+    return stmt.all(JSON.stringify(queryEmbedding), limit) as ClipboardItem[];
+  }
+
   close() {
     this.db.close();
     log.info("Database closed");

src/main/main.ts

@@ -180,6 +180,14 @@ function createTray() {
           }
         },
       },
+      {
+        label: "Archive",
+        click: () => {
+          win?.show();
+          win?.focus();
+          win?.webContents.send("navigate", "archive");
+        },
+      },
       {
         label: "Settings",
         click: () => {
@@ -330,6 +338,101 @@ ipcMain.handle("navigate-to", (_event, page: string) => {
   }
 });
 
+// Archive-related IPC handlers
+ipcMain.handle(
+  "get-archived-history",
+  (_event, limit: number = 50, offset: number = 0) => {
+    return databaseManager?.getArchivedItems(limit, offset) || [];
+  }
+);
+
+ipcMain.handle("unarchive-item", (_event, id: number) => {
+  try {
+    if (!databaseManager) {
+      return { success: false, error: "Database not initialized" };
+    }
+    const success = databaseManager.unarchiveItem(id);
+    if (success) {
+      // Reload clipboard manager's history
+      clipboardManager?.loadHistoryFromDB();
+    }
+    return { success };
+  } catch (error) {
+    log.error("Failed to unarchive item:", error);
+    return { success: false, error: String(error) };
+  }
+});
+
+ipcMain.handle("delete-archived-item", (_event, id: number) => {
+  try {
+    if (!databaseManager) {
+      return { success: false, error: "Database not initialized" };
+    }
+    const success = databaseManager.deleteArchivedItem(id);
+    return { success };
+  } catch (error) {
+    log.error("Failed to delete archived item:", error);
+    return { success: false, error: String(error) };
+  }
+});
+
+ipcMain.handle("clear-archive", () => {
+  try {
+    if (!databaseManager) {
+      return { success: false, error: "Database not initialized" };
+    }
+    databaseManager.clearArchive();
+    return { success: true };
+  } catch (error) {
+    log.error("Failed to clear archive:", error);
+    return { success: false, error: String(error) };
+  }
+});
+
+ipcMain.handle("set-retention-period", (_event, days: number) => {
+  try {
+    configManager?.setRetentionPeriodDays(days);
+    return { success: true };
+  } catch (error) {
+    log.error("Failed to set retention period:", error);
+    return { success: false, error: String(error) };
+  }
+});
+
+ipcMain.handle("archive-old-items", () => {
+  try {
+    if (!databaseManager || !configManager) {
+      return { success: false, error: "Services not initialized" };
+    }
+    const retentionDays = configManager.getRetentionPeriodDays();
+    const count = databaseManager.archiveOldItems(retentionDays);
+
+    // Reload clipboard manager to reflect changes
+    clipboardManager?.loadHistoryFromDB();
+
+    return { success: true, count };
+  } catch (error) {
+    log.error("Failed to archive items:", error);
+    return { success: false, error: String(error) };
+  }
+});
+
+ipcMain.handle(
+  "semantic-search-archive",
+  async (_event, query: string, limit: number = 10) => {
+    try {
+      if (!databaseManager || !embeddingService) {
+        throw new Error("Services not initialized");
+      }
+      const queryEmbedding = await embeddingService.getEmbedding(query);
+      return databaseManager.semanticSearchArchive(queryEmbedding, limit);
+    } catch (error) {
+      log.error("Failed to perform archive semantic search:", error);
+      throw error;
+    }
+  }
+);
+
 function registerGlobalShortcut(shortcut: string = "CommandOrControl+Shift+V") {
   globalShortcut.unregisterAll();
 
@@ -371,6 +474,10 @@ app.whenReady().then(() => {
     databaseManager = new DatabaseManager();
     embeddingService = new EmbeddingService(configManager);
 
+    const retentionDays = configManager.getRetentionPeriodDays();
+    const archivedCount = databaseManager.archiveOldItems(retentionDays);
+    log.info(`Auto-archival complete: ${archivedCount} items archived`);
+
     app.setLoginItemSettings({
       openAtLogin: true,
     });

src/main/preload.ts

@@ -24,4 +24,16 @@ contextBridge.exposeInMainWorld("electronAPI", {
     ipcRenderer.invoke("set-openai-api-key", apiKey),
   clearHistory: () => ipcRenderer.invoke("clear-history"),
   navigate: (page: string) => ipcRenderer.invoke("navigate-to", page),
+  // Archive methods
+  getArchivedHistory: (limit: number, offset: number) =>
+    ipcRenderer.invoke("get-archived-history", limit, offset),
+  unarchiveItem: (id: number) => ipcRenderer.invoke("unarchive-item", id),
+  deleteArchivedItem: (id: number) =>
+    ipcRenderer.invoke("delete-archived-item", id),
+  clearArchive: () => ipcRenderer.invoke("clear-archive"),
+  setRetentionPeriod: (days: number) =>
+    ipcRenderer.invoke("set-retention-period", days),
+  archiveOldItems: () => ipcRenderer.invoke("archive-old-items"),
+  semanticSearchArchive: (query: string, limit?: number) =>
+    ipcRenderer.invoke("semantic-search-archive", query, limit),
 });

src/renderer/App.tsx

@@ -1,16 +1,17 @@
 import { useState, useEffect } from "react";
 import ClipboardHistory from "./pages/ClipboardHistory";
 import Settings from "./pages/Settings";
+import Archive from "./pages/Archive";
 
 export default function App() {
-  const [currentPage, setCurrentPage] = useState<"history" | "settings">(
+  const [currentPage, setCurrentPage] = useState<"history" | "settings" | "archive">(
     "history"
   );
   const [isTransparent, setIsTransparent] = useState(false);
 
   useEffect(() => {
     window.electronAPI.onNavigate((page) => {
-      setCurrentPage(page as "history" | "settings");
+      setCurrentPage(page as "history" | "settings" | "archive");
     });
   }, []);
 
@@ -27,6 +28,7 @@ export default function App() {
           onTransparencyChange={setIsTransparent}
         />
       )}
+      {currentPage === "archive" && <Archive />}
     </>
   );
 }

src/renderer/components/ClipboardItem.css

@@ -1,10 +1,10 @@
 /* Modern Clipboard Item Card */
 .history-item {
   display: flex;
-  gap: 0.875rem;
+  gap: 0.75rem;
   background: rgba(255, 255, 255, 0.06);
-  padding: 1rem 1.25rem;
-  border-radius: 12px;
+  padding: 0.75rem 1rem;
+  border-radius: 10px;
   border: 1px solid rgba(255, 255, 255, 0.08);
   transition: all 0.25s cubic-bezier(0.4, 0, 0.2, 1);
   animation: itemSlideIn 0.3s ease-out backwards;
@@ -213,6 +213,28 @@
   color: #4ade80;
 }
 
+.action-btn--unarchive {
+  background: rgba(52, 199, 89, 0.1);
+  color: #34C759;
+  border-color: rgba(52, 199, 89, 0.3);
+}
+
+.action-btn--unarchive:hover {
+  background: rgba(52, 199, 89, 0.2);
+  color: #4ade80;
+}
+
+.action-btn--delete {
+  background: rgba(255, 59, 48, 0.1);
+  color: #FF3B30;
+  border-color: rgba(255, 59, 48, 0.3);
+}
+
+.action-btn--delete:hover {
+  background: rgba(255, 59, 48, 0.2);
+  color: #ff5a50;
+}
+
 /* Code Block */
 .item-code {
   background: rgba(0, 0, 0, 0.4);