claudedesk 4.3.1 → 4.4.0

package/src/renderer/hooks/useGit.ts

@@ -0,0 +1,395 @@
+import { useState, useCallback, useEffect, useRef } from 'react';
+import type {
+  GitStatus,
+  GitBranchInfo,
+  GitCommitInfo,
+  GitDiffResult,
+  GeneratedCommitMessage,
+  GitCommitRequest,
+} from '../../shared/types/git-types';
+import { showToast } from '../utils/toast';
+
+export function useGit(projectPath: string | null) {
+  const [status, setStatus] = useState<GitStatus | null>(null);
+  const [branches, setBranches] = useState<GitBranchInfo[]>([]);
+  const [log, setLog] = useState<GitCommitInfo[]>([]);
+  const [selectedDiff, setSelectedDiff] = useState<GitDiffResult | null>(null);
+  const [generatedMessage, setGeneratedMessage] = useState<GeneratedCommitMessage | null>(null);
+  const [isLoading, setIsLoading] = useState(false);
+  const [operationInProgress, setOperationInProgress] = useState<string | null>(null);
+  const [error, setError] = useState<string | null>(null);
+  const lastPath = useRef<string | null>(null);
+
+  // Subscribe to status change events
+  useEffect(() => {
+    const unsub = window.electronAPI.onGitStatusChanged((newStatus) => {
+      setStatus(newStatus);
+    });
+    return unsub;
+  }, []);
+
+  // Load status when project path changes
+  useEffect(() => {
+    if (projectPath && projectPath !== lastPath.current) {
+      lastPath.current = projectPath;
+      refreshStatus();
+    }
+    if (!projectPath) {
+      setStatus(null);
+      setBranches([]);
+      setLog([]);
+      setSelectedDiff(null);
+      setGeneratedMessage(null);
+      lastPath.current = null;
+    }
+    // eslint-disable-next-line react-hooks/exhaustive-deps
+  }, [projectPath]);
+
+  const refreshStatus = useCallback(async () => {
+    if (!projectPath) return;
+    setIsLoading(true);
+    setError(null);
+    try {
+      const s = await window.electronAPI.getGitStatus(projectPath);
+      setStatus(s);
+    } catch (err) {
+      console.error('Failed to get git status:', err);
+      setError('Failed to get git status');
+    } finally {
+      setIsLoading(false);
+    }
+  }, [projectPath]);
+
+  const loadBranches = useCallback(async () => {
+    if (!projectPath) return;
+    try {
+      const b = await window.electronAPI.getGitBranches(projectPath);
+      setBranches(b);
+    } catch (err) {
+      console.error('Failed to load branches:', err);
+    }
+  }, [projectPath]);
+
+  const loadHistory = useCallback(async (count?: number) => {
+    if (!projectPath) return;
+    try {
+      const h = await window.electronAPI.gitLog(projectPath, count);
+      setLog(h);
+    } catch (err) {
+      console.error('Failed to load history:', err);
+    }
+  }, [projectPath]);
+
+  const stageFiles = useCallback(async (files: string[]) => {
+    if (!projectPath) return;
+    setOperationInProgress('staging');
+    try {
+      const result = await window.electronAPI.gitStageFiles(projectPath, files);
+      if (!result.success) {
+        showToast(result.message, 'error');
+      }
+      await refreshStatus();
+    } catch (err) {
+      showToast('Failed to stage files', 'error');
+    } finally {
+      setOperationInProgress(null);
+    }
+  }, [projectPath, refreshStatus]);
+
+  const unstageFiles = useCallback(async (files: string[]) => {
+    if (!projectPath) return;
+    setOperationInProgress('unstaging');
+    try {
+      const result = await window.electronAPI.gitUnstageFiles(projectPath, files);
+      if (!result.success) {
+        showToast(result.message, 'error');
+      }
+      await refreshStatus();
+    } catch (err) {
+      showToast('Failed to unstage files', 'error');
+    } finally {
+      setOperationInProgress(null);
+    }
+  }, [projectPath, refreshStatus]);
+
+  const stageAll = useCallback(async () => {
+    if (!projectPath) return;
+    setOperationInProgress('staging');
+    try {
+      const result = await window.electronAPI.gitStageAll(projectPath);
+      if (!result.success) showToast(result.message, 'error');
+      await refreshStatus();
+    } catch (err) {
+      showToast('Failed to stage all', 'error');
+    } finally {
+      setOperationInProgress(null);
+    }
+  }, [projectPath, refreshStatus]);
+
+  const unstageAll = useCallback(async () => {
+    if (!projectPath) return;
+    setOperationInProgress('unstaging');
+    try {
+      const result = await window.electronAPI.gitUnstageAll(projectPath);
+      if (!result.success) showToast(result.message, 'error');
+      await refreshStatus();
+    } catch (err) {
+      showToast('Failed to unstage all', 'error');
+    } finally {
+      setOperationInProgress(null);
+    }
+  }, [projectPath, refreshStatus]);
+
+  const commit = useCallback(async (request: GitCommitRequest) => {
+    setOperationInProgress('committing');
+    try {
+      const result = await window.electronAPI.gitCommit(request);
+      if (result.success) {
+        showToast(result.message, 'success');
+        await refreshStatus();
+        await loadHistory(10);
+      } else {
+        showToast(result.message, 'error');
+      }
+      return result;
+    } catch (err) {
+      showToast('Failed to commit', 'error');
+      return { success: false, message: 'Failed to commit', errorCode: 'UNKNOWN' as const };
+    } finally {
+      setOperationInProgress(null);
+    }
+  }, [refreshStatus, loadHistory]);
+
+  const generateMessage = useCallback(async () => {
+    if (!projectPath) return;
+    setOperationInProgress('generating');
+    try {
+      const msg = await window.electronAPI.gitGenerateMessage(projectPath);
+      setGeneratedMessage(msg);
+      return msg;
+    } catch (err) {
+      showToast('Failed to generate commit message', 'error');
+      return null;
+    } finally {
+      setOperationInProgress(null);
+    }
+  }, [projectPath]);
+
+  const push = useCallback(async (setUpstream?: boolean) => {
+    if (!projectPath) return;
+    setOperationInProgress('pushing');
+    try {
+      const result = await window.electronAPI.gitPush(projectPath, setUpstream);
+      if (result.success) {
+        showToast(result.message, 'success');
+        await refreshStatus();
+      } else {
+        showToast(result.message, 'error');
+      }
+      return result;
+    } catch (err) {
+      showToast('Failed to push', 'error');
+      return null;
+    } finally {
+      setOperationInProgress(null);
+    }
+  }, [projectPath, refreshStatus]);
+
+  const pull = useCallback(async () => {
+    if (!projectPath) return;
+    setOperationInProgress('pulling');
+    try {
+      const result = await window.electronAPI.gitPull(projectPath);
+      if (result.success) {
+        showToast(result.message, 'success');
+        await refreshStatus();
+        await loadHistory(10);
+      } else {
+        showToast(result.message, 'error');
+      }
+      return result;
+    } catch (err) {
+      showToast('Failed to pull', 'error');
+      return null;
+    } finally {
+      setOperationInProgress(null);
+    }
+  }, [projectPath, refreshStatus, loadHistory]);
+
+  const fetch_ = useCallback(async () => {
+    if (!projectPath) return;
+    setOperationInProgress('fetching');
+    try {
+      const result = await window.electronAPI.gitFetch(projectPath);
+      if (result.success) {
+        showToast(result.message, 'success');
+        await refreshStatus();
+      } else {
+        showToast(result.message, 'error');
+      }
+      return result;
+    } catch (err) {
+      showToast('Failed to fetch', 'error');
+      return null;
+    } finally {
+      setOperationInProgress(null);
+    }
+  }, [projectPath, refreshStatus]);
+
+  const switchBranch = useCallback(async (branch: string) => {
+    if (!projectPath) return;
+    setOperationInProgress('switching');
+    try {
+      const result = await window.electronAPI.gitSwitchBranch(projectPath, branch);
+      if (result.success) {
+        showToast(`Switched to branch '${branch}'`, 'success');
+        await refreshStatus();
+        await loadBranches();
+        await loadHistory(10);
+      } else {
+        showToast(result.message, 'error');
+      }
+      return result;
+    } catch (err) {
+      showToast('Failed to switch branch', 'error');
+      return null;
+    } finally {
+      setOperationInProgress(null);
+    }
+  }, [projectPath, refreshStatus, loadBranches, loadHistory]);
+
+  const createBranch = useCallback(async (branch: string) => {
+    if (!projectPath) return;
+    setOperationInProgress('creating branch');
+    try {
+      const result = await window.electronAPI.gitCreateBranch(projectPath, branch);
+      if (result.success) {
+        showToast(`Created branch '${branch}'`, 'success');
+        await refreshStatus();
+        await loadBranches();
+      } else {
+        showToast(result.message, 'error');
+      }
+      return result;
+    } catch (err) {
+      showToast('Failed to create branch', 'error');
+      return null;
+    } finally {
+      setOperationInProgress(null);
+    }
+  }, [projectPath, refreshStatus, loadBranches]);
+
+  const viewDiff = useCallback(async (filePath: string, staged: boolean) => {
+    if (!projectPath) return;
+    try {
+      const diff = await window.electronAPI.gitDiff(projectPath, filePath, staged);
+      setSelectedDiff(diff);
+    } catch (err) {
+      showToast('Failed to load diff', 'error');
+    }
+  }, [projectPath]);
+
+  const discardFile = useCallback(async (filePath: string) => {
+    if (!projectPath) return;
+    setOperationInProgress('discarding');
+    try {
+      const result = await window.electronAPI.gitDiscardFile(projectPath, filePath);
+      if (result.success) {
+        showToast(`Discarded changes to ${filePath}`, 'success');
+        await refreshStatus();
+      } else {
+        showToast(result.message, 'error');
+      }
+    } catch (err) {
+      showToast('Failed to discard changes', 'error');
+    } finally {
+      setOperationInProgress(null);
+    }
+  }, [projectPath, refreshStatus]);
+
+  const discardAll = useCallback(async () => {
+    if (!projectPath) return;
+    setOperationInProgress('discarding');
+    try {
+      const result = await window.electronAPI.gitDiscardAll(projectPath);
+      if (result.success) {
+        showToast('Discarded all unstaged changes', 'success');
+        await refreshStatus();
+      } else {
+        showToast(result.message, 'error');
+      }
+    } catch (err) {
+      showToast('Failed to discard all changes', 'error');
+    } finally {
+      setOperationInProgress(null);
+    }
+  }, [projectPath, refreshStatus]);
+
+  const initRepo = useCallback(async () => {
+    if (!projectPath) return;
+    setOperationInProgress('initializing');
+    try {
+      const result = await window.electronAPI.gitInit(projectPath);
+      if (result.success) {
+        showToast('Initialized git repository', 'success');
+        await refreshStatus();
+      } else {
+        showToast(result.message, 'error');
+      }
+    } catch (err) {
+      showToast('Failed to initialize git repository', 'error');
+    } finally {
+      setOperationInProgress(null);
+    }
+  }, [projectPath, refreshStatus]);
+
+  const startWatching = useCallback(async () => {
+    if (!projectPath) return;
+    try {
+      await window.electronAPI.gitStartWatching(projectPath);
+    } catch (err) {
+      console.warn('Failed to start git watching:', err);
+    }
+  }, [projectPath]);
+
+  const stopWatching = useCallback(async () => {
+    if (!projectPath) return;
+    try {
+      await window.electronAPI.gitStopWatching(projectPath);
+    } catch (err) {
+      console.warn('Failed to stop git watching:', err);
+    }
+  }, [projectPath]);
+
+  return {
+    status,
+    branches,
+    log,
+    selectedDiff,
+    generatedMessage,
+    isLoading,
+    operationInProgress,
+    error,
+    refreshStatus,
+    loadBranches,
+    loadHistory,
+    stageFiles,
+    unstageFiles,
+    stageAll,
+    unstageAll,
+    commit,
+    generateMessage,
+    push,
+    pull,
+    fetch: fetch_,
+    switchBranch,
+    createBranch,
+    viewDiff,
+    setSelectedDiff,
+    discardFile,
+    discardAll,
+    initRepo,
+    startWatching,
+    stopWatching,
+  };
+}

