repoburg 1.3.201 → 1.3.204

package/agent-pane/frontend/src/store/store.ts

@@ -1,37 +0,0 @@
-import { create } from 'zustand';
-import type { SessionSlice } from './sessionSlice.ts';
-import type { WorkspaceSlice } from './workspaceSlice.ts';
-import type { WsSlice } from './wsSlice.ts';
-import type { UiSlice } from './uiSlice.ts';
-import type { ThreadSlice } from './threadSlice.ts';
-import { createSessionSlice } from './sessionSlice.ts';
-import { createWorkspaceSlice } from './workspaceSlice.ts';
-import { createWsSlice } from './wsSlice.ts';
-import { createUiSlice } from './uiSlice.ts';
-import { createThreadSlice } from './threadSlice.ts';
-
-export interface CreateSessionBody {
-  title?: string;
-  runtime_type?: string;
-  model?: string;
-  model_reasoning_effort?: string;
-  cwd?: string;
-}
-
-export interface Toast {
-  id: string;
-  type: 'success' | 'error' | 'info' | 'warn';
-  message: string;
-  undoAction?: () => void;
-  undoLabel?: string;
-}
-
-export type StoreState = SessionSlice & WorkspaceSlice & WsSlice & UiSlice & ThreadSlice;
-
-export const useStore = create<StoreState>()((...a) => ({
-  ...createSessionSlice(...a),
-  ...createWorkspaceSlice(...a),
-  ...createWsSlice(...a),
-  ...createUiSlice(...a),
-  ...createThreadSlice(...a),
-}));

package/agent-pane/frontend/src/store/threadSlice.ts

