@agile-vibe-coding/avc 0.1.1 → 0.3.1

package/kanban/client/src/store/__tests__/kanbanStore.test.js

@@ -0,0 +1,164 @@
+import { describe, it, expect, beforeEach, vi } from 'vitest';
+import { useKanbanStore } from '../kanbanStore';
+import * as api from '../../lib/api';
+
+// Mock the API module
+vi.mock('../../lib/api', () => ({
+  getWorkItems: vi.fn(),
+}));
+
+describe('kanbanStore', () => {
+  beforeEach(() => {
+    // Reset store state before each test
+    useKanbanStore.setState({
+      workItems: [],
+      loading: false,
+      error: null,
+    });
+    vi.clearAllMocks();
+  });
+
+  describe('initial state', () => {
+    it('should have empty work items array', () => {
+      const state = useKanbanStore.getState();
+      expect(state.workItems).toEqual([]);
+    });
+
+    it('should not be loading initially', () => {
+      const state = useKanbanStore.getState();
+      expect(state.loading).toBe(false);
+    });
+
+    it('should have no error initially', () => {
+      const state = useKanbanStore.getState();
+      expect(state.error).toBeNull();
+    });
+  });
+
+  describe('loadWorkItems', () => {
+    it('should load work items successfully', async () => {
+      const mockItems = [
+        { id: 'EPIC-001', type: 'epic', status: 'implementing' },
+        { id: 'STORY-001', type: 'story', status: 'ready' },
+      ];
+
+      api.getWorkItems.mockResolvedValueOnce({ items: mockItems });
+
+      const { loadWorkItems } = useKanbanStore.getState();
+      await loadWorkItems();
+
+      const state = useKanbanStore.getState();
+      expect(state.workItems).toEqual(mockItems);
+      expect(state.loading).toBe(false);
+      expect(state.error).toBeNull();
+    });
+
+    it('should set loading state during fetch', async () => {
+      api.getWorkItems.mockImplementation(() => {
+        // Check loading state while promise is pending
+        const state = useKanbanStore.getState();
+        expect(state.loading).toBe(true);
+        return Promise.resolve({ items: [] });
+      });
+
+      const { loadWorkItems } = useKanbanStore.getState();
+      await loadWorkItems();
+    });
+
+    it('should handle errors gracefully', async () => {
+      const error = new Error('Failed to fetch');
+      api.getWorkItems.mockRejectedValueOnce(error);
+
+      const { loadWorkItems } = useKanbanStore.getState();
+      await loadWorkItems();
+
+      const state = useKanbanStore.getState();
+      expect(state.workItems).toEqual([]);
+      expect(state.loading).toBe(false);
+      expect(state.error).toBe('Failed to fetch');
+    });
+
+    it('should pass filters to API', async () => {
+      api.getWorkItems.mockResolvedValueOnce({ items: [] });
+
+      const { loadWorkItems } = useKanbanStore.getState();
+      await loadWorkItems({ type: 'epic', status: 'ready' });
+
+      expect(api.getWorkItems).toHaveBeenCalledWith({ type: 'epic', status: 'ready' });
+    });
+  });
+
+  describe('updateWorkItem', () => {
+    it('should update existing work item', () => {
+      const initialItems = [
+        { id: 'EPIC-001', name: 'Old Name', status: 'planned' },
+        { id: 'STORY-001', name: 'Story', status: 'ready' },
+      ];
+
+      useKanbanStore.setState({ workItems: initialItems });
+
+      const { updateWorkItem } = useKanbanStore.getState();
+      updateWorkItem('EPIC-001', { name: 'New Name', status: 'implementing' });
+
+      const state = useKanbanStore.getState();
+      expect(state.workItems[0]).toEqual({
+        id: 'EPIC-001',
+        name: 'New Name',
+        status: 'implementing',
+      });
+      expect(state.workItems[1]).toEqual(initialItems[1]); // Unchanged
+    });
+
+    it('should not modify state if item not found', () => {
+      const initialItems = [{ id: 'EPIC-001', name: 'Epic', status: 'planned' }];
+
+      useKanbanStore.setState({ workItems: initialItems });
+
+      const { updateWorkItem } = useKanbanStore.getState();
+      updateWorkItem('NONEXISTENT', { name: 'New Name' });
+
+      const state = useKanbanStore.getState();
+      expect(state.workItems).toEqual(initialItems);
+    });
+
+    it('should merge updates with existing properties', () => {
+      const initialItems = [
+        {
+          id: 'EPIC-001',
+          name: 'Epic',
+          status: 'planned',
+          description: 'Description',
+          type: 'epic',
+        },
+      ];
+
+      useKanbanStore.setState({ workItems: initialItems });
+
+      const { updateWorkItem } = useKanbanStore.getState();
+      updateWorkItem('EPIC-001', { status: 'implementing' });
+
+      const state = useKanbanStore.getState();
+      expect(state.workItems[0]).toEqual({
+        id: 'EPIC-001',
+        name: 'Epic',
+        status: 'implementing', // Updated
+        description: 'Description', // Preserved
+        type: 'epic', // Preserved
+      });
+    });
+  });
+
+  describe('refresh', () => {
+    it('should reload work items', async () => {
+      const mockItems = [{ id: 'EPIC-001', type: 'epic' }];
+      api.getWorkItems.mockResolvedValueOnce({ items: mockItems });
+
+      const { refresh } = useKanbanStore.getState();
+      await refresh();
+
+      const state = useKanbanStore.getState();
+      expect(state.workItems).toEqual(mockItems);
+      expect(api.getWorkItems).toHaveBeenCalled();
+    });
+  });
+});

