omni-cortex 1.0.0__py3-none-any.whl

omni_cortex-1.0.0.data/data/share/omni-cortex/hooks/post_tool_use.py

@@ -0,0 +1,154 @@
+#!/usr/bin/env python3
+"""PostToolUse hook - logs tool result after execution.
+
+This hook is called by Claude Code after each tool completes.
+It logs the tool output, duration, and success/error status.
+
+Hook configuration for settings.json:
+{
+    "hooks": {
+        "PostToolUse": [
+            {
+                "type": "command",
+                "command": "python hooks/post_tool_use.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 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 PostToolUse hook."""
+    try:
+        # Read input from stdin
+        input_data = json.load(sys.stdin)
+
+        # Extract data from hook input
+        tool_name = input_data.get("tool_name")
+        tool_input = input_data.get("tool_input", {})
+        tool_output = input_data.get("tool_output", {})
+        agent_id = input_data.get("agent_id")
+
+        # Determine success/error
+        is_error = input_data.get("is_error", False)
+        error_message = None
+        if is_error and isinstance(tool_output, dict):
+            error_message = tool_output.get("error") or tool_output.get("message")
+
+        # Skip logging our own tools to prevent recursion
+        if tool_name and tool_name.startswith("cortex_"):
+            print(json.dumps({}))
+            return
+
+        session_id = os.environ.get("CLAUDE_SESSION_ID")
+        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)
+
+        # Insert activity record
+        cursor = conn.cursor()
+        cursor.execute(
+            """
+            INSERT INTO activities (
+                id, session_id, agent_id, timestamp, event_type,
+                tool_name, tool_input, tool_output, success, error_message, project_path
+            ) VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)
+            """,
+            (
+                generate_id(),
+                session_id,
+                agent_id,
+                datetime.now(timezone.utc).isoformat(),
+                "post_tool_use",
+                tool_name,
+                truncate(json.dumps(tool_input, default=str)),
+                truncate(json.dumps(tool_output, default=str)),
+                0 if is_error else 1,
+                error_message,
+                project_path,
+            ),
+        )
+        conn.commit()
+        conn.close()
+
+        # Return empty response (no modification)
+        print(json.dumps({}))
+
+    except Exception as e:
+        # Hooks should never block - log error but continue
+        print(json.dumps({"systemMessage": f"Cortex post_tool_use: {e}"}))
+
+    sys.exit(0)
+
+
+if __name__ == "__main__":
+    main()

omni_cortex-1.0.0.data/data/share/omni-cortex/hooks/pre_tool_use.py

