flock-core 0.5.0b71__py3-none-any.whl → 0.5.0b75__py3-none-any.whl

flock/dashboard/models/graph.py

@@ -0,0 +1,156 @@
+from __future__ import annotations
+
+from datetime import datetime
+from enum import Enum
+from typing import Any, Literal
+
+from pydantic import BaseModel, ConfigDict, Field
+
+
+class GraphTimeRangePreset(str, Enum):
+    LAST_5_MIN = "last5min"
+    LAST_10_MIN = "last10min"
+    LAST_1_HOUR = "last1hour"
+    ALL = "all"
+    CUSTOM = "custom"
+
+
+class GraphTimeRange(BaseModel):
+    model_config = ConfigDict(populate_by_name=True)
+
+    preset: GraphTimeRangePreset = GraphTimeRangePreset.LAST_10_MIN
+    start: datetime | None = None
+    end: datetime | None = None
+
+
+class GraphFilters(BaseModel):
+    model_config = ConfigDict(populate_by_name=True)
+
+    correlation_id: str | None = None
+    time_range: GraphTimeRange = Field(default_factory=GraphTimeRange)
+    artifact_types: list[str] = Field(default_factory=list, alias="artifactTypes")
+    producers: list[str] = Field(default_factory=list)
+    tags: list[str] = Field(default_factory=list)
+    visibility: list[str] = Field(default_factory=list)
+
+
+class GraphRequestOptions(BaseModel):
+    model_config = ConfigDict(populate_by_name=True)
+
+    include_statistics: bool = Field(default=True, alias="includeStatistics")
+    label_offset_strategy: str = Field(default="stack", alias="labelOffsetStrategy")
+    limit: int = 500
+
+
+class GraphRequest(BaseModel):
+    model_config = ConfigDict(populate_by_name=True)
+
+    view_mode: Literal["agent", "blackboard"] = Field(alias="viewMode")
+    filters: GraphFilters = Field(default_factory=GraphFilters)
+    options: GraphRequestOptions = Field(default_factory=GraphRequestOptions)
+
+
+class GraphPosition(BaseModel):
+    x: float = 0.0
+    y: float = 0.0
+
+
+class GraphMarker(BaseModel):
+    model_config = ConfigDict(populate_by_name=True)
+
+    type: str = "arrowclosed"
+    width: float = 20.0
+    height: float = 20.0
+
+
+class GraphNode(BaseModel):
+    model_config = ConfigDict(populate_by_name=True)
+
+    id: str
+    type: Literal["agent", "message"]
+    data: dict[str, Any] = Field(default_factory=dict)
+    position: GraphPosition | None = None
+    hidden: bool = False
+
+
+class GraphEdge(BaseModel):
+    model_config = ConfigDict(populate_by_name=True)
+
+    id: str
+    source: str
+    target: str
+    type: Literal["message_flow", "transformation"]
+    label: str | None = None
+    data: dict[str, Any] = Field(default_factory=dict)
+    marker_end: GraphMarker | None = Field(default=None, alias="markerEnd")
+    hidden: bool = False
+
+
+class GraphAgentMetrics(BaseModel):
+    model_config = ConfigDict(populate_by_name=True)
+
+    total: int = 0
+    by_type: dict[str, int] = Field(default_factory=dict, alias="byType")
+
+
+class GraphStatistics(BaseModel):
+    model_config = ConfigDict(populate_by_name=True)
+
+    produced_by_agent: dict[str, GraphAgentMetrics] = Field(
+        default_factory=dict, alias="producedByAgent"
+    )
+    consumed_by_agent: dict[str, GraphAgentMetrics] = Field(
+        default_factory=dict, alias="consumedByAgent"
+    )
+    artifact_summary: dict[str, Any] = Field(default_factory=dict, alias="artifactSummary")
+
+
+class GraphArtifact(BaseModel):
+    model_config = ConfigDict(populate_by_name=True)
+
+    artifact_id: str = Field(alias="artifactId")
+    artifact_type: str = Field(alias="artifactType")
+    produced_by: str = Field(alias="producedBy")
+    consumed_by: list[str] = Field(default_factory=list, alias="consumedBy")
+    published_at: datetime = Field(alias="publishedAt")
+    payload: dict[str, Any] = Field(default_factory=dict)
+    correlation_id: str | None = Field(default=None, alias="correlationId")
+    visibility_kind: str | None = Field(default=None, alias="visibilityKind")
+    tags: list[str] = Field(default_factory=list)
+
+
+class GraphRun(BaseModel):
+    model_config = ConfigDict(populate_by_name=True)
+
+    run_id: str = Field(alias="runId")
+    agent_name: str = Field(alias="agentName")
+    correlation_id: str | None = Field(default=None, alias="correlationId")
+    status: Literal["active", "completed", "error"] = "active"
+    consumed_artifacts: list[str] = Field(default_factory=list, alias="consumedArtifacts")
+    produced_artifacts: list[str] = Field(default_factory=list, alias="producedArtifacts")
+    duration_ms: float | None = Field(default=None, alias="durationMs")
+    started_at: datetime | None = Field(default=None, alias="startedAt")
+    completed_at: datetime | None = Field(default=None, alias="completedAt")
+    metrics: dict[str, Any] = Field(default_factory=dict)
+    error_message: str | None = Field(default=None, alias="errorMessage")
+
+
+class GraphState(BaseModel):
+    model_config = ConfigDict(populate_by_name=True)
+
+    consumptions: dict[str, list[str]] = Field(default_factory=dict)
+    runs: list[GraphRun] = Field(default_factory=list)
+    agent_status: dict[str, str] = Field(default_factory=dict, alias="agentStatus")
+
+
+class GraphSnapshot(BaseModel):
+    model_config = ConfigDict(populate_by_name=True)
+
+    generated_at: datetime = Field(alias="generatedAt")
+    view_mode: Literal["agent", "blackboard"] = Field(alias="viewMode")
+    filters: GraphFilters
+    nodes: list[GraphNode] = Field(default_factory=list)
+    edges: list[GraphEdge] = Field(default_factory=list)
+    statistics: GraphStatistics | None = None
+    total_artifacts: int = Field(alias="totalArtifacts", default=0)
+    truncated: bool = False

