flock-core 0.4.543__py3-none-any.whl → 0.5.0__py3-none-any.whl

flock/frontend/src/types/filters.ts

@@ -0,0 +1,47 @@
+export type TimeRangePreset = 'last5min' | 'last10min' | 'last1hour' | 'custom' | 'all';
+
+export interface TimeRange {
+  preset: TimeRangePreset;
+  start?: number;
+  end?: number;
+}
+
+export interface CorrelationIdMetadata {
+  correlation_id: string;
+  first_seen: number;
+  artifact_count: number;
+  run_count: number;
+}
+
+export interface FilterFacets {
+  artifactTypes: string[];
+  producers: string[];
+  tags: string[];
+  visibilities: string[];
+}
+
+export interface ArtifactSummary {
+  total: number;
+  by_type: Record<string, number>;
+  by_producer: Record<string, number>;
+  by_visibility: Record<string, number>;
+  tag_counts: Record<string, number>;
+  earliest_created_at: string | null;
+  latest_created_at: string | null;
+}
+
+export interface FilterSnapshot {
+  correlationId: string | null;
+  timeRange: TimeRange;
+  artifactTypes: string[];
+  producers: string[];
+  tags: string[];
+  visibility: string[];
+}
+
+export interface SavedFilterMeta {
+  filter_id: string;
+  name: string;
+  created_at: number;
+  filters: FilterSnapshot;
+}

flock/frontend/src/types/graph.ts

@@ -0,0 +1,95 @@
+// Legacy types (still used during migration for events, WebSocket handlers)
+export interface Message {
+  id: string;
+  type: string;
+  payload: any;
+  timestamp: number;
+  correlationId: string;
+  producedBy: string;
+  tags?: string[];
+  visibilityKind?: string;
+  partitionKey?: string | null;
+  version?: number;
+  isStreaming?: boolean;
+  streamingText?: string;
+  consumedBy?: string[];
+}
+
+// New backend API types (Phase 1 - Spec 002)
+export interface GraphRequest {
+  viewMode: 'agent' | 'blackboard';
+  filters: GraphFilters;
+  options?: GraphRequestOptions;
+}
+
+export interface GraphFilters {
+  correlation_id?: string | null;
+  time_range: TimeRangeFilter;
+  artifactTypes: string[];
+  producers: string[];
+  tags: string[];
+  visibility: string[];
+}
+
+export interface TimeRangeFilter {
+  preset: 'last10min' | 'last5min' | 'last1hour' | 'all' | 'custom';
+  start?: string | null;
+  end?: string | null;
+}
+
+export interface GraphRequestOptions {
+  include_statistics?: boolean;
+  label_offset_strategy?: 'stack' | 'none';
+  limit?: number;
+}
+
+export interface GraphSnapshot {
+  generatedAt: string;
+  viewMode: 'agent' | 'blackboard';
+  filters: GraphFilters;
+  nodes: GraphNode[];
+  edges: GraphEdge[];
+  statistics: GraphStatistics | null;
+  totalArtifacts: number;
+  truncated: boolean;
+}
+
+export interface GraphNode {
+  id: string;
+  type: 'agent' | 'message';
+  data: Record<string, any>;
+  position: { x: number; y: number };
+  hidden: boolean;
+}
+
+export interface GraphEdge {
+  id: string;
+  source: string;
+  target: string;
+  type: 'message_flow' | 'transformation';
+  label?: string | null;
+  data: Record<string, any>;
+  markerEnd?: { type: string; width: number; height: number };
+  hidden: boolean;
+}
+
+export interface GraphStatistics {
+  producedByAgent: Record<string, GraphAgentMetrics>;
+  consumedByAgent: Record<string, GraphAgentMetrics>;
+  artifactSummary: ArtifactSummary;
+}
+
+export interface GraphAgentMetrics {
+  total: number;
+  byType: Record<string, number>;
+}
+
+export interface ArtifactSummary {
+  total: number;
+  by_type: Record<string, number>;
+  by_producer: Record<string, number>;
+  by_visibility: Record<string, number>;
+  tag_counts: Record<string, number>;
+  earliest_created_at: string;
+  latest_created_at: string;
+}

flock/frontend/src/types/modules.ts

@@ -0,0 +1,10 @@
+export interface ModuleInstance {
+  id: string; // unique instance ID
+  type: string; // module definition ID
+  position: { x: number; y: number };
+  size: { width: number; height: number };
+  visible: boolean;
+  maximized?: boolean;
+  preMaximizePosition?: { x: number; y: number };
+  preMaximizeSize?: { width: number; height: number };
+}