@@ -0,0 +1,144 @@
+#!/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 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 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
+        input_data = json.load(sys.stdin)
+
+        # 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
+        if tool_name and tool_name.startswith("cortex_"):
+            print(json.dumps({}))
+            return
+
+        session_id = os.environ.get("CLAUDE_SESSION_ID")
+        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)
+
+        # 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 (?, ?, ?, ?, ?, ?, ?, ?)
+            """,
+            (
+                generate_id(),
+                session_id,
+                agent_id,
+                datetime.now(timezone.utc).isoformat(),
+                "pre_tool_use",
+                tool_name,
+                truncate(json.dumps(tool_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-1.0.0.data/data/share/omni-cortex/hooks/stop.py

@@ -0,0 +1,184 @@
+#!/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
+
+        # End the session
+        cursor.execute(
+            "UPDATE sessions SET ended_at = ? WHERE id = ? AND ended_at IS NULL",
+            (now, 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()
+
+        if existing:
+            cursor.execute(
+                """
+                UPDATE session_summaries
+                SET key_errors = ?, files_modified = ?, tools_used = ?,
+                    total_activities = ?, total_memories_created = ?
+                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_id,
+                ),
+            )
+        else:
+            cursor.execute(
+                """
+                INSERT INTO session_summaries (
+                    id, session_id, key_errors, files_modified, tools_used,
+                    total_activities, total_memories_created, created_at
+                ) 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,
+                ),
+            )
+
+        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()

omni_cortex-1.0.0.data/data/share/omni-cortex/hooks/subagent_stop.py

@@ -0,0 +1,120 @@
+#!/usr/bin/env python3
+"""SubagentStop hook - logs when a subagent completes.
+
+This hook is called when a subagent (spawned by the Task tool) finishes.
+It logs the subagent completion and any results.
+
+Hook configuration for settings.json:
+{
+    "hooks": {
+        "SubagentStop": [
+            {
+                "type": "command",
+                "command": "python hooks/subagent_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() -> 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 SubagentStop hook."""
+    try:
+        # Read input from stdin
+        input_data = json.load(sys.stdin)
+
+        db_path = get_db_path()
+
+        # Only log if database exists
+        if not db_path.exists():
+            print(json.dumps({}))
+            return
+
+        # Extract data from hook input
+        subagent_id = input_data.get("subagent_id")
+        subagent_type = input_data.get("subagent_type", "subagent")
+        result = input_data.get("result", {})
+
+        session_id = os.environ.get("CLAUDE_SESSION_ID")
+        project_path = os.environ.get("CLAUDE_PROJECT_DIR", os.getcwd())
+        now = datetime.now(timezone.utc).isoformat()
+
+        # Connect to database
+        conn = sqlite3.connect(str(db_path))
+        cursor = conn.cursor()
+
+        # Log the subagent completion as an activity
+        cursor.execute(
+            """
+            INSERT INTO activities (
+                id, session_id, agent_id, timestamp, event_type,
+                tool_name, tool_output, success, project_path
+            ) VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?)
+            """,
+            (
+                generate_id(),
+                session_id,
+                subagent_id,
+                now,
+                "subagent_stop",
+                f"subagent_{subagent_type}",
+                truncate(json.dumps(result, default=str)),
+                1,
+                project_path,
+            ),
+        )
+
+        # Update or create agent record
+        cursor.execute(
+            """
+            INSERT INTO agents (id, name, type, first_seen, last_seen, total_activities)
+            VALUES (?, ?, ?, ?, ?, 1)
+            ON CONFLICT(id) DO UPDATE SET
+                last_seen = ?,
+                total_activities = total_activities + 1
+            """,
+            (subagent_id, None, "subagent", now, now, now),
+        )
+
+        conn.commit()
+        conn.close()
+
+        print(json.dumps({}))
+
+    except Exception as e:
+        # Hooks should never block
+        print(json.dumps({"systemMessage": f"Cortex subagent_stop: {e}"}))
+
+    sys.exit(0)
+
+
+if __name__ == "__main__":
+    main()

omni_cortex-1.0.0.dist-info/METADATA

@@ -0,0 +1,216 @@
+Metadata-Version: 2.4
+Name: omni-cortex
+Version: 1.0.0
+Summary: Universal Memory MCP for Claude Code - dual-layer activity logging and knowledge storage
+Project-URL: Homepage, https://github.com/AllCytes/Omni-Cortex
+Project-URL: Repository, https://github.com/AllCytes/Omni-Cortex
+Project-URL: Issues, https://github.com/AllCytes/Omni-Cortex/issues
+Project-URL: Documentation, https://github.com/AllCytes/Omni-Cortex#readme
+Author: Tony
+License-Expression: MIT
+License-File: LICENSE
+Keywords: ai,anthropic,claude,claude-code,llm,mcp,memory,semantic-search
+Classifier: Development Status :: 4 - Beta
+Classifier: Intended Audience :: Developers
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.10
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Programming Language :: Python :: 3.13
+Classifier: Topic :: Scientific/Engineering :: Artificial Intelligence
+Classifier: Topic :: Software Development :: Libraries :: Python Modules
+Requires-Python: >=3.10
+Requires-Dist: httpx>=0.25.0
+Requires-Dist: mcp>=1.0.0
+Requires-Dist: pydantic>=2.0.0
+Requires-Dist: pyyaml>=6.0.0
+Provides-Extra: dev
+Requires-Dist: black>=23.0.0; extra == 'dev'
+Requires-Dist: pytest-asyncio>=0.21.0; extra == 'dev'
+Requires-Dist: pytest>=7.0.0; extra == 'dev'
+Requires-Dist: ruff>=0.1.0; extra == 'dev'
+Provides-Extra: semantic
+Requires-Dist: numpy>=1.24.0; extra == 'semantic'
+Requires-Dist: sentence-transformers>=2.2.0; extra == 'semantic'
+Description-Content-Type: text/markdown
+
+# Omni Cortex MCP
+
+A universal memory system for Claude Code that combines activity logging with intelligent knowledge storage.
+
+## Features
+
+- **Zero Configuration**: Works out of the box - just install and run setup
+- **Dual-Layer Storage**: Activity logging (audit trail) + Knowledge store (memories)
+- **15 MCP Tools**: Full-featured API for memory management, activity tracking, and session continuity
+- **Semantic Search**: AI-powered search using sentence-transformers (optional)
+- **Hybrid Search**: Combines keyword (FTS5) + semantic search for best results
+- **Full-Text Search**: SQLite FTS5-powered keyword search with smart ranking
+- **Auto-Categorization**: Automatic memory type detection and tag suggestions
+- **Session Continuity**: "Last time you were working on..." context
+- **Importance Decay**: Frequently accessed memories naturally surface
+- **Auto Activity Logging**: Automatically logs all tool calls via hooks
+
+## Installation
+
+### Quick Install (Recommended)
+
+```bash
+# Install the package
+pip install omni-cortex
+
+# Run automatic setup (configures MCP server + hooks)
+omni-cortex-setup
+```
+
+That's it! Omni Cortex will now:
+- Automatically log all Claude Code tool calls
+- Provide memory tools (cortex_remember, cortex_recall, etc.)
+- Create a per-project database at `.omni-cortex/cortex.db`
+
+### With Semantic Search
+
+For AI-powered semantic search capabilities:
+
+```bash
+pip install omni-cortex[semantic]
+omni-cortex-setup
+```
+
+### From Source
+
+```bash
+git clone https://github.com/AllCytes/Omni-Cortex.git
+cd omni-cortex
+pip install -e ".[semantic]"
+python -m omni_cortex.setup
+```
+
+### Manual Configuration
+
+If you prefer manual setup, add to `~/.claude.json`:
+
+```json
+{
+  "mcpServers": {
+    "omni-cortex": {
+      "command": "python",
+      "args": ["-m", "omni_cortex.server"]
+    }
+  }
+}
+```
+
+And optionally configure hooks in `~/.claude/settings.json` for activity logging:
+
+```json
+{
+  "hooks": {
+    "PreToolUse": [{
+      "type": "command",
+      "command": "python -m omni_cortex.hooks.pre_tool_use"
+    }],
+    "PostToolUse": [{
+      "type": "command",
+      "command": "python -m omni_cortex.hooks.post_tool_use"
+    }]
+  }
+}
+```
+
+### Uninstall
+
+```bash
+omni-cortex-setup --uninstall
+pip uninstall omni-cortex
+```
+
+## Tools
+
+### Memory Tools (6)
+
+| Tool | Description |
+|------|-------------|
+| `cortex_remember` | Store information with auto-categorization |
+| `cortex_recall` | Search memories (modes: keyword, semantic, hybrid) |
+| `cortex_list_memories` | List memories with filters and pagination |
+| `cortex_update_memory` | Update memory content, tags, or status |
+| `cortex_forget` | Delete a memory |
+| `cortex_link_memories` | Create relationships between memories |
+
+### Activity Tools (3)
+
+| Tool | Description |
+|------|-------------|
+| `cortex_log_activity` | Manually log an activity |
+| `cortex_get_activities` | Query the activity log |
+| `cortex_get_timeline` | Get a chronological timeline |
+
+### Session Tools (3)
+
+| Tool | Description |
+|------|-------------|
+| `cortex_start_session` | Start a new session with context |
+| `cortex_end_session` | End session and generate summary |
+| `cortex_get_session_context` | Get context from previous sessions |
+
+### Utility Tools (3)
+
+| Tool | Description |
+|------|-------------|
+| `cortex_list_tags` | List all tags with usage counts |
+| `cortex_review_memories` | Review and update memory freshness |
+| `cortex_export` | Export data to markdown or JSON |
+
+## Memory Types
+
+Memories are automatically categorized into:
+
+- `general` - General notes and information
+- `warning` - Cautions, things to avoid
+- `tip` - Tips, tricks, best practices
+- `config` - Configuration and settings
+- `troubleshooting` - Debugging and problem-solving
+- `code` - Code snippets and algorithms
+- `error` - Error messages and failures
+- `solution` - Solutions to problems
+- `command` - CLI commands
+- `concept` - Definitions and explanations
+- `decision` - Architectural decisions
+
+## Storage
+
+- **Per-project**: `.omni-cortex/cortex.db` in your project directory
+- **Global**: `~/.omni-cortex/global.db` for cross-project search
+
+## Configuration
+
+Create `.omni-cortex/config.yaml` in your project:
+
+```yaml
+schema_version: "1.0"
+embedding_enabled: true
+decay_rate_per_day: 0.5
+freshness_review_days: 30
+auto_provide_context: true
+context_depth: 3
+```
+
+## Development
+
+```bash
+# Install dev dependencies
+pip install -e ".[dev]"
+
+# Run tests
+pytest
+
+# Format code
+black src tests
+ruff check src tests
+```
+
+## License
+
+MIT

omni_cortex-1.0.0.dist-info/RECORD

@@ -0,0 +1,9 @@
+omni_cortex-1.0.0.data/data/share/omni-cortex/hooks/post_tool_use.py,sha256=J9NDtoPE4MbCacAX9XYhqRXF2Agaw_SRbik8U0jlovs,4828
+omni_cortex-1.0.0.data/data/share/omni-cortex/hooks/pre_tool_use.py,sha256=jLkoleRSb_MJ0iy-uNwKVi8-gS49vlmLaF--riJoff0,4351
+omni_cortex-1.0.0.data/data/share/omni-cortex/hooks/stop.py,sha256=T1bwcmbTLj0gzjrVvFBT1zB6wff4J2YkYBAY-ZxZI5g,5336
+omni_cortex-1.0.0.data/data/share/omni-cortex/hooks/subagent_stop.py,sha256=V9HQSFGNOfkg8ZCstPEy4h5V8BP4AbrVr8teFzN1kNk,3314
+omni_cortex-1.0.0.dist-info/METADATA,sha256=Q3zKLHnNw0YmcG9Kd2XnMjlKtEYcPFauZVJr931Nfus,6130
+omni_cortex-1.0.0.dist-info/WHEEL,sha256=WLgqFyCfm_KASv4WHyYy0P3pM_m7J5L9k2skdKLirC8,87
+omni_cortex-1.0.0.dist-info/entry_points.txt,sha256=eRePHG-7dXr4ZAHwI1l-GY5rgVrpa1wZPL3sYBeC5QU,99
+omni_cortex-1.0.0.dist-info/licenses/LICENSE,sha256=oG_397owMmi-Umxp5sYocJ6RPohp9_bDNnnEu9OUphg,1072
+omni_cortex-1.0.0.dist-info/RECORD,,

omni_cortex-1.0.0.dist-info/WHEEL

@@ -0,0 +1,4 @@
+Wheel-Version: 1.0
+Generator: hatchling 1.28.0
+Root-Is-Purelib: true
+Tag: py3-none-any

omni_cortex-1.0.0.dist-info/entry_points.txt

@@ -0,0 +1,3 @@
+[console_scripts]
+omni-cortex = omni_cortex.server:main
+omni-cortex-setup = omni_cortex.setup:main

omni_cortex-1.0.0.dist-info/licenses/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2025 Tony Simonovsky
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.