flock/dashboard/service.py

@@ -20,6 +20,8 @@ from pydantic import ValidationError
 
 from flock.dashboard.collector import DashboardEventCollector
 from flock.dashboard.events import MessagePublishedEvent, VisibilitySpec
+from flock.dashboard.graph_builder import GraphAssembler
+from flock.dashboard.models.graph import GraphRequest, GraphSnapshot
 from flock.dashboard.websocket import WebSocketManager
 from flock.logging.logging import get_logger
 from flock.orchestrator import Flock
@@ -45,6 +47,8 @@ class DashboardHTTPService(BlackboardHTTPService):
         orchestrator: Flock,
         websocket_manager: WebSocketManager | None = None,
         event_collector: DashboardEventCollector | None = None,
+        *,
+        use_v2: bool = False,
     ) -> None:
         """Initialize DashboardHTTPService.
 
@@ -58,11 +62,19 @@ class DashboardHTTPService(BlackboardHTTPService):
 
         # Initialize WebSocket manager and event collector
         self.websocket_manager = websocket_manager or WebSocketManager()
-        self.event_collector = event_collector or DashboardEventCollector()
+        self.event_collector = event_collector or DashboardEventCollector(
+            store=self.orchestrator.store
+        )
+        self.use_v2 = use_v2
 
         # Integrate collector with WebSocket manager
         self.event_collector.set_websocket_manager(self.websocket_manager)
 
+        # Graph assembler powers both dashboards by default
+        self.graph_assembler: GraphAssembler | None = GraphAssembler(
+            self.orchestrator.store, self.event_collector, self.orchestrator
+        )
+
         # Configure CORS if DASHBOARD_DEV environment variable is set
         if os.environ.get("DASHBOARD_DEV") == "1":
             logger.info("DASHBOARD_DEV mode enabled - adding CORS middleware")
@@ -122,13 +134,22 @@ class DashboardHTTPService(BlackboardHTTPService):
                 # Clean up: remove client from pool
                 await self.websocket_manager.remove_client(websocket)
 
-        # Serve static files for dashboard frontend
-        # Look for static files in dashboard directory
+        if self.graph_assembler is not None:
+
+            @app.post("/api/dashboard/graph", response_model=GraphSnapshot)
+            async def get_dashboard_graph(request: GraphRequest) -> GraphSnapshot:
+                """Return server-side assembled dashboard graph snapshot."""
+                return await self.graph_assembler.build_snapshot(request)
+
         dashboard_dir = Path(__file__).parent
-        static_dir = dashboard_dir / "static"
+        frontend_root = dashboard_dir.parent / ("frontend_v2" if self.use_v2 else "frontend")
+        static_dir = dashboard_dir / ("static_v2" if self.use_v2 else "static")
 
-        # Also check for 'dist' or 'build' directories (common build output names)
-        possible_dirs = [static_dir, dashboard_dir / "dist", dashboard_dir / "build"]
+        possible_dirs = [
+            static_dir,
+            frontend_root / "dist",
+            frontend_root / "build",
+        ]
 
         for dir_path in possible_dirs:
             if dir_path.exists() and dir_path.is_dir():
@@ -142,9 +163,7 @@ class DashboardHTTPService(BlackboardHTTPService):
                 break
         else:
             logger.warning(
-                f"No static directory found in {dashboard_dir}. "
-                "Dashboard frontend will not be served. "
-                "Expected directories: static/, dist/, or build/"
+                f"No static directory found for dashboard frontend (expected one of: {possible_dirs})."
             )
 
     def _register_control_routes(self) -> None:
@@ -503,9 +522,10 @@ class DashboardHTTPService(BlackboardHTTPService):
                     "operations": ["Flock.publish", "Agent.execute", ...]
                 }
             """
