@yancyyu/openhermit 1.5.8

package/src/renderer/store/slices/notificationSlice.ts

@@ -0,0 +1,277 @@
+/**
+ * Notification slice - manages notifications state and actions.
+ */
+
+import { api } from '@renderer/api';
+import { createErrorNavigationRequest, findTabBySessionAndProject } from '@renderer/types/tabs';
+import { createLogger } from '@shared/utils/logger';
+
+import { getAllTabs } from '../utils/paneHelpers';
+
+import type { AppState } from '../types';
+import type { DetectedError } from '@renderer/types/data';
+import type { StateCreator } from 'zustand';
+
+const logger = createLogger('Store:notification');
+const NOTIFICATIONS_FETCH_LIMIT = 200;
+
+// =============================================================================
+// Slice Interface
+// =============================================================================
+
+export interface NotificationSlice {
+  // State
+  notifications: DetectedError[];
+  unreadCount: number;
+  notificationsLoading: boolean;
+  notificationsError: string | null;
+
+  // Actions
+  fetchNotifications: () => Promise<void>;
+  markNotificationRead: (id: string) => Promise<void>;
+  markAllNotificationsRead: (triggerName?: string) => Promise<void>;
+  deleteNotification: (id: string) => Promise<void>;
+  clearNotifications: (triggerName?: string) => Promise<void>;
+  navigateToError: (error: DetectedError) => void;
+  openNotificationsTab: () => void;
+}
+
+// =============================================================================
+// Slice Creator
+// =============================================================================
+
+export const createNotificationSlice: StateCreator<AppState, [], [], NotificationSlice> = (
+  set,
+  get
+) => ({
+  // Initial state
+  notifications: [],
+  unreadCount: 0,
+  notificationsLoading: false,
+  notificationsError: null,
+
+  // Fetch all notifications from main process
+  fetchNotifications: async () => {
+    set({ notificationsLoading: true, notificationsError: null });
+    try {
+      // Fetch the full stored history (manager currently caps storage at 100).
+      const result = await api.notifications.get({
+        limit: NOTIFICATIONS_FETCH_LIMIT,
+        offset: 0,
+      });
+      const notifications = result.notifications || [];
+      const unreadCount =
+        typeof result.unreadCount === 'number' && Number.isFinite(result.unreadCount)
+          ? Math.max(0, Math.floor(result.unreadCount))
+          : notifications.filter((n: { isRead: boolean }) => !n.isRead).length;
+      set({
+        notifications,
+        unreadCount,
+        notificationsLoading: false,
+      });
+    } catch (error) {
+      set({
+        notificationsError:
+          error instanceof Error ? error.message : 'Failed to fetch notifications',
+        notificationsLoading: false,
+      });
+    }
+  },
+
+  // Mark a single notification as read
+  markNotificationRead: async (id: string) => {
+    try {
+      const success = await api.notifications.markRead(id);
+      if (!success) {
+        await get().fetchNotifications();
+        return;
+      }
+      // Optimistically update local state
+      set((state) => {
+        const notifications = state.notifications.map((n) =>
+          n.id === id ? { ...n, isRead: true } : n
+        );
+        const unreadCount = notifications.filter((n) => !n.isRead).length;
+        return { notifications, unreadCount };
+      });
+    } catch (error) {
+      logger.error('Failed to mark notification as read:', error);
+    }
+  },
+
+  // Mark all notifications as read (optionally scoped to a trigger)
+  markAllNotificationsRead: async (triggerName?: string) => {
+    try {
+      if (triggerName !== undefined) {
+        // Scoped: mark only matching unread notifications
+        const { notifications } = get();
+        const matching = notifications.filter((n) => {
+          const label = n.triggerName ?? 'Other';
+          return label === triggerName && !n.isRead;
+        });
+        if (matching.length === 0) return;
+        const results = await Promise.all(matching.map((n) => api.notifications.markRead(n.id)));
+        if (results.some((r) => !r)) {
+          await get().fetchNotifications();
+          return;
+        }
+        const matchingIds = new Set(matching.map((n) => n.id));
+        set((state) => {
+          const updated = state.notifications.map((n) =>
+            matchingIds.has(n.id) ? { ...n, isRead: true } : n
+          );
+          return { notifications: updated, unreadCount: updated.filter((n) => !n.isRead).length };
+        });
+      } else {
+        // Unscoped: mark all
+        const success = await api.notifications.markAllRead();
+        if (!success) {
+          await get().fetchNotifications();
+          return;
+        }
+        set((state) => ({
+          notifications: state.notifications.map((n) => ({ ...n, isRead: true })),
+          unreadCount: 0,
+        }));
+      }
+    } catch (error) {
+      logger.error('Failed to mark all notifications as read:', error);
+    }
+  },
+
+  // Delete a single notification
+  deleteNotification: async (id: string) => {
+    try {
+      const success = await api.notifications.delete(id);
+      if (!success) {
+        await get().fetchNotifications();
+        return;
+      }
+      // Optimistically update local state
+      set((state) => {
+        const notifications = state.notifications.filter((n) => n.id !== id);
+        const unreadCount = notifications.filter((n) => !n.isRead).length;
+        return { notifications, unreadCount };
+      });
+    } catch (error) {
+      logger.error('Failed to delete notification:', error);
+    }
+  },
+
+  // Clear all notifications (optionally scoped to a trigger)
+  clearNotifications: async (triggerName?: string) => {
+    try {
+      if (triggerName !== undefined) {
+        // Scoped: delete only matching notifications
+        const { notifications } = get();
+        const matching = notifications.filter((n) => {
+          const label = n.triggerName ?? 'Other';
+          return label === triggerName;
+        });
+        if (matching.length === 0) return;
+        const results = await Promise.all(matching.map((n) => api.notifications.delete(n.id)));
+        if (results.some((r) => !r)) {
+          await get().fetchNotifications();
+          return;
+        }
+        const matchingIds = new Set(matching.map((n) => n.id));
+        set((state) => {
+          const remaining = state.notifications.filter((n) => !matchingIds.has(n.id));
+          return {
+            notifications: remaining,
+            unreadCount: remaining.filter((n) => !n.isRead).length,
+          };
+        });
+      } else {
+        // Unscoped: clear all
+        const success = await api.notifications.clear();
+        if (!success) {
+          await get().fetchNotifications();
+          return;
+        }
+        set({
+          notifications: [],
+          unreadCount: 0,
+        });
+      }
+    } catch (error) {
+      logger.error('Failed to clear notifications:', error);
+    }
+  },
+
+  // Navigate to error location in session (deep linking)
+  navigateToError: (error: DetectedError) => {
+    const state = get();
+
+    // Mark the notification as read
+    void state.markNotificationRead(error.id);
+
+    // Team notifications (inbox, clarification, status change, rate-limit): open team tab
+    if (error.sessionId.startsWith('team:')) {
+      const teamName = error.sessionId.slice('team:'.length);
+      state.openTeamTab(teamName, error.context.cwd);
+      return;
+    }
+
+    // Create the navigation request with a fresh nonce
+    const navRequest = createErrorNavigationRequest(
+      {
+        errorId: error.id,
+        errorTimestamp: error.timestamp,
+        toolUseId: error.toolUseId,
+        subagentId: error.subagentId,
+        lineNumber: error.lineNumber,
+      },
+      'notification',
+      error.triggerColor
+    );
+
+    // Check if session tab is already open across all panes
+    const allTabs = getAllTabs(state.paneLayout);
+    const existingTab = findTabBySessionAndProject(allTabs, error.sessionId, error.projectId);
+
+    if (existingTab) {
+      // Focus existing tab via setActiveTab for proper sidebar sync
+      state.setActiveTab(existingTab.id);
+      // Enqueue navigation request with fresh nonce
+      state.enqueueTabNavigation(existingTab.id, navRequest);
+    } else {
+      // Open new session tab via openTab (properly adds to focused pane)
+      state.openTab({
+        type: 'session',
+        label: 'Loading...',
+        projectId: error.projectId,
+        sessionId: error.sessionId,
+      });
+
+      // Enqueue navigation on the newly created tab, then trigger sidebar
+      // sync + session data fetch via setActiveTab
+      const newTabId = get().activeTabId;
+      if (newTabId) {
+        state.enqueueTabNavigation(newTabId, navRequest);
+        get().setActiveTab(newTabId);
+      }
+    }
+  },
+
+  // Open or focus the notifications tab (per-pane singleton)
+  openNotificationsTab: () => {
+    const state = get();
+
+    // Check if notifications tab exists in focused pane
+    const focusedPane = state.paneLayout.panes.find((p) => p.id === state.paneLayout.focusedPaneId);
+    const notificationsTab = focusedPane?.tabs.find((t) => t.type === 'notifications');
+    if (notificationsTab) {
+      state.setActiveTab(notificationsTab.id);
+      // Re-sync in case updates happened while tab was inactive.
+      void state.fetchNotifications();
+      return;
+    }
+
+    // Create new notifications tab via openTab (which adds to focused pane)
+    state.openTab({
+      type: 'notifications',
+      label: 'Notifications',
+    });
+  },
+});

