omni-cortex 1.17.2__py3-none-any.whl → 1.17.3__py3-none-any.whl

omni_cortex/_bundled/hooks/pre_tool_use.py

@@ -0,0 +1,277 @@
+#!/usr/bin/env python3
+"""PreToolUse hook - logs tool call before execution.
+
+This hook is called by Claude Code before each tool is executed.
+It logs the tool name and input to the Cortex activity database.
+
+Hook configuration for settings.json:
+{
+    "hooks": {
+        "PreToolUse": [
+            {
+                "type": "command",
+                "command": "python hooks/pre_tool_use.py"
+            }
+        ]
+    }
+}
+"""
+
+import json
+import re
+import sys
+import os
+import sqlite3
+from datetime import datetime, timezone
+from pathlib import Path
+
+# Import shared session management
+from session_utils import get_or_create_session
+
+
+# === Tool Timing Management ===
+# Store tool start timestamps for duration calculation in post_tool_use
+
+def get_timing_file_path() -> Path:
+    """Get the path to the tool timing file."""
+    project_path = os.environ.get("CLAUDE_PROJECT_DIR", os.getcwd())
+    return Path(project_path) / ".omni-cortex" / "tool_timing.json"
+
+
+def load_timing_data() -> dict:
+    """Load current timing data from file."""
+    timing_file = get_timing_file_path()
+    if not timing_file.exists():
+        return {}
+    try:
+        with open(timing_file, "r") as f:
+            return json.load(f)
+    except (json.JSONDecodeError, IOError):
+        return {}
+
+
+def save_timing_data(data: dict) -> None:
+    """Save timing data to file."""
+    timing_file = get_timing_file_path()
+    timing_file.parent.mkdir(parents=True, exist_ok=True)
+    with open(timing_file, "w") as f:
+        json.dump(data, f)
+
+
+def record_tool_start(tool_name: str, activity_id: str, agent_id: str = None) -> None:
+    """Record the start time for a tool execution.
+
+    Args:
+        tool_name: Name of the tool being executed
+        activity_id: Unique activity ID for this tool call
+        agent_id: Optional agent ID
+    """
+    timing_data = load_timing_data()
+
+    # Use activity_id as key (unique per tool call)
+    # Also store by tool_name for simpler matching in post_tool_use
+    key = f"{tool_name}_{agent_id or 'main'}"
+
+    timing_data[key] = {
+        "activity_id": activity_id,
+        "tool_name": tool_name,
+        "agent_id": agent_id,
+        "start_time_ms": int(datetime.now(timezone.utc).timestamp() * 1000),
+        "start_time_iso": datetime.now(timezone.utc).isoformat(),
+    }
+
+    # Clean up old entries (older than 1 hour) to prevent file bloat
+    now_ms = int(datetime.now(timezone.utc).timestamp() * 1000)
+    one_hour_ms = 60 * 60 * 1000
+    timing_data = {
+        k: v for k, v in timing_data.items()
+        if now_ms - v.get("start_time_ms", 0) < one_hour_ms
+    }
+
+    save_timing_data(timing_data)
+
+
+# Patterns for sensitive field names that should be redacted
+SENSITIVE_FIELD_PATTERNS = [
+    r'(?i)(api[_-]?key|apikey)',
+    r'(?i)(password|passwd|pwd)',
+    r'(?i)(secret|token|credential)',
+    r'(?i)(auth[_-]?token|access[_-]?token)',
+    r'(?i)(private[_-]?key|ssh[_-]?key)',
+]
+
+
+def redact_sensitive_fields(data: dict) -> dict:
+    """Redact sensitive fields from a dictionary for safe logging.
+
+    Recursively processes nested dicts and lists.
+    """
+    if not isinstance(data, dict):
+        return data
+
+    result = {}
+    for key, value in data.items():
+        # Check if key matches sensitive patterns
+        is_sensitive = any(
+            re.search(pattern, str(key))
+            for pattern in SENSITIVE_FIELD_PATTERNS
+        )
+
+        if is_sensitive:
+            result[key] = '[REDACTED]'
+        elif isinstance(value, dict):
+            result[key] = redact_sensitive_fields(value)
+        elif isinstance(value, list):
+            result[key] = [
+                redact_sensitive_fields(item) if isinstance(item, dict) else item
+                for item in value
+            ]
+        else:
+            result[key] = value
+
+    return result
+
+
+def get_db_path() -> Path:
+    """Get the database path for the current project."""
+    project_path = os.environ.get("CLAUDE_PROJECT_DIR", os.getcwd())
+    return Path(project_path) / ".omni-cortex" / "cortex.db"
+
+
+def ensure_database(db_path: Path) -> sqlite3.Connection:
+    """Ensure database exists and is initialized.
+
+    Auto-creates the database and schema if it doesn't exist.
+    This enables 'out of the box' functionality.
+    """
+    db_path.parent.mkdir(parents=True, exist_ok=True)
+    conn = sqlite3.connect(str(db_path))
+
+    # Check if schema exists
+    cursor = conn.cursor()
+    cursor.execute("SELECT name FROM sqlite_master WHERE type='table' AND name='activities'")
+    if cursor.fetchone() is None:
+        # Apply minimal schema for activities (full schema applied by MCP)
+        conn.executescript("""
+            CREATE TABLE IF NOT EXISTS activities (
+                id TEXT PRIMARY KEY,
+                session_id TEXT,
+                agent_id TEXT,
+                timestamp TEXT NOT NULL,
+                event_type TEXT NOT NULL,
+                tool_name TEXT,
+                tool_input TEXT,
+                tool_output TEXT,
+                duration_ms INTEGER,
+                success INTEGER DEFAULT 1,
+                error_message TEXT,
+                project_path TEXT,
+                file_path TEXT,
+                metadata TEXT
+            );
+            CREATE INDEX IF NOT EXISTS idx_activities_timestamp ON activities(timestamp DESC);
+            CREATE INDEX IF NOT EXISTS idx_activities_tool ON activities(tool_name);
+        """)
+        conn.commit()
+
+    return conn
+
+
+def generate_id() -> str:
+    """Generate a unique activity ID."""
+    timestamp_ms = int(datetime.now().timestamp() * 1000)
+    random_hex = os.urandom(4).hex()
+    return f"act_{timestamp_ms}_{random_hex}"
+
+
+def truncate(text: str, max_length: int = 10000) -> str:
+    """Truncate text to max length."""
+    if len(text) <= max_length:
+        return text
+    return text[:max_length - 20] + "\n... [truncated]"
+
+
+def main():
+    """Process PreToolUse hook."""
+    try:
+        # Read input from stdin with timeout protection
+        import select
+        if sys.platform != "win32":
+            # Unix: use select for timeout
+            ready, _, _ = select.select([sys.stdin], [], [], 5.0)
+            if not ready:
+                print(json.dumps({}))
+                return
+
+        # Read all input at once
+        raw_input = sys.stdin.read()
+        if not raw_input or not raw_input.strip():
+            print(json.dumps({}))
+            return
+
+        input_data = json.loads(raw_input)
+
+        # Extract data from hook input
+        tool_name = input_data.get("tool_name")
+        tool_input = input_data.get("tool_input", {})
+        agent_id = input_data.get("agent_id")
+
+        # Skip logging our own tools to prevent recursion
+        # MCP tools are named like "mcp__omni-cortex__cortex_remember"
+        if tool_name and ("cortex_" in tool_name or "omni-cortex" in tool_name):
+            print(json.dumps({}))
+            return
+
+        project_path = os.environ.get("CLAUDE_PROJECT_DIR", os.getcwd())
+
+        # Auto-initialize database (creates if not exists)
+        db_path = get_db_path()
+        conn = ensure_database(db_path)
+
+        # Get or create session (auto-manages session lifecycle)
+        session_id = get_or_create_session(conn, project_path)
+
+        # Redact sensitive fields before logging
+        safe_input = redact_sensitive_fields(tool_input) if isinstance(tool_input, dict) else tool_input
+
+        # Generate activity ID
+        activity_id = generate_id()
+
+        # Record tool start time for duration calculation
+        record_tool_start(tool_name, activity_id, agent_id)
+
+        # Insert activity record
+        cursor = conn.cursor()
+        cursor.execute(
+            """
+            INSERT INTO activities (
+                id, session_id, agent_id, timestamp, event_type,
+                tool_name, tool_input, project_path
+            ) VALUES (?, ?, ?, ?, ?, ?, ?, ?)
+            """,
+            (
+                activity_id,
+                session_id,
+                agent_id,
+                datetime.now(timezone.utc).isoformat(),
+                "pre_tool_use",
+                tool_name,
+                truncate(json.dumps(safe_input, default=str)),
+                project_path,
+            ),
+        )
+        conn.commit()
+        conn.close()
+
+        # Return empty response (no modification to tool call)
+        print(json.dumps({}))
+
+    except Exception as e:
+        # Hooks should never block - log error but continue
+        print(json.dumps({"systemMessage": f"Cortex pre_tool_use: {e}"}))
+
+    sys.exit(0)
+
+
+if __name__ == "__main__":
+    main()