package/src/renderer/hooks/useLayoutPicker.ts

@@ -0,0 +1,77 @@
+import { useState, useEffect, useCallback } from 'react';
+import { LayoutPreset } from '../../types/layout-presets';
+
+export interface UseLayoutPickerReturn {
+  isPickerOpen: boolean;
+  presets: LayoutPreset[];
+  currentPresetId: string | null;
+  setCurrentPresetId: (id: string | null) => void;
+  openPicker: () => void;
+  closePicker: () => void;
+  selectPreset: (preset: LayoutPreset) => Promise<void>;
+}
+
+export function useLayoutPicker(
+  onPresetSelected?: (preset: LayoutPreset) => void
+): UseLayoutPickerReturn {
+  const [isPickerOpen, setIsPickerOpen] = useState(false);
+  const [presets, setPresets] = useState<LayoutPreset[]>([]);
+  const [currentPresetId, setCurrentPresetId] = useState<string | null>(null);
+
+  // Load presets on mount
+  useEffect(() => {
+    const loadPresets = async () => {
+      try {
+        const fetchedPresets = await window.electronAPI.getLayoutPresets();
+        setPresets(fetchedPresets);
+
+        // Load last used preset ID from settings
+        const settings = await window.electronAPI.getSettings();
+        setCurrentPresetId(settings.lastUsedLayoutPresetId || null);
+      } catch (err) {
+        console.error('Failed to load layout presets:', err);
+      }
+    };
+
+    loadPresets();
+  }, []);
+
+  const openPicker = useCallback(() => {
+    setIsPickerOpen(true);
+  }, []);
+
+  const closePicker = useCallback(() => {
+    setIsPickerOpen(false);
+  }, []);
+
+  const selectPreset = useCallback(async (preset: LayoutPreset) => {
+    try {
+      // Apply the preset
+      const success = await window.electronAPI.applyLayoutPreset(preset.id);
+
+      if (success) {
+        setCurrentPresetId(preset.id);
+        closePicker();
+
+        // Notify callback
+        if (onPresetSelected) {
+          onPresetSelected(preset);
+        }
+      } else {
+        console.error('Failed to apply preset:', preset.id);
+      }
+    } catch (err) {
+      console.error('Error applying preset:', err);
+    }
+  }, [closePicker, onPresetSelected]);
+
+  return {
+    isPickerOpen,
+    presets,
+    currentPresetId,
+    setCurrentPresetId,
+    openPicker,
+    closePicker,
+    selectPreset,
+  };
+}

