flock-core 0.5.0b65__py3-none-any.whl → 0.5.0b70__py3-none-any.whl

flock/frontend/src/store/filterStore.test.ts

@@ -1,242 +1,162 @@
 import { describe, it, expect, beforeEach } from 'vitest';
 import { useFilterStore } from './filterStore';
+import type { FilterFacets, FilterSnapshot } from '../types/filters';
 
 describe('filterStore', () => {
   beforeEach(() => {
-    const store = useFilterStore.getState();
-    store.clearFilters();
-    store.updateAvailableCorrelationIds([]);
+    useFilterStore.setState({
+      correlationId: null,
+      timeRange: { preset: 'last10min' },
+      selectedArtifactTypes: [],
+      selectedProducers: [],
+      selectedTags: [],
+      selectedVisibility: [],
+      availableCorrelationIds: [],
+      availableArtifactTypes: [],
+      availableProducers: [],
+      availableTags: [],
+      availableVisibility: [],
+      summary: null,
+      savedFilters: [],
+    });
   });
 
-  describe('Initial State', () => {
-    it('should have no correlation ID selected', () => {
+  describe('initial state', () => {
+    it('should have defaults set', () => {
       const state = useFilterStore.getState();
       expect(state.correlationId).toBeNull();
-    });
-
-    it('should have default time range of last 10 minutes', () => {
-      const state = useFilterStore.getState();
       expect(state.timeRange).toEqual({ preset: 'last10min' });
-    });
-
-    it('should have empty available correlation IDs', () => {
-      const state = useFilterStore.getState();
+      expect(state.selectedArtifactTypes).toEqual([]);
       expect(state.availableCorrelationIds).toEqual([]);
     });
   });
 
-  describe('setCorrelationId', () => {
-    it('should set correlation ID', () => {
-      const store = useFilterStore.getState();
-      store.setCorrelationId('test-correlation-id');
-
-      expect(useFilterStore.getState().correlationId).toBe('test-correlation-id');
-    });
-
-    it('should clear correlation ID when set to null', () => {
-      const store = useFilterStore.getState();
-      store.setCorrelationId('test-id');
-      store.setCorrelationId(null);
-
-      expect(useFilterStore.getState().correlationId).toBeNull();
-    });
-  });
-
-  describe('setTimeRange', () => {
-    it('should set time range preset', () => {
+  describe('mutators', () => {
+    it('should update correlation id and time range', () => {
       const store = useFilterStore.getState();
+      store.setCorrelationId('abc');
       store.setTimeRange({ preset: 'last5min' });
-
+      expect(useFilterStore.getState().correlationId).toBe('abc');
       expect(useFilterStore.getState().timeRange).toEqual({ preset: 'last5min' });
     });
 
-    it('should set custom time range', () => {
+    it('should update multi-select filters', () => {
       const store = useFilterStore.getState();
-      const customRange = {
-        preset: 'custom' as const,
-        start: Date.now() - 3600000,
-        end: Date.now(),
-      };
-      store.setTimeRange(customRange);
+      store.setArtifactTypes(['TypeB', 'TypeA']);
+      store.setProducers(['b', 'a']);
+      store.setTags(['beta']);
+      store.setVisibility(['Private', 'Public']);
 
-      expect(useFilterStore.getState().timeRange).toEqual(customRange);
+      const state = useFilterStore.getState();
+      expect(state.selectedArtifactTypes).toEqual(['TypeA', 'TypeB']);
+      expect(state.selectedProducers).toEqual(['a', 'b']);
+      expect(state.selectedTags).toEqual(['beta']);
+      expect(state.selectedVisibility).toEqual(['Private', 'Public']);
     });
-  });
 
-  describe('clearFilters', () => {
-    it('should reset all filters to defaults', () => {
+    it('should clear filters to defaults', () => {
       const store = useFilterStore.getState();
-      store.setCorrelationId('test-id');
-      store.setTimeRange({ preset: 'last1hour' });
-
+      store.setCorrelationId('abc');
+      store.setArtifactTypes(['TypeA']);
+      store.setTags(['x']);
       store.clearFilters();
 
       const state = useFilterStore.getState();
       expect(state.correlationId).toBeNull();
+      expect(state.selectedArtifactTypes).toEqual([]);
+      expect(state.selectedTags).toEqual([]);
       expect(state.timeRange).toEqual({ preset: 'last10min' });
     });
-  });
 
-  describe('updateAvailableCorrelationIds', () => {
-    it('should update available correlation IDs with metadata', () => {
-      const store = useFilterStore.getState();
+    it('should update available correlation ids', () => {
       const now = Date.now();
-      const metadata = [
-        {
-          correlation_id: 'abc123',
-          first_seen: now - 120000,
-          artifact_count: 5,
-          run_count: 2,
-        },
-        {
-          correlation_id: 'def456',
-          first_seen: now - 60000,
-          artifact_count: 3,
-          run_count: 1,
-        },
-      ];
-
-      store.updateAvailableCorrelationIds(metadata);
-
-      const state = useFilterStore.getState();
-      // Should be sorted by most recent first
-      expect(state.availableCorrelationIds).toHaveLength(2);
-      expect(state.availableCorrelationIds[0]?.correlation_id).toBe('def456');
-      expect(state.availableCorrelationIds[1]?.correlation_id).toBe('abc123');
-    });
-
-    it('should limit to 50 correlation IDs', () => {
-      const store = useFilterStore.getState();
-      const metadata = Array.from({ length: 100 }, (_, i) => ({
-        correlation_id: `id-${i}`,
-        first_seen: Date.now() - i * 1000,
-        artifact_count: i,
-        run_count: 1,
-      }));
-
-      store.updateAvailableCorrelationIds(metadata);
-
+      useFilterStore
+        .getState()
+        .updateAvailableCorrelationIds([
+          { correlation_id: 'old', first_seen: now - 10_000, artifact_count: 1, run_count: 1 },
+          { correlation_id: 'new', first_seen: now - 1_000, artifact_count: 2, run_count: 2 },
+        ]);
       const state = useFilterStore.getState();
-      expect(state.availableCorrelationIds).toHaveLength(50);
+      expect(state.availableCorrelationIds.map((m) => m.correlation_id)).toEqual(['new', 'old']);
     });
 
-    it('should sort by most recent first', () => {
-      const store = useFilterStore.getState();
-      const now = Date.now();
-      const metadata = [
-        {
-          correlation_id: 'oldest',
-          first_seen: now - 300000,
-          artifact_count: 1,
-          run_count: 1,
-        },
-        {
-          correlation_id: 'newest',
-          first_seen: now - 10000,
-          artifact_count: 2,
-          run_count: 1,
-        },
-        {
-          correlation_id: 'middle',
-          first_seen: now - 120000,
-          artifact_count: 3,
-          run_count: 1,
-        },
-      ];
-
-      store.updateAvailableCorrelationIds(metadata);
-
+    it('should update available facets', () => {
+      const facets: FilterFacets = {
+        artifactTypes: ['TypeB', 'TypeA'],
+        producers: ['b', 'a'],
+        tags: ['beta', 'alpha'],
+        visibilities: ['Private', 'Public'],
+      };
+      useFilterStore.getState().updateAvailableFacets(facets);
       const state = useFilterStore.getState();
-      expect(state.availableCorrelationIds[0]?.correlation_id).toBe('newest');
-      expect(state.availableCorrelationIds[1]?.correlation_id).toBe('middle');
-      expect(state.availableCorrelationIds[2]?.correlation_id).toBe('oldest');
+      expect(state.availableArtifactTypes).toEqual(['TypeA', 'TypeB']);
+      expect(state.availableProducers).toEqual(['a', 'b']);
+      expect(state.availableTags).toEqual(['alpha', 'beta']);
+      expect(state.availableVisibility).toEqual(['Private', 'Public']);
     });
   });
 
-  describe('getActiveFilters', () => {
-    it('should return empty array when no filters active', () => {
-      const store = useFilterStore.getState();
-      const activeFilters = store.getActiveFilters();
-      expect(activeFilters).toEqual([]);
-    });
-
-    it('should return correlation ID filter when set', () => {
-      const store = useFilterStore.getState();
-      store.setCorrelationId('test-123');
-
-      const activeFilters = store.getActiveFilters();
-      expect(activeFilters).toHaveLength(1);
-      expect(activeFilters[0]).toEqual({
-        type: 'correlationId',
-        value: 'test-123',
-        label: 'Correlation ID: test-123',
-      });
-    });
-
-    it('should return time range filter when not default', () => {
+  describe('active filters', () => {
+    it('should return active filters across selections', () => {
       const store = useFilterStore.getState();
+      store.setCorrelationId('abc');
       store.setTimeRange({ preset: 'last5min' });
+      store.setArtifactTypes(['TypeA']);
+      store.setProducers(['agent1']);
+      store.setTags(['urgent']);
+      store.setVisibility(['Public']);
 
-      const activeFilters = store.getActiveFilters();
-      expect(activeFilters).toHaveLength(1);
-      expect(activeFilters[0]).toEqual({
-        type: 'timeRange',
-        value: { preset: 'last5min' },
-        label: 'Time: Last 5 min',
-      });
+      const active = store.getActiveFilters();
+      expect(active).toHaveLength(6);
+      expect(active.map((f) => f.type)).toContain('visibility');
     });
 
-    it('should return custom time range filter with formatted dates', () => {
+    it('should remove individual filters', () => {
       const store = useFilterStore.getState();
-      const start = Date.now() - 3600000;
-      const end = Date.now();
-      store.setTimeRange({ preset: 'custom', start, end });
-
-      const activeFilters = store.getActiveFilters();
-      expect(activeFilters).toHaveLength(1);
-      expect(activeFilters[0]?.type).toBe('timeRange');
-      expect(activeFilters[0]?.label).toMatch(/^Time: /);
-    });
+      store.setArtifactTypes(['TypeA', 'TypeB']);
 
-    it('should return both filters when both are active', () => {
-      const store = useFilterStore.getState();
-      store.setCorrelationId('test-123');
-      store.setTimeRange({ preset: 'last1hour' });
+      const [firstFilter] = store.getActiveFilters().filter((f) => f.type === 'artifactTypes');
+      expect(firstFilter?.value).toBe('TypeA');
 
-      const activeFilters = store.getActiveFilters();
-      expect(activeFilters).toHaveLength(2);
+      useFilterStore.getState().removeFilter(firstFilter!);
+      expect(useFilterStore.getState().selectedArtifactTypes).toEqual(['TypeB']);
     });
   });
 
-  describe('removeFilter', () => {
-    it('should remove correlation ID filter', () => {
+  describe('snapshots', () => {
+    it('should export and reapply filter snapshots', () => {
       const store = useFilterStore.getState();
-      store.setCorrelationId('test-123');
+      store.setCorrelationId('snapshot');
+      store.setArtifactTypes(['TypeA']);
 
-      store.removeFilter('correlationId');
-
-      expect(useFilterStore.getState().correlationId).toBeNull();
-    });
-
-    it('should reset time range filter to default', () => {
-      const store = useFilterStore.getState();
-      store.setTimeRange({ preset: 'last1hour' });
-
-      store.removeFilter('timeRange');
-
-      expect(useFilterStore.getState().timeRange).toEqual({ preset: 'last10min' });
-    });
-
-    it('should not affect other filters', () => {
-      const store = useFilterStore.getState();
-      store.setCorrelationId('test-123');
-      store.setTimeRange({ preset: 'last1hour' });
-
-      store.removeFilter('correlationId');
+      const snapshot = store.getFilterSnapshot();
+      useFilterStore.getState().clearFilters();
+      useFilterStore.getState().applyFilterSnapshot(snapshot);
 
       const state = useFilterStore.getState();
-      expect(state.correlationId).toBeNull();
-      expect(state.timeRange).toEqual({ preset: 'last1hour' });
+      expect(state.correlationId).toBe('snapshot');
+      expect(state.selectedArtifactTypes).toEqual(['TypeA']);
+    });
+
+    it('should manage saved filters list', () => {
+      const snapshot: FilterSnapshot = {
+        correlationId: null,
+        timeRange: { preset: 'last10min' },
+        artifactTypes: [],
+        producers: [],
+        tags: [],
+        visibility: [],
+      };
+      useFilterStore.getState().addSavedFilter({
+        filter_id: '1',
+        name: 'Default',
+        created_at: Date.now(),
+        filters: snapshot,
+      });
+
+      expect(useFilterStore.getState().savedFilters).toHaveLength(1);
+      useFilterStore.getState().removeSavedFilter('1');
+      expect(useFilterStore.getState().savedFilters).toHaveLength(0);
     });
   });
 });

flock/frontend/src/store/filterStore.ts

@@ -1,72 +1,169 @@
 import { create } from 'zustand';
 import { devtools } from 'zustand/middleware';
-import { TimeRange, CorrelationIdMetadata } from '../types/filters';
+import {
+  TimeRange,
+  CorrelationIdMetadata,
+  FilterFacets,
+  ArtifactSummary,
+  SavedFilterMeta,
+  FilterSnapshot,
+} from '../types/filters';
+
+export type ActiveFilterType =
+  | 'correlationId'
+  | 'timeRange'
+  | 'artifactTypes'
+  | 'producers'
+  | 'tags'
+  | 'visibility';
 
 export interface ActiveFilter {
-  type: 'correlationId' | 'timeRange';
+  type: ActiveFilterType;
   value: string | TimeRange;
   label: string;
 }
 
 interface FilterState {
-  // Active filters
   correlationId: string | null;
   timeRange: TimeRange;
-
-  // Autocomplete data
+  selectedArtifactTypes: string[];
+  selectedProducers: string[];
+  selectedTags: string[];
+  selectedVisibility: string[];
   availableCorrelationIds: CorrelationIdMetadata[];
+  availableArtifactTypes: string[];
+  availableProducers: string[];
+  availableTags: string[];
+  availableVisibility: string[];
+  summary: ArtifactSummary | null;
+  savedFilters: SavedFilterMeta[];
 
-  // Actions
   setCorrelationId: (id: string | null) => void;
   setTimeRange: (range: TimeRange) => void;
+  setArtifactTypes: (types: string[]) => void;
+  setProducers: (producers: string[]) => void;
+  setTags: (tags: string[]) => void;
+  setVisibility: (visibility: string[]) => void;
   clearFilters: () => void;
 
-  // Update available IDs
   updateAvailableCorrelationIds: (metadata: CorrelationIdMetadata[]) => void;
+  updateAvailableFacets: (facets: FilterFacets) => void;
+  setSummary: (summary: ArtifactSummary | null) => void;
 
-  // Get active filters
-  getActiveFilters: () => ActiveFilter[];
+  setSavedFilters: (filters: SavedFilterMeta[]) => void;
+  addSavedFilter: (filter: SavedFilterMeta) => void;
+  removeSavedFilter: (filterId: string) => void;
 
-  // Remove specific filter
-  removeFilter: (type: 'correlationId' | 'timeRange') => void;
+  getActiveFilters: () => ActiveFilter[];
+  removeFilter: (filter: ActiveFilter) => void;
+  getFilterSnapshot: () => FilterSnapshot;
+  applyFilterSnapshot: (snapshot: FilterSnapshot) => void;
 }
 
-const formatTimeRange = (range: TimeRange): string => {
+const defaultTimeRange: TimeRange = { preset: 'last10min' };
+
+export const formatTimeRange = (range: TimeRange): string => {
   if (range.preset === 'last5min') return 'Last 5 min';
   if (range.preset === 'last10min') return 'Last 10 min';
   if (range.preset === 'last1hour') return 'Last hour';
+  if (range.preset === 'all') return 'All time';
   if (range.preset === 'custom' && range.start && range.end) {
     const startDate = new Date(range.start).toLocaleString();
     const endDate = new Date(range.end).toLocaleString();
     return `${startDate} - ${endDate}`;
   }
-  return 'Unknown';
+  if (range.preset === 'custom') {
+    return 'Custom range';
+  }
+  return 'Last 10 min';
 };
 
+const uniqueSorted = (items: string[]) => Array.from(new Set(items)).sort((a, b) => a.localeCompare(b));
+
 export const useFilterStore = create<FilterState>()(
   devtools(
     (set, get) => ({
       correlationId: null,
-      timeRange: { preset: 'last10min' },
+      timeRange: defaultTimeRange,
+      selectedArtifactTypes: [],
+      selectedProducers: [],
+      selectedTags: [],
+      selectedVisibility: [],
       availableCorrelationIds: [],
+      availableArtifactTypes: [],
+      availableProducers: [],
+      availableTags: [],
+      availableVisibility: [],
+      summary: null,
+      savedFilters: [],
 
       setCorrelationId: (id) => set({ correlationId: id }),
       setTimeRange: (range) => set({ timeRange: range }),
+      setArtifactTypes: (types) => set({ selectedArtifactTypes: uniqueSorted(types) }),
+      setProducers: (producers) => set({ selectedProducers: uniqueSorted(producers) }),
+      setTags: (tags) => set({ selectedTags: uniqueSorted(tags) }),
+      setVisibility: (visibility) => set({ selectedVisibility: uniqueSorted(visibility) }),
       clearFilters: () =>
         set({
           correlationId: null,
-          timeRange: { preset: 'last10min' },
+          timeRange: defaultTimeRange,
+          selectedArtifactTypes: [],
+          selectedProducers: [],
+          selectedTags: [],
+          selectedVisibility: [],
         }),
 
       updateAvailableCorrelationIds: (metadata) => {
-        // Sort by most recent first
         const sorted = [...metadata].sort((a, b) => b.first_seen - a.first_seen);
         set({
           availableCorrelationIds: sorted.slice(0, 50),
         });
       },
 
+      updateAvailableFacets: (facets) =>
+        set({
+          availableArtifactTypes: uniqueSorted(facets.artifactTypes),
+          availableProducers: uniqueSorted(facets.producers),
+          availableTags: uniqueSorted(facets.tags),
+          availableVisibility: uniqueSorted(facets.visibilities),
+        }),
+
+      setSummary: (summary) => set({ summary }),
+
+      setSavedFilters: (filters) => set({ savedFilters: filters }),
+      addSavedFilter: (filter) =>
+        set((state) => ({
+          savedFilters: [...state.savedFilters.filter((f) => f.filter_id !== filter.filter_id), filter],
+        })),
+      removeSavedFilter: (filterId) =>
+        set((state) => ({
+          savedFilters: state.savedFilters.filter((f) => f.filter_id !== filterId),
+        })),
+
+      getFilterSnapshot: () => {
+        const state = get();
+        return {
+          correlationId: state.correlationId,
+          timeRange: state.timeRange,
+          artifactTypes: [...state.selectedArtifactTypes],
+          producers: [...state.selectedProducers],
+          tags: [...state.selectedTags],
+          visibility: [...state.selectedVisibility],
+        };
+      },
+
+      applyFilterSnapshot: (snapshot) =>
+        set({
+          correlationId: snapshot.correlationId,
+          timeRange: snapshot.timeRange,
+          selectedArtifactTypes: uniqueSorted(snapshot.artifactTypes),
+          selectedProducers: uniqueSorted(snapshot.producers),
+          selectedTags: uniqueSorted(snapshot.tags),
+          selectedVisibility: uniqueSorted(snapshot.visibility),
+        }),
+
       getActiveFilters: () => {
+        console.debug('[filterStore] computing active filters', { correlationId: get().correlationId, timeRange: get().timeRange });
         const state = get();
         const filters: ActiveFilter[] = [];
 
@@ -78,24 +175,74 @@ export const useFilterStore = create<FilterState>()(
           });
         }
 
-        // Only add time range if it's not the default
-        if (state.timeRange.preset !== 'last10min') {
+        filters.push({
+          type: 'timeRange',
+          value: state.timeRange,
+          label: `Time: ${formatTimeRange(state.timeRange)}`,
+        });
+
+        state.selectedArtifactTypes.forEach((type) => {
           filters.push({
-            type: 'timeRange',
-            value: state.timeRange,
-            label: `Time: ${formatTimeRange(state.timeRange)}`,
+            type: 'artifactTypes',
+            value: type,
+            label: `Type: ${type}`,
           });
-        }
+        });
+
+        state.selectedProducers.forEach((producer) => {
+          filters.push({
+            type: 'producers',
+            value: producer,
+            label: `Producer: ${producer}`,
+          });
+        });
+
+        state.selectedTags.forEach((tag) => {
+          filters.push({
+            type: 'tags',
+            value: tag,
+            label: `Tag: ${tag}`,
+          });
+        });
+
+        state.selectedVisibility.forEach((kind) => {
+          filters.push({
+            type: 'visibility',
+            value: kind,
+            label: `Visibility: ${kind}`,
+          });
+        });
 
         return filters;
       },
 
-      removeFilter: (type) => {
-        if (type === 'correlationId') {
+      removeFilter: (filter) => {
+        if (filter.type === 'correlationId') {
           set({ correlationId: null });
-        } else if (type === 'timeRange') {
-          set({ timeRange: { preset: 'last10min' } });
+          return;
+        }
+        if (filter.type === 'timeRange') {
+          set({ timeRange: defaultTimeRange });
+          return;
         }
+        if (typeof filter.value !== 'string') {
+          return;
+        }
+        set((state) => {
+          if (filter.type === 'artifactTypes') {
+            return { selectedArtifactTypes: state.selectedArtifactTypes.filter((item) => item !== filter.value) };
+          }
+          if (filter.type === 'producers') {
+            return { selectedProducers: state.selectedProducers.filter((item) => item !== filter.value) };
+          }
+          if (filter.type === 'tags') {
+            return { selectedTags: state.selectedTags.filter((item) => item !== filter.value) };
+          }
+          if (filter.type === 'visibility') {
+            return { selectedVisibility: state.selectedVisibility.filter((item) => item !== filter.value) };
+          }
+          return {};
+        });
       },
     }),
     { name: 'filterStore' }

flock/frontend/src/store/graphStore.test.ts

@@ -9,6 +9,8 @@ describe('graphStore', () => {
       agents: new Map(),
       messages: new Map(),
       events: [],
+      runs: new Map(),
+      consumptions: new Map(),
       nodes: [],
       edges: [],
     });
@@ -183,4 +185,21 @@ describe('graphStore', () => {
     expect(nodes[0]?.type).toBe('agent');
     expect(edges.length).toBeGreaterThan(0);
   });
+
+  it('should hydrate consumptions from message payload', () => {
+    const message: Message = {
+      id: 'msg-embed',
+      type: 'Recipe',
+      payload: {},
+      timestamp: Date.now(),
+      correlationId: 'corr-embed',
+      producedBy: 'chef',
+      consumedBy: ['critic'],
+    };
+
+    useGraphStore.getState().batchUpdate({ messages: [message] });
+
+    const state = useGraphStore.getState();
+    expect(state.consumptions.get('msg-embed')).toEqual(['critic']);
+  });
 });