omni_cortex/_bundled/hooks/session_utils.py

@@ -0,0 +1,186 @@
+#!/usr/bin/env python3
+"""Shared session management utilities for Claude Code hooks.
+
+This module provides session management functionality that can be shared
+across pre_tool_use.py and post_tool_use.py hooks to ensure consistent
+session tracking.
+
+Session Management Logic:
+1. Check for existing session file at `.omni-cortex/current_session.json`
+2. If session exists and is valid (not timed out), use it
+3. If no valid session, create a new one in both file and database
+4. Update last_activity_at on each use to track session activity
+"""
+
+import json
+import os
+import sqlite3
+import time
+from datetime import datetime, timezone
+from pathlib import Path
+from typing import Optional
+
+
+# Session timeout in seconds (4 hours of inactivity = new session)
+SESSION_TIMEOUT_SECONDS = 4 * 60 * 60
+
+
+def generate_session_id() -> str:
+    """Generate a unique session ID matching the MCP format.
+
+    Returns:
+        Session ID in format: sess_{timestamp_ms}_{random_hex}
+    """
+    timestamp_ms = int(time.time() * 1000)
+    random_hex = os.urandom(4).hex()
+    return f"sess_{timestamp_ms}_{random_hex}"
+
+
+def get_session_file_path() -> Path:
+    """Get the path to the current session file.
+
+    Returns:
+        Path to .omni-cortex/current_session.json
+    """
+    project_path = os.environ.get("CLAUDE_PROJECT_DIR", os.getcwd())
+    return Path(project_path) / ".omni-cortex" / "current_session.json"
+
+
+def load_session_file() -> Optional[dict]:
+    """Load the current session from file if it exists.
+
+    Returns:
+        Session data dict or None if file doesn't exist or is invalid
+    """
+    session_file = get_session_file_path()
+    if not session_file.exists():
+        return None
+
+    try:
+        with open(session_file, "r") as f:
+            return json.load(f)
+    except (json.JSONDecodeError, IOError):
+        return None
+
+
+def save_session_file(session_data: dict) -> None:
+    """Save the current session to file.
+
+    Args:
+        session_data: Dict containing session_id, project_path, started_at, last_activity_at
+    """
+    session_file = get_session_file_path()
+    session_file.parent.mkdir(parents=True, exist_ok=True)
+
+    with open(session_file, "w") as f:
+        json.dump(session_data, f, indent=2)
+
+
+def is_session_valid(session_data: dict) -> bool:
+    """Check if a session is still valid (not timed out).
+
+    A session is valid if:
+    - It has a last_activity_at timestamp
+    - The timestamp is within SESSION_TIMEOUT_SECONDS of now
+
+    Args:
+        session_data: Session dict with last_activity_at field
+
+    Returns:
+        True if session is valid, False otherwise
+    """
+    last_activity = session_data.get("last_activity_at")
+    if not last_activity:
+        return False
+
+    try:
+        last_time = datetime.fromisoformat(last_activity.replace("Z", "+00:00"))
+        now = datetime.now(timezone.utc)
+        elapsed_seconds = (now - last_time).total_seconds()
+        return elapsed_seconds < SESSION_TIMEOUT_SECONDS
+    except (ValueError, TypeError):
+        return False
+
+
+def create_session_in_db(conn: sqlite3.Connection, session_id: str, project_path: str) -> None:
+    """Create a new session record in the database.
+
+    Also creates the sessions table if it doesn't exist (for first-run scenarios).
+
+    Args:
+        conn: SQLite database connection
+        session_id: The session ID to create
+        project_path: The project directory path
+    """
+    cursor = conn.cursor()
+    now = datetime.now(timezone.utc).isoformat()
+
+    # Check if sessions table exists (it might not if only activities table was created)
+    cursor.execute("SELECT name FROM sqlite_master WHERE type='table' AND name='sessions'")
+    if cursor.fetchone() is None:
+        # Create sessions table with minimal schema
+        conn.executescript("""
+            CREATE TABLE IF NOT EXISTS sessions (
+                id TEXT PRIMARY KEY,
+                project_path TEXT NOT NULL,
+                started_at TEXT NOT NULL,
+                ended_at TEXT,
+                summary TEXT,
+                tags TEXT,
+                metadata TEXT
+            );
+            CREATE INDEX IF NOT EXISTS idx_sessions_started ON sessions(started_at DESC);
+            CREATE INDEX IF NOT EXISTS idx_sessions_project ON sessions(project_path);
+        """)
+        conn.commit()
+
+    cursor.execute(
+        """
+        INSERT OR IGNORE INTO sessions (id, project_path, started_at)
+        VALUES (?, ?, ?)
+        """,
+        (session_id, project_path, now),
+    )
+    conn.commit()
+
+
+def get_or_create_session(conn: sqlite3.Connection, project_path: str) -> str:
+    """Get the current session ID, creating a new one if needed.
+
+    Session management logic:
+    1. Check for existing session file
+    2. If exists and not timed out, use it and update last_activity
+    3. If doesn't exist or timed out, create new session
+
+    Args:
+        conn: SQLite database connection
+        project_path: The project directory path
+
+    Returns:
+        The session ID to use for activity logging
+    """
+    session_data = load_session_file()
+    now_iso = datetime.now(timezone.utc).isoformat()
+
+    if session_data and is_session_valid(session_data):
+        # Update last activity time
+        session_data["last_activity_at"] = now_iso
+        save_session_file(session_data)
+        return session_data["session_id"]
+
+    # Create new session
+    session_id = generate_session_id()
+
+    # Create in database
+    create_session_in_db(conn, session_id, project_path)
+
+    # Save to file
+    session_data = {
+        "session_id": session_id,
+        "project_path": project_path,
+        "started_at": now_iso,
+        "last_activity_at": now_iso,
+    }
+    save_session_file(session_data)
+
+    return session_id

