flock-core 0.5.0b28__py3-none-any.whl → 0.5.0b51__py3-none-any.whl

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

@@ -0,0 +1,242 @@
+import { describe, it, expect, beforeEach } from 'vitest';
+import { useFilterStore } from './filterStore';
+
+describe('filterStore', () => {
+  beforeEach(() => {
+    const store = useFilterStore.getState();
+    store.clearFilters();
+    store.updateAvailableCorrelationIds([]);
+  });
+
+  describe('Initial State', () => {
+    it('should have no correlation ID selected', () => {
+      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.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', () => {
+      const store = useFilterStore.getState();
+      store.setTimeRange({ preset: 'last5min' });
+
+      expect(useFilterStore.getState().timeRange).toEqual({ preset: 'last5min' });
+    });
+
+    it('should set custom time range', () => {
+      const store = useFilterStore.getState();
+      const customRange = {
+        preset: 'custom' as const,
+        start: Date.now() - 3600000,
+        end: Date.now(),
+      };
+      store.setTimeRange(customRange);
+
+      expect(useFilterStore.getState().timeRange).toEqual(customRange);
+    });
+  });
+
+  describe('clearFilters', () => {
+    it('should reset all filters to defaults', () => {
+      const store = useFilterStore.getState();
+      store.setCorrelationId('test-id');
+      store.setTimeRange({ preset: 'last1hour' });
+
+      store.clearFilters();
+
+      const state = useFilterStore.getState();
+      expect(state.correlationId).toBeNull();
+      expect(state.timeRange).toEqual({ preset: 'last10min' });
+    });
+  });
+
+  describe('updateAvailableCorrelationIds', () => {
+    it('should update available correlation IDs with metadata', () => {
+      const store = useFilterStore.getState();
+      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);
+
+      const state = useFilterStore.getState();
+      expect(state.availableCorrelationIds).toHaveLength(50);
+    });
+
+    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);
+
+      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');
+    });
+  });
+
+  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', () => {
+      const store = useFilterStore.getState();
+      store.setTimeRange({ preset: 'last5min' });
+
+      const activeFilters = store.getActiveFilters();
+      expect(activeFilters).toHaveLength(1);
+      expect(activeFilters[0]).toEqual({
+        type: 'timeRange',
+        value: { preset: 'last5min' },
+        label: 'Time: Last 5 min',
+      });
+    });
+
+    it('should return custom time range filter with formatted dates', () => {
+      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: /);
+    });
+
+    it('should return both filters when both are active', () => {
+      const store = useFilterStore.getState();
+      store.setCorrelationId('test-123');
+      store.setTimeRange({ preset: 'last1hour' });
+
+      const activeFilters = store.getActiveFilters();
+      expect(activeFilters).toHaveLength(2);
+    });
+  });
+
+  describe('removeFilter', () => {
+    it('should remove correlation ID filter', () => {
+      const store = useFilterStore.getState();
+      store.setCorrelationId('test-123');
+
+      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 state = useFilterStore.getState();
+      expect(state.correlationId).toBeNull();
+      expect(state.timeRange).toEqual({ preset: 'last1hour' });
+    });
+  });
+});

flock/frontend/src/store/filterStore.ts

@@ -0,0 +1,103 @@
+import { create } from 'zustand';
+import { devtools } from 'zustand/middleware';
+import { TimeRange, CorrelationIdMetadata } from '../types/filters';
+
+export interface ActiveFilter {
+  type: 'correlationId' | 'timeRange';
+  value: string | TimeRange;
+  label: string;
+}
+
+interface FilterState {
+  // Active filters
+  correlationId: string | null;
+  timeRange: TimeRange;
+
+  // Autocomplete data
+  availableCorrelationIds: CorrelationIdMetadata[];
+
+  // Actions
+  setCorrelationId: (id: string | null) => void;
+  setTimeRange: (range: TimeRange) => void;
+  clearFilters: () => void;
+
+  // Update available IDs
+  updateAvailableCorrelationIds: (metadata: CorrelationIdMetadata[]) => void;
+
+  // Get active filters
+  getActiveFilters: () => ActiveFilter[];
+
+  // Remove specific filter
+  removeFilter: (type: 'correlationId' | 'timeRange') => void;
+}
+
+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 === 'custom' && range.start && range.end) {
+    const startDate = new Date(range.start).toLocaleString();
+    const endDate = new Date(range.end).toLocaleString();
+    return `${startDate} - ${endDate}`;
+  }
+  return 'Unknown';
+};
+
+export const useFilterStore = create<FilterState>()(
+  devtools(
+    (set, get) => ({
+      correlationId: null,
+      timeRange: { preset: 'last10min' },
+      availableCorrelationIds: [],
+
+      setCorrelationId: (id) => set({ correlationId: id }),
+      setTimeRange: (range) => set({ timeRange: range }),
+      clearFilters: () =>
+        set({
+          correlationId: null,
+          timeRange: { preset: 'last10min' },
+        }),
+
+      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),
+        });
+      },
+
+      getActiveFilters: () => {
+        const state = get();
+        const filters: ActiveFilter[] = [];
+
+        if (state.correlationId) {
+          filters.push({
+            type: 'correlationId',
+            value: state.correlationId,
+            label: `Correlation ID: ${state.correlationId}`,
+          });
+        }
+
+        // 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)}`,
+          });
+        }
+
+        return filters;
+      },
+
+      removeFilter: (type) => {
+        if (type === 'correlationId') {
+          set({ correlationId: null });
+        } else if (type === 'timeRange') {
+          set({ timeRange: { preset: 'last10min' } });
+        }
+      },
+    }),
+    { name: 'filterStore' }
+  )
+);

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