-            import duckdb
             from pathlib import Path
 
+            import duckdb
+
             db_path = Path(".flock/traces.duckdb")
 
             if not db_path.exists():
@@ -564,9 +584,10 @@ class DashboardHTTPService(BlackboardHTTPService):
 
             Security: Only SELECT queries allowed, rate-limited.
             """
-            import duckdb
             from pathlib import Path
 
+            import duckdb
+
             query = request.get("query", "").strip()
 
             if not query:
@@ -610,7 +631,7 @@ class DashboardHTTPService(BlackboardHTTPService):
 
                     return {"results": results, "columns": columns, "row_count": len(results)}
             except Exception as e:
-                logger.error(f"DuckDB query error: {e}")
+                logger.exception(f"DuckDB query error: {e}")
                 return {"error": str(e), "results": [], "columns": []}
 
         @app.get("/api/traces/stats")
@@ -627,9 +648,10 @@ class DashboardHTTPService(BlackboardHTTPService):
                     "database_size_mb": 12.5
                 }
             """
-            import duckdb
-            from pathlib import Path
             from datetime import datetime
+            from pathlib import Path
+
+            import duckdb
 
             db_path = Path(".flock/traces.duckdb")
 
@@ -737,6 +759,145 @@ class DashboardHTTPService(BlackboardHTTPService):
                     status_code=500, detail=f"Failed to get streaming history: {e!s}"
                 )
 