package/src/renderer/store/slices/paneSlice.ts

@@ -0,0 +1,357 @@
+/**
+ * Pane slice - manages multi-pane split layout state and actions.
+ * Each pane has its own tab bar, active tab, and selected tabs.
+ */
+
+import { MAX_PANES } from '@renderer/types/panes';
+
+import {
+  createEmptyPane,
+  findPane,
+  findPaneByTabId,
+  getAllTabs,
+  insertPane,
+  removePane,
+  syncFocusedPaneState,
+  updatePane,
+} from '../utils/paneHelpers';
+
+import type { AppState } from '../types';
+import type { PaneLayout } from '@renderer/types/panes';
+import type { Tab } from '@renderer/types/tabs';
+import type { StateCreator } from 'zustand';
+
+// =============================================================================
+// Slice Interface
+// =============================================================================
+
+export interface PaneSlice {
+  // State
+  paneLayout: PaneLayout;
+
+  // Pane lifecycle
+  focusPane: (paneId: string) => void;
+  splitPane: (sourcePaneId: string, tabId: string, direction: 'left' | 'right') => void;
+  closePane: (paneId: string) => void;
+
+  // Tab movement
+  moveTabToPane: (
+    tabId: string,
+    sourcePaneId: string,
+    targetPaneId: string,
+    insertIndex?: number
+  ) => void;
+  moveTabToNewPane: (
+    tabId: string,
+    sourcePaneId: string,
+    adjacentPaneId: string,
+    direction: 'left' | 'right'
+  ) => void;
+  reorderTabInPane: (paneId: string, fromIndex: number, toIndex: number) => void;
+
+  // Resize
+  resizePanes: (paneId: string, newWidthFraction: number) => void;
+
+  // Queries
+  getPaneForTab: (tabId: string) => string | null;
+  getAllPaneTabs: () => Tab[];
+}
+
+// =============================================================================
+// Helpers
+// =============================================================================
+
+/**
+ * Sync root-level openTabs/activeTabId/selectedTabIds from the focused pane.
+ * This maintains backward compatibility for consumers that read root-level state.
+ */
+function syncRootState(layout: PaneLayout): Record<string, unknown> {
+  const synced = syncFocusedPaneState(layout);
+  return {
+    paneLayout: layout,
+    openTabs: synced.openTabs,
+    activeTabId: synced.activeTabId,
+    selectedTabIds: synced.selectedTabIds,
+  };
+}
+
+// =============================================================================
+// Slice Creator
+// =============================================================================
+
+export const createPaneSlice: StateCreator<AppState, [], [], PaneSlice> = (set, get) => ({
+  // Initial state: single pane (populated by tabSlice init or first openTab)
+  paneLayout: {
+    panes: [
+      {
+        id: 'pane-default',
+        tabs: [],
+        activeTabId: null,
+        selectedTabIds: [],
+        widthFraction: 1,
+      },
+    ],
+    focusedPaneId: 'pane-default',
+  },
+
+  focusPane: (paneId: string) => {
+    const state = get();
+    const { paneLayout } = state;
+    if (paneLayout.focusedPaneId === paneId) return;
+
+    const pane = findPane(paneLayout, paneId);
+    if (!pane) return;
+
+    const newLayout: PaneLayout = { ...paneLayout, focusedPaneId: paneId };
+    set(syncRootState(newLayout));
+
+    // Trigger sidebar sync for the focused pane's active tab
+    if (pane.activeTabId) {
+      get().setActiveTab(pane.activeTabId);
+    }
+  },
+
+  splitPane: (sourcePaneId: string, tabId: string, direction: 'left' | 'right') => {
+    const state = get();
+    const { paneLayout } = state;
+
+    if (paneLayout.panes.length >= MAX_PANES) return;
+
+    const sourcePane = findPane(paneLayout, sourcePaneId);
+    if (!sourcePane) return;
+
+    const tab = sourcePane.tabs.find((t) => t.id === tabId);
+    if (!tab) return;
+
+    // Remove tab from source pane
+    const newSourceTabs = sourcePane.tabs.filter((t) => t.id !== tabId);
+    let newSourceActiveTabId = sourcePane.activeTabId;
+    if (sourcePane.activeTabId === tabId) {
+      // Focus adjacent tab in source
+      const oldIndex = sourcePane.tabs.findIndex((t) => t.id === tabId);
+      newSourceActiveTabId = newSourceTabs[oldIndex]?.id ?? newSourceTabs[oldIndex - 1]?.id ?? null;
+    }
+
+    const updatedSource = {
+      ...sourcePane,
+      tabs: newSourceTabs,
+      activeTabId: newSourceActiveTabId,
+      selectedTabIds: sourcePane.selectedTabIds.filter((id) => id !== tabId),
+    };
+
+    // Create new pane with the tab
+    const newPaneId = crypto.randomUUID();
+    const newPane = {
+      ...createEmptyPane(newPaneId),
+      tabs: [tab],
+      activeTabId: tab.id,
+    };
+
+    // Update layout
+    let newLayout = updatePane(paneLayout, updatedSource);
+
+    // If source pane is now empty, remove it
+    if (newSourceTabs.length === 0 && paneLayout.panes.length > 1) {
+      newLayout = removePane(newLayout, sourcePaneId);
+    }
+
+    newLayout = insertPane(
+      newLayout,
+      updatedSource.id !== sourcePaneId ? paneLayout.panes[0].id : sourcePaneId,
+      newPane,
+      direction
+    );
+    newLayout = { ...newLayout, focusedPaneId: newPaneId };
+
+    set(syncRootState(newLayout));
+
+    // Sync sidebar for the new pane's active tab
+    if (tab.type === 'session') {
+      get().setActiveTab(tab.id);
+    }
+  },
+
+  closePane: (paneId: string) => {
+    const state = get();
+    const { paneLayout } = state;
+
+    if (paneLayout.panes.length <= 1) return; // Can't close the last pane
+
+    const pane = findPane(paneLayout, paneId);
+    if (!pane) return;
+
+    // Cleanup tab UI state and session data for all tabs in the pane
+    for (const tab of pane.tabs) {
+      state.cleanupTabUIState(tab.id);
+      state.cleanupTabSessionData(tab.id);
+    }
+
+    const newLayout = removePane(paneLayout, paneId);
+    set(syncRootState(newLayout));
+
+    // Sync sidebar for the newly focused pane
+    const focusedPane = findPane(newLayout, newLayout.focusedPaneId);
+    if (focusedPane?.activeTabId) {
+      get().setActiveTab(focusedPane.activeTabId);
+    }
+  },
+
+  moveTabToPane: (
+    tabId: string,
+    sourcePaneId: string,
+    targetPaneId: string,
+    insertIndex?: number
+  ) => {
+    const state = get();
+    const { paneLayout } = state;
+
+    if (sourcePaneId === targetPaneId) return;
+
+    const sourcePane = findPane(paneLayout, sourcePaneId);
+    const targetPane = findPane(paneLayout, targetPaneId);
+    if (!sourcePane || !targetPane) return;
+
+    const tab = sourcePane.tabs.find((t) => t.id === tabId);
+    if (!tab) return;
+
+    // Remove from source
+    const newSourceTabs = sourcePane.tabs.filter((t) => t.id !== tabId);
+    let newSourceActiveTabId = sourcePane.activeTabId;
+    if (sourcePane.activeTabId === tabId) {
+      const oldIndex = sourcePane.tabs.findIndex((t) => t.id === tabId);
+      newSourceActiveTabId = newSourceTabs[oldIndex]?.id ?? newSourceTabs[oldIndex - 1]?.id ?? null;
+    }
+
+    // Add to target at insertion index
+    const newTargetTabs = [...targetPane.tabs];
+    if (insertIndex !== undefined && insertIndex >= 0 && insertIndex <= newTargetTabs.length) {
+      newTargetTabs.splice(insertIndex, 0, tab);
+    } else {
+      newTargetTabs.push(tab);
+    }
+
+    let newLayout = updatePane(paneLayout, {
+      ...sourcePane,
+      tabs: newSourceTabs,
+      activeTabId: newSourceActiveTabId,
+      selectedTabIds: sourcePane.selectedTabIds.filter((id) => id !== tabId),
+    });
+    newLayout = updatePane(newLayout, {
+      ...targetPane,
+      tabs: newTargetTabs,
+      activeTabId: tab.id,
+    });
+
+    // Auto-close source pane if it's empty and not the sole pane
+    if (newSourceTabs.length === 0 && newLayout.panes.length > 1) {
+      newLayout = removePane(newLayout, sourcePaneId);
+    }
+
+    // Focus the target pane
+    newLayout = { ...newLayout, focusedPaneId: targetPaneId };
+
+    set(syncRootState(newLayout));
+  },
+
+  moveTabToNewPane: (
+    tabId: string,
+    sourcePaneId: string,
+    adjacentPaneId: string,
+    direction: 'left' | 'right'
+  ) => {
+    const state = get();
+    const { paneLayout } = state;
+
+    if (paneLayout.panes.length >= MAX_PANES) return;
+
+    const sourcePane = findPane(paneLayout, sourcePaneId);
+    if (!sourcePane) return;
+
+    const tab = sourcePane.tabs.find((t) => t.id === tabId);
+    if (!tab) return;
+
+    // Remove from source
+    const newSourceTabs = sourcePane.tabs.filter((t) => t.id !== tabId);
+    let newSourceActiveTabId = sourcePane.activeTabId;
+    if (sourcePane.activeTabId === tabId) {
+      const oldIndex = sourcePane.tabs.findIndex((t) => t.id === tabId);
+      newSourceActiveTabId = newSourceTabs[oldIndex]?.id ?? newSourceTabs[oldIndex - 1]?.id ?? null;
+    }
+
+    const newPaneId = crypto.randomUUID();
+    const newPane = {
+      ...createEmptyPane(newPaneId),
+      tabs: [tab],
+      activeTabId: tab.id,
+    };
+
+    let newLayout = updatePane(paneLayout, {
+      ...sourcePane,
+      tabs: newSourceTabs,
+      activeTabId: newSourceActiveTabId,
+      selectedTabIds: sourcePane.selectedTabIds.filter((id) => id !== tabId),
+    });
+
+    // Auto-close source pane if it's empty and not the sole pane
+    if (newSourceTabs.length === 0 && newLayout.panes.length > 1) {
+      newLayout = removePane(newLayout, sourcePaneId);
+    }
+
+    newLayout = insertPane(newLayout, adjacentPaneId, newPane, direction);
+    newLayout = { ...newLayout, focusedPaneId: newPaneId };
+
+    set(syncRootState(newLayout));
+  },
+
+  reorderTabInPane: (paneId: string, fromIndex: number, toIndex: number) => {
+    const { paneLayout } = get();
+    const pane = findPane(paneLayout, paneId);
+    if (!pane) return;
+
+    if (fromIndex < 0 || fromIndex >= pane.tabs.length) return;
+    if (toIndex < 0 || toIndex >= pane.tabs.length) return;
+    if (fromIndex === toIndex) return;
+
+    const newTabs = [...pane.tabs];
+    const [moved] = newTabs.splice(fromIndex, 1);
+    newTabs.splice(toIndex, 0, moved);
+
+    const newLayout = updatePane(paneLayout, { ...pane, tabs: newTabs });
+    set(syncRootState(newLayout));
+  },
+
+  resizePanes: (paneId: string, newWidthFraction: number) => {
+    const { paneLayout } = get();
+    const paneIndex = paneLayout.panes.findIndex((p) => p.id === paneId);
+    if (paneIndex === -1 || paneIndex >= paneLayout.panes.length - 1) return;
+
+    const MIN_FRACTION = 0.1;
+    const clamped = Math.max(
+      MIN_FRACTION,
+      Math.min(1 - MIN_FRACTION * (paneLayout.panes.length - 1), newWidthFraction)
+    );
+    const currentPane = paneLayout.panes[paneIndex];
+    const nextPane = paneLayout.panes[paneIndex + 1];
+    const combinedWidth = currentPane.widthFraction + nextPane.widthFraction;
+    const nextWidth = combinedWidth - clamped;
+
+    if (nextWidth < MIN_FRACTION) return;
+
+    const newPanes = paneLayout.panes.map((p, i) => {
+      if (i === paneIndex) return { ...p, widthFraction: clamped };
+      if (i === paneIndex + 1) return { ...p, widthFraction: nextWidth };
+      return p;
+    });
+
+    set({ paneLayout: { ...paneLayout, panes: newPanes } });
+  },
+
+  getPaneForTab: (tabId: string) => {
+    const pane = findPaneByTabId(get().paneLayout, tabId);
+    return pane?.id ?? null;
+  },
+
+  getAllPaneTabs: () => {
+    return getAllTabs(get().paneLayout);
+  },
+});

package/src/renderer/store/slices/projectSlice.ts

@@ -0,0 +1,70 @@
+/**
+ * Project slice - manages project list state and selection.
+ */
+
+import { api } from '@renderer/api';
+
+import { getSessionResetState } from '../utils/stateResetHelpers';
+
+import type { AppState } from '../types';
+import type { Project } from '@renderer/types/data';
+import type { StateCreator } from 'zustand';
+
+// =============================================================================
+// Slice Interface
+// =============================================================================
+
+export interface ProjectSlice {
+  // State
+  projects: Project[];
+  selectedProjectId: string | null;
+  projectsLoading: boolean;
+  projectsError: string | null;
+
+  // Actions
+  fetchProjects: () => Promise<void>;
+  selectProject: (id: string) => void;
+}
+
+// =============================================================================
+// Slice Creator
+// =============================================================================
+
+export const createProjectSlice: StateCreator<AppState, [], [], ProjectSlice> = (set, get) => ({
+  // Initial state
+  projects: [],
+  selectedProjectId: null,
+  projectsLoading: false,
+  projectsError: null,
+
+  // Fetch all projects from main process
+  fetchProjects: async () => {
+    // Guard: prevent concurrent fetches (component mount + centralized init chain)
+    if (get().projectsLoading) return;
+    set({ projectsLoading: true, projectsError: null });
+    try {
+      const projects = await api.getProjects();
+      // Sort by most recent session (descending)
+      const sorted = [...projects].sort(
+        (a, b) => (b.mostRecentSession ?? 0) - (a.mostRecentSession ?? 0)
+      );
+      set({ projects: sorted, projectsLoading: false });
+    } catch (error) {
+      set({
+        projectsError: error instanceof Error ? error.message : 'Failed to fetch projects',
+        projectsLoading: false,
+      });
+    }
+  },
+
+  // Select a project and fetch its sessions (paginated)
+  selectProject: (id: string) => {
+    set({
+      selectedProjectId: id,
+      ...getSessionResetState(),
+    });
+
+    // Fetch sessions for this project (paginated)
+    void get().fetchSessionsInitial(id);
+  },
+});