htmlgraph 0.26.24__py3-none-any.whl → 0.27.0__py3-none-any.whl

htmlgraph/api/main.py

@@ -204,7 +204,37 @@ def get_app(db_path: str) -> FastAPI:
             return "0"
         return f"{value:,}"
 
+    def format_duration(seconds: float | int | None) -> str:
+        """Format duration in seconds to human-readable string."""
+        if seconds is None:
+            return "0.00s"
+        return f"{float(seconds):.2f}s"
+
+    def format_bytes(bytes_size: int | float | None) -> str:
+        """Format bytes to MB with 2 decimal places."""
+        if bytes_size is None:
+            return "0.00MB"
+        return f"{int(bytes_size) / (1024 * 1024):.2f}MB"
+
+    def truncate_text(text: str | None, length: int = 50) -> str:
+        """Truncate text to specified length with ellipsis."""
+        if text is None:
+            return ""
+        return text[:length] + "..." if len(text) > length else text
+
+    def format_timestamp(ts: Any) -> str:
+        """Format timestamp to readable string."""
+        if ts is None:
+            return ""
+        if hasattr(ts, "strftime"):
+            return str(ts.strftime("%Y-%m-%d %H:%M:%S"))
+        return str(ts)
+
     templates.env.filters["format_number"] = format_number
+    templates.env.filters["format_duration"] = format_duration
+    templates.env.filters["format_bytes"] = format_bytes
+    templates.env.filters["truncate"] = truncate_text
+    templates.env.filters["format_timestamp"] = format_timestamp
 
     # Setup static files
     static_dir = Path(__file__).parent / "static"
@@ -267,7 +297,19 @@ def get_app(db_path: str) -> FastAPI:
                         COUNT(*) as event_count,
                         SUM(e.cost_tokens) as total_tokens,
                         COUNT(DISTINCT e.session_id) as session_count,
-                        MAX(e.timestamp) as last_active
+                        MAX(e.timestamp) as last_active,
+                        MAX(e.model) as model,
+                        CASE
+                            WHEN MAX(e.timestamp) > datetime('now', '-5 minutes') THEN 'active'
+                            ELSE 'idle'
+                        END as status,
+                        AVG(e.execution_duration_seconds) as avg_duration,
+                        SUM(CASE WHEN e.event_type = 'error' THEN 1 ELSE 0 END) as error_count,
+                        ROUND(
+                            100.0 * COUNT(CASE WHEN e.status = 'completed' THEN 1 END) /
+                            CAST(COUNT(*) AS FLOAT),
+                            1
+                        ) as success_rate
                     FROM agent_events e
                     GROUP BY e.agent_id
                     ORDER BY event_count DESC
@@ -275,8 +317,8 @@ def get_app(db_path: str) -> FastAPI:
 
                 # Execute query with timing
                 exec_start = time.time()
-                cursor = await db.execute(query)
-                rows = await cursor.fetchall()
+                async with db.execute(query) as cursor:
+                    rows = await cursor.fetchall()
                 exec_time_ms = (time.time() - exec_start) * 1000
 
                 agents = []
@@ -297,11 +339,19 @@ def get_app(db_path: str) -> FastAPI:
 
                     agents.append(
                         {
+                            "id": row[0],
                             "agent_id": row[0],
+                            "name": row[0],
                             "event_count": event_count,
                             "total_tokens": row[2] or 0,
                             "session_count": row[3],
+                            "last_activity": row[4],
                             "last_active": row[4],
+                            "model": row[5] or "unknown",
+                            "status": row[6] or "idle",
+                            "avg_duration": row[7],
+                            "error_count": row[8] or 0,
+                            "success_rate": row[9] or 0.0,
                             "workload_pct": round(workload_pct, 1),
                         }
                     )
@@ -414,8 +464,8 @@ def get_app(db_path: str) -> FastAPI:
 
                 # Execute query with timing
                 exec_start = time.time()
-                cursor = await db.execute(query, params)
-                rows = await cursor.fetchall()
+                async with db.execute(query, params) as cursor:
+                    rows = await cursor.fetchall()
                 exec_time_ms = (time.time() - exec_start) * 1000
 
                 # Build result models
@@ -465,15 +515,15 @@ def get_app(db_path: str) -> FastAPI:
                     (SELECT COUNT(DISTINCT agent_id) FROM agent_events) as total_agents,
                     (SELECT COUNT(*) FROM sessions) as total_sessions
             """
-            cursor = await db.execute(stats_query)
-            row = await cursor.fetchone()
+            async with db.execute(stats_query) as cursor:
+                row = await cursor.fetchone()
 
             # Query distinct agent IDs for the agent set
             agents_query = (
                 "SELECT DISTINCT agent_id FROM agent_events WHERE agent_id IS NOT NULL"
             )
-            agents_cursor = await db.execute(agents_query)
-            agents_rows = await agents_cursor.fetchall()
+            async with db.execute(agents_query) as agents_cursor:
+                agents_rows = await agents_cursor.fetchall()
             agents = [row[0] for row in agents_rows]
 
             if row is None:
@@ -596,8 +646,8 @@ def get_app(db_path: str) -> FastAPI:
             parent_query += " ORDER BY timestamp DESC LIMIT ?"
             parent_params.append(limit)
 
-            cursor = await db.execute(parent_query, parent_params)
-            parent_rows = await cursor.fetchall()
+            async with db.execute(parent_query, parent_params) as cursor:
+                parent_rows = await cursor.fetchall()
 
             traces: list[dict[str, Any]] = []
 
@@ -635,8 +685,8 @@ def get_app(db_path: str) -> FastAPI:
                     WHERE parent_event_id = ?
                     ORDER BY timestamp ASC
                 """
-                child_cursor = await db.execute(child_query, (parent_event_id,))
-                child_rows = await child_cursor.fetchall()
+                async with db.execute(child_query, (parent_event_id,)) as child_cursor:
+                    child_rows = await child_cursor.fetchall()
 
                 child_events = []
                 for child_row in child_rows:
@@ -786,8 +836,8 @@ def get_app(db_path: str) -> FastAPI:
             params.append(limit)
 
             exec_start = time.time()
