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

flock/frontend/src/services/api.ts

@@ -7,6 +7,8 @@
  * Base URL defaults to /api for same-origin requests.
  */
 
+import type { ArtifactSummary } from '../types/filters';
+
 const BASE_URL = import.meta.env.VITE_API_BASE_URL || '/api';
 
 export interface ArtifactType {
@@ -47,6 +49,56 @@ export interface AgentsResponse {
   agents: Agent[];
 }
 
+export interface ArtifactListItem {
+  id: string;
+  type: string;
+  payload: Record<string, any>;
+  produced_by: string;
+  created_at: string;
+  correlation_id: string | null;
+  partition_key: string | null;
+  tags: string[];
+  visibility: { kind: string; [key: string]: any };
+  visibility_kind?: string;
+  version?: number;
+  consumptions?: ArtifactConsumption[];
+  consumed_by?: string[];
+}
+
+export interface ArtifactConsumption {
+  artifact_id: string;
+  consumer: string;
+  run_id: string | null;
+  correlation_id: string | null;
+  consumed_at: string;
+}
+
+export interface ArtifactListResponse {
+  items: ArtifactListItem[];
+  pagination: {
+    limit: number;
+    offset: number;
+    total: number;
+  };
+}
+
+export interface ArtifactSummaryResponse {
+  summary: ArtifactSummary;
+}
+
+export interface ArtifactQueryOptions {
+  types?: string[];
+  producers?: string[];
+  correlationId?: string | null;
+  tags?: string[];
+  visibility?: string[];
+  from?: string;
+  to?: string;
+  limit?: number;
+  offset?: number;
+  embedMeta?: boolean;
+}
+
 export interface ErrorResponse {
   error: string;
   message: string;
@@ -211,3 +263,91 @@ export async function invokeAgent(agentName: string): Promise<InvokeResponse> {
     throw new Error('Failed to connect to API server');
   }
 }
+
+const buildArtifactQuery = (options: ArtifactQueryOptions): string => {
+  const params = new URLSearchParams();
+
+  options.types?.forEach((value) => params.append('type', value));
+  options.producers?.forEach((value) => params.append('produced_by', value));
+  options.tags?.forEach((value) => params.append('tag', value));
+  options.visibility?.forEach((value) => params.append('visibility', value));
+
+  if (options.correlationId) {
+    params.append('correlation_id', options.correlationId);
+  }
+  if (options.from) {
+    params.append('from', options.from);
+  }
+  if (options.to) {
+    params.append('to', options.to);
+  }
+  if (typeof options.limit === 'number') {
+    params.append('limit', String(options.limit));
+  }
+  if (typeof options.offset === 'number') {
+    params.append('offset', String(options.offset));
+  }
+  if (options.embedMeta) {
+    params.append('embed_meta', 'true');
+  }
+
+  return params.toString();
+};
+
+export async function fetchArtifacts(options: ArtifactQueryOptions = {}): Promise<ArtifactListResponse> {
+  const query = buildArtifactQuery(options);
+
+  try {
+    const response = await fetch(`${BASE_URL}/v1/artifacts${query ? `?${query}` : ''}`, {
+      method: 'GET',
+      headers: {
+        'Content-Type': 'application/json',
+      },
+    });
+
+    if (!response.ok) {
+      const errorData = await response.json().catch(() => ({
+        error: 'Unknown error',
+        message: 'Failed to fetch artifacts',
+      }));
+      throw new ApiError(response.status, errorData);
+    }
+
+    const data: ArtifactListResponse = await response.json();
+    return data;
+  } catch (error) {
+    if (error instanceof ApiError) {
+      throw error;
+    }
+    throw new Error('Failed to connect to API server');
+  }
+}
+
+export async function fetchArtifactSummary(options: ArtifactQueryOptions = {}): Promise<ArtifactSummary> {
+  const query = buildArtifactQuery(options);
+
+  try {
+    const response = await fetch(`${BASE_URL}/v1/artifacts/summary${query ? `?${query}` : ''}`, {
+      method: 'GET',
+      headers: {
+        'Content-Type': 'application/json',
+      },
+    });
+
+    if (!response.ok) {
+      const errorData = await response.json().catch(() => ({
+        error: 'Unknown error',
+        message: 'Failed to fetch artifact summary',
+      }));
+      throw new ApiError(response.status, errorData);
+    }
+
+    const data: ArtifactSummaryResponse = await response.json();
+    return data.summary;
+  } catch (error) {
+    if (error instanceof ApiError) {
+      throw error;
+    }
+    throw new Error('Failed to connect to API server');
+  }
+}

flock/frontend/src/services/indexeddb.ts

@@ -27,6 +27,8 @@
 // Note: idb library is available for production use, but we use raw IndexedDB API
 // for better compatibility with test mocks
 
+import type { FilterSnapshot } from '../types/filters';
+
 // Database constants
 const DB_NAME = 'flock_dashboard_v1';
 const DB_VERSION = 1;
@@ -128,8 +130,8 @@ interface SessionRecord {
 export interface FilterRecord {
   filter_id: string; // PRIMARY KEY
   name: string;
-  filters: Record<string, any>;
-  created_at: string;
+  filters: FilterSnapshot;
+  created_at: number;
 }
 
 // Helper to wrap IDBRequest in Promise
@@ -430,6 +432,58 @@ export class IndexedDBService {
     }
   }
 
+  // ============================================================================
+  // CRUD Operations - Filters Store
+  // ============================================================================
+
+  async saveFilterPreset(record: FilterRecord): Promise<void> {
+    if (!this.db) {
+      this.inMemoryStore.get('filters')?.set(record.filter_id, record);
+      return;
+    }
+
+    try {
+      const tx = this.db.transaction('filters', 'readwrite');
+      const store = tx.objectStore('filters');
+      await promisifyRequest(store.put(record));
+    } catch (error) {
+      console.error('[IndexedDB] Failed to save filter preset:', error);
+    }
+  }
+
+  async getAllFilterPresets(): Promise<FilterRecord[]> {
+    if (!this.db) {
+      const filters = this.inMemoryStore.get('filters');
+      if (!filters) return [];
+      return Array.from(filters.values()).sort((a, b) => b.created_at - a.created_at);
+    }
+
+    try {
+      const tx = this.db.transaction('filters', 'readonly');
+      const store = tx.objectStore('filters');
+      const records: FilterRecord[] = await promisifyRequest(store.getAll());
+      return records.sort((a, b) => b.created_at - a.created_at);
+    } catch (error) {
+      console.error('[IndexedDB] Failed to load filter presets:', error);
+      return [];
+    }
+  }
+
+  async deleteFilterPreset(filterId: string): Promise<void> {
+    if (!this.db) {
+      this.inMemoryStore.get('filters')?.delete(filterId);
+      return;
+    }
+
+    try {
+      const tx = this.db.transaction('filters', 'readwrite');
+      const store = tx.objectStore('filters');
+      await promisifyRequest(store.delete(filterId));
+    } catch (error) {
+      console.error('[IndexedDB] Failed to delete filter preset:', error);
+    }
+  }
+
   // ============================================================================
   // CRUD Operations - Runs Store
   // ============================================================================

flock/frontend/src/services/websocket.ts

@@ -1,5 +1,7 @@
 import { useWSStore } from '../store/wsStore';
 import { useGraphStore } from '../store/graphStore';
+import { useFilterStore } from '../store/filterStore';
+import { useUIStore } from '../store/uiStore';
 
 interface WebSocketMessage {
   event_type: 'agent_activated' | 'message_published' | 'streaming_output' | 'agent_completed' | 'agent_error';
@@ -51,6 +53,109 @@ export class WebSocketClient {
     this.setupEventHandlers();
   }
 
+  private updateFilterStateFromPublishedMessage(data: any): void {
+    const filterStore = useFilterStore.getState();
+
+    const artifactType = typeof data.artifact_type === 'string' ? data.artifact_type : '';
+    const producer = typeof data.produced_by === 'string' ? data.produced_by : '';
+    const tags = Array.isArray(data.tags) ? data.tags.filter((tag: unknown) => typeof tag === 'string' && tag.length > 0) : [];
+    const visibilityKind =
+      (typeof data.visibility === 'object' && data.visibility && typeof data.visibility.kind === 'string'
+        ? data.visibility.kind
+        : undefined) ||
+      (typeof data.visibility_kind === 'string' ? data.visibility_kind : undefined) ||
+      (typeof data.visibility === 'string' ? data.visibility : undefined) ||
+      '';
+
+    const nextArtifactTypes = artifactType
+      ? [...filterStore.availableArtifactTypes, artifactType]
+      : [...filterStore.availableArtifactTypes];
+    const nextProducers = producer
+      ? [...filterStore.availableProducers, producer]
+      : [...filterStore.availableProducers];
+    const nextTags = tags.length > 0 ? [...filterStore.availableTags, ...tags] : [...filterStore.availableTags];
+    const nextVisibility = visibilityKind
+      ? [...filterStore.availableVisibility, visibilityKind]
+      : [...filterStore.availableVisibility];
+
+    filterStore.updateAvailableFacets({
+      artifactTypes: nextArtifactTypes,
+      producers: nextProducers,
+      tags: nextTags,
+      visibilities: nextVisibility,
+    });
+
+    const baseSummary =
+      filterStore.summary ?? {
+        total: 0,
+        by_type: {} as Record<string, number>,
+        by_producer: {} as Record<string, number>,
+        by_visibility: {} as Record<string, number>,
+        tag_counts: {} as Record<string, number>,
+        earliest_created_at: null as string | null,
+        latest_created_at: null as string | null,
+      };
+
+    const timestampIso =
+      (typeof data.timestamp === 'string' ? data.timestamp : undefined) ?? new Date().toISOString();
+
+    const updatedSummary = {
+      total: baseSummary.total + 1,
+      by_type: { ...baseSummary.by_type },
+      by_producer: { ...baseSummary.by_producer },
+      by_visibility: { ...baseSummary.by_visibility },
+      tag_counts: { ...baseSummary.tag_counts },
+      earliest_created_at:
+        baseSummary.earliest_created_at === null || timestampIso < baseSummary.earliest_created_at
+          ? timestampIso
+          : baseSummary.earliest_created_at,
+      latest_created_at:
+        baseSummary.latest_created_at === null || timestampIso > baseSummary.latest_created_at
+          ? timestampIso
+          : baseSummary.latest_created_at,
+    };
+
+    if (artifactType) {
+      updatedSummary.by_type[artifactType] = (updatedSummary.by_type[artifactType] || 0) + 1;
+    }
+    if (producer) {
+      updatedSummary.by_producer[producer] = (updatedSummary.by_producer[producer] || 0) + 1;
+    }
+    if (visibilityKind) {
+      updatedSummary.by_visibility[visibilityKind] = (updatedSummary.by_visibility[visibilityKind] || 0) + 1;
+    }
+    tags.forEach((tag: string) => {
+      updatedSummary.tag_counts[tag] = (updatedSummary.tag_counts[tag] || 0) + 1;
+    });
+
+    filterStore.setSummary(updatedSummary);
+
+    if (typeof data.correlation_id === 'string' && data.correlation_id.length > 0) {
+      const timestampMs =
+        typeof data.timestamp === 'string' ? new Date(data.timestamp).getTime() : Date.now();
+      const existing = filterStore.availableCorrelationIds.find(
+        (item) => item.correlation_id === data.correlation_id
+      );
+      const updatedRecord = existing
+        ? {
+            ...existing,
+            artifact_count: existing.artifact_count + 1,
+            first_seen: Math.min(existing.first_seen, timestampMs),
+          }
+        : {
+            correlation_id: data.correlation_id,
+            first_seen: timestampMs,
+            artifact_count: 1,
+            run_count: 0,
+          };
+      const nextMetadata = [
+        ...filterStore.availableCorrelationIds.filter((item) => item.correlation_id !== data.correlation_id),
+        updatedRecord,
+      ];
+      filterStore.updateAvailableCorrelationIds(nextMetadata);
+    }
+  }
+
   private setupEventHandlers(): void {
     // Handler for agent_activated: create/update agent in graph AND create Run
     this.on('agent_activated', (data) => {
@@ -117,11 +222,17 @@ export class WebSocketClient {
 
       if (existingMessage) {
         // Update existing streaming message with final data
+        const tags = Array.isArray(data.tags) ? data.tags : [];
+        const visibilityKind = data.visibility?.kind || data.visibility_kind || 'Unknown';
         const finalMessage = {
           ...existingMessage,
           id: data.artifact_id, // Replace temp ID with real artifact ID
           type: data.artifact_type,
           payload: data.payload,
+          tags,
+          visibilityKind,
+          partitionKey: data.partition_key ?? null,
+          version: data.version ?? 1,
           isStreaming: false, // Streaming complete
           streamingText: '', // Clear streaming text
         };
@@ -130,6 +241,8 @@ export class WebSocketClient {
         useGraphStore.getState().finalizeStreamingMessage(streamingMessageId, finalMessage);
       } else {
         // No streaming message - create new message directly
+        const tags = Array.isArray(data.tags) ? data.tags : [];
+        const visibilityKind = data.visibility?.kind || data.visibility_kind || 'Unknown';
         const message = {
           id: data.artifact_id,
           type: data.artifact_type,
@@ -137,6 +250,10 @@ export class WebSocketClient {
           timestamp: data.timestamp ? new Date(data.timestamp).getTime() : Date.now(),
           correlationId: data.correlation_id || '',
           producedBy: data.produced_by,
+          tags,
+          visibilityKind,
+          partitionKey: data.partition_key ?? null,
+          version: data.version ?? 1,
           isStreaming: false,
         };
         this.store.addMessage(message);
@@ -206,6 +323,16 @@ export class WebSocketClient {
           }
         }
       }
+
+      this.updateFilterStateFromPublishedMessage(data);
+
+      // Ensure blackboard graph reflects the newly published artifact immediately
+      const mode = useUIStore.getState().mode;
+      if (mode === 'blackboard') {
+        useGraphStore.getState().generateBlackboardViewGraph();
+      } else if (mode === 'agent') {
+        useGraphStore.getState().generateAgentViewGraph();
+      }
     });
 
     // Handler for streaming_output: update live output (Phase 6)
@@ -255,6 +382,8 @@ export class WebSocketClient {
             timestamp: data.timestamp ? new Date(data.timestamp).getTime() : Date.now(),
             correlationId: data.correlation_id || '',
             producedBy: data.agent_name,
+            tags: [],
+            visibilityKind: 'Unknown',
             isStreaming: true,
             streamingText: data.content,
           };