package/kanban/client/src/store/ceremonyStore.js

@@ -0,0 +1,172 @@
+import { create } from 'zustand';
+
+/**
+ * Ceremony Store
+ * Manages the sponsor-call wizard state (not persisted).
+ */
+export const useCeremonyStore = create((set, get) => ({
+  // ── Modal open/close ───────────────────────────────────────────────────────
+  isOpen: false,
+
+  // ── Wizard navigation ──────────────────────────────────────────────────────
+  wizardStep: 1,
+  analyzing: false,   // true while an analyze API call is in-flight
+
+  // ── Step 1: Deployment strategy ───────────────────────────────────────────
+  strategy: null,     // 'local-mvp' | 'cloud'
+
+  // ── Step 2: Mission & Scope ───────────────────────────────────────────────
+  mission: '',
+  initialScope: '',
+
+  // ── Step 3: Database ──────────────────────────────────────────────────────
+  dbResult: null,     // API response from analyze/database
+  dbChoice: null,     // 'sql' | 'nosql' (user selection)
+
+  // ── Step 4: Architecture ──────────────────────────────────────────────────
+  archOptions: [],    // array of architecture objects from analyze/architecture
+  selectedArch: null, // chosen architecture object
+
+  // ── Step 5: Review & Edit ─────────────────────────────────────────────────
+  prefillResult: null, // API response from analyze/prefill
+
+  // ── Requirements (all 7 template variables) ───────────────────────────────
+  requirements: {
+    MISSION_STATEMENT: '',
+    INITIAL_SCOPE: '',
+    TARGET_USERS: '',
+    DEPLOYMENT_TARGET: '',
+    TECHNICAL_CONSIDERATIONS: '',
+    TECHNICAL_EXCLUSIONS: '',
+    SECURITY_AND_COMPLIANCE_REQUIREMENTS: '',
+  },
+
+  // ── Mission generator progress ─────────────────────────────────────────────
+  missionProgressLog: [],   // { step, message }
+
+  // ── Steps 6-7: Running / Complete ─────────────────────────────────────────
+  progressLog: [],          // { type:'progress'|'substep', message?, substep?, meta? }
+  ceremonyStatus: 'idle',   // 'idle' | 'running' | 'complete' | 'error'
+  ceremonyResult: null,
+  ceremonyError: null,
+  isPaused: false,
+  processId: null,          // active fork processId (set after run starts)
+
+  // ── Actions ────────────────────────────────────────────────────────────────
+
+  openWizard: () => set({ isOpen: true }),
+
+  closeWizard: () => set({ isOpen: false }),
+
+  // Reopen without resetting state — used by ProcessMonitorBar chip click
+  reopenWizard: () => set((s) => ({
+    isOpen: true,
+    wizardStep: s.ceremonyStatus === 'complete' ? 7 : 6,
+  })),
+
+  resetWizard: () =>
+    set({
+      wizardStep: 1,
+      analyzing: false,
+      strategy: null,
+      mission: '',
+      initialScope: '',
+      dbResult: null,
+      dbChoice: null,
+      archOptions: [],
+      selectedArch: null,
+      prefillResult: null,
+      requirements: {
+        MISSION_STATEMENT: '',
+        INITIAL_SCOPE: '',
+        TARGET_USERS: '',
+        DEPLOYMENT_TARGET: '',
+        TECHNICAL_CONSIDERATIONS: '',
+        TECHNICAL_EXCLUSIONS: '',
+        SECURITY_AND_COMPLIANCE_REQUIREMENTS: '',
+      },
+      progressLog: [],
+      ceremonyStatus: 'idle',
+      ceremonyResult: null,
+      ceremonyError: null,
+    }),
+
+  setStrategy: (strategy) => set({ strategy }),
+
+  setMission: (mission) => set({ mission }),
+
+  setInitialScope: (initialScope) => set({ initialScope }),
+
+  setDbResult: (dbResult) => set({ dbResult }),
+
+  setDbChoice: (dbChoice) => set({ dbChoice }),
+
+  setArchOptions: (archOptions) => set({ archOptions }),
+
+  setSelectedArch: (selectedArch) => set({ selectedArch }),
+
+  setPrefillResult: (prefillResult) => set({ prefillResult }),
+
+  setAnalyzing: (analyzing) => set({ analyzing }),
+
+  setWizardStep: (wizardStep) => set({ wizardStep }),
+
+  updateRequirement: (key, value) =>
+    set((state) => ({
+      requirements: { ...state.requirements, [key]: value },
+    })),
+
+  setRequirements: (requirements) => set({ requirements }),
+
+  // Called from App.jsx WebSocket message handler
+  appendProgress: (entry) =>
+    set((state) => ({
+      progressLog: [...state.progressLog, entry],
+    })),
+
+  setProgressLog: (entries) => set({ progressLog: Array.isArray(entries) ? entries : [] }),
+
+  appendMissionProgress: (entry) =>
+    set((state) => ({
+      missionProgressLog: [...state.missionProgressLog, entry],
+    })),
+
+  clearMissionProgress: () => set({ missionProgressLog: [] }),
+
+  setCeremonyStatus: (ceremonyStatus) => set({ ceremonyStatus }),
+
+  setCeremonyResult: (ceremonyResult) => set({ ceremonyResult }),
+
+  setCeremonyError: (ceremonyError) => set({ ceremonyError }),
+
+  setPaused: (isPaused) => set({ isPaused }),
+
+  setProcessId: (processId) => set({ processId }),
+
+  // Sync requirements from prefill result + step 1-2 data
+  applyPrefill: (prefillResult, strategy, mission, initialScope) => {
+    set((state) => ({
+      prefillResult,
+      requirements: {
+        ...state.requirements,
+        MISSION_STATEMENT: mission,
+        INITIAL_SCOPE: initialScope,
+        TARGET_USERS: prefillResult.TARGET_USERS || '',
+        DEPLOYMENT_TARGET: prefillResult.DEPLOYMENT_TARGET || '',
+        TECHNICAL_CONSIDERATIONS: prefillResult.TECHNICAL_CONSIDERATIONS || '',
+        SECURITY_AND_COMPLIANCE_REQUIREMENTS:
+          prefillResult.SECURITY_AND_COMPLIANCE_REQUIREMENTS || '',
+        // TECHNICAL_EXCLUSIONS stays as user entered (empty by default)
+      },
+    }));
+  },
+
+  // Initialize ceremony run
+  startRun: () =>
+    set({
+      ceremonyStatus: 'running',
+      progressLog: [],
+      ceremonyResult: null,
+      ceremonyError: null,
+    }),
+}));