@@ -1,136 +0,0 @@
-import type { StateCreator } from 'zustand';
-import type { DiscussionThread, Turn } from '../types/index.ts';
-import type { StoreState } from './store.ts';
-import { apiPost, apiPatch, apiDelete } from '../api/client.ts';
-
-export type ThreadSlice = {
-  createThread: (sessionId: string, params: {
-    itemId: string;
-    turnId: string;
-    startOffset: number;
-    endOffset: number;
-    selectedText: string;
-    message: string;
-  }) => Promise<void>;
-  followupThread: (sessionId: string, threadId: string, message: string) => Promise<void>;
-  resolveThread: (sessionId: string, threadId: string) => Promise<void>;
-  reopenThread: (sessionId: string, threadId: string) => Promise<void>;
-  deleteThread: (sessionId: string, threadId: string) => Promise<void>;
-
-  onThreadCreated: (sessionId: string, thread: DiscussionThread, turn: Turn) => void;
-  onThreadFollowup: (sessionId: string, threadId: string, turn: Turn) => void;
-  onThreadResolved: (sessionId: string, threadId: string, status: 'open' | 'resolved') => void;
-  onThreadDeleted: (sessionId: string, threadId: string) => void;
-};
-
-export const createThreadSlice: StateCreator<StoreState, [], [], ThreadSlice> = (set, get) => ({
-  createThread: async (sessionId, params) => {
-    try {
-      await apiPost(`/sessions/${sessionId}/threads`, params);
-      get().addLogEntry('INFO', `Thread created — "${params.message.slice(0, 40)}"`);
-    } catch (err) {
-      get().addToast('error', `Failed to create thread — ${(err as Error).message}`);
-    }
-  },
-
-  followupThread: async (sessionId, threadId, message) => {
-    try {
-      await apiPost(`/sessions/${sessionId}/threads/${threadId}/followup`, { message });
-      get().addLogEntry('INFO', `Thread follow-up — "${message.slice(0, 40)}"`);
-    } catch (err) {
-      get().addToast('error', `Failed to send follow-up — ${(err as Error).message}`);
-    }
-  },
-
-  resolveThread: async (sessionId, threadId) => {
-    try {
-      await apiPatch(`/sessions/${sessionId}/threads/${threadId}`, { status: 'resolved' });
-    } catch (err) {
-      get().addToast('error', `Failed to resolve thread — ${(err as Error).message}`);
-    }
-  },
-
-  reopenThread: async (sessionId, threadId) => {
-    try {
-      await apiPatch(`/sessions/${sessionId}/threads/${threadId}`, { status: 'open' });
-    } catch (err) {
-      get().addToast('error', `Failed to reopen thread — ${(err as Error).message}`);
-    }
-  },
-
-  deleteThread: async (sessionId, threadId) => {
-    try {
-      await apiDelete(`/sessions/${sessionId}/threads/${threadId}`);
-    } catch (err) {
-      get().addToast('error', `Failed to delete thread — ${(err as Error).message}`);
-    }
-  },
-
-  onThreadCreated: (sessionId, thread, turn) => {
-    set((state) => {
-      const detail = state.sessionDetails[sessionId];
-      if (!detail) return {};
-      return {
-        sessionDetails: {
-          ...state.sessionDetails,
-          [sessionId]: {
-            ...detail,
-            threads: [...(detail.threads ?? []), thread],
-            turns: [...detail.turns, { ...turn, items: [] }],
-          },
-        },
-      };
-    });
-  },
-
-  onThreadFollowup: (sessionId, _threadId, turn) => {
-    set((state) => {
-      const detail = state.sessionDetails[sessionId];
-      if (!detail) return {};
-      return {
-        sessionDetails: {
-          ...state.sessionDetails,
-          [sessionId]: {
-            ...detail,
-            turns: [...detail.turns, { ...turn, items: [] }],
-          },
-        },
-      };
-    });
-  },
-
-  onThreadResolved: (sessionId, threadId, status) => {
-    set((state) => {
-      const detail = state.sessionDetails[sessionId];
-      if (!detail) return {};
-      const threads = (detail.threads ?? []).map((t) =>
-        t.id === threadId
-          ? { ...t, status, resolved_at: status === 'resolved' ? new Date().toISOString() : null }
-          : t,
-      );
-      return {
-        sessionDetails: {
-          ...state.sessionDetails,
-          [sessionId]: { ...detail, threads },
-        },
-      };
-    });
-  },
-
-  onThreadDeleted: (sessionId, threadId) => {
-    set((state) => {
-      const detail = state.sessionDetails[sessionId];
-      if (!detail) return {};
-      return {
-        sessionDetails: {
-          ...state.sessionDetails,
-          [sessionId]: {
-            ...detail,
-            threads: (detail.threads ?? []).filter((t) => t.id !== threadId),
-            turns: detail.turns.filter((t) => t.thread_id !== threadId),
-          },
-        },
-      };
-    });
-  },
-});

package/agent-pane/frontend/src/store/uiSlice.ts

@@ -1,133 +0,0 @@
-import type { StateCreator } from 'zustand';
-import type { LogEntry, RightTab, ChangesScope, ModelInfo } from '../types/index.ts';
-import type { StoreState, Toast } from './store.ts';
-import { fetchModels } from '../api/models.ts';
-
-/** Default + clamp bounds for resizable side panels (px). */
-export const SIDEBAR_MIN = 160;
-export const SIDEBAR_MAX = 480;
-export const SIDEBAR_DEFAULT = 240;
-export const RIGHT_PANEL_MIN = 220;
-export const RIGHT_PANEL_MAX = 600;
-export const RIGHT_PANEL_DEFAULT = 300;
-
-const SIDEBAR_KEY = 'agentpane:sidebar-width';
-const RIGHT_PANEL_KEY = 'agentpane:right-panel-width';
-
-/** Read a stored px width, falling back to `fallback` on missing/invalid data. */
-function readWidth(key: string, min: number, max: number, fallback: number): number {
-  try {
-    const raw = localStorage.getItem(key);
-    if (raw == null) return fallback;
-    const n = Number(raw);
-    if (!Number.isFinite(n)) return fallback;
-    return Math.min(max, Math.max(min, n));
-  } catch {
-    return fallback;
-  }
-}
-
-export type UiSlice = {
-  activeRightTab: RightTab;
-  changesScope: ChangesScope;
-  eventLog: LogEntry[];
-  loading: boolean;
-  error: string | null;
-  showNewSessionDialog: boolean;
-  toasts: Toast[];
-  showCommandPalette: boolean;
-  selectedChangePath: string | null;
-  lastModelConfig: { provider: string; model: string; reasoning: string } | null;
-  models: ModelInfo[];
-  modelsLoading: boolean;
-  showModelSelector: boolean;
-  sidebarWidth: number;
-  rightPanelWidth: number;
-
-  setActiveTurnIndex: (idx: number) => void;
-  switchRightTab: (tab: RightTab) => void;
-  setChangesScope: (scope: ChangesScope) => void;
-  setShowNewSessionDialog: (show: boolean) => void;
-  setShowCommandPalette: (show: boolean) => void;
-  setShowModelSelector: (show: boolean) => void;
-  setSelectedChangePath: (path: string | null) => void;
-  setSidebarWidth: (w: number) => void;
-  setRightPanelWidth: (w: number) => void;
-  addToast: (type: Toast['type'], message: string, undoAction?: () => void, undoLabel?: string) => void;
-  removeToast: (id: string) => void;
-  addLogEntry: (level: LogEntry['level'], message: string) => void;
-  loadModels: (providerId: string) => Promise<void>;
-};
-
-export const createUiSlice: StateCreator<StoreState, [], [], UiSlice> = (set, get) => ({
-  activeRightTab: 'turns',
-  changesScope: 'session',
-  eventLog: [],
-  loading: false,
-  error: null,
-  showNewSessionDialog: false,
-  toasts: [],
-  showCommandPalette: false,
-  selectedChangePath: null,
-  lastModelConfig: null,
-  models: [],
-  modelsLoading: false,
-  showModelSelector: false,
-  sidebarWidth: readWidth(SIDEBAR_KEY, SIDEBAR_MIN, SIDEBAR_MAX, SIDEBAR_DEFAULT),
-  rightPanelWidth: readWidth(RIGHT_PANEL_KEY, RIGHT_PANEL_MIN, RIGHT_PANEL_MAX, RIGHT_PANEL_DEFAULT),
-
-  setActiveTurnIndex: (idx) => set({ activeTurnIndex: idx }),
-  switchRightTab: (tab) => set({ activeRightTab: tab }),
-  setChangesScope: (scope) => set({ changesScope: scope }),
-  setShowNewSessionDialog: (show) => set({ showNewSessionDialog: show }),
-  setShowCommandPalette: (show) => set({ showCommandPalette: show }),
-  setShowModelSelector: (show) => set({ showModelSelector: show }),
-  setSelectedChangePath: (path) => set({ selectedChangePath: path }),
-
-  setSidebarWidth: (w) => {
-    const clamped = Math.min(SIDEBAR_MAX, Math.max(SIDEBAR_MIN, Math.round(w)));
-    set({ sidebarWidth: clamped });
-    try {
-      localStorage.setItem(SIDEBAR_KEY, String(clamped));
-    } catch {
-      /* ignore quota / disabled storage */
-    }
-  },
-
-  setRightPanelWidth: (w) => {
-    const clamped = Math.min(RIGHT_PANEL_MAX, Math.max(RIGHT_PANEL_MIN, Math.round(w)));
-    set({ rightPanelWidth: clamped });
-    try {
-      localStorage.setItem(RIGHT_PANEL_KEY, String(clamped));
-    } catch {
-      /* ignore quota / disabled storage */
-    }
-  },
-
-  addToast: (type, message, undoAction, undoLabel) => {
-    const id = Math.random().toString(36).slice(2, 9);
-    set((state) => ({ toasts: [...state.toasts, { id, type, message, undoAction, undoLabel }] }));
-  },
-
-  removeToast: (id) => {
-    set((state) => ({ toasts: state.toasts.filter((t) => t.id !== id) }));
-  },
-
-  addLogEntry: (level, message) => {
-    const time = new Date().toLocaleTimeString('en-GB', { hour12: false });
-    set((state) => ({
-      eventLog: [...state.eventLog, { time, level, message }],
-    }));
-  },
-
-  loadModels: async (providerId) => {
-    if (get().modelsLoading) return;
-    set({ modelsLoading: true, models: [] });
-    try {
-      const models = await fetchModels(providerId);
-      set({ models, modelsLoading: false });
-    } catch {
-      set({ modelsLoading: false });
-    }
-  },
-});