@@ -0,0 +1,186 @@
+import { describe, it, expect, beforeEach } from 'vitest';
+import { useGraphStore } from './graphStore';
+import { Agent, Message } from '../types/graph';
+
+describe('graphStore', () => {
+  beforeEach(() => {
+    // Reset store before each test
+    useGraphStore.setState({
+      agents: new Map(),
+      messages: new Map(),
+      events: [],
+      nodes: [],
+      edges: [],
+    });
+  });
+
+  it('should add an agent', () => {
+    const agent: Agent = {
+      id: 'test-agent',
+      name: 'test-agent',
+      status: 'idle',
+      subscriptions: ['Movie'],
+      lastActive: Date.now(),
+      sentCount: 0,
+      recvCount: 0,
+    };
+
+    useGraphStore.getState().addAgent(agent);
+
+    const agents = useGraphStore.getState().agents;
+    expect(agents.size).toBe(1);
+    expect(agents.get('test-agent')).toEqual(agent);
+  });
+
+  it('should update an agent', () => {
+    const agent: Agent = {
+      id: 'test-agent',
+      name: 'test-agent',
+      status: 'idle',
+      subscriptions: [],
+      lastActive: Date.now(),
+      sentCount: 0,
+      recvCount: 0,
+    };
+
+    useGraphStore.getState().addAgent(agent);
+    useGraphStore.getState().updateAgent('test-agent', { status: 'running', sentCount: 5 });
+
+    const updatedAgent = useGraphStore.getState().agents.get('test-agent');
+    expect(updatedAgent?.status).toBe('running');
+    expect(updatedAgent?.sentCount).toBe(5);
+  });
+
+  it('should add a message', () => {
+    const message: Message = {
+      id: 'msg-1',
+      type: 'Movie',
+      payload: { title: 'Test Movie' },
+      timestamp: Date.now(),
+      correlationId: 'corr-1',
+      producedBy: 'movie',
+    };
+
+    useGraphStore.getState().addMessage(message);
+
+    const messages = useGraphStore.getState().messages;
+    const events = useGraphStore.getState().events;
+    expect(messages.size).toBe(1);
+    expect(messages.get('msg-1')).toEqual(message);
+    expect(events.length).toBe(1);
+    expect(events[0]).toEqual(message);
+  });
+
+  it('should limit events to 100', () => {
+    for (let i = 0; i < 120; i++) {
+      const message: Message = {
+        id: `msg-${i}`,
+        type: 'Movie',
+        payload: { index: i },
+        timestamp: Date.now(),
+        correlationId: 'corr-1',
+        producedBy: 'movie',
+      };
+      useGraphStore.getState().addMessage(message);
+    }
+
+    const events = useGraphStore.getState().events;
+    expect(events.length).toBe(100);
+  });
+
+  it('should batch update agents and messages', () => {
+    const agents: Agent[] = [
+      {
+        id: 'agent-1',
+        name: 'agent-1',
+        status: 'idle',
+        subscriptions: [],
+        lastActive: Date.now(),
+        sentCount: 0,
+        recvCount: 0,
+      },
+      {
+        id: 'agent-2',
+        name: 'agent-2',
+        status: 'running',
+        subscriptions: [],
+        lastActive: Date.now(),
+        sentCount: 0,
+        recvCount: 0,
+      },
+    ];
+
+    const messages: Message[] = [
+      {
+        id: 'msg-1',
+        type: 'Movie',
+        payload: {},
+        timestamp: Date.now(),
+        correlationId: 'corr-1',
+        producedBy: 'agent-1',
+      },
+    ];
+
+    useGraphStore.getState().batchUpdate({ agents, messages });
+
+    expect(useGraphStore.getState().agents.size).toBe(2);
+    expect(useGraphStore.getState().messages.size).toBe(1);
+    expect(useGraphStore.getState().events.length).toBe(1);
+  });
+
+  it('should generate agent view graph', () => {
+    const agents: Agent[] = [
+      {
+        id: 'movie',
+        name: 'movie',
+        status: 'idle',
+        subscriptions: [],
+        lastActive: Date.now(),
+        sentCount: 2,
+        recvCount: 0,
+        position: { x: 0, y: 0 },
+      },
+      {
+        id: 'tagline',
+        name: 'tagline',
+        status: 'idle',
+        subscriptions: ['Movie'],
+        lastActive: Date.now(),
+        sentCount: 0,
+        recvCount: 2,
+        position: { x: 200, y: 0 },
+      },
+    ];
+
+    const messages: Message[] = [
+      {
+        id: 'msg-1',
+        type: 'Movie',
+        payload: {},
+        timestamp: Date.now(),
+        correlationId: 'corr-1',
+        producedBy: 'movie',
+      },
+      {
+        id: 'msg-2',
+        type: 'Movie',
+        payload: {},
+        timestamp: Date.now(),
+        correlationId: 'corr-1',
+        producedBy: 'movie',
+      },
+    ];
+
+    useGraphStore.getState().batchUpdate({ agents, messages });
+    // Phase 11 fix: Record consumption to populate consumed_by field
+    useGraphStore.getState().recordConsumption(['msg-1', 'msg-2'], 'tagline');
+    useGraphStore.getState().generateAgentViewGraph();
+
+    const nodes = useGraphStore.getState().nodes;
+    const edges = useGraphStore.getState().edges;
+
+    expect(nodes.length).toBe(2);
+    expect(nodes[0]?.type).toBe('agent');
+    expect(edges.length).toBeGreaterThan(0);
+  });
+});