flock/frontend/src/types/theme.ts

@@ -0,0 +1,55 @@
+/**
+ * Theme Type Definitions
+ *
+ * Terminal theme format matching TOML structure from src/flock/themes/
+ */
+
+export interface TerminalColors {
+  black: string;
+  red: string;
+  green: string;
+  yellow: string;
+  blue: string;
+  magenta: string;
+  cyan: string;
+  white: string;
+}
+
+export interface PrimaryColors {
+  background: string;
+  foreground: string;
+}
+
+export interface SelectionColors {
+  background: string;
+  text: string;
+}
+
+export interface CursorColors {
+  cursor: string;
+  text: string;
+}
+
+export interface ThemeColors {
+  primary: PrimaryColors;
+  normal: TerminalColors;
+  bright: TerminalColors;
+  selection: SelectionColors;
+  cursor: CursorColors;
+}
+
+export interface TerminalTheme {
+  name: string;
+  colors: ThemeColors;
+}
+
+export interface ThemeListResponse {
+  themes: string[];
+}
+
+export interface ThemeDataResponse {
+  name: string;
+  data: {
+    colors: ThemeColors;
+  };
+}

flock/frontend/src/utils/artifacts.ts

@@ -0,0 +1,24 @@
+import type { ArtifactListItem } from '../services/api';
+import type { Message } from '../types/graph';
+
+export function mapArtifactToMessage(item: ArtifactListItem): Message {
+  const consumedBy =
+    item.consumed_by ??
+    (item.consumptions ? Array.from(new Set(item.consumptions.map((record) => record.consumer))) : []);
+
+  return {
+    id: item.id,
+    type: item.type,
+    payload: item.payload,
+    timestamp: new Date(item.created_at).getTime(),
+    correlationId: item.correlation_id ?? '',
+    producedBy: item.produced_by,
+    tags: item.tags || [],
+    visibilityKind: item.visibility_kind || item.visibility?.kind || 'Unknown',
+    partitionKey: item.partition_key ?? null,
+    version: item.version ?? 1,
+    isStreaming: false,
+    streamingText: '',
+    consumedBy,
+  };
+}

flock/frontend/src/utils/mockData.ts

@@ -0,0 +1,98 @@
+import { Message } from '../types/graph';
+
+// UI Optimization Migration (Phase 4.1 - Spec 002): OLD Phase 1 mock data (unused)
+// Kept for potential future testing, but Agent type no longer exists
+type LegacyAgent = {
+  id: string;
+  name: string;
+  status: string;
+  subscriptions: string[];
+  lastActive: number;
+  sentCount: number;
+  recvCount: number;
+  position: { x: number; y: number };
+};
+
+export const mockAgents: LegacyAgent[] = [
+  {
+    id: 'movie',
+    name: 'movie',
+    status: 'idle',
+    subscriptions: [],
+    lastActive: Date.now() - 5000,
+    sentCount: 3,
+    recvCount: 0,
+    position: { x: 100, y: 100 },
+  },
+  {
+    id: 'tagline',
+    name: 'tagline',
+    status: 'running',
+    subscriptions: ['Movie'],
+    lastActive: Date.now() - 2000,
+    sentCount: 2,
+    recvCount: 3,
+    position: { x: 400, y: 100 },
+  },
+  {
+    id: 'reviewer',
+    name: 'reviewer',
+    status: 'idle',
+    subscriptions: ['Tagline'],
+    lastActive: Date.now() - 1000,
+    sentCount: 0,
+    recvCount: 2,
+    position: { x: 700, y: 100 },
+  },
+];
+
+export const mockMessages: Message[] = [
+  {
+    id: 'msg-1',
+    type: 'Movie',
+    payload: { title: 'The Matrix', year: 1999, genre: 'Sci-Fi' },
+    timestamp: Date.now() - 10000,
+    correlationId: 'corr-123',
+    producedBy: 'movie',
+  },
+  {
+    id: 'msg-2',
+    type: 'Movie',
+    payload: { title: 'Inception', year: 2010, genre: 'Sci-Fi' },
+    timestamp: Date.now() - 8344,
+    correlationId: 'corr-123',
+    producedBy: 'movie',
+  },
+  {
+    id: 'msg-3',
+    type: 'Movie',
+    payload: { title: 'Interstellar', year: 2014, genre: 'Sci-Fi' },
+    timestamp: Date.now() - 6000,
+    correlationId: 'corr-123',
+    producedBy: 'movie',
+  },
+  {
+    id: 'msg-4',
+    type: 'Tagline',
+    payload: { movie: 'The Matrix', tagline: 'Reality is not what it seems' },
+    timestamp: Date.now() - 5000,
+    correlationId: 'corr-123',
+    producedBy: 'tagline',
+  },
+  {
+    id: 'msg-5',
+    type: 'Tagline',
+    payload: { movie: 'Inception', tagline: 'Your mind is the scene of the crime' },
+    timestamp: Date.now() - 3000,
+    correlationId: 'corr-123',
+    producedBy: 'tagline',
+  },
+];
+
+export function initializeMockData() {
+  // This will be called from main.tsx to populate stores
+  return {
+    agents: mockAgents,
+    messages: mockMessages,
+  };
+}

