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

htmlgraph/__init__.py

@@ -96,7 +96,7 @@ from htmlgraph.types import (
 )
 from htmlgraph.work_type_utils import infer_work_type, infer_work_type_from_id
 
-__version__ = "0.26.24"
+__version__ = "0.26.25"
 __all__ = [
     # Exceptions
     "HtmlGraphError",

htmlgraph/api/main.py

@@ -267,7 +267,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
@@ -297,11 +309,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),
                         }
                     )
@@ -1663,22 +1683,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 +1716,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 +1760,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 +1857,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 +1887,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"