omni_cortex/_bundled/hooks/stop.py

@@ -0,0 +1,219 @@
+#!/usr/bin/env python3
+"""Stop hook - logs session end when Claude Code stops.
+
+This hook is called when Claude Code exits or the session ends.
+It finalizes the session and generates a summary.
+
+Hook configuration for settings.json:
+{
+    "hooks": {
+        "Stop": [
+            {
+                "type": "command",
+                "command": "python hooks/stop.py"
+            }
+        ]
+    }
+}
+"""
+
+import json
+import sys
+import os
+import sqlite3
+from datetime import datetime, timezone
+from pathlib import Path
+
+
+def get_db_path() -> Path:
+    """Get the database path for the current project."""
+    project_path = os.environ.get("CLAUDE_PROJECT_DIR", os.getcwd())
+    return Path(project_path) / ".omni-cortex" / "cortex.db"
+
+
+def generate_id(prefix: str) -> str:
+    """Generate a unique ID."""
+    timestamp_ms = int(datetime.now().timestamp() * 1000)
+    random_hex = os.urandom(4).hex()
+    return f"{prefix}_{timestamp_ms}_{random_hex}"
+
+
+def main():
+    """Process Stop hook."""
+    try:
+        # Read input from stdin
+        input_data = json.load(sys.stdin)
+
+        db_path = get_db_path()
+
+        # Only process if database exists
+        if not db_path.exists():
+            print(json.dumps({}))
+            return
+
+        session_id = os.environ.get("CLAUDE_SESSION_ID")
+        if not session_id:
+            print(json.dumps({}))
+            return
+
+        now = datetime.now(timezone.utc).isoformat()
+
+        # Connect to database
+        conn = sqlite3.connect(str(db_path))
+        conn.row_factory = sqlite3.Row
+        cursor = conn.cursor()
+
+        # Check if session exists
+        cursor.execute("SELECT id FROM sessions WHERE id = ?", (session_id,))
+        if not cursor.fetchone():
+            print(json.dumps({}))
+            conn.close()
+            return
+
+        # Get session start time for duration calculation
+        cursor.execute("SELECT started_at FROM sessions WHERE id = ?", (session_id,))
+        session_row = cursor.fetchone()
+        session_duration_ms = None
+
+        if session_row and session_row["started_at"]:
+            try:
+                started_at = session_row["started_at"]
+                started_dt = datetime.fromisoformat(started_at.replace("Z", "+00:00"))
+                ended_dt = datetime.now(timezone.utc)
+                session_duration_ms = int((ended_dt - started_dt).total_seconds() * 1000)
+            except (ValueError, TypeError):
+                pass
+
+        # End the session with duration
+        cursor.execute(
+            "UPDATE sessions SET ended_at = ?, duration_ms = ? WHERE id = ? AND ended_at IS NULL",
+            (now, session_duration_ms, session_id),
+        )
+
+        # Gather session statistics
+        cursor.execute(
+            "SELECT COUNT(*) as cnt FROM activities WHERE session_id = ?",
+            (session_id,),
+        )
+        total_activities = cursor.fetchone()["cnt"]
+
+        cursor.execute(
+            "SELECT COUNT(*) as cnt FROM memories WHERE source_session_id = ?",
+            (session_id,),
+        )
+        total_memories = cursor.fetchone()["cnt"]
+
+        # Get tools used
+        cursor.execute(
+            """
+            SELECT tool_name, COUNT(*) as cnt
+            FROM activities
+            WHERE session_id = ? AND tool_name IS NOT NULL
+            GROUP BY tool_name
+            """,
+            (session_id,),
+        )
+        tools_used = {row["tool_name"]: row["cnt"] for row in cursor.fetchall()}
+
+        # Get files modified
+        cursor.execute(
+            """
+            SELECT DISTINCT file_path
+            FROM activities
+            WHERE session_id = ? AND file_path IS NOT NULL
+            """,
+            (session_id,),
+        )
+        files_modified = [row["file_path"] for row in cursor.fetchall()]
+
+        # Get errors
+        cursor.execute(
+            """
+            SELECT error_message
+            FROM activities
+            WHERE session_id = ? AND success = 0 AND error_message IS NOT NULL
+            LIMIT 10
+            """,
+            (session_id,),
+        )
+        key_errors = [row["error_message"] for row in cursor.fetchall()]
+
+        # Create or update summary
+        cursor.execute(
+            "SELECT id FROM session_summaries WHERE session_id = ?",
+            (session_id,),
+        )
+        existing = cursor.fetchone()
+
+        # Calculate tool duration breakdown from activities
+        cursor.execute(
+            """
+            SELECT tool_name, SUM(duration_ms) as total_ms, COUNT(*) as cnt
+            FROM activities
+            WHERE session_id = ? AND tool_name IS NOT NULL AND duration_ms IS NOT NULL
+            GROUP BY tool_name
+            """,
+            (session_id,),
+        )
+        tool_duration_breakdown = {
+            row["tool_name"]: {"total_ms": row["total_ms"], "count": row["cnt"]}
+            for row in cursor.fetchall()
+        }
+
+        if existing:
+            cursor.execute(
+                """
+                UPDATE session_summaries
+                SET key_errors = ?, files_modified = ?, tools_used = ?,
+                    total_activities = ?, total_memories_created = ?,
+                    duration_ms = ?, tool_duration_breakdown = ?
+                WHERE session_id = ?
+                """,
+                (
+                    json.dumps(key_errors) if key_errors else None,
+                    json.dumps(files_modified) if files_modified else None,
+                    json.dumps(tools_used) if tools_used else None,
+                    total_activities,
+                    total_memories,
+                    session_duration_ms,
+                    json.dumps(tool_duration_breakdown) if tool_duration_breakdown else None,
+                    session_id,
+                ),
+            )
+        else:
+            cursor.execute(
+                """
+                INSERT INTO session_summaries (
+                    id, session_id, key_errors, files_modified, tools_used,
+                    total_activities, total_memories_created, created_at,
+                    duration_ms, tool_duration_breakdown
+                ) VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?)
+                """,
+                (
+                    generate_id("sum"),
+                    session_id,
+                    json.dumps(key_errors) if key_errors else None,
+                    json.dumps(files_modified) if files_modified else None,
+                    json.dumps(tools_used) if tools_used else None,
+                    total_activities,
+                    total_memories,
+                    now,
+                    session_duration_ms,
+                    json.dumps(tool_duration_breakdown) if tool_duration_breakdown else None,
+                ),
+            )
+
+        conn.commit()
+        conn.close()
+
+        print(json.dumps({}))
+
+    except Exception as e:
+        # Hooks should never block
+        print(json.dumps({"systemMessage": f"Cortex stop: {e}"}))
+
+    sys.exit(0)
+
+
+if __name__ == "__main__":
+    main()