package/agent-pane/frontend/src/store/workspaceSlice.ts

@@ -1,77 +0,0 @@
-import type { StateCreator } from 'zustand';
-import type { Workspace } from '../types/index.ts';
-import type { StoreState } from './store.ts';
-import {
-  fetchWorkspaces as apiFetchWorkspaces,
-  createWorkspace as apiCreateWorkspace,
-  hideWorkspace as apiHideWorkspace,
-  pickDirectory as apiPickDirectory,
-} from '../api/workspaces.ts';
-import { createSession as apiCreateSession } from '../api/sessions.ts';
-
-export type WorkspaceSlice = {
-  workspaces: Workspace[];
-  addWorkspace: (path: string) => Promise<void>;
-  removeWorkspace: (path: string) => Promise<void>;
-  createSessionInWorkspace: (cwd: string) => Promise<void>;
-  pickAndAddWorkspace: () => Promise<void>;
-};
-
-export const createWorkspaceSlice: StateCreator<StoreState, [], [], WorkspaceSlice> = (set, get) => ({
-  workspaces: [],
-
-  addWorkspace: async (path) => {
-    set({ error: null });
-    try {
-      const workspace = await apiCreateWorkspace(path.trim());
-      set((state) => ({ workspaces: [...state.workspaces, workspace] }));
-      get().addToast('success', `Workspace added — ${workspace.path}`);
-    } catch (err) {
-      get().addToast('error', `Failed to add workspace — ${(err as Error).message}`);
-    }
-  },
-
-  removeWorkspace: async (path) => {
-    set({ error: null });
-    try {
-      await apiHideWorkspace(path);
-      const workspaces = await apiFetchWorkspaces();
-      set({ workspaces });
-      get().addToast('info', 'Workspace hidden');
-    } catch (err) {
-      get().addToast('error', `Failed to hide workspace — ${(err as Error).message}`);
-    }
-  },
-
-  createSessionInWorkspace: async (cwd) => {
-    set({ error: null });
-    try {
-      const lastConfig = get().lastModelConfig;
-      const session = await apiCreateSession({
-        cwd,
-        runtime_type: lastConfig?.provider ?? 'codex',
-        model: lastConfig?.model,
-        model_reasoning_effort: lastConfig?.reasoning,
-      });
-      set((state) => ({
-        sessions: [session, ...state.sessions],
-      }));
-      await get().selectSession(session.id);
-      get().addLogEntry('INFO', `Session created in ${cwd} — ${session.id.slice(0, 8)}`);
-      get().addToast('success', `Session created in ${cwd.split('/').pop() || cwd}`);
-    } catch (err) {
-      set({ error: (err as Error).message });
-      get().addToast('error', `Failed to create session — ${(err as Error).message}`);
-    }
-  },
-
-  pickAndAddWorkspace: async () => {
-    try {
-      const result = await apiPickDirectory();
-      if (result.cancelled || !result.path) return;
-      await get().addWorkspace(result.path);
-    } catch (err) {
-      get().addToast('error', `Failed to pick directory — ${(err as Error).message}`);
-    }
-  },
-});