flock/frontend/src/utils/performance.ts

@@ -0,0 +1,16 @@
+export function measureRenderTime(componentName: string, startMark: string, endMark: string) {
+  performance.mark(endMark);
+  const measure = performance.measure(
+    `${componentName}-render`,
+    startMark,
+    endMark
+  );
+  console.log(`[Performance] ${componentName} render time: ${measure.duration.toFixed(2)}ms`);
+  return measure.duration;
+}
+
+export function startRenderMeasure(componentName: string) {
+  const markName = `${componentName}-start`;
+  performance.mark(markName);
+  return markName;
+}

flock/frontend/src/vite-env.d.ts

@@ -0,0 +1,17 @@
+/// <reference types="vite/client" />
+
+interface ImportMetaEnv {
+  readonly VITE_WS_URL?: string;
+}
+
+interface ImportMeta {
+  readonly env: ImportMetaEnv;
+}
+
+declare const __BUILD_TIMESTAMP__: string;
+declare const __BUILD_HASH__: string;
+
+declare module '*.module.css' {
+  const classes: { [key: string]: string };
+  export default classes;
+}

flock/frontend/tsconfig.json

@@ -0,0 +1,27 @@
+{
+  "compilerOptions": {
+    "target": "ES2020",
+    "useDefineForClassFields": true,
+    "lib": ["ES2020", "DOM", "DOM.Iterable"],
+    "module": "ESNext",
+    "skipLibCheck": true,
+
+    /* Bundler mode */
+    "moduleResolution": "bundler",
+    "allowImportingTsExtensions": true,
+    "resolveJsonModule": true,
+    "isolatedModules": true,
+    "noEmit": true,
+    "jsx": "react-jsx",
+
+    /* Linting */
+    "strict": true,
+    "noUnusedLocals": true,
+    "noUnusedParameters": true,
+    "noFallthroughCasesInSwitch": true,
+    "noUncheckedIndexedAccess": true,
+    "types": ["vitest/globals", "@testing-library/jest-dom"]
+  },
+  "include": ["src"],
+  "references": [{ "path": "./tsconfig.node.json" }]
+}

flock/frontend/tsconfig.node.json

@@ -0,0 +1,11 @@
+{
+  "compilerOptions": {
+    "composite": true,
+    "skipLibCheck": true,
+    "module": "ESNext",
+    "moduleResolution": "bundler",
+    "allowSyntheticDefaultImports": true,
+    "strict": true
+  },
+  "include": ["vite.config.ts"]
+}

flock/frontend/vite.config.ts

@@ -0,0 +1,25 @@
+import { defineConfig } from 'vite';
+import react from '@vitejs/plugin-react';
+
+export default defineConfig({
+  plugins: [react()],
+  define: {
+    __BUILD_TIMESTAMP__: JSON.stringify(new Date().toISOString()),
+    __BUILD_HASH__: JSON.stringify(
+      Date.now().toString(36) + Math.random().toString(36).substring(2, 9)
+    ),
+  },
+  server: {
+    port: 5173,
+    proxy: {
+      '/api': {
+        target: 'http://localhost:8344',
+        changeOrigin: true,
+      },
+      '/ws': {
+        target: 'ws://localhost:8344',
+        ws: true,
+      },
+    },
+  },
+});

flock/frontend/vitest.config.ts

@@ -0,0 +1,11 @@
+import { defineConfig } from 'vitest/config';
+import react from '@vitejs/plugin-react';
+
+export default defineConfig({
+  plugins: [react()],
+  test: {
+    globals: true,
+    environment: 'jsdom',
+    setupFiles: './src/test/setup.ts',
+  },
+});

flock/{core/util → helper}/cli_helper.py

