auto-claude: 225-bulk-delete-and-archive-chat-history

apps/frontend/src/main/insights-service.ts

@@ -70,8 +70,8 @@ export class InsightsService extends EventEmitter {
   /**
    * List all sessions for a project
    */
-  listSessions(projectPath: string): InsightsSessionSummary[] {
-    return this.sessionManager.listSessions(projectPath);
+  listSessions(projectPath: string, includeArchived = false): InsightsSessionSummary[] {
+    return this.sessionManager.listSessions(projectPath, includeArchived);
   }
 
   /**
@@ -95,6 +95,34 @@ export class InsightsService extends EventEmitter {
     return this.sessionManager.deleteSession(projectId, projectPath, sessionId);
   }
 
+  /**
+   * Archive a session
+   */
+  archiveSession(projectId: string, projectPath: string, sessionId: string): boolean {
+    return this.sessionManager.archiveSession(projectId, projectPath, sessionId);
+  }
+
+  /**
+   * Unarchive a session
+   */
+  unarchiveSession(projectPath: string, sessionId: string): boolean {
+    return this.sessionManager.unarchiveSession(projectPath, sessionId);
+  }
+
+  /**
+   * Delete multiple sessions
+   */
+  deleteSessions(projectId: string, projectPath: string, sessionIds: string[]): { deletedIds: string[]; failedIds: string[] } {
+    return this.sessionManager.deleteSessions(projectId, projectPath, sessionIds);
+  }
+
+  /**
+   * Archive multiple sessions
+   */
+  archiveSessions(projectId: string, projectPath: string, sessionIds: string[]): { archivedIds: string[]; failedIds: string[] } {
+    return this.sessionManager.archiveSessions(projectId, projectPath, sessionIds);
+  }
+
   /**
    * Rename a session
    */

apps/frontend/src/main/insights/session-manager.ts

@@ -40,10 +40,10 @@ export class SessionManager {
   /**
    * List all sessions for a project
    */
-  listSessions(projectPath: string): InsightsSessionSummary[] {
+  listSessions(projectPath: string, includeArchived = false): InsightsSessionSummary[] {
     // Migrate old format if needed
     this.storage.migrateOldSession(projectPath);
-    return this.storage.listSessions(projectPath);
+    return this.storage.listSessions(projectPath, includeArchived);
   }
 
   /**
@@ -105,6 +105,80 @@ export class SessionManager {
     return true;
   }
 
+  /**
+   * Archive a session
+   */
+  archiveSession(projectId: string, projectPath: string, sessionId: string): boolean {
+    const success = this.storage.archiveSession(projectPath, sessionId);
+    if (!success) return false;
+
+    // If this was the current session, auto-switch
+    const currentSession = this.sessions.get(projectId);
+    if (currentSession?.id === sessionId) {
+      this.sessions.delete(projectId);
+
+      const remaining = this.listSessions(projectPath);
+      if (remaining.length > 0) {
+        this.switchSession(projectId, projectPath, remaining[0].id);
+      } else {
+        this.storage.clearCurrentSessionId(projectPath);
+      }
+    }
+
+    return true;
+  }
+
+  /**
+   * Unarchive a session
+   */
+  unarchiveSession(projectPath: string, sessionId: string): boolean {
+    return this.storage.unarchiveSession(projectPath, sessionId);
+  }
+
+  /**
+   * Delete multiple sessions
+   */
+  deleteSessions(projectId: string, projectPath: string, sessionIds: string[]): { deletedIds: string[]; failedIds: string[] } {
+    const result = this.storage.deleteSessions(projectPath, sessionIds);
+
+    // Check if current cached session was among deleted
+    const currentSession = this.sessions.get(projectId);
+    if (currentSession && result.deletedIds.includes(currentSession.id)) {
+      this.sessions.delete(projectId);
+
+      const remaining = this.listSessions(projectPath);
+      if (remaining.length > 0) {
+        this.switchSession(projectId, projectPath, remaining[0].id);
+      } else {
+        this.storage.clearCurrentSessionId(projectPath);
+      }
+    }
+
+    return result;
+  }
+
+  /**
+   * Archive multiple sessions
+   */
+  archiveSessions(projectId: string, projectPath: string, sessionIds: string[]): { archivedIds: string[]; failedIds: string[] } {
+    const result = this.storage.archiveSessions(projectPath, sessionIds);
+
+    // Check if current cached session was among archived
+    const currentSession = this.sessions.get(projectId);
+    if (currentSession && result.archivedIds.includes(currentSession.id)) {
+      this.sessions.delete(projectId);
+
+      const remaining = this.listSessions(projectPath);
+      if (remaining.length > 0) {
+        this.switchSession(projectId, projectPath, remaining[0].id);
+      } else {
+        this.storage.clearCurrentSessionId(projectPath);
+      }
+    }
+
+    return result;
+  }
+
   /**
    * Rename a session
    */

apps/frontend/src/main/insights/session-storage.ts

@@ -64,6 +64,74 @@ export class SessionStorage {
     writeFileSync(sessionPath, JSON.stringify(session, null, 2), 'utf-8');
   }
 
+  /**
+   * Archive a session
+   */
+  archiveSession(projectPath: string, sessionId: string): boolean {
+    const session = this.loadSessionById(projectPath, sessionId);
+    if (!session) return false;
+
+    try {
+      session.archivedAt = new Date();
+      this.saveSession(projectPath, session);
+      return true;
+    } catch {
+      return false;
+    }
+  }
+
+  /**
+   * Unarchive a session
+   */
+  unarchiveSession(projectPath: string, sessionId: string): boolean {
+    const session = this.loadSessionById(projectPath, sessionId);
+    if (!session) return false;
+
+    try {
+      delete session.archivedAt;
+      this.saveSession(projectPath, session);
+      return true;
+    } catch {
+      return false;
+    }
+  }
+
+  /**
+   * Delete multiple sessions
+   */
+  deleteSessions(projectPath: string, sessionIds: string[]): { deletedIds: string[]; failedIds: string[] } {
+    const deletedIds: string[] = [];
+    const failedIds: string[] = [];
+
+    for (const sessionId of sessionIds) {
+      if (this.deleteSession(projectPath, sessionId)) {
+        deletedIds.push(sessionId);
+      } else {
+        failedIds.push(sessionId);
+      }
+    }
+
+    return { deletedIds, failedIds };
+  }
+
+  /**
+   * Archive multiple sessions
+   */
+  archiveSessions(projectPath: string, sessionIds: string[]): { archivedIds: string[]; failedIds: string[] } {
+    const archivedIds: string[] = [];
+    const failedIds: string[] = [];
+
+    for (const sessionId of sessionIds) {
+      if (this.archiveSession(projectPath, sessionId)) {
+        archivedIds.push(sessionId);
+      } else {
+        failedIds.push(sessionId);
+      }
+    }
+
+    return { archivedIds, failedIds };
+  }
+
   /**
    * Delete a session from disk
    */
@@ -82,7 +150,7 @@ export class SessionStorage {
   /**
    * List all sessions for a project
    */
-  listSessions(projectPath: string): InsightsSessionSummary[] {
+  listSessions(projectPath: string, includeArchived = false): InsightsSessionSummary[] {
     const sessionsDir = this.paths.getSessionsDir(projectPath);
     if (!existsSync(sessionsDir)) return [];
 
@@ -104,13 +172,20 @@ export class SessionStorage {
               : 'Untitled Conversation';
           }
 
+          // Skip archived sessions unless explicitly included
+          if (!includeArchived && session.archivedAt) {
+            continue;
+          }
+
           sessions.push({
             id: session.id,
             projectId: session.projectId,
             title: title || 'New Conversation',
             messageCount: session.messages.length,
+            modelConfig: session.modelConfig,
             createdAt: new Date(session.createdAt),
-            updatedAt: new Date(session.updatedAt)
+            updatedAt: new Date(session.updatedAt),
+            ...(session.archivedAt ? { archivedAt: new Date(session.archivedAt) } : {})
           });
         } catch {
           // Skip invalid session files

apps/frontend/src/main/ipc-handlers/insights-handlers.ts

@@ -249,17 +249,79 @@ export function registerInsightsHandlers(getMainWindow: () => BrowserWindow | nu
   // List all sessions for a project
   ipcMain.handle(
     IPC_CHANNELS.INSIGHTS_LIST_SESSIONS,
-    async (_, projectId: string): Promise<IPCResult<InsightsSessionSummary[]>> => {
+    async (_, projectId: string, includeArchived?: boolean): Promise<IPCResult<InsightsSessionSummary[]>> => {
       const project = projectStore.getProject(projectId);
       if (!project) {
         return { success: false, error: "Project not found" };
       }
 
-      const sessions = insightsService.listSessions(project.path);
+      const sessions = insightsService.listSessions(project.path, includeArchived ?? false);
       return { success: true, data: sessions };
     }
   );
 
+  // Delete multiple sessions
+  ipcMain.handle(
+    IPC_CHANNELS.INSIGHTS_DELETE_SESSIONS,
+    async (_, projectId: string, sessionIds: string[]): Promise<IPCResult<{ deletedIds: string[]; failedIds: string[] }>> => {
+      const project = projectStore.getProject(projectId);
+      if (!project) {
+        return { success: false, error: "Project not found" };
+      }
+
+      const result = insightsService.deleteSessions(projectId, project.path, sessionIds);
+      return { success: true, data: result };
+    }
+  );
+
+  // Archive a session
+  ipcMain.handle(
+    IPC_CHANNELS.INSIGHTS_ARCHIVE_SESSION,
+    async (_, projectId: string, sessionId: string): Promise<IPCResult> => {
+      const project = projectStore.getProject(projectId);
+      if (!project) {
+        return { success: false, error: "Project not found" };
+      }
+
+      const success = insightsService.archiveSession(projectId, project.path, sessionId);
+      if (success) {
+        return { success: true };
+      }
+      return { success: false, error: "Failed to archive session" };
+    }
+  );
+
+  // Archive multiple sessions
+  ipcMain.handle(
+    IPC_CHANNELS.INSIGHTS_ARCHIVE_SESSIONS,
+    async (_, projectId: string, sessionIds: string[]): Promise<IPCResult<{ archivedIds: string[]; failedIds: string[] }>> => {
+      const project = projectStore.getProject(projectId);
+      if (!project) {
+        return { success: false, error: "Project not found" };
+      }
+
+      const result = insightsService.archiveSessions(projectId, project.path, sessionIds);
+      return { success: true, data: result };
+    }
+  );
+
+  // Unarchive a session
+  ipcMain.handle(
+    IPC_CHANNELS.INSIGHTS_UNARCHIVE_SESSION,
+    async (_, projectId: string, sessionId: string): Promise<IPCResult> => {
+      const project = projectStore.getProject(projectId);
+      if (!project) {
+        return { success: false, error: "Project not found" };
+      }
+
+      const success = insightsService.unarchiveSession(project.path, sessionId);
+      if (success) {
+        return { success: true };
+      }
+      return { success: false, error: "Failed to unarchive session" };
+    }
+  );
+
   // Create a new session
   ipcMain.handle(
     IPC_CHANNELS.INSIGHTS_NEW_SESSION,

apps/frontend/src/preload/api/modules/insights-api.ts

@@ -25,10 +25,14 @@ export interface InsightsAPI {
     description: string,
     metadata?: TaskMetadata
   ) => Promise<IPCResult<Task>>;
-  listInsightsSessions: (projectId: string) => Promise<IPCResult<InsightsSessionSummary[]>>;
+  listInsightsSessions: (projectId: string, includeArchived?: boolean) => Promise<IPCResult<InsightsSessionSummary[]>>;
   newInsightsSession: (projectId: string) => Promise<IPCResult<InsightsSession>>;
   switchInsightsSession: (projectId: string, sessionId: string) => Promise<IPCResult<InsightsSession | null>>;
   deleteInsightsSession: (projectId: string, sessionId: string) => Promise<IPCResult>;
+  deleteInsightsSessions: (projectId: string, sessionIds: string[]) => Promise<IPCResult<{ deletedIds: string[]; failedIds: string[] }>>;
+  archiveInsightsSession: (projectId: string, sessionId: string) => Promise<IPCResult>;
+  archiveInsightsSessions: (projectId: string, sessionIds: string[]) => Promise<IPCResult<{ archivedIds: string[]; failedIds: string[] }>>;
+  unarchiveInsightsSession: (projectId: string, sessionId: string) => Promise<IPCResult>;
   renameInsightsSession: (projectId: string, sessionId: string, newTitle: string) => Promise<IPCResult>;
   updateInsightsModelConfig: (projectId: string, sessionId: string, modelConfig: InsightsModelConfig) => Promise<IPCResult>;
 
@@ -69,8 +73,8 @@ export const createInsightsAPI = (): InsightsAPI => ({
   ): Promise<IPCResult<Task>> =>
     invokeIpc(IPC_CHANNELS.INSIGHTS_CREATE_TASK, projectId, title, description, metadata),
 
-  listInsightsSessions: (projectId: string): Promise<IPCResult<InsightsSessionSummary[]>> =>
-    invokeIpc(IPC_CHANNELS.INSIGHTS_LIST_SESSIONS, projectId),
+  listInsightsSessions: (projectId: string, includeArchived?: boolean): Promise<IPCResult<InsightsSessionSummary[]>> =>
+    invokeIpc(IPC_CHANNELS.INSIGHTS_LIST_SESSIONS, projectId, includeArchived),
 
   newInsightsSession: (projectId: string): Promise<IPCResult<InsightsSession>> =>
     invokeIpc(IPC_CHANNELS.INSIGHTS_NEW_SESSION, projectId),
@@ -81,6 +85,18 @@ export const createInsightsAPI = (): InsightsAPI => ({
   deleteInsightsSession: (projectId: string, sessionId: string): Promise<IPCResult> =>
     invokeIpc(IPC_CHANNELS.INSIGHTS_DELETE_SESSION, projectId, sessionId),
 
+  deleteInsightsSessions: (projectId: string, sessionIds: string[]): Promise<IPCResult<{ deletedIds: string[]; failedIds: string[] }>> =>
+    invokeIpc(IPC_CHANNELS.INSIGHTS_DELETE_SESSIONS, projectId, sessionIds),
+
+  archiveInsightsSession: (projectId: string, sessionId: string): Promise<IPCResult> =>
+    invokeIpc(IPC_CHANNELS.INSIGHTS_ARCHIVE_SESSION, projectId, sessionId),
+
+  archiveInsightsSessions: (projectId: string, sessionIds: string[]): Promise<IPCResult<{ archivedIds: string[]; failedIds: string[] }>> =>
+    invokeIpc(IPC_CHANNELS.INSIGHTS_ARCHIVE_SESSIONS, projectId, sessionIds),
+
+  unarchiveInsightsSession: (projectId: string, sessionId: string): Promise<IPCResult> =>
+    invokeIpc(IPC_CHANNELS.INSIGHTS_UNARCHIVE_SESSION, projectId, sessionId),
+
   renameInsightsSession: (projectId: string, sessionId: string, newTitle: string): Promise<IPCResult> =>
     invokeIpc(IPC_CHANNELS.INSIGHTS_RENAME_SESSION, projectId, sessionId, newTitle),