+        @app.get("/api/artifacts/history/{node_id}")
+        async def get_message_history(node_id: str) -> dict[str, Any]:
+            """Get complete message history for a node (both produced and consumed).
+
+            Phase 4.1 Feature Gap Fix: Returns both messages produced by AND consumed by
+            the specified node, enabling complete message history view in MessageHistoryTab.
+
+            Args:
+                node_id: ID of the node (agent name or message ID)
+
+            Returns:
+                {
+                    "node_id": "agent_name",
+                    "messages": [
+                        {
+                            "id": "artifact-uuid",
+                            "type": "ArtifactType",
+                            "direction": "published"|"consumed",
+                            "payload": {...},
+                            "timestamp": "2025-10-11T...",
+                            "correlation_id": "uuid",
+                            "produced_by": "producer_name",
+                            "consumed_at": "2025-10-11T..." (only for consumed)
+                        },
+                        ...
+                    ],
+                    "total": 123
+                }
+            """
+            try:
+                from flock.store import FilterConfig
+
+                messages = []
+
+                # 1. Get messages PRODUCED by this node
+                produced_filter = FilterConfig(produced_by={node_id})
+                produced_artifacts, _produced_count = await orchestrator.store.query_artifacts(
+                    produced_filter, limit=100, offset=0, embed_meta=False
+                )
+
+                for artifact in produced_artifacts:
+                    messages.append(
+                        {
+                            "id": str(artifact.id),
+                            "type": artifact.type,
+                            "direction": "published",
+                            "payload": artifact.payload,
+                            "timestamp": artifact.created_at.isoformat(),
+                            "correlation_id": str(artifact.correlation_id)
+                            if artifact.correlation_id
+                            else None,
+                            "produced_by": artifact.produced_by,
+                        }
+                    )
+
+                # 2. Get messages CONSUMED by this node
+                # Query all artifacts with consumption metadata
+                all_artifacts_filter = FilterConfig()  # No filter = all artifacts
+                all_envelopes, _ = await orchestrator.store.query_artifacts(
+                    all_artifacts_filter, limit=500, offset=0, embed_meta=True
+                )
+
+                for envelope in all_envelopes:
+                    artifact = envelope.artifact
+                    for consumption in envelope.consumptions:
+                        if consumption.consumer == node_id:
+                            messages.append(
+                                {
+                                    "id": str(artifact.id),
+                                    "type": artifact.type,
+                                    "direction": "consumed",
+                                    "payload": artifact.payload,
+                                    "timestamp": artifact.created_at.isoformat(),
+                                    "correlation_id": str(artifact.correlation_id)
+                                    if artifact.correlation_id
+                                    else None,
+                                    "produced_by": artifact.produced_by,
+                                    "consumed_at": consumption.consumed_at.isoformat(),
+                                }
+                            )
+
+                # Sort by timestamp (most recent first)
+                messages.sort(key=lambda m: m.get("consumed_at", m["timestamp"]), reverse=True)
+
+                return {"node_id": node_id, "messages": messages, "total": len(messages)}
+
+            except Exception as e:
+                logger.exception(f"Failed to get message history for {node_id}: {e}")
+                raise HTTPException(status_code=500, detail=f"Failed to get message history: {e!s}")
+
+        @app.get("/api/agents/{agent_id}/runs")
+        async def get_agent_runs(agent_id: str) -> dict[str, Any]:
+            """Get run history for an agent.
+
+            Phase 4.1 Feature Gap Fix: Returns agent execution history with metrics
+            for display in RunStatusTab.
+
+            Args:
+                agent_id: ID of the agent
+
+            Returns:
+                {
+                    "agent_id": "agent_name",
+                    "runs": [
+                        {
+                            "run_id": "uuid",
+                            "start_time": "2025-10-11T...",
+                            "end_time": "2025-10-11T...",
+                            "duration_ms": 1234,
+                            "status": "completed"|"active"|"error",
+                            "metrics": {
+                                "tokens_used": 123,
+                                "cost_usd": 0.0012,
+                                "artifacts_produced": 5
+                            },
+                            "error_message": "error details" (if status=error)
+                        },
+                        ...
+                    ],
+                    "total": 50
+                }
+            """
+            try:
+                # TODO: Implement run history tracking in orchestrator
+                # For now, return empty array with proper structure
+                # This unblocks frontend development and can be enhanced later
+
+                runs = []
+
+                # FUTURE: Query run history from orchestrator or store
+                # Example implementation when run tracking is added:
+                # runs = await orchestrator.get_agent_run_history(agent_id, limit=50)
+
+                return {"agent_id": agent_id, "runs": runs, "total": len(runs)}
+
+            except Exception as e:
+                logger.exception(f"Failed to get run history for {agent_id}: {e}")
+                raise HTTPException(status_code=500, detail=f"Failed to get run history: {e!s}")
+
     def _register_theme_routes(self) -> None:
         """Register theme API endpoints for dashboard customization."""
         from pathlib import Path