claude-ws 0.3.97 → 0.3.99

package/src/stores/questions-store.ts

@@ -0,0 +1,76 @@
+import { create } from 'zustand';
+
+export interface PendingQuestionEntry {
+  attemptId: string;
+  taskId: string;
+  taskTitle: string;
+  projectId: string;
+  toolUseId: string;
+  questions: unknown[];
+  timestamp: number;
+}
+
+interface QuestionsStore {
+  isOpen: boolean;
+  pendingQuestions: Map<string, PendingQuestionEntry>;
+  togglePanel: () => void;
+  openPanel: () => void;
+  closePanel: () => void;
+  fetchQuestions: (projectIds?: string[]) => Promise<void>;
+  addQuestion: (entry: PendingQuestionEntry) => void;
+  removeQuestion: (attemptId: string) => void;
+  getCount: () => number;
+  getByTaskId: (taskId: string) => PendingQuestionEntry | undefined;
+}
+
+export const useQuestionsStore = create<QuestionsStore>((set, get) => ({
+  isOpen: false,
+  pendingQuestions: new Map<string, PendingQuestionEntry>(),
+
+  togglePanel: () => set((state) => ({ isOpen: !state.isOpen })),
+  openPanel: () => set({ isOpen: true }),
+  closePanel: () => set({ isOpen: false }),
+
+  fetchQuestions: async (projectIds?: string[]) => {
+    try {
+      const params = projectIds?.length ? `?projectIds=${projectIds.join(',')}` : '';
+      const res = await fetch(`/api/questions${params}`);
+      if (!res.ok) return;
+      const data = await res.json();
+      const newMap = new Map<string, PendingQuestionEntry>();
+      for (const q of data.questions || []) {
+        newMap.set(q.attemptId, q);
+      }
+      set({ pendingQuestions: newMap });
+    } catch {
+      // Silently fail — will retry on next poll
+    }
+  },
+
+  addQuestion: (entry) => {
+    set((state) => {
+      const newMap = new Map(state.pendingQuestions);
+      newMap.set(entry.attemptId, entry);
+      return { pendingQuestions: newMap };
+    });
+  },
+
+  removeQuestion: (attemptId) => {
+    set((state) => {
+      const newMap = new Map(state.pendingQuestions);
+      newMap.delete(attemptId);
+      return { pendingQuestions: newMap };
+    });
+  },
+
+  getCount: () => {
+    return get().pendingQuestions.size;
+  },
+
+  getByTaskId: (taskId) => {
+    for (const entry of get().pendingQuestions.values()) {
+      if (entry.taskId === taskId) return entry;
+    }
+    return undefined;
+  },
+}));

package/src/stores/workflow-store.ts

@@ -0,0 +1,71 @@
+import { create } from 'zustand';
+import type { SubagentNode, AgentMessage, WorkflowSummary } from '@/lib/workflow-tracker';
+
+export interface WorkflowEntry {
+  attemptId: string;
+  taskId: string;
+  taskTitle: string;
+  nodes: SubagentNode[];
+  messages: AgentMessage[];
+  summary: WorkflowSummary;
+}
+
+interface WorkflowStore {
+  isOpen: boolean;
+  workflows: Map<string, WorkflowEntry>;
+  togglePanel: () => void;
+  openPanel: () => void;
+  closePanel: () => void;
+  updateWorkflow: (attemptId: string, data: Partial<WorkflowEntry>) => void;
+  removeWorkflow: (attemptId: string) => void;
+  getActiveAgentCount: () => number;
+  getByTaskId: (taskId: string) => WorkflowEntry | undefined;
+}
+
+export const useWorkflowStore = create<WorkflowStore>((set, get) => ({
+  isOpen: false,
+  workflows: new Map<string, WorkflowEntry>(),
+
+  togglePanel: () => set((state) => ({ isOpen: !state.isOpen })),
+  openPanel: () => set({ isOpen: true }),
+  closePanel: () => set({ isOpen: false }),
+
+  updateWorkflow: (attemptId, data) => {
+    set((state) => {
+      const newMap = new Map(state.workflows);
+      const existing = newMap.get(attemptId);
+      newMap.set(attemptId, {
+        attemptId,
+        taskId: data.taskId || existing?.taskId || '',
+        taskTitle: data.taskTitle || existing?.taskTitle || '',
+        nodes: data.nodes || existing?.nodes || [],
+        messages: data.messages || existing?.messages || [],
+        summary: data.summary || existing?.summary || { chain: [], completedCount: 0, activeCount: 0, totalCount: 0 },
+      });
+      return { workflows: newMap };
+    });
+  },
+
+  removeWorkflow: (attemptId) => {
+    set((state) => {
+      const newMap = new Map(state.workflows);
+      newMap.delete(attemptId);
+      return { workflows: newMap };
+    });
+  },
+
+  getActiveAgentCount: () => {
+    let count = 0;
+    for (const entry of get().workflows.values()) {
+      count += entry.summary.activeCount;
+    }
+    return count;
+  },
+
+  getByTaskId: (taskId) => {
+    for (const entry of get().workflows.values()) {
+      if (entry.taskId === taskId) return entry;
+    }
+    return undefined;
+  },
+}));