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

flock/frontend/src/utils/transforms.ts

@@ -0,0 +1,323 @@
+import { Edge } from '@xyflow/react';
+
+/**
+ * Phase 4: Graph Visualization & Dual Views - Edge Derivation Algorithms
+ *
+ * Implements edge derivation logic as specified in DATA_MODEL.md:
+ * - deriveAgentViewEdges: Creates message flow edges between agents (producer → consumer)
+ * - deriveBlackboardViewEdges: Creates transformation edges between artifacts (consumed → produced)
+ *
+ * SPECIFICATION: docs/specs/003-real-time-dashboard/DATA_MODEL.md lines 770-853
+ * REFERENCE: docs/specs/003-real-time-dashboard/PLAN.md Phase 4
+ */
+
+// Type definitions matching DATA_MODEL.md specification
+export interface Artifact {
+  artifact_id: string;
+  artifact_type: string;
+  produced_by: string;
+  consumed_by: string[];
+  published_at: string; // ISO timestamp
+  payload: any;
+  correlation_id: string;
+}
+
+export interface Run {
+  run_id: string;
+  agent_name: string;
+  correlation_id: string; // Groups multiple agent runs together
+  status: 'active' | 'completed' | 'error';
+  consumed_artifacts: string[];
+  produced_artifacts: string[];
+  duration_ms?: number;
+  started_at?: string;
+  completed_at?: string;
+  metrics?: {
+    tokensUsed?: number;
+    costUsd?: number;
+    artifactsProduced?: number;
+  };
+  error_message?: string;
+}
+
+export interface DashboardState {
+  artifacts: Map<string, Artifact>;
+  runs: Map<string, Run>;
+  consumptions: Map<string, string[]>; // Phase 11: Track actual consumption (artifact_id -> consumer_ids[])
+}
+
+// Edge type definitions from DATA_MODEL.md
+// Note: Using camelCase for TypeScript/JavaScript convention
+export interface AgentViewEdge extends Edge {
+  type: 'message_flow';
+  label: string; // Format: "messageType (count)"
+  data: {
+    messageType: string;
+    messageCount: number;
+    artifactIds: string[];
+    latestTimestamp: string;
+    labelOffset?: number; // Phase 11: Vertical offset in pixels to prevent label overlap
+  };
+}
+
+export interface BlackboardViewEdge extends Edge {
+  type: 'transformation';
+  label: string; // agentName
+  data: {
+    transformerAgent: string;
+    runId: string;
+    durationMs?: number;
+    labelOffset?: number; // Phase 11: Vertical offset in pixels to prevent label overlap
+  };
+}
+
+/**
+ * Derive Agent View edges from dashboard state
+ *
+ * Algorithm (DATA_MODEL.md lines 770-821):
+ * 1. Group messages by (producer, consumer, message_type)
+ * 2. Create one edge per unique triple
+ * 3. Count artifacts in each group
+ * 4. Track latest timestamp
+ * 5. Add label offset for multiple edges between same nodes (Phase 11 bug fix)
+ *
+ * Edge format:
+ * - ID: `${producer}_${consumer}_${message_type}`
+ * - Type: 'message_flow'
+ * - Label: "Type (N)" where N is the count
+ * - Data: { message_type, message_count, artifact_ids[], latest_timestamp, labelOffset }
+ *
+ * @param state - Dashboard state with artifacts and runs
+ * @returns Array of message flow edges
+ */
+export function deriveAgentViewEdges(state: DashboardState): AgentViewEdge[] {
+  const edgeMap = new Map<
+    string,
+    {
+      source: string;
+      target: string;
+      message_type: string;
+      artifact_ids: string[];
+      latest_timestamp: string;
+    }
+  >();
+
+  // Iterate through all artifacts
+  state.artifacts.forEach((artifact) => {
+    const producer = artifact.produced_by;
+    const messageType = artifact.artifact_type;
+
+    // For each consumer, create or update edge
+    artifact.consumed_by.forEach((consumer) => {
+      const edgeKey = `${producer}_${consumer}_${messageType}`;
+
+      const existing = edgeMap.get(edgeKey);
+
+      if (existing) {
+        // Update existing edge
+        existing.artifact_ids.push(artifact.artifact_id);
+
+        // Update latest timestamp if this artifact is newer
+        if (artifact.published_at > existing.latest_timestamp) {
+          existing.latest_timestamp = artifact.published_at;
+        }
+      } else {
+        // Create new edge entry
+        edgeMap.set(edgeKey, {
+          source: producer,
+          target: consumer,
+          message_type: messageType,
+          artifact_ids: [artifact.artifact_id],
+          latest_timestamp: artifact.published_at,
+        });
+      }
+    });
+  });
+
+  // Phase 11 Bug Fix: Calculate label offsets for edges between same node pairs
+  // Group edges by node pair to detect multiple edges
+  // Use canonical pair key (sorted) so A→B and B→A are treated as same pair
+  const nodePairEdges = new Map<string, string[]>();
+  edgeMap.forEach((data, edgeKey) => {
+    const nodes = [data.source, data.target].sort();
+    const pairKey = `${nodes[0]}_${nodes[1]}`;
+    const existing = nodePairEdges.get(pairKey) || [];
+    existing.push(edgeKey);
+    nodePairEdges.set(pairKey, existing);
+  });
+
+  // Convert map to edges with label offsets
+  const edges: AgentViewEdge[] = [];
+
+  edgeMap.forEach((data, edgeKey) => {
+    const nodes = [data.source, data.target].sort();
+    const pairKey = `${nodes[0]}_${nodes[1]}`;
+    const edgesInPair = nodePairEdges.get(pairKey) || [];
+    const edgeIndex = edgesInPair.indexOf(edgeKey);
+    const totalEdgesInPair = edgesInPair.length;
+
+    // Calculate label offset (spread labels vertically if multiple edges)
+    // Offset range: -20 to +20 pixels for up to 3 edges, more if needed
+    let labelOffset = 0;
+    if (totalEdgesInPair > 1) {
+      const offsetRange = Math.min(40, totalEdgesInPair * 15);
+      const step = offsetRange / (totalEdgesInPair - 1);
+      labelOffset = edgeIndex * step - offsetRange / 2;
+    }
+
+    // Phase 11 Bug Fix: Calculate filtered count from actual consumption data
+    // Count how many artifacts were actually consumed by the target agent
+    const totalCount = data.artifact_ids.length;
+    const consumedCount = data.artifact_ids.filter((artifactId) => {
+      const consumers = state.consumptions.get(artifactId) || [];
+      return consumers.includes(data.target);
+    }).length;
+
+    // Format label: "Type (total, filtered: consumed)" if filtering occurred
+    let label = `${data.message_type} (${totalCount})`;
+    if (consumedCount < totalCount && consumedCount > 0) {
+      label = `${data.message_type} (${totalCount}, filtered: ${consumedCount})`;
+    }
+
+    edges.push({
+      id: edgeKey,
+      source: data.source,
+      target: data.target,
+      type: 'message_flow',
+      label,
+      markerEnd: {
+        type: 'arrowclosed',
+        width: 20,
+        height: 20,
+      },
+      data: {
+        messageType: data.message_type,
+        messageCount: data.artifact_ids.length,
+        artifactIds: data.artifact_ids,
+        latestTimestamp: data.latest_timestamp,
+        labelOffset, // Phase 11: Added for label positioning
+      },
+    });
+  });
+
+  return edges;
+}
+
+/**
+ * Derive Blackboard View edges from dashboard state
+ *
+ * Algorithm (DATA_MODEL.md lines 824-853):
+ * 1. For each completed run (status !== 'active')
+ * 2. Create edges from consumed artifacts to produced artifacts
+ * 3. Label with agent name
+ * 4. Include run metadata (run_id, duration_ms)
+ * 5. Add label offset for multiple edges between same artifacts (Phase 11 bug fix)
+ *
+ * Edge format:
+ * - ID: `${consumed_id}_${produced_id}_${run_id}` (Phase 11: Added run_id for uniqueness)
+ * - Type: 'transformation'
+ * - Label: agent_name
+ * - Data: { transformer_agent, run_id, duration_ms, labelOffset }
+ *
+ * @param state - Dashboard state with artifacts and runs
+ * @returns Array of transformation edges
+ */
+export function deriveBlackboardViewEdges(
+  state: DashboardState
+): BlackboardViewEdge[] {
+  const tempEdges: Array<{
+    id: string;
+    source: string;
+    target: string;
+    label: string;
+    data: {
+      transformerAgent: string;
+      runId: string;
+      durationMs?: number;
+    };
+  }> = [];
+
+  // Iterate through all runs
+  state.runs.forEach((run) => {
+    // Skip active runs (only process completed or error runs)
+    if (run.status === 'active') {
+      return;
+    }
+
+    // Skip runs with no consumed or produced artifacts
+    if (
+      run.consumed_artifacts.length === 0 ||
+      run.produced_artifacts.length === 0
+    ) {
+      return;
+    }
+
+    // Create edges for each consumed × produced pair
+    run.consumed_artifacts.forEach((consumedId) => {
+      run.produced_artifacts.forEach((producedId) => {
+        // Phase 11: Include run_id in edge ID to make it unique per transformation
+        const edgeId = `${consumedId}_${producedId}_${run.run_id}`;
+
+        tempEdges.push({
+          id: edgeId,
+          source: consumedId,
+          target: producedId,
+          label: run.agent_name,
+          data: {
+            transformerAgent: run.agent_name,
+            runId: run.run_id,
+            durationMs: run.duration_ms,
+          },
+        });
+      });
+    });
+  });
+
+  // Phase 11 Bug Fix: Calculate label offsets for edges between same artifact pairs
+  // Group edges by artifact pair to detect multiple transformations
+  // Use canonical pair key (sorted) so A→B and B→A are treated as same pair
+  const artifactPairEdges = new Map<string, string[]>();
+  tempEdges.forEach((edge) => {
+    const nodes = [edge.source, edge.target].sort();
+    const pairKey = `${nodes[0]}_${nodes[1]}`;
+    const existing = artifactPairEdges.get(pairKey) || [];
+    existing.push(edge.id);
+    artifactPairEdges.set(pairKey, existing);
+  });
+
+  // Convert to final edges with label offsets
+  const edges: BlackboardViewEdge[] = tempEdges.map((edge) => {
+    const nodes = [edge.source, edge.target].sort();
+    const pairKey = `${nodes[0]}_${nodes[1]}`;
+    const edgesInPair = artifactPairEdges.get(pairKey) || [];
+    const edgeIndex = edgesInPair.indexOf(edge.id);
+    const totalEdgesInPair = edgesInPair.length;
+
+    // Calculate label offset (spread labels vertically if multiple transformations)
+    let labelOffset = 0;
+    if (totalEdgesInPair > 1) {
+      const offsetRange = Math.min(40, totalEdgesInPair * 15);
+      const step = offsetRange / (totalEdgesInPair - 1);
+      labelOffset = edgeIndex * step - offsetRange / 2;
+    }
+
+    return {
+      id: edge.id,
+      source: edge.source,
+      target: edge.target,
+      type: 'transformation',
+      label: edge.label,
+      markerEnd: {
+        type: 'arrowclosed',
+        width: 20,
+        height: 20,
+      },
+      data: {
+        ...edge.data,
+        labelOffset, // Phase 11: Added for label positioning
+      },
+    };
+  });
+
+  return edges;
+}

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:8000',
+        changeOrigin: true,
+      },
+      '/ws': {
+        target: 'ws://localhost:8000',
+        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,7 +1,8 @@
 from importlib.metadata import PackageNotFoundError, version
 
+
 try:
-    __version__ = version("flock-core")
+    __version__ = version("flock-flow")
 except PackageNotFoundError:
     __version__ = "0.2.0"
 
@@ -51,7 +52,7 @@ def init_console(clear_screen: bool = True, show_banner: bool = True, model: str
 │ ▒█▀▀▀ █░░ █▀▀█ █▀▀ █░█ │
 │ ▒█▀▀▀ █░░ █░░█ █░░ █▀▄ │
 │ ▒█░░░ ▀▀▀ ▀▀▀▀ ▀▀▀ ▀░▀ │
-╰━━━━━━━━v{__version__}━━━━━━━╯
+╰━━━━━━━━v{__version__}━━━━━━━━━╯
 🦆     🐤    🐧     🐓
 """,
         justify="center",
@@ -63,7 +64,7 @@ def init_console(clear_screen: bool = True, show_banner: bool = True, model: str
     if show_banner:
         console.print(banner_text)
         console.print(
-            "[italic]'Kea'[/] milestone - [bold]white duck GmbH[/] - [cyan]https://whiteduck.de[/]\n"
+            "[italic]'Raven'[/] milestone - [bold]white duck GmbH[/] - [cyan]https://whiteduck.de[/]\n"
         )
 
     if model:

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/{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:

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

@@ -153,9 +153,7 @@ def generate_default_rich_block(theme: dict | None = None) -> dict[str, Any]:
         ),
         "panel_padding": random.choice([[1, 2], [1, 1], [2, 2], [0, 2]]),
         "panel_title_align": random.choice(["left", "center", "right"]),
-        "table_row_styles": random.choice(
-            [["", "dim"], ["", "italic"], ["", "underline"]]
-        ),
+        "table_row_styles": random.choice([["", "dim"], ["", "italic"], ["", "underline"]]),
     }
     # Extra table layout properties (non-content).
     default_extra_table_props = {
@@ -175,13 +173,12 @@ def generate_default_rich_block(theme: dict | None = None) -> dict[str, Any]:
         "table_caption_justify": "center",
         "table_highlight": False,
     }
-    defaults = {
+    return {
         **default_color_props,
         **extra_color_props,
         **default_non_color_props,
         **default_extra_table_props,
     }
-    return defaults
 
 
 def load_theme_from_file(filepath: str) -> dict:
@@ -207,9 +204,7 @@ def get_default_styles(theme: dict | None) -> dict[str, Any]:
     else:
         defaults = generate_default_rich_block(theme)
         rich_props = theme.get("rich", {})
-        final_styles = {
-            key: rich_props.get(key, defaults[key]) for key in defaults
-        }
+        final_styles = {key: rich_props.get(key, defaults[key]) for key in defaults}
     # Ensure tuple for padding properties.
     final_styles["panel_padding"] = tuple(final_styles["panel_padding"])
     if "table_padding" in final_styles:
@@ -272,33 +267,23 @@ def create_rich_renderable(
         table.add_column("Key", style=styles["column_output"])
         table.add_column("Value", style=styles["column_value"])
         for k, v in value.items():
-            table.add_row(
-                str(k), create_rich_renderable(v, level + 1, theme, styles)
-            )
+            table.add_row(str(k), create_rich_renderable(v, level + 1, theme, styles))
         return table
 
-    elif isinstance(value, (list, tuple)):
+    if isinstance(value, (list, tuple)):
         if all(isinstance(item, dict) for item in value):
             sub_tables = []
             for i, item in enumerate(value):
                 sub_tables.append(f"[bold]Item {i + 1}[/bold]")
-                sub_tables.append(
-                    create_rich_renderable(item, level + 1, theme, styles)
-                )
+                sub_tables.append(create_rich_renderable(item, level + 1, theme, styles))
             return Group(*sub_tables)
-        else:
-            rendered_items = [
-                create_rich_renderable(item, level + 1, theme, styles)
-                for item in value
-            ]
-            if all(isinstance(item, str) for item in rendered_items):
-                return "\n".join(rendered_items)
-            else:
-                return Group(*rendered_items)
-    else:
-        if isinstance(value, str) and "\n" in value:
-            return f"\n{value}\n"
-        return str(value)
+        rendered_items = [create_rich_renderable(item, level + 1, theme, styles) for item in value]
+        if all(isinstance(item, str) for item in rendered_items):
+            return "\n".join(rendered_items)
+        return Group(*rendered_items)
+    if isinstance(value, str) and "\n" in value:
+        return f"\n{value}\n"
+    return str(value)
 
 
 # --- Theme Builder Functions --- #
@@ -312,9 +297,7 @@ def load_theme_files(theme_dir: pathlib.Path) -> list[pathlib.Path]:
 def display_color_palette(theme: dict) -> None:
     """Display the color palette from a theme's [colors] sections with a color preview."""
     console = Console()
-    palette_table = Table(
-        title="Color Palette", show_header=True, header_style="bold"
-    )
+    palette_table = Table(title="Color Palette", show_header=True, header_style="bold")
     palette_table.add_column("Section", style="bold")
     palette_table.add_column("Key", style="italic")
     palette_table.add_column("Value", style="bold")
@@ -331,9 +314,7 @@ def display_color_palette(theme: dict) -> None:
     console.print(palette_table)
 
 
-def generate_sample_rich_blocks(
-    chosen_theme: dict, count: int
-) -> list[dict[str, Any]]:
+def generate_sample_rich_blocks(chosen_theme: dict, count: int) -> list[dict[str, Any]]:
     """Generate a list of sample rich blocks (randomized layout) using the chosen theme's colors."""
     samples = []
     for _ in range(count):
@@ -349,9 +330,7 @@ def generate_sample_table(sample_theme: dict, dummy_data: dict) -> Panel:
     # For simplicity, we create our own panel.
     styles = get_default_styles(sample_theme)
     # Build a basic table (using our earlier functions)
-    table = create_rich_renderable(
-        dummy_data, theme=sample_theme, styles=styles
-    )
+    table = create_rich_renderable(dummy_data, theme=sample_theme, styles=styles)
     return Panel(
         table,
         title="Sample Table",
@@ -373,7 +352,7 @@ def save_theme(theme: dict, filename: pathlib.Path) -> None:
 
 def theme_builder():
     console = Console(force_terminal=True, color_system="truecolor")
-    themes_dir = pathlib.Path(__file__).parent.parent.parent.parent / "themes"
+    themes_dir = pathlib.Path(__file__).parent.parent.parent / "themes"
     theme_files = load_theme_files(themes_dir)
 
     if not theme_files:
@@ -443,9 +422,7 @@ def theme_builder():
     samples = []
     for i, rich_block in enumerate(sample_rich_blocks):
         # Build a sample theme: copy the chosen theme and override its [rich] block.
-        sample_theme = dict(
-            chosen_theme
-        )  # shallow copy (good enough if colors remain unchanged)
+        sample_theme = dict(chosen_theme)  # shallow copy (good enough if colors remain unchanged)
         sample_theme["rich"] = rich_block
         sample_table = generate_sample_table(sample_theme, dummy_data)
         samples.append((sample_theme, sample_table))
@@ -468,9 +445,7 @@ def theme_builder():
         return
 
     # Ask for file name to save the chosen theme.
-    filename = console.input(
-        "\nEnter a filename to save the chosen theme (e.g. mytheme.toml): "
-    )
+    filename = console.input("\nEnter a filename to save the chosen theme (e.g. mytheme.toml): ")
     save_path = themes_dir / filename
     save_theme(chosen_sample_theme, save_path)
     console.print(f"\n[green]Theme saved as {save_path}.[/green]")