package/kanban/client/src/store/filterStore.js

@@ -0,0 +1,201 @@
+import { create } from 'zustand';
+import { persist } from 'zustand/middleware';
+
+/**
+ * Filter Store
+ * Manages filters, grouping, and search state
+ * Persisted to localStorage
+ */
+export const useFilterStore = create(
+  persist(
+    (set, get) => ({
+      // State
+      typeFilters: {
+        epic: true,
+        story: true,
+        task: true,
+        subtask: true,
+      },
+      columnVisibility: {
+        Backlog: true,
+        Ready: true,
+        'In Progress': true,
+        Review: true,
+        Done: true,
+      },
+      searchQuery: '',
+      groupBy: 'epic', // 'status' | 'epic' | 'type' | 'category'
+
+      // Actions
+
+      /**
+       * Toggle type filter
+       * @param {string} type - Work item type
+       */
+      toggleTypeFilter: (type) => {
+        set((state) => ({
+          typeFilters: {
+            ...state.typeFilters,
+            [type]: !state.typeFilters[type],
+          },
+        }));
+      },
+
+      /**
+       * Set all type filters
+       * @param {boolean} value - Enable or disable all
+       */
+      setAllTypeFilters: (value) => {
+        set({
+          typeFilters: {
+            epic: value,
+            story: value,
+            task: value,
+            subtask: value,
+          },
+        });
+      },
+
+      /**
+       * Toggle column visibility
+       * @param {string} column - Column name
+       */
+      toggleColumnVisibility: (column) => {
+        set((state) => ({
+          columnVisibility: {
+            ...state.columnVisibility,
+            [column]: !state.columnVisibility[column],
+          },
+        }));
+      },
+
+      /**
+       * Set all column visibility
+       * @param {boolean} value - Show or hide all
+       */
+      setAllColumnsVisibility: (value) => {
+        set((state) => {
+          const updated = {};
+          Object.keys(state.columnVisibility).forEach((col) => {
+            updated[col] = value;
+          });
+          return { columnVisibility: updated };
+        });
+      },
+
+      /**
+       * Apply preset filter
+       * @param {string} preset - Preset name
+       */
+      applyPreset: (preset) => {
+        switch (preset) {
+          case 'all':
+            get().setAllColumnsVisibility(true);
+            get().setAllTypeFilters(true);
+            break;
+          case 'active':
+            set({
+              columnVisibility: {
+                Backlog: false,
+                Ready: true,
+                'In Progress': true,
+                Review: true,
+                Done: false,
+              },
+            });
+            break;
+          case 'hide-completed':
+            set({
+              columnVisibility: {
+                Backlog: true,
+                Ready: true,
+                'In Progress': true,
+                Review: true,
+                Done: false,
+              },
+            });
+            break;
+          default:
+            break;
+        }
+      },
+
+      /**
+       * Set search query
+       * @param {string} query - Search query
+       */
+      setSearchQuery: (query) => {
+        set({ searchQuery: query });
+      },
+
+      /**
+       * Clear search query
+       */
+      clearSearch: () => {
+        set({ searchQuery: '' });
+      },
+
+      /**
+       * Set grouping mode
+       * @param {string} mode - Grouping mode
+       */
+      setGroupBy: (mode) => {
+        set({ groupBy: mode });
+      },
+
+      /**
+       * Get active type filters
+       * @returns {string[]} Array of active types
+       */
+      getActiveTypes: () => {
+        const { typeFilters } = get();
+        return Object.entries(typeFilters)
+          .filter(([_, enabled]) => enabled)
+          .map(([type]) => type);
+      },
+
+      /**
+       * Get visible columns
+       * @returns {string[]} Array of visible column names
+       */
+      getVisibleColumns: () => {
+        const { columnVisibility } = get();
+        return Object.entries(columnVisibility)
+          .filter(([_, visible]) => visible)
+          .map(([column]) => column);
+      },
+
+      /**
+       * Reset all filters to defaults
+       */
+      resetFilters: () => {
+        set({
+          typeFilters: {
+            epic: true,
+            story: true,
+            task: true,
+            subtask: true,
+          },
+          columnVisibility: {
+            Backlog: true,
+            Ready: true,
+            'In Progress': true,
+            Review: true,
+            Done: true,
+          },
+          searchQuery: '',
+          groupBy: 'epic',
+        });
+      },
+    }),
+    {
+      name: 'avc-kanban-filters', // localStorage key
+      partialize: (state) => ({
+        // Only persist these fields
+        typeFilters: state.typeFilters,
+        columnVisibility: state.columnVisibility,
+        groupBy: state.groupBy,
+      }),
+    }
+  )
+);