-            cursor = await db.execute(query, params)
-            rows = await cursor.fetchall()
+            async with db.execute(query, params) as cursor:
+                rows = await cursor.fetchall()
 
             for row in rows:
                 events.append(
@@ -831,8 +881,8 @@ def get_app(db_path: str) -> FastAPI:
                     spike_query += " ORDER BY created_at DESC LIMIT ?"
                     spike_params.append(limit)
 
-                    spike_cursor = await db.execute(spike_query, spike_params)
-                    spike_rows = await spike_cursor.fetchall()
+                    async with db.execute(spike_query, spike_params) as spike_cursor:
+                        spike_rows = await spike_cursor.fetchall()
 
                     for row in spike_rows:
                         events.append(
@@ -882,8 +932,8 @@ def get_app(db_path: str) -> FastAPI:
                     collab_query += " ORDER BY timestamp DESC LIMIT ?"
                     collab_params.append(limit)
 
-                    collab_cursor = await db.execute(collab_query, collab_params)
-                    collab_rows = await collab_cursor.fetchall()
+                    async with db.execute(collab_query, collab_params) as collab_cursor:
+                        collab_rows = await collab_cursor.fetchall()
 
                     for row in collab_rows:
                         events.append(
@@ -996,8 +1046,8 @@ def get_app(db_path: str) -> FastAPI:
                 LIMIT ?
             """
 
-            cursor = await db.execute(user_query_query, [limit])
-            user_query_rows = await cursor.fetchall()
+            async with db.execute(user_query_query, [limit]) as cursor:
+                user_query_rows = await cursor.fetchall()
 
             conversation_turns: list[dict[str, Any]] = []
 
@@ -1041,8 +1091,8 @@ def get_app(db_path: str) -> FastAPI:
                     if depth >= max_depth:
                         return [], 0.0, 0, 0
 
-                    cursor = await db.execute(children_query, [parent_id])
-                    rows = await cursor.fetchall()
+                    async with db.execute(children_query, [parent_id]) as cursor:
+                        rows = await cursor.fetchall()
 
                     children_list: list[dict[str, Any]] = []
                     total_dur = 0.0
@@ -1318,8 +1368,8 @@ def get_app(db_path: str) -> FastAPI:
             query += " ORDER BY started_at DESC LIMIT ? OFFSET ?"
             params.extend([limit, offset])
 
-            cursor = await db.execute(query, params)
-            rows = await cursor.fetchall()
+            async with db.execute(query, params) as cursor:
+                rows = await cursor.fetchall()
 
             # Get total count for pagination
             count_query = "SELECT COUNT(*) FROM sessions WHERE 1=1"
@@ -1328,8 +1378,8 @@ def get_app(db_path: str) -> FastAPI:
                 count_query += " AND status = ?"
                 count_params.append(status)
 
-            count_cursor = await db.execute(count_query, count_params)
-            count_row = await count_cursor.fetchone()
+            async with db.execute(count_query, count_params) as count_cursor:
+                count_row = await count_cursor.fetchone()
             total = int(count_row[0]) if count_row else 0
 
             # Build session objects
@@ -1396,8 +1446,8 @@ def get_app(db_path: str) -> FastAPI:
                 LIMIT 50
             """
 
-            cursor = await db.execute(query)
-            rows = list(await cursor.fetchall())
+            async with db.execute(query) as cursor:
+                rows = list(await cursor.fetchall())
             logger.debug(f"orchestration_view: Query executed, got {len(rows)} rows")
 
             delegations = []
@@ -1663,22 +1713,29 @@ def get_app(db_path: str) -> FastAPI:
         finally:
             await db.close()
 
-    # ========== FEATURES ENDPOINTS ==========
+    # ========== WORK ITEMS ENDPOINTS ==========
 
     @app.get("/views/features", response_class=HTMLResponse)
-    async def features_view(request: Request, status: str = "all") -> HTMLResponse:
-        """Get features by status as HTMX partial."""
+    async def features_view_redirect(
+        request: Request, status: str = "all"
+    ) -> HTMLResponse:
+        """Redirect to work-items view (legacy endpoint for backward compatibility)."""
+        return await work_items_view(request, status)
+
+    @app.get("/views/work-items", response_class=HTMLResponse)
+    async def work_items_view(request: Request, status: str = "all") -> HTMLResponse:
+        """Get work items (features, bugs, spikes) by status as HTMX partial."""
         db = await get_db()
         cache = app.state.query_cache
         query_start_time = time.time()
 
         try:
             # Create cache key from query parameters
-            cache_key = f"features_view:{status}"
+            cache_key = f"work_items_view:{status}"
 
             # Check cache first
             cached_response = cache.get(cache_key)
-            features_by_status: dict = {
+            work_items_by_status: dict = {
                 "todo": [],
                 "in_progress": [],
                 "blocked": [],
@@ -1689,9 +1746,9 @@ def get_app(db_path: str) -> FastAPI:
                 query_time_ms = (time.time() - query_start_time) * 1000
                 cache.record_metric(cache_key, query_time_ms, cache_hit=True)
                 logger.debug(
-                    f"Cache HIT for features_view (key={cache_key}, time={query_time_ms:.2f}ms)"
+                    f"Cache HIT for work_items_view (key={cache_key}, time={query_time_ms:.2f}ms)"
                 )
-                features_by_status = cached_response
+                work_items_by_status = cached_response
             else:
                 # OPTIMIZATION: Use composite index idx_features_status_priority
                 # for efficient filtering and ordering
@@ -1733,37 +1790,37 @@ def get_app(db_path: str) -> FastAPI:
                 exec_time_ms = (time.time() - exec_start) * 1000
 
                 for row in rows:
-                    feature_id = row[0]
-                    feature_status = row[3]
-                    features_by_status.setdefault(feature_status, []).append(
+                    item_id = row[0]
+                    item_status = row[3]
+                    work_items_by_status.setdefault(item_status, []).append(
                         {
-                            "id": feature_id,
+                            "id": item_id,
                             "type": row[1],
                             "title": row[2],
-                            "status": feature_status,
+                            "status": item_status,
                             "priority": row[4],
                             "assigned_to": row[5],
                             "created_at": row[6],
                             "updated_at": row[7],
                             "description": row[8],
-                            "contributors": feature_agents.get(feature_id, []),
+                            "contributors": feature_agents.get(item_id, []),
                         }
                     )
 
                 # Cache the results
-                cache.set(cache_key, features_by_status)
+                cache.set(cache_key, work_items_by_status)
                 query_time_ms = (time.time() - query_start_time) * 1000
                 cache.record_metric(cache_key, exec_time_ms, cache_hit=False)
                 logger.debug(
-                    f"Cache MISS for features_view (key={cache_key}, "
+                    f"Cache MISS for work_items_view (key={cache_key}, "
                     f"db_time={exec_time_ms:.2f}ms, total_time={query_time_ms:.2f}ms)"
                 )
 
             return templates.TemplateResponse(
-                "partials/features.html",
+                "partials/work-items.html",
                 {
                     "request": request,
-                    "features_by_status": features_by_status,
+                    "work_items_by_status": work_items_by_status,
                 },
             )
         finally:
@@ -1830,19 +1887,19 @@ def get_app(db_path: str) -> FastAPI:
             else:
                 # OPTIMIZATION: Combine session data with event counts in single query
                 # This eliminates N+1 query problem (was 20+ queries, now 2)
-                # Note: Database uses agent_assigned but started_at/ended_at (partial migration)
+                # Note: Database uses created_at and completed_at (not started_at/ended_at)
                 query = """
                     SELECT
                         s.session_id,
                         s.agent_assigned,
                         s.status,
-                        s.started_at,
-                        s.ended_at,
+                        s.created_at,
+                        s.completed_at,
                         COUNT(DISTINCT e.event_id) as event_count
                     FROM sessions s
                     LEFT JOIN agent_events e ON s.session_id = e.session_id
                     GROUP BY s.session_id
-                    ORDER BY s.started_at DESC
+                    ORDER BY s.created_at DESC
                     LIMIT 20
                 """
 
@@ -1860,7 +1917,13 @@ def get_app(db_path: str) -> FastAPI:
                         ended_at = datetime.fromisoformat(row[4])
                         duration_seconds = (ended_at - started_at).total_seconds()
                     else:
-                        duration_seconds = (datetime.now() - started_at).total_seconds()
+                        # Use UTC to handle timezone-aware datetime comparison
+                        now = (
+                            datetime.now(started_at.tzinfo)
+                            if started_at.tzinfo
+                            else datetime.now()
+                        )
+                        duration_seconds = (now - started_at).total_seconds()
 
                     sessions.append(
                         {

htmlgraph/api/templates/dashboard-redesign.html

@@ -53,12 +53,12 @@
                 <span class="tab-icon">◊</span>
                 ORCHESTRATION
             </button>
-            <button class="tab-button" data-tab="features"
-                    hx-get="/views/features"
+            <button class="tab-button" data-tab="work-items"
+                    hx-get="/views/work-items"
                     hx-target="#content-area"
                     hx-trigger="click">
                 <span class="tab-icon">█</span>
-                FEATURES
+                WORK ITEMS
             </button>
             <button class="tab-button" data-tab="agents"
                     hx-get="/views/agents"

htmlgraph/api/templates/dashboard.html

@@ -52,12 +52,12 @@
                 Orchestration
             </button>
             <button class="tab-button"
-                    hx-get="/views/features"
+                    hx-get="/views/work-items"
                     hx-target="#content-area"
                     hx-trigger="click"
-                    data-tab="features">
+                    data-tab="work-items">
                 <span class="tab-icon">🎯</span>
-                Features
+                Work Items
             </button>
             <button class="tab-button"
                     hx-get="/views/agents"