package/src/renderer/hooks/useModelHistory.ts

@@ -0,0 +1,69 @@
+import { useState, useEffect, useCallback } from 'react';
+import type { ModelSwitchHistoryEntry } from '../../main/model-history-manager';
+
+export interface UseModelHistoryReturn {
+  history: ModelSwitchHistoryEntry[];
+  isLoading: boolean;
+  refresh: () => Promise<void>;
+  clearHistory: () => Promise<void>;
+}
+
+export function useModelHistory(sessionId: string | null): UseModelHistoryReturn {
+  const [history, setHistory] = useState<ModelSwitchHistoryEntry[]>([]);
+  const [isLoading, setIsLoading] = useState(false);
+
+  const loadHistory = useCallback(async () => {
+    if (!sessionId) {
+      setHistory([]);
+      return;
+    }
+
+    setIsLoading(true);
+    try {
+      const result = await window.electronAPI.getModelHistory(sessionId);
+      setHistory(result);
+    } catch (err) {
+      console.error('[useModelHistory] Failed to load history:', err);
+      setHistory([]);
+    } finally {
+      setIsLoading(false);
+    }
+  }, [sessionId]);
+
+  const clearHistory = useCallback(async () => {
+    if (!sessionId) return;
+
+    try {
+      await window.electronAPI.clearModelHistory(sessionId);
+      setHistory([]);
+    } catch (err) {
+      console.error('[useModelHistory] Failed to clear history:', err);
+    }
+  }, [sessionId]);
+
+  // Load on mount and when sessionId changes
+  useEffect(() => {
+    loadHistory();
+  }, [loadHistory]);
+
+  // Listen for model change events to refresh
+  useEffect(() => {
+    if (!sessionId) return;
+
+    const unsubscribe = window.electronAPI.onModelChanged((event) => {
+      // Refresh if the event is for our session
+      if (event.sessionId === sessionId) {
+        loadHistory();
+      }
+    });
+
+    return unsubscribe;
+  }, [sessionId, loadHistory]);
+
+  return {
+    history,
+    isLoading,
+    refresh: loadHistory,
+    clearHistory,
+  };
+}

package/src/renderer/hooks/useSessionManager.test.ts

@@ -0,0 +1,146 @@
+import { describe, it, expect, vi, beforeEach } from 'vitest';
+import { renderHook, act, waitFor } from '@testing-library/react';
+import { getElectronAPI } from '../../../test/helpers/electron-api-mock';
+import { useSessionManager } from './useSessionManager';
+
+describe('useSessionManager', () => {
+  let api: ReturnType<typeof getElectronAPI>;
+
+  beforeEach(() => {
+    api = getElectronAPI();
+  });
+
+  it('loads initial sessions on mount', async () => {
+    const mockSessions = [
+      { id: 's1', name: 'Session 1', workingDirectory: '/test', permissionMode: 'standard' as const, status: 'running' as const, createdAt: Date.now() },
+    ];
+    api.listSessions.mockResolvedValue({
+      sessions: mockSessions,
+      activeSessionId: 's1',
+    });
+
+    const { result } = renderHook(() => useSessionManager());
+
+    await waitFor(() => {
+      expect(result.current.isLoading).toBe(false);
+    });
+
+    expect(result.current.sessions).toHaveLength(1);
+    expect(result.current.sessions[0].id).toBe('s1');
+    expect(result.current.activeSessionId).toBe('s1');
+  });
+
+  it('createSession calls electronAPI.createSession', async () => {
+    api.listSessions.mockResolvedValue({ sessions: [], activeSessionId: null });
+    api.createSession.mockResolvedValue({ id: 's-new', name: 'New', workingDirectory: '/test', permissionMode: 'standard', status: 'running', createdAt: Date.now() });
+    api.getSettings.mockResolvedValue({ version: 1, workspaces: [], defaultModel: 'sonnet' });
+
+    const { result } = renderHook(() => useSessionManager());
+    await waitFor(() => expect(result.current.isLoading).toBe(false));
+
+    await act(async () => {
+      await result.current.createSession('New', '/test', 'standard');
+    });
+
+    expect(api.createSession).toHaveBeenCalledWith({
+      name: 'New',
+      workingDirectory: '/test',
+      permissionMode: 'standard',
+      model: 'sonnet',
+    });
+  });
+
+  it('closeSession calls electronAPI.closeSession', async () => {
+    api.listSessions.mockResolvedValue({
+      sessions: [{ id: 's1', name: 'S1', workingDirectory: '/', permissionMode: 'standard', status: 'running', createdAt: Date.now() }],
+      activeSessionId: 's1',
+    });
+    api.closeSession.mockResolvedValue(true);
+
+    const { result } = renderHook(() => useSessionManager());
+    await waitFor(() => expect(result.current.isLoading).toBe(false));
+
+    await act(async () => {
+      await result.current.closeSession('s1');
+    });
+
+    expect(api.closeSession).toHaveBeenCalledWith('s1');
+  });
+
+  it('switchSession calls electronAPI.switchSession', async () => {
+    api.listSessions.mockResolvedValue({
+      sessions: [
+        { id: 's1', name: 'S1', workingDirectory: '/', permissionMode: 'standard', status: 'running', createdAt: Date.now() },
+        { id: 's2', name: 'S2', workingDirectory: '/', permissionMode: 'standard', status: 'running', createdAt: Date.now() },
+      ],
+      activeSessionId: 's1',
+    });
+    api.switchSession.mockResolvedValue(true);
+
+    const { result } = renderHook(() => useSessionManager());
+    await waitFor(() => expect(result.current.isLoading).toBe(false));
+
+    await act(async () => {
+      await result.current.switchSession('s2');
+    });
+
+    expect(api.switchSession).toHaveBeenCalledWith('s2');
+  });
+
+  it('subscribes to session events and cleans up on unmount', () => {
+    api.listSessions.mockResolvedValue({ sessions: [], activeSessionId: null });
+
+    const unsubCreated = vi.fn();
+    const unsubClosed = vi.fn();
+    const unsubSwitched = vi.fn();
+    const unsubUpdated = vi.fn();
+    const unsubOutput = vi.fn();
+    const unsubExited = vi.fn();
+
+    api.onSessionCreated.mockReturnValue(unsubCreated);
+    api.onSessionClosed.mockReturnValue(unsubClosed);
+    api.onSessionSwitched.mockReturnValue(unsubSwitched);
+    api.onSessionUpdated.mockReturnValue(unsubUpdated);
+    api.onSessionOutput.mockReturnValue(unsubOutput);
+    api.onSessionExited.mockReturnValue(unsubExited);
+
+    const { unmount } = renderHook(() => useSessionManager());
+
+    expect(api.onSessionCreated).toHaveBeenCalled();
+    expect(api.onSessionClosed).toHaveBeenCalled();
+    expect(api.onSessionOutput).toHaveBeenCalled();
+
+    unmount();
+    expect(unsubCreated).toHaveBeenCalled();
+    expect(unsubClosed).toHaveBeenCalled();
+    expect(unsubOutput).toHaveBeenCalled();
+  });
+
+  it('output callback supports multiple subscribers', async () => {
+    api.listSessions.mockResolvedValue({ sessions: [], activeSessionId: null });
+
+    let outputListener: Function;
+    api.onSessionOutput.mockImplementation((cb: Function) => {
+      outputListener = cb;
+      return vi.fn();
+    });
+
+    const { result } = renderHook(() => useSessionManager());
+
+    const cb1 = vi.fn();
+    const cb2 = vi.fn();
+
+    act(() => {
+      result.current.onOutput(cb1);
+      result.current.onOutput(cb2);
+    });
+
+    // Simulate output event
+    act(() => {
+      outputListener({ sessionId: 's1', data: 'hello' });
+    });
+
+    expect(cb1).toHaveBeenCalledWith('s1', 'hello');
+    expect(cb2).toHaveBeenCalledWith('s1', 'hello');
+  });
+});

package/src/renderer/hooks/useSessionManager.ts

@@ -102,10 +102,15 @@ export function useSessionManager(): UseSessionManagerReturn {
     permissionMode: 'standard' | 'skip-permissions'
   ) => {
     try {
+      // Read default model from settings
+      const settings = await window.electronAPI.getSettings();
+      const defaultModel = settings.defaultModel || 'sonnet';
+
       await window.electronAPI.createSession({
         name: name || undefined,
         workingDirectory,
         permissionMode,
+        model: defaultModel,
       });
     } catch (err) {
       console.error('Failed to create session:', err);