hjworktree-cli 2.0.0 → 2.2.0

package/web/src/stores/useAppStore.ts

@@ -1,5 +1,5 @@
 import { create } from 'zustand';
-import type { Branch, TerminalInfo, AgentId, AgentStatus, NavigationStep, StepStatus } from '../../../shared/types/index.js';
+import type { Branch, TerminalInfo, AgentId, AgentStatus, NavigationStep, StepStatus, ModalType, SessionGroup } from '../../../shared/types/index.js';
 import { STEP_ORDER } from '../../../shared/types/index.js';
 import { DEFAULT_PARALLEL_COUNT, MIN_PARALLEL_COUNT, MAX_PARALLEL_COUNT } from '../../../shared/constants.js';
 
@@ -31,6 +31,18 @@ interface AppState {
   terminals: TerminalInfo[];
   activeTerminalIndex: number;
 
+  // Session management (new)
+  activeSessionId: string | null;
+  selectedSessionIds: string[];
+
+  // LNB state (new)
+  isSetupCollapsed: boolean;
+  collapsedBranches: string[];
+
+  // Modal state (new)
+  modalType: ModalType;
+  modalData: { sessionIds?: string[]; branchName?: string } | null;
+
   // Loading states
   isLoading: boolean;
   loadingMessage: string;
@@ -73,6 +85,25 @@ interface AppActions {
   setActiveTerminal: (index: number) => void;
   clearAllTerminals: () => void;
 
+  // Session management (new)
+  setActiveSession: (sessionId: string | null) => void;
+  toggleSessionSelection: (sessionId: string) => void;
+  selectAllSessions: () => void;
+  clearSessionSelection: () => void;
+  removeSelectedSessions: () => Promise<void>;
+  getSessionGroups: () => SessionGroup[];
+
+  // LNB state (new)
+  toggleSetupCollapse: () => void;
+  toggleBranchCollapse: (branchName: string) => void;
+
+  // Modal (new)
+  openModal: (type: ModalType, data?: { sessionIds?: string[]; branchName?: string }) => void;
+  closeModal: () => void;
+
+  // Single worktree creation (new)
+  createSingleWorktree: (branch: string, agentType: AgentId) => Promise<void>;
+
   // Execute
   execute: () => Promise<void>;
 
@@ -98,6 +129,12 @@ const initialState: AppState = {
   worktreeCount: DEFAULT_PARALLEL_COUNT,
   terminals: [],
   activeTerminalIndex: 0,
+  activeSessionId: null,
+  selectedSessionIds: [],
+  isSetupCollapsed: false,
+  collapsedBranches: [],
+  modalType: null,
+  modalData: null,
   isLoading: false,
   loadingMessage: '',
   error: null,
@@ -277,7 +314,164 @@ export const useAppStore = create<AppStore>((set, get) => ({
 
   setActiveTerminal: (index) => set({ activeTerminalIndex: index }),
 
-  clearAllTerminals: () => set({ terminals: [], activeTerminalIndex: 0 }),
+  clearAllTerminals: () => set({ terminals: [], activeTerminalIndex: 0, activeSessionId: null, selectedSessionIds: [] }),
+
+  // Session management
+  setActiveSession: (sessionId) => {
+    const { terminals } = get();
+    const index = terminals.findIndex(t => t.sessionId === sessionId);
+    set({
+      activeSessionId: sessionId,
+      activeTerminalIndex: index >= 0 ? index : 0,
+    });
+  },
+
+  toggleSessionSelection: (sessionId) => set((state) => {
+    const selectedIds = [...state.selectedSessionIds];
+    const index = selectedIds.indexOf(sessionId);
+    if (index >= 0) {
+      selectedIds.splice(index, 1);
+    } else {
+      selectedIds.push(sessionId);
+    }
+    return { selectedSessionIds: selectedIds };
+  }),
+
+  selectAllSessions: () => set((state) => ({
+    selectedSessionIds: state.terminals.map(t => t.sessionId),
+  })),
+
+  clearSessionSelection: () => set({ selectedSessionIds: [] }),
+
+  removeSelectedSessions: async () => {
+    const { selectedSessionIds, terminals } = get();
+    if (selectedSessionIds.length === 0) return;
+
+    const names = terminals
+      .filter(t => selectedSessionIds.includes(t.sessionId))
+      .map(t => t.worktreeName);
+
+    try {
+      const response = await fetch('/api/worktrees/batch', {
+        method: 'DELETE',
+        headers: { 'Content-Type': 'application/json' },
+        body: JSON.stringify({ names }),
+      });
+
+      if (response.ok) {
+        set((state) => {
+          const remainingTerminals = state.terminals.filter(
+            t => !selectedSessionIds.includes(t.sessionId)
+          );
+          return {
+            terminals: remainingTerminals,
+            selectedSessionIds: [],
+            activeTerminalIndex: Math.min(state.activeTerminalIndex, Math.max(0, remainingTerminals.length - 1)),
+            activeSessionId: remainingTerminals.length > 0 ? remainingTerminals[0].sessionId : null,
+          };
+        });
+      }
+    } catch (error) {
+      console.error('Failed to remove sessions:', error);
+    }
+  },
+
+  getSessionGroups: () => {
+    const { terminals, collapsedBranches } = get();
+    const groupMap = new Map<string, TerminalInfo[]>();
+
+    for (const terminal of terminals) {
+      // Extract base branch name from worktree branch (e.g., "main-project-1" -> "main")
+      const baseBranch = terminal.branchName.replace(/-project-\d+$/, '');
+      if (!groupMap.has(baseBranch)) {
+        groupMap.set(baseBranch, []);
+      }
+      groupMap.get(baseBranch)!.push(terminal);
+    }
+
+    const groups: SessionGroup[] = [];
+    for (const [branchName, sessions] of groupMap) {
+      groups.push({
+        branchName,
+        sessions: sessions.map(s => ({
+          ...s,
+          id: s.sessionId,
+          createdAt: Date.now(),
+        })),
+        isCollapsed: collapsedBranches.includes(branchName),
+      });
+    }
+
+    return groups.sort((a, b) => a.branchName.localeCompare(b.branchName));
+  },
+
+  // LNB state
+  toggleSetupCollapse: () => set((state) => ({
+    isSetupCollapsed: !state.isSetupCollapsed,
+  })),
+
+  toggleBranchCollapse: (branchName) => set((state) => {
+    const collapsed = [...state.collapsedBranches];
+    const index = collapsed.indexOf(branchName);
+    if (index >= 0) {
+      collapsed.splice(index, 1);
+    } else {
+      collapsed.push(branchName);
+    }
+    return { collapsedBranches: collapsed };
+  }),
+
+  // Modal
+  openModal: (type, data) => set({ modalType: type, modalData: data || null }),
+  closeModal: () => set({ modalType: null, modalData: null }),
+
+  // Single worktree creation
+  createSingleWorktree: async (branch, agentType) => {
+    const { setLoading, setError, addTerminal, setActiveSession } = get();
+
+    setLoading(true, 'Creating worktree...');
+    setError(null);
+
+    try {
+      const response = await fetch('/api/worktrees/single', {
+        method: 'POST',
+        headers: { 'Content-Type': 'application/json' },
+        body: JSON.stringify({ branch, agentType }),
+      });
+
+      if (!response.ok) {
+        const data = await response.json();
+        throw new Error(data.error || 'Failed to create worktree');
+      }
+
+      const { worktree } = await response.json();
+      const sessionId = `${worktree.name}-${Date.now()}`;
+
+      addTerminal({
+        sessionId,
+        worktreePath: worktree.path,
+        worktreeName: worktree.name,
+        branchName: worktree.branch,
+        agentType,
+        status: 'initializing',
+      });
+
+      // Auto-switch to the new session
+      setActiveSession(sessionId);
+
+      // Auto-collapse setup and switch to running
+      set({
+        step: 'running',
+        isSetupCollapsed: true,
+        modalType: null,
+        modalData: null,
+      });
+    } catch (error) {
+      setError(error instanceof Error ? error.message : 'Unknown error');
+    } finally {
+      setLoading(false);
+    }
+  },
 
   // Execute
   execute: async () => {
@@ -323,9 +517,12 @@ export const useAppStore = create<AppStore>((set, get) => ({
       }
 
       // Mark all setup steps as complete and transition to running
+      const { terminals: updatedTerminals } = get();
       set({
         step: 'running',
-        completedSteps: ['branch', 'agent', 'worktree']
+        completedSteps: ['branch', 'agent', 'worktree'],
+        isSetupCollapsed: true,
+        activeSessionId: updatedTerminals.length > 0 ? updatedTerminals[0].sessionId : null,
       });
     } catch (error) {
       setError(error instanceof Error ? error.message : 'Unknown error');