package/kanban/client/src/store/kanbanStore.js

@@ -0,0 +1,123 @@
+import { create } from 'zustand';
+import { getWorkItems, getWorkItemsGrouped } from '../lib/api';
+
+/**
+ * Kanban Store
+ * Manages work items, loading states, and data fetching
+ */
+export const useKanbanStore = create((set, get) => ({
+  // State
+  workItems: [],
+  groupedItems: {},
+  loading: false,
+  error: null,
+  lastUpdated: null,
+  ceremonyActive: false, // true while sprint-planning is writing items — board is read-only
+
+  // Actions
+
+  /**
+   * Load all work items
+   * @param {object} filters - Optional filters
+   */
+  loadWorkItems: async (filters = {}) => {
+    set({ loading: true, error: null });
+
+    try {
+      const data = await getWorkItems(filters);
+      set({
+        workItems: data.items || [],
+        loading: false,
+        lastUpdated: Date.now(),
+        error: null,
+      });
+    } catch (error) {
+      set({
+        loading: false,
+        error: error.message,
+      });
+      console.error('Failed to load work items:', error);
+    }
+  },
+
+  /**
+   * Load work items grouped by column
+   */
+  loadGroupedItems: async () => {
+    set({ loading: true, error: null });
+
+    try {
+      const data = await getWorkItemsGrouped();
+      set({
+        groupedItems: data,
+        loading: false,
+        lastUpdated: Date.now(),
+        error: null,
+      });
+    } catch (error) {
+      set({
+        loading: false,
+        error: error.message,
+      });
+      console.error('Failed to load grouped items:', error);
+    }
+  },
+
+  /**
+   * Refresh work items (re-fetch from server)
+   */
+  refresh: async () => {
+    const { loadWorkItems } = get();
+    await loadWorkItems();
+  },
+
+  /**
+   * Update a single work item in the store
+   * Used for WebSocket updates
+   * @param {string} id - Work item ID
+   * @param {object} updatedItem - Updated work item data
+   */
+  updateWorkItem: (id, updatedItem) => {
+    set((state) => ({
+      workItems: state.workItems.map((item) =>
+        item.id === id ? { ...item, ...updatedItem } : item
+      ),
+    }));
+  },
+
+  /**
+   * Add a new work item to the store
+   * Used for WebSocket updates
+   * @param {object} newItem - New work item
+   */
+  addWorkItem: (newItem) => {
+    set((state) => ({
+      workItems: [...state.workItems, newItem],
+    }));
+  },
+
+  /**
+   * Remove a work item from the store
+   * Used for WebSocket updates
+   * @param {string} id - Work item ID to remove
+   */
+  removeWorkItem: (id) => {
+    set((state) => ({
+      workItems: state.workItems.filter((item) => item.id !== id),
+    }));
+  },
+
+  /**
+   * Clear error state
+   */
+  clearError: () => {
+    set({ error: null });
+  },
+
+  /**
+   * Set ceremony active state (read-only mode for work items)
+   */
+  setCeremonyActive: (active) => {
+    set({ ceremonyActive: active });
+  },
+}));