@@ -1,9 +1,10 @@
 from importlib.metadata import PackageNotFoundError, version
 
+
 try:
-    __version__ = version("flock-core")
+    __version__ = version("flock-flow")
 except PackageNotFoundError:
-    __version__ = "0.2.0"
+    __version__ = "0.5.0b"
 
 
 def display_hummingbird():
@@ -38,7 +39,7 @@ def display_hummingbird():
 """)
 
 
-def init_console(clear_screen: bool = True, show_banner: bool = True):
+def init_console(clear_screen: bool = True, show_banner: bool = True, model: str = ""):
     """Display the Flock banner."""
     from rich.console import Console
     from rich.syntax import Text
@@ -51,7 +52,7 @@ def init_console(clear_screen: bool = True, show_banner: bool = True):
 │ ▒█▀▀▀ █░░ █▀▀█ █▀▀ █░█ │
 │ ▒█▀▀▀ █░░ █░░█ █░░ █▀▄ │
 │ ▒█░░░ ▀▀▀ ▀▀▀▀ ▀▀▀ ▀░▀ │
-╰━━━━━━━━v{__version__}━━━━━━━━╯
+╰━━━━━━━━v{__version__}━━━━━━━━━╯
 🦆     🐤    🐧     🐓
 """,
         justify="center",
@@ -63,9 +64,12 @@ def init_console(clear_screen: bool = True, show_banner: bool = True):
     if show_banner:
         console.print(banner_text)
         console.print(
-            "[italic]'Magpie'[/] milestone - [bold]white duck GmbH[/] - [cyan]https://whiteduck.de[/]\n"
+            "[italic]'Raven'[/] milestone - [bold]white duck GmbH[/] - [cyan]https://whiteduck.de[/]\n"
         )
 
+    if model:
+        console.print(f"[italic]Global Model:[/] {model}\n")
+
 
 def display_banner_no_version():
     """Display the Flock banner."""

flock/{core/logging → logging}/__init__.py

@@ -1,6 +1,5 @@
 """Flock logging system with Rich integration and structured logging support."""
 
-from .logging import configure_logging
-
-__all__ = ["configure_logging"]
+# from flock.logging import configure_logging
 
+# __all__ = ["configure_logging"]

flock/logging/auto_trace.py

@@ -0,0 +1,159 @@
+"""Metaclass for automatic method tracing via OpenTelemetry."""
+
+from __future__ import annotations
+
+import json
+import os
+
+from flock.logging.trace_and_logged import _trace_filter_config, traced_and_logged
+
+
+# Check if auto-tracing is enabled via environment variable
+ENABLE_AUTO_TRACE = os.getenv("FLOCK_AUTO_TRACE", "true").lower() in {"true", "1", "yes", "on"}
+
+
+# Parse trace filter configuration from environment variables
+def _parse_trace_filters():
+    """Parse FLOCK_TRACE_SERVICES and FLOCK_TRACE_IGNORE from environment."""
+    # Parse FLOCK_TRACE_SERVICES (whitelist)
+    services_env = os.getenv("FLOCK_TRACE_SERVICES", "")
+    if services_env:
+        try:
+            services_list = json.loads(services_env)
+            if isinstance(services_list, list):
+                # Store as lowercase set for case-insensitive matching
+                _trace_filter_config.services = {
+                    s.lower() for s in services_list if isinstance(s, str)
+                }
+        except (json.JSONDecodeError, ValueError):
+            print(f"Warning: Invalid FLOCK_TRACE_SERVICES format: {services_env}")
+
+    # Parse FLOCK_TRACE_IGNORE (blacklist)
+    ignore_env = os.getenv("FLOCK_TRACE_IGNORE", "")
+    if ignore_env:
+        try:
+            ignore_list = json.loads(ignore_env)
+            if isinstance(ignore_list, list):
+                _trace_filter_config.ignore_operations = {
+                    op for op in ignore_list if isinstance(op, str)
+                }
+        except (json.JSONDecodeError, ValueError):
+            print(f"Warning: Invalid FLOCK_TRACE_IGNORE format: {ignore_env}")
+
+
+# Auto-configure logging and telemetry when auto-tracing is enabled
+if ENABLE_AUTO_TRACE:
+    # Configure trace filters first
+    _parse_trace_filters()
+    from flock.logging.logging import configure_logging
+    from flock.logging.telemetry import TelemetryConfig
+
+    # Configure logging to DEBUG
+    configure_logging(
+        flock_level="DEBUG",
+        external_level="WARNING",
+        specific_levels={
+            "tools": "DEBUG",
+            "agent": "DEBUG",
+            "flock": "DEBUG",
+        },
+    )
+
+    # Initialize telemetry for OTEL trace context
+    # Only enable exporters if explicitly configured via env vars
+    enable_file_export = os.getenv("FLOCK_TRACE_FILE", "false").lower() in {
+        "true",
+        "1",
+        "yes",
+        "on",
+    }
+    enable_otlp_export = os.getenv("OTEL_EXPORTER_OTLP_ENDPOINT") is not None
+
+    # Parse TTL (Time To Live) for trace cleanup
+    trace_ttl_days = None
+    ttl_env = os.getenv("FLOCK_TRACE_TTL_DAYS", "")
+    if ttl_env:
+        try:
+            trace_ttl_days = int(ttl_env)
+        except ValueError:
+            print(f"Warning: Invalid FLOCK_TRACE_TTL_DAYS value: {ttl_env}")
+
+    telemetry_config = TelemetryConfig(
+        service_name="flock-auto-trace",
+        enable_jaeger=False,
+        enable_file=False,  # Disable file export, use DuckDB instead
+        enable_sql=False,
+        enable_duckdb=enable_file_export,  # Use DuckDB when file export is enabled
+        enable_otlp=enable_otlp_export,
+        otlp_endpoint=os.getenv("OTEL_EXPORTER_OTLP_ENDPOINT", "http://localhost:4317"),
+        local_logging_dir=".flock",
+        duckdb_name="traces.duckdb",
+        duckdb_ttl_days=trace_ttl_days,
+    )
+    telemetry_config.setup_tracing()
+
+
+class AutoTracedMeta(type):
+    """Metaclass that automatically applies @traced_and_logged to all public methods.
+
+    This enables automatic OpenTelemetry span creation and debug logging for all
+    method calls on classes using this metaclass.
+
+    Control via environment variable:
+        FLOCK_AUTO_TRACE=true   - Enable auto-tracing (default)
+        FLOCK_AUTO_TRACE=false  - Disable auto-tracing
+
+    Example:
+        class Agent(metaclass=AutoTracedMeta):
+            def execute(self, ctx, artifacts):
+                # Automatically traced and logged
+                ...
+    """
+
+    def __new__(mcs, name, bases, namespace, **kwargs):
+        """Create a new class with auto-traced methods."""
+        if not ENABLE_AUTO_TRACE:
+            # If auto-tracing is disabled, return the class unchanged
+            return super().__new__(mcs, name, bases, namespace, **kwargs)
+
+        # Apply @traced_and_logged to all public methods
+        for attr_name, attr_value in list(namespace.items()):
+            # Skip private methods (starting with _)
+            if attr_name.startswith("_"):
+                continue
+
+            # Skip non-callables
+            if not callable(attr_value):
+                continue
+
+            # Skip if already traced
+            if getattr(attr_value, "_traced", False):
+                continue
+
+            # Skip if explicitly marked to skip tracing
+            if getattr(attr_value, "_skip_trace", False):
+                continue
+
+            # Apply the decorator
+            traced_func = traced_and_logged(attr_value)
+            traced_func._traced = True  # Mark as traced to avoid double-wrapping
+            namespace[attr_name] = traced_func
+
+        return super().__new__(mcs, name, bases, namespace, **kwargs)
+
+
+def skip_trace(func):
+    """Decorator to mark a method to skip auto-tracing.
+
+    Use this for methods that are called very frequently or are not
+    interesting for debugging purposes.
+
+    Example:
+        class Agent(metaclass=AutoTracedMeta):
+            @skip_trace
+            def _internal_helper(self):
+                # Not traced
+                ...
+    """
+    func._skip_trace = True
+    return func

flock/{core/logging → logging}/formatters/enum_builder.py

@@ -4,14 +4,13 @@ import os
 import pathlib
 import re
 
-theme_folder = pathlib.Path(__file__).parent.parent.parent.parent / "themes"
+
+theme_folder = pathlib.Path(__file__).parent.parent.parent / "themes"
 
 if not theme_folder.exists():
     raise FileNotFoundError(f"Theme folder not found: {theme_folder}")
 
-theme_files = [
-    pathlib.Path(f.path).stem for f in os.scandir(theme_folder) if f.is_file()
-]
+theme_files = [pathlib.Path(f.path).stem for f in os.scandir(theme_folder) if f.is_file()]
 
 theme_enum_entries = {}
 for theme in theme_files: