htmlgraph 0.25.0__py3-none-any.whl → 0.26.2__py3-none-any.whl

htmlgraph/hooks/context.py

@@ -37,6 +37,7 @@ class HookContext:
         session_id: Unique session identifier for this execution
         agent_id: Agent/tool that's executing (e.g., 'claude-code', 'codex')
         hook_input: Raw hook input data from Claude Code
+        model_name: Specific Claude model name (e.g., 'claude-haiku', 'claude-opus', 'claude-sonnet')
         _session_manager: Cached SessionManager instance (lazy-loaded)
         _database: Cached HtmlGraphDB instance (lazy-loaded)
     """
@@ -45,18 +46,20 @@ class HookContext:
     graph_dir: Path
     session_id: str
     agent_id: str
-    hook_input: dict
+    hook_input: dict[str, Any]
+    model_name: str | None = field(default=None, repr=False)
     _session_manager: Any | None = field(default=None, repr=False)
     _database: Any | None = field(default=None, repr=False)
 
     @classmethod
-    def from_input(cls, hook_input: dict) -> "HookContext":
+    def from_input(cls, hook_input: dict[str, Any]) -> "HookContext":
         """
         Create HookContext from raw hook input.
 
         Performs automatic environment resolution:
         - Extracts session_id from hook_input
         - Detects agent_id from environment or hook_input
+        - Detects model_name (e.g., claude-haiku, claude-opus, claude-sonnet)
         - Resolves project directory via bootstrap
         - Initializes graph directory
 
@@ -79,7 +82,7 @@ class HookContext:
                 ...
             }
             context = HookContext.from_input(hook_input)
-            logger.info(f"Session: {context.session_id}, Agent: {context.agent_id}")
+            logger.info(f"Session: {context.session_id}, Agent: {context.agent_id}, Model: {context.model_name}")
             ```
         """
         # Import bootstrap locally to avoid circular imports
@@ -88,8 +91,69 @@ class HookContext:
             resolve_project_dir,
         )
 
-        # Extract session ID from hook input
-        session_id = hook_input.get("session_id", "unknown")
+        # Resolve project directory first
+        project_dir = resolve_project_dir()
+        graph_dir = get_graph_dir(project_dir)
+
+        # Extract session ID with multiple fallbacks
+        # Priority order:
+        # 1. hook_input["session_id"] (if Claude Code passes it)
+        # 2. hook_input["sessionId"] (camelCase variant)
+        # 3. HTMLGRAPH_SESSION_ID environment variable
+        # 4. CLAUDE_SESSION_ID environment variable
+        # 5. Most recent active session from database (NEW)
+        # 6. "unknown" as last resort
+        #
+        # NOTE: We intentionally do NOT use SessionManager.get_active_session()
+        # as a fallback because the "active session" is stored in a global file
+        # (.htmlgraph/session.json) that's shared across all Claude windows.
+        # Using it would cause cross-window event contamination where tool calls
+        # from Window B get linked to UserQuery events from Window A.
+        #
+        # However, we DO query the database by status='active' and created_at,
+        # which is different because it retrieves the most recent session that
+        # was explicitly marked as active (e.g., by SessionStart hook), without
+        # relying on a shared global agent state file.
+        session_id = (
+            hook_input.get("session_id")
+            or hook_input.get("sessionId")
+            or os.environ.get("HTMLGRAPH_SESSION_ID")
+            or os.environ.get("CLAUDE_SESSION_ID")
+        )
+
+        # Fallback: Query database for most recent active session
+        # This solves the issue where PostToolUse hooks don't receive session_id
+        # in hook_input, but SessionStart hook already created a session in the database.
+        if not session_id:
+            db_path = graph_dir / "htmlgraph.db"
+            if db_path.exists():
+                try:
+                    import sqlite3
+
+                    conn = sqlite3.connect(str(db_path), timeout=1.0)
+                    cursor = conn.cursor()
+                    cursor.execute("""
+                        SELECT session_id FROM sessions
+                        WHERE status = 'active'
+                        ORDER BY created_at DESC
+                        LIMIT 1
+                    """)
+                    row = cursor.fetchone()
+                    conn.close()
+                    if row:
+                        session_id = row[0]
+                        logger.info(f"Resolved session_id from database: {session_id}")
+                except Exception as e:
+                    logger.warning(f"Failed to query active session from database: {e}")
+
+            # Final fallback to "unknown" if database query fails
+            if not session_id:
+                session_id = "unknown"
+                logger.warning(
+                    "Could not resolve session_id from hook_input, environment, or database. "
+                    "Events will not be linked to parent UserQuery. "
+                    "For multi-window support, set HTMLGRAPH_SESSION_ID env var."
+                )
 
         # Detect agent ID (priority order)
         # 1. Explicit agent_id in hook input
@@ -102,15 +166,28 @@ class HookContext:
             or os.environ.get("CLAUDE_AGENT_NICKNAME", "unknown")
         )
 
-        # Resolve project directory with fallbacks
-        project_dir = resolve_project_dir()
+        # Detect model name (priority order)
+        # 1. Explicit model_name in hook input
+        # 2. CLAUDE_MODEL environment variable
+        # 3. HTMLGRAPH_MODEL environment variable
+        # 4. Status line cache (from ~/.cache/claude-code/status-{session_id}.json)
+        # 5. None (not available)
+        model_name = (
+            hook_input.get("model_name")
+            or hook_input.get("model")
+            or os.environ.get("CLAUDE_MODEL")
+            or os.environ.get("HTMLGRAPH_MODEL")
+        )
 
-        # Get or create graph directory
-        graph_dir = get_graph_dir(project_dir)
+        # Fallback: Try status line cache if model not detected yet
+        if not model_name and session_id and session_id != "unknown":
+            from htmlgraph.hooks.event_tracker import get_model_from_status_cache
+
+            model_name = get_model_from_status_cache(session_id)
 
         logger.info(
             f"Initializing hook context: session={session_id}, "
-            f"agent={agent_id}, project={project_dir}"
+            f"agent={agent_id}, model={model_name}, project={project_dir}"
         )
 
         return cls(
@@ -119,6 +196,7 @@ class HookContext:
             session_id=session_id,
             agent_id=agent_id,
             hook_input=hook_input,
+            model_name=model_name,
         )
 
     @property

htmlgraph/hooks/drift_handler.py

@@ -25,10 +25,9 @@ import os
 import subprocess
 from datetime import datetime, timedelta
 from pathlib import Path
-from typing import Any, Optional
+from typing import Any
 
 from htmlgraph.hooks.context import HookContext
-from htmlgraph.hooks.state_manager import DriftQueueManager
 
 logger = logging.getLogger(__name__)
 
@@ -113,7 +112,7 @@ DEFAULT_DRIFT_CONFIG = {
 }
 
 
-def load_drift_config(graph_dir: Path) -> dict:
+def load_drift_config(graph_dir: Path) -> dict[str, Any]:
     """
     Load drift configuration from project or fallback to defaults.
 
@@ -151,7 +150,7 @@ def load_drift_config(graph_dir: Path) -> dict:
         if config_path.exists() and config_path.is_file():
             try:
                 with open(config_path) as f:
-                    config = json.load(f)
+                    config: dict[str, Any] = json.load(f)
                     logger.debug(f"Loaded drift config from {config_path}")
                     return config
             except json.JSONDecodeError as e:
@@ -163,7 +162,9 @@ def load_drift_config(graph_dir: Path) -> dict:
     return DEFAULT_DRIFT_CONFIG
 
 
-def detect_drift(activity_result: dict, config: dict) -> tuple[float, Optional[str]]:
+def detect_drift(
+    activity_result: dict[str, Any], config: dict[str, Any]
+) -> tuple[float, str | None]:
     """
     Calculate drift score from activity result and check thresholds.
 
@@ -201,9 +202,7 @@ def detect_drift(activity_result: dict, config: dict) -> tuple[float, Optional[s
     drift_score = getattr(activity_result, "drift_score", 0.0) or 0.0
     feature_id = getattr(activity_result, "feature_id", None)
 
-    logger.debug(
-        f"Drift detected: score={drift_score:.2f}, feature={feature_id}"
-    )
+    logger.debug(f"Drift detected: score={drift_score:.2f}, feature={feature_id}")
 
     return (drift_score, feature_id)
 
@@ -211,9 +210,9 @@ def detect_drift(activity_result: dict, config: dict) -> tuple[float, Optional[s
 def handle_high_drift(
     context: HookContext,
     drift_score: float,
-    queue: dict,
-    config: dict,
-) -> Optional[str]:
+    queue: dict[str, Any],
+    config: dict[str, Any],
+) -> str | None:
     """
     Generate nudge message for high-drift activities.
 
@@ -255,7 +254,6 @@ def handle_high_drift(
         return None
 
     # Get queue size for nudge message
-    queue_manager = DriftQueueManager(context.graph_dir)
     min_activities = drift_config.get("min_activities_before_classify", 3)
     current_count = len(queue.get("activities", []))
 
@@ -275,9 +273,9 @@ def handle_high_drift(
 
 def trigger_auto_classification(
     context: HookContext,
-    queue: dict,
+    queue: dict[str, Any],
     feature_id: str,
-    config: dict,
+    config: dict[str, Any],
 ) -> bool:
     """
     Check if auto-classification should be triggered.
@@ -344,7 +342,7 @@ def trigger_auto_classification(
     return True
 
 
-def build_classification_prompt(queue: dict, feature_id: str) -> str:
+def build_classification_prompt(queue: dict[str, Any], feature_id: str) -> str:
     """
     Build structured prompt for auto-classification agent.
 
@@ -423,8 +421,8 @@ Create the work item now using Write tool."""
 
 
 def run_headless_classification(
-    context: HookContext, prompt: str, config: dict
-) -> tuple[bool, Optional[str]]:
+    context: HookContext, prompt: str, config: dict[str, Any]
+) -> tuple[bool, str | None]:
     """
     Attempt to run auto-classification via headless claude subprocess.
 
@@ -460,7 +458,14 @@ def run_headless_classification(
 
     try:
         result = subprocess.run(
-            ["claude", "-p", prompt, "--model", model, "--dangerously-skip-permissions"],
+            [
+                "claude",
+                "-p",
+                prompt,
+                "--model",
+                model,
+                "--dangerously-skip-permissions",
+            ],
             capture_output=True,
             text=True,
             timeout=120,
@@ -497,8 +502,7 @@ def run_headless_classification(
     except FileNotFoundError:
         logger.error("claude command not found")
         nudge = (
-            "HIGH DRIFT - claude not available. "
-            "Please classify manually in .htmlgraph/"
+            "HIGH DRIFT - claude not available. Please classify manually in .htmlgraph/"
         )
         return (False, nudge)
     except Exception as e: