htmlgraph 0.9.3__py3-none-any.whl → 0.27.5__py3-none-any.whl

htmlgraph/analytics/work_type.py

@@ -1,3 +1,9 @@
+from __future__ import annotations
+
+import logging
+
+logger = logging.getLogger(__name__)
+
 """
 Analytics API for HtmlGraph work type analysis.
 
@@ -25,16 +31,33 @@ Example:
     # Returns: 25.5 (% of work spent on maintenance)
 """
 
-from __future__ import annotations
-from datetime import datetime
+from datetime import datetime, timezone
 from typing import TYPE_CHECKING
 
 if TYPE_CHECKING:
     from htmlgraph import SDK
 
-from htmlgraph.models import WorkType, Session
-from htmlgraph.session_manager import SessionManager
 from htmlgraph.converter import html_to_session
+from htmlgraph.models import Session, WorkType, utc_now
+from htmlgraph.session_manager import SessionManager
+
+
+def normalize_datetime(dt: datetime | None) -> datetime | None:
+    """
+    Normalize datetime to UTC-aware format for safe comparisons.
+
+    Handles three cases:
+    - None: returns None
+    - Naive (no timezone): assumes UTC and adds timezone
+    - Aware (has timezone): converts to UTC
+    """
+    if dt is None:
+        return None
+    if dt.tzinfo is None:
+        # Naive datetime - assume UTC
+        return dt.replace(tzinfo=timezone.utc)
+    # Already aware - convert to UTC
+    return dt.astimezone(timezone.utc)
 
 
 class Analytics:
@@ -78,7 +101,7 @@ class Analytics:
         Example:
             >>> analytics = sdk.analytics
             >>> dist = analytics.work_type_distribution(session_id="session-123")
-            >>> print(dist)
+            >>> logger.info("%s", dist)
             {
                 "feature-implementation": 45.2,
                 "spike-investigation": 28.3,
@@ -144,11 +167,11 @@ class Analytics:
 
         Example:
             >>> ratio = sdk.analytics.spike_to_feature_ratio(session_id="session-123")
-            >>> print(f"Spike-to-feature ratio: {ratio:.2f}")
+            >>> logger.info(f"Spike-to-feature ratio: {ratio:.2f}")
             Spike-to-feature ratio: 0.63
 
             >>> if ratio > 0.5:
-            ...     print("This was a research-heavy session")
+            ...     logger.info("This was a research-heavy session")
         """
         events = self._get_events(session_id, start_date, end_date)
 
@@ -202,11 +225,11 @@ class Analytics:
 
         Example:
             >>> burden = sdk.analytics.maintenance_burden(session_id="session-123")
-            >>> print(f"Maintenance burden: {burden:.1f}%")
+            >>> logger.info(f"Maintenance burden: {burden:.1f}%")
             Maintenance burden: 32.5%
 
             >>> if burden > 40:
-            ...     print("⚠️  High maintenance burden - consider addressing technical debt")
+            ...     logger.info("⚠️  High maintenance burden - consider addressing technical debt")
         """
         events = self._get_events(session_id, start_date, end_date)
 
@@ -257,7 +280,7 @@ class Analytics:
             >>> spike_sessions = sdk.analytics.get_sessions_by_work_type(
             ...     "spike-investigation"
             ... )
-            >>> print(f"Found {len(spike_sessions)} exploratory sessions")
+            >>> logger.info(f"Found {len(spike_sessions)} exploratory sessions")
         """
         session_nodes = self.sdk.sessions.all()
         matching_sessions = []
@@ -269,9 +292,11 @@ class Analytics:
                 continue
 
             # Check date range
-            if start_date and session.started_at < start_date:
+            start_normalized = normalize_datetime(start_date)
+            end_normalized = normalize_datetime(end_date)
+            if start_normalized and session.started_at < start_normalized:
                 continue
-            if end_date and session.started_at > end_date:
+            if end_normalized and session.started_at > end_normalized:
                 continue
 
             # Check primary work type
@@ -295,7 +320,7 @@ class Analytics:
 
         Example:
             >>> breakdown = sdk.analytics.calculate_session_work_breakdown("session-123")
-            >>> print(breakdown)
+            >>> logger.info("%s", breakdown)
             {
                 "feature-implementation": 45,
                 "spike-investigation": 28,
@@ -323,7 +348,7 @@ class Analytics:
 
         Example:
             >>> primary = sdk.analytics.calculate_session_primary_work_type("session-123")
-            >>> print(f"Primary work type: {primary}")
+            >>> logger.info(f"Primary work type: {primary}")
             Primary work type: spike-investigation
         """
         session = self._get_session(session_id)
@@ -352,6 +377,157 @@ class Analytics:
         except Exception:
             return None
 
+    def transition_time_metrics(
+        self,
+        session_id: str | None = None,
+        start_date: datetime | None = None,
+        end_date: datetime | None = None,
+    ) -> dict[str, float]:
+        """
+        Calculate time spent in transitions vs feature work.
+
+        Analyzes time spent in transition spikes (session-init, transition,
+        conversation-init) versus regular feature implementation.
+
+        Args:
+            session_id: Optional session ID to analyze (analyzes single session)
+            start_date: Optional start date for date range query
+            end_date: Optional end date for date range query
+
+        Returns:
+            Dictionary with transition metrics:
+            - transition_minutes: Total time in transition spikes
+            - feature_minutes: Total time in regular features
+            - total_minutes: Combined time
+            - transition_percent: % time spent in transitions (0-100)
+
+        Example:
+            >>> metrics = sdk.analytics.transition_time_metrics(session_id="session-123")
+            >>> logger.info(f"Transition time: {metrics['transition_percent']:.1f}%")
+            Transition time: 15.3%
+        """
+        from pathlib import Path
+
+        from htmlgraph.converter import NodeConverter
+
+        transition_minutes = 0.0
+        feature_minutes = 0.0
+
+        # Get all spikes
+        spikes_dir = Path(self.sdk._directory) / "spikes"
+        if not spikes_dir.exists():
+            return {
+                "transition_minutes": 0.0,
+                "feature_minutes": 0.0,
+                "total_minutes": 0.0,
+                "transition_percent": 0.0,
+            }
+
+        spike_converter = NodeConverter(spikes_dir)
+        all_spikes = spike_converter.load_all()
+
+        # Filter spikes by session if specified
+        if session_id:
+            session = self._get_session(session_id)
+            if session:
+                # Only include spikes linked to this session
+                spike_ids = set(session.worked_on)
+                all_spikes = [s for s in all_spikes if s.id in spike_ids]
+
+        # Calculate time for each spike
+        for spike in all_spikes:
+            # Apply date filters
+            start_normalized = normalize_datetime(start_date)
+            end_normalized = normalize_datetime(end_date)
+            if start_normalized and spike.created < start_normalized:
+                continue
+            if end_normalized and spike.created > end_normalized:
+                continue
+
+            # Calculate duration (normalize datetimes for safe comparison)
+            start_time = normalize_datetime(spike.created)
+            if not start_time:
+                continue  # Skip if spike creation date is missing
+            if spike.status == "done" and spike.updated:
+                end_time = normalize_datetime(spike.updated)
+            else:
+                # If still in progress, use last updated time
+                end_time = normalize_datetime(
+                    spike.updated if spike.updated else utc_now()
+                )
+            if not end_time:
+                end_time = start_time  # Fallback to start time if end time missing
+
+            duration = (
+                end_time - start_time
+            ).total_seconds() / 60  # Convert to minutes
+
+            # Categorize as transition or feature work
+            is_transition = spike.type == "spike" and spike.spike_subtype in (
+                "session-init",
+                "transition",
+                "conversation-init",
+            )
+
+            if is_transition:
+                transition_minutes += duration
+            else:
+                feature_minutes += duration
+
+        # Also get regular features, bugs, etc.
+        for collection in ["features", "bugs"]:
+            collection_dir = Path(self.sdk._directory) / collection
+            if not collection_dir.exists():
+                continue
+
+            converter = NodeConverter(collection_dir)
+            nodes = converter.load_all()
+
+            # Filter by session if specified
+            if session_id:
+                session = self._get_session(session_id)
+                if session:
+                    node_ids = set(session.worked_on)
+                    nodes = [n for n in nodes if n.id in node_ids]
+
+            for node in nodes:
+                # Apply date filters
+                start_normalized = normalize_datetime(start_date)
+                end_normalized = normalize_datetime(end_date)
+                if start_normalized and node.created < start_normalized:
+                    continue
+                if end_normalized and node.created > end_normalized:
+                    continue
+
+                # Calculate duration (normalize datetimes for safe comparison)
+                start_time = normalize_datetime(node.created)
+                if not start_time:
+                    continue  # Skip if node creation date is missing
+                if node.status == "done" and node.updated:
+                    end_time = normalize_datetime(node.updated)
+                else:
+                    end_time = normalize_datetime(
+                        node.updated if node.updated else utc_now()
+                    )
+                if not end_time:
+                    end_time = start_time  # Fallback to start time if end time missing
+
+                duration = (end_time - start_time).total_seconds() / 60
+                feature_minutes += duration
+
+        # Calculate metrics
+        total_minutes = transition_minutes + feature_minutes
+        transition_percent = (
+            (transition_minutes / total_minutes * 100) if total_minutes > 0 else 0.0
+        )
+
+        return {
+            "transition_minutes": round(transition_minutes, 2),
+            "feature_minutes": round(feature_minutes, 2),
+            "total_minutes": round(total_minutes, 2),
+            "transition_percent": round(transition_percent, 2),
+        }
+
     def _get_events(
         self,
         session_id: str | None = None,

htmlgraph/analytics_index.py

@@ -1,3 +1,5 @@
+from __future__ import annotations
+
 """
 SQLite analytics index for HtmlGraph event logs.
 
@@ -5,17 +7,15 @@ This is a rebuildable cache/index for fast dashboard queries.
 The canonical source of truth is the JSONL event log under `.htmlgraph/events/`.
 """
 
-from __future__ import annotations
 
 import json
 import sqlite3
+from collections.abc import Iterable
 from dataclasses import dataclass
-from datetime import datetime
 from pathlib import Path
-from typing import Any, Iterable
-
+from typing import Any
 
-SCHEMA_VERSION = 2
+SCHEMA_VERSION = 4  # Bumped: renamed 'agent' column to 'agent_assigned'
 
 
 @dataclass(frozen=True)
@@ -83,12 +83,14 @@ class AnalyticsIndex:
                 """
                 CREATE TABLE IF NOT EXISTS sessions (
                     session_id TEXT PRIMARY KEY,
-                    agent TEXT,
+                    agent_assigned TEXT,
                     start_commit TEXT,
                     continued_from TEXT,
                     status TEXT,
                     started_at TEXT,
-                    ended_at TEXT
+                    ended_at TEXT,
+                    parent_session_id TEXT,
+                    parent_event_id TEXT
                 )
                 """
             )
@@ -104,6 +106,9 @@ class AnalyticsIndex:
                     feature_id TEXT,
                     drift_score REAL,
                     payload_json TEXT,
+                    parent_event_id TEXT,
+                    cost_tokens INTEGER,
+                    execution_duration_seconds REAL,
                     FOREIGN KEY(session_id) REFERENCES sessions(session_id)
                 )
                 """
@@ -158,6 +163,9 @@ class AnalyticsIndex:
             )
 
             # Indexes for typical dashboard queries
+            conn.execute(
+                "CREATE INDEX IF NOT EXISTS idx_sessions_parent ON sessions(parent_session_id)"
+            )
             conn.execute("CREATE INDEX IF NOT EXISTS idx_events_ts ON events(ts)")
             conn.execute(
                 "CREATE INDEX IF NOT EXISTS idx_events_session_ts ON events(session_id, ts)"
@@ -165,7 +173,9 @@ class AnalyticsIndex:
             conn.execute(
                 "CREATE INDEX IF NOT EXISTS idx_events_feature_ts ON events(feature_id, ts)"
             )
-            conn.execute("CREATE INDEX IF NOT EXISTS idx_events_tool_ts ON events(tool, ts)")
+            conn.execute(
+                "CREATE INDEX IF NOT EXISTS idx_events_tool_ts ON events(tool, ts)"
+            )
             conn.execute(
                 "CREATE INDEX IF NOT EXISTS idx_events_success_ts ON events(success, ts)"
             )
@@ -175,8 +185,12 @@ class AnalyticsIndex:
             conn.execute(
                 "CREATE UNIQUE INDEX IF NOT EXISTS idx_event_files_event_path ON event_files(event_id, path)"
             )
-            conn.execute("CREATE INDEX IF NOT EXISTS idx_git_commits_ts ON git_commits(ts)")
-            conn.execute("CREATE INDEX IF NOT EXISTS idx_git_commit_features_feature ON git_commit_features(feature_id)")
+            conn.execute(
+                "CREATE INDEX IF NOT EXISTS idx_git_commits_ts ON git_commits(ts)"
+            )
+            conn.execute(
+                "CREATE INDEX IF NOT EXISTS idx_git_commit_features_feature ON git_commit_features(feature_id)"
+            )
 
     def upsert_session(self, session: dict[str, Any]) -> None:
         """
@@ -185,15 +199,17 @@ class AnalyticsIndex:
         with self.connect() as conn:
             conn.execute(
                 """
-                INSERT INTO sessions(session_id, agent, start_commit, continued_from, status, started_at, ended_at)
-                VALUES(?,?,?,?,?,?,?)
+                INSERT INTO sessions(session_id, agent_assigned, start_commit, continued_from, status, started_at, ended_at, parent_session_id, parent_event_id)
+                VALUES(?,?,?,?,?,?,?,?,?)
                 ON CONFLICT(session_id) DO UPDATE SET
-                    agent=excluded.agent,
+                    agent_assigned=excluded.agent_assigned,
                     start_commit=excluded.start_commit,
                     continued_from=excluded.continued_from,
                     status=excluded.status,
                     started_at=excluded.started_at,
-                    ended_at=excluded.ended_at
+                    ended_at=excluded.ended_at,
+                    parent_session_id=excluded.parent_session_id,
+                    parent_event_id=excluded.parent_event_id
                 """,
                 (
                     session.get("session_id"),
@@ -203,6 +219,8 @@ class AnalyticsIndex:
                     session.get("status"),
                     session.get("started_at"),
                     session.get("ended_at"),
+                    session.get("parent_session_id"),
+                    session.get("parent_event_id"),
                 ),
             )
 
@@ -221,7 +239,9 @@ class AnalyticsIndex:
 
         payload = event.get("payload")
         payload_json = (
-            json.dumps(payload, ensure_ascii=False, default=str) if payload is not None else None
+            json.dumps(payload, ensure_ascii=False, default=str)
+            if payload is not None
+            else None
         )
 
         file_paths = event.get("file_paths") or []
@@ -231,8 +251,8 @@ class AnalyticsIndex:
         with self.connect() as conn:
             conn.execute(
                 """
-                INSERT OR IGNORE INTO events(event_id, session_id, ts, tool, summary, success, feature_id, drift_score, payload_json)
-                VALUES(?,?,?,?,?,?,?,?,?)
+                INSERT OR IGNORE INTO events(event_id, session_id, ts, tool, summary, success, feature_id, drift_score, payload_json, parent_event_id, cost_tokens, execution_duration_seconds)
+                VALUES(?,?,?,?,?,?,?,?,?,?,?,?)
                 """,
                 (
                     event_id,
@@ -244,6 +264,9 @@ class AnalyticsIndex:
                     event.get("feature_id"),
                     event.get("drift_score"),
                     payload_json,
+                    event.get("parent_event_id"),
+                    event.get("cost_tokens"),
+                    event.get("execution_duration_seconds"),
                 ),
             )
             # Insert file path rows, idempotent by (event_id, path)
@@ -291,20 +314,34 @@ class AnalyticsIndex:
                     if not ts:
                         return None
 
-                    features = event.get("features") if isinstance(event.get("features"), list) else []
+                    features = (
+                        event.get("features")
+                        if isinstance(event.get("features"), list)
+                        else []
+                    )
                     feature_id = features[0] if features else None
 
                     # Best-effort deterministic IDs for GitCommit (by hash), otherwise timestamp-based.
                     if legacy_type == "GitCommit" and event.get("commit_hash"):
                         base = f"git-commit-{event.get('commit_hash')}"
-                        event_id = base if feature_id is None else f"{base}-{feature_id}"
-                        msg = (event.get("commit_message") or "").strip().splitlines()[0] if event.get("commit_message") else ""
-                        summary = f"Commit {event.get('commit_hash_short','')}: {msg}".strip()
+                        event_id = (
+                            base if feature_id is None else f"{base}-{feature_id}"
+                        )
+                        msg = (
+                            (event.get("commit_message") or "").strip().splitlines()[0]
+                            if event.get("commit_message")
+                            else ""
+                        )
+                        summary = f"Commit {event.get('commit_hash_short', '')}: {msg}".strip()
                     else:
                         event_id = f"legacy-{legacy_type.lower()}-{ts}"
                         summary = legacy_type
 
-                    file_paths = event.get("files_changed") if isinstance(event.get("files_changed"), list) else []
+                    file_paths = (
+                        event.get("files_changed")
+                        if isinstance(event.get("files_changed"), list)
+                        else []
+                    )
 
                     return {
                         "event_id": event_id,
@@ -336,15 +373,20 @@ class AnalyticsIndex:
                     continue
 
                 # Track session metadata from events (best-effort)
-                meta = session_meta.setdefault(session_id, {
-                    "session_id": session_id,
-                    "agent": event.get("agent"),
-                    "start_commit": event.get("start_commit"),
-                    "continued_from": event.get("continued_from"),
-                    "status": event.get("session_status"),
-                    "started_at": None,
-                    "ended_at": None,
-                })
+                meta = session_meta.setdefault(
+                    session_id,
+                    {
+                        "session_id": session_id,
+                        "agent": event.get("agent"),
+                        "start_commit": event.get("start_commit"),
+                        "continued_from": event.get("continued_from"),
+                        "status": event.get("session_status"),
+                        "started_at": None,
+                        "ended_at": None,
+                        "parent_session_id": event.get("parent_session_id"),
+                        "parent_event_id": event.get("parent_event_id"),
+                    },
+                )
                 if meta.get("agent") is None and event.get("agent"):
                     meta["agent"] = event.get("agent")
                 if meta.get("start_commit") is None and event.get("start_commit"):
@@ -353,6 +395,12 @@ class AnalyticsIndex:
                     meta["continued_from"] = event.get("continued_from")
                 if meta.get("status") is None and event.get("session_status"):
                     meta["status"] = event.get("session_status")
+                if meta.get("parent_session_id") is None and event.get(
+                    "parent_session_id"
+                ):
+                    meta["parent_session_id"] = event.get("parent_session_id")
+                if meta.get("parent_event_id") is None and event.get("parent_event_id"):
+                    meta["parent_event_id"] = event.get("parent_event_id")
 
                 # Track time range (treat earliest event as started_at, latest as ended_at if session is ended)
                 if meta["started_at"] is None or ts < meta["started_at"]:
@@ -362,13 +410,15 @@ class AnalyticsIndex:
 
                 payload = event.get("payload")
                 payload_json = (
-                    json.dumps(payload, ensure_ascii=False, default=str) if payload is not None else None
+                    json.dumps(payload, ensure_ascii=False, default=str)
+                    if payload is not None
+                    else None
                 )
 
                 conn.execute(
                     """
-                    INSERT OR IGNORE INTO events(event_id, session_id, ts, tool, summary, success, feature_id, drift_score, payload_json)
-                    VALUES(?,?,?,?,?,?,?,?,?)
+                    INSERT OR IGNORE INTO events(event_id, session_id, ts, tool, summary, success, feature_id, drift_score, payload_json, parent_event_id, cost_tokens, execution_duration_seconds)
+                    VALUES(?,?,?,?,?,?,?,?,?,?,?,?)
                     """,
                     (
                         event_id,
@@ -380,6 +430,9 @@ class AnalyticsIndex:
                         event.get("feature_id"),
                         event.get("drift_score"),
                         payload_json,
+                        event.get("parent_event_id"),
+                        event.get("cost_tokens"),
+                        event.get("execution_duration_seconds"),
                     ),
                 )
 
@@ -457,17 +510,19 @@ class AnalyticsIndex:
             for meta in session_meta.values():
                 conn.execute(
                     """
-                    INSERT INTO sessions(session_id, agent, start_commit, continued_from, status, started_at, ended_at)
-                    VALUES(?,?,?,?,?,?,?)
+                    INSERT INTO sessions(session_id, agent_assigned, start_commit, continued_from, status, started_at, ended_at, parent_session_id, parent_event_id)
+                    VALUES(?,?,?,?,?,?,?,?,?)
                     """,
                     (
                         meta.get("session_id"),
-                        meta.get("agent"),
+                        meta.get("agent"),  # Source data still uses 'agent' key
                         meta.get("start_commit"),
                         meta.get("continued_from"),
                         meta.get("status"),
                         meta.get("started_at"),
                         meta.get("ended_at"),
+                        meta.get("parent_session_id"),
+                        meta.get("parent_event_id"),
                     ),
                 )
 
@@ -477,7 +532,9 @@ class AnalyticsIndex:
     # Git continuity queries
     # ---------------------------------------------------------------------
 
-    def feature_commits(self, feature_id: str, limit: int = 200) -> list[dict[str, Any]]:
+    def feature_commits(
+        self, feature_id: str, limit: int = 200
+    ) -> list[dict[str, Any]]:
         """
         Return commit timeline for a feature based on GitCommit events.
         """
@@ -541,9 +598,28 @@ class AnalyticsIndex:
                 external.add(parent)
             edges.append({"from": parent, "to": r["commit_hash"]})
 
-        nodes = [{"id": c["commit_hash"], **{k: c.get(k) for k in ("commit_hash_short","ts","branch","subject","is_merge","insertions","deletions")}} for c in commits]
+        nodes = [
+            {
+                "id": c["commit_hash"],
+                **{
+                    k: c.get(k)
+                    for k in (
+                        "commit_hash_short",
+                        "ts",
+                        "branch",
+                        "subject",
+                        "is_merge",
+                        "insertions",
+                        "deletions",
+                    )
+                },
+            }
+            for c in commits
+        ]
         for parent in sorted(external):
-            nodes.append({"id": parent, "commit_hash_short": parent[:7], "external": True})
+            nodes.append(
+                {"id": parent, "commit_hash_short": parent[:7], "external": True}
+            )
 
         return {"nodes": nodes, "edges": edges}
 
@@ -551,7 +627,9 @@ class AnalyticsIndex:
     # Query helpers for API
     # ---------------------------------------------------------------------
 
-    def overview(self, since: str | None = None, until: str | None = None) -> dict[str, Any]:
+    def overview(
+        self, since: str | None = None, until: str | None = None
+    ) -> dict[str, Any]:
         """
         Return overview stats.
         since/until should be ISO8601 timestamps.
@@ -586,14 +664,14 @@ class AnalyticsIndex:
         return {
             "events": int(row["events"] or 0),
             "failures": int(row["failures"] or 0),
-            "failure_rate": (
-                float(row["failures"] or 0) / float(row["events"] or 1)
-            ),
+            "failure_rate": (float(row["failures"] or 0) / float(row["events"] or 1)),
             "avg_drift": row["avg_drift"],
             "top_tools": [dict(r) for r in by_tool],
         }
 
-    def top_features(self, since: str | None = None, until: str | None = None, limit: int = 50) -> list[dict[str, Any]]:
+    def top_features(
+        self, since: str | None = None, until: str | None = None, limit: int = 50
+    ) -> list[dict[str, Any]]:
         self.ensure_schema()
         clauses = []
         params: list[Any] = []
@@ -627,13 +705,17 @@ class AnalyticsIndex:
         with self.connect() as conn:
             rows = conn.execute(
                 """
-                SELECT event_id, session_id, ts, tool, summary, success, feature_id, drift_score
-                FROM events
-                WHERE session_id=?
-                ORDER BY ts DESC
+                SELECT e.event_id, e.session_id, e.ts, e.tool, e.summary, e.success, e.feature_id, e.drift_score,
+                       COALESCE(e.parent_event_id, s.parent_event_id) as parent_event_id,
+                       e.cost_tokens, e.execution_duration_seconds
+                FROM events e
+                JOIN sessions s ON e.session_id = s.session_id
+                WHERE e.session_id = ?
+                   OR s.parent_session_id = ?
+                ORDER BY e.ts DESC
                 LIMIT ?
                 """,
-                (session_id, int(limit)),
+                (session_id, session_id, int(limit)),
             ).fetchall()
         return [dict(r) for r in rows]
 
@@ -725,7 +807,9 @@ class AnalyticsIndex:
         return [dict(r) for r in rows]
 
 
-def _time_where_clause(column: str, since: str | None, until: str | None) -> tuple[str, tuple[Any, ...]]:
+def _time_where_clause(
+    column: str, since: str | None, until: str | None
+) -> tuple[str, tuple[Any, ...]]:
     clauses = []
     params: list[Any] = []
     if since:

htmlgraph/api/__init__.py

@@ -0,0 +1,3 @@
+"""HtmlGraph FastAPI Backend - Real-time Agent Observability Dashboard."""
+
+__all__ = ["app", "get_app"]