omni-cortex 1.5.0__tar.gz → 1.7.0__tar.gz

{omni_cortex-1.5.0 → omni_cortex-1.7.0}/.gitignore

@@ -155,3 +155,8 @@ PROMPT.md
 memories.json
 .claude/
 .mcp.json
+
+# Personal/local files
+adws/
+specs/omni-cortex-adw-system.md
+nul

{omni_cortex-1.5.0 → omni_cortex-1.7.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: omni-cortex
-Version: 1.5.0
+Version: 1.7.0
 Summary: Give Claude Code a perfect memory - auto-logs everything, searches smartly, and gets smarter over time
 Project-URL: Homepage, https://github.com/AllCytes/Omni-Cortex
 Project-URL: Repository, https://github.com/AllCytes/Omni-Cortex
@@ -294,18 +294,47 @@ The PDFs use a light theme with blue/purple/green accents. Edit `docs/create_pdf
 
 ## Development
 
+### Quick Setup (with Claude Code)
+
+If you're using Claude Code, just run:
+
+```bash
+/dev-setup
+```
+
+This will guide you through setting up the development environment.
+
+### Manual Setup
+
 ```bash
-# Install dev dependencies
-pip install -e ".[dev]"
+# Clone and install in editable mode
+git clone https://github.com/AllCytes/Omni-Cortex.git
+cd Omni-Cortex
+pip install -e .
+
+# Install dashboard dependencies
+cd dashboard/backend && pip install -r requirements.txt
+cd ../frontend && npm install
+cd ../..
+
+# Verify installation
+omni-cortex --help
+omni-cortex-dashboard --help
+```
 
-# Run tests
+**Important**: Always use `pip install -e .` (editable mode) so changes are immediately reflected without reinstalling.
+
+### Running Tests
+
+```bash
 pytest
 
-# Format code
-black src tests
-ruff check src tests
+# With coverage
+pytest --cov=src/omni_cortex
 ```
 
+See [CONTRIBUTING.md](CONTRIBUTING.md) for full development guidelines.
+
 ## Security
 
 Omni Cortex v1.0.3 has been security reviewed:

{omni_cortex-1.5.0 → omni_cortex-1.7.0}/README.md

@@ -257,18 +257,47 @@ The PDFs use a light theme with blue/purple/green accents. Edit `docs/create_pdf
 
 ## Development
 
+### Quick Setup (with Claude Code)
+
+If you're using Claude Code, just run:
+
+```bash
+/dev-setup
+```
+
+This will guide you through setting up the development environment.
+
+### Manual Setup
+
 ```bash
-# Install dev dependencies
-pip install -e ".[dev]"
+# Clone and install in editable mode
+git clone https://github.com/AllCytes/Omni-Cortex.git
+cd Omni-Cortex
+pip install -e .
+
+# Install dashboard dependencies
+cd dashboard/backend && pip install -r requirements.txt
+cd ../frontend && npm install
+cd ../..
+
+# Verify installation
+omni-cortex --help
+omni-cortex-dashboard --help
+```
 
-# Run tests
+**Important**: Always use `pip install -e .` (editable mode) so changes are immediately reflected without reinstalling.
+
+### Running Tests
+
+```bash
 pytest
 
-# Format code
-black src tests
-ruff check src tests
+# With coverage
+pytest --cov=src/omni_cortex
 ```
 
+See [CONTRIBUTING.md](CONTRIBUTING.md) for full development guidelines.
+
 ## Security
 
 Omni Cortex v1.0.3 has been security reviewed:

{omni_cortex-1.5.0 → omni_cortex-1.7.0}/dashboard/backend/chat_service.py

@@ -214,9 +214,13 @@ async def save_conversation(
     client = get_client()
     if client:
         try:
+            # Escape content to prevent injection in summary generation
+            safe_content = xml_escape(content[:2000])
             summary_prompt = f"""Summarize this conversation in one concise sentence (max 100 chars):
 
-{content[:2000]}
+<conversation>
+{safe_content}
+</conversation>
 
 Summary:"""
             response = client.models.generate_content(

{omni_cortex-1.5.0 → omni_cortex-1.7.0}/dashboard/backend/image_service.py

@@ -209,9 +209,9 @@ Tags: {', '.join(memory.tags) if memory.tags else 'N/A'}
             if preset_prompt:
                 parts.append(f"\nImage style guidance:\n{preset_prompt}")
 
-        # Add user's custom prompt
+        # Add user's custom prompt (escaped to prevent injection)
         if request.custom_prompt:
-            parts.append(f"\nUser request: {request.custom_prompt}")
+            parts.append(f"\nUser request: {xml_escape(request.custom_prompt)}")
 
         parts.append("\nGenerate a professional, high-quality image optimized for social media sharing.")
 
@@ -461,10 +461,10 @@ Tags: {', '.join(memory.tags) if memory.tags else 'N/A'}
                 "parts": parts
             })
 
-        # Add refinement prompt
+        # Add refinement prompt (escaped to prevent injection)
         contents.append({
             "role": "user",
-            "parts": [{"text": refinement_prompt}]
+            "parts": [{"text": xml_escape(refinement_prompt)}]
         })
 
         # Configure - use defaults or provided values

{omni_cortex-1.5.0 → omni_cortex-1.7.0}/dashboard/backend/main.py

@@ -135,6 +135,7 @@ class DatabaseChangeHandler(FileSystemEventHandler):
         self.loop = loop
         self._debounce_task: Optional[asyncio.Task] = None
         self._last_path: Optional[str] = None
+        self._last_activity_count: dict[str, int] = {}
 
     def on_modified(self, event):
         if event.src_path.endswith("cortex.db") or event.src_path.endswith("global.db"):
@@ -146,9 +147,35 @@ class DatabaseChangeHandler(FileSystemEventHandler):
                 )
 
     async def _debounced_notify(self):
-        await asyncio.sleep(0.5)  # Wait for rapid changes to settle
+        await asyncio.sleep(0.3)  # Reduced from 0.5s for faster updates
         if self._last_path:
-            await self.ws_manager.broadcast("database_changed", {"path": self._last_path})
+            db_path = self._last_path
+
+            # Broadcast general database change
+            await self.ws_manager.broadcast("database_changed", {"path": db_path})
+
+            # Fetch and broadcast latest activities (IndyDevDan pattern)
+            try:
+                # Get recent activities
+                recent = get_activities(db_path, limit=5, offset=0)
+                if recent:
+                    # Broadcast each new activity
+                    for activity in recent:
+                        await self.ws_manager.broadcast_activity_logged(
+                            db_path,
+                            activity if isinstance(activity, dict) else activity.model_dump()
+                        )
+
+                    # Also broadcast session update
+                    sessions = get_recent_sessions(db_path, limit=1)
+                    if sessions:
+                        session = sessions[0]
+                        await self.ws_manager.broadcast_session_updated(
+                            db_path,
+                            session if isinstance(session, dict) else dict(session)
+                        )
+            except Exception as e:
+                print(f"[WS] Error broadcasting activities: {e}")
 
 
 # File watcher

{omni_cortex-1.5.0 → omni_cortex-1.7.0}/dashboard/backend/websocket_manager.py

@@ -77,6 +77,28 @@ class WebSocketManager:
         """Get the number of active connections."""
         return len(self.connections)
 
+    # Typed broadcast methods (IndyDevDan pattern)
+    async def broadcast_activity_logged(self, project: str, activity: dict[str, Any]):
+        """Broadcast when a new activity is logged."""
+        await self.broadcast("activity_logged", {
+            "project": project,
+            "activity": activity,
+        })
+
+    async def broadcast_session_updated(self, project: str, session: dict[str, Any]):
+        """Broadcast when a session is updated."""
+        await self.broadcast("session_updated", {
+            "project": project,
+            "session": session,
+        })
+
+    async def broadcast_stats_updated(self, project: str, stats: dict[str, Any]):
+        """Broadcast when stats change (for charts/panels)."""
+        await self.broadcast("stats_updated", {
+            "project": project,
+            "stats": stats,
+        })
+
 
 # Global manager instance
 manager = WebSocketManager()

omni_cortex-1.7.0/hooks/post_tool_use.py

@@ -0,0 +1,379 @@
+#!/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 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
+
+
+# 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 extract_skill_info(tool_input: dict, project_path: str) -> tuple:
+    """Extract skill name and scope from Skill tool input.
+
+    Returns:
+        Tuple of (skill_name, command_scope)
+    """
+    try:
+        skill_name = tool_input.get("skill", "")
+        if not skill_name:
+            return None, None
+
+        # Determine scope by checking file locations
+        project_cmd = Path(project_path) / ".claude" / "commands" / f"{skill_name}.md"
+        if project_cmd.exists():
+            return skill_name, "project"
+
+        universal_cmd = Path.home() / ".claude" / "commands" / f"{skill_name}.md"
+        if universal_cmd.exists():
+            return skill_name, "universal"
+
+        return skill_name, "unknown"
+    except Exception:
+        return None, None
+
+
+def extract_mcp_server(tool_name: str) -> str:
+    """Extract MCP server name from tool name pattern mcp__servername__toolname."""
+    if not tool_name or not tool_name.startswith("mcp__"):
+        return None
+
+    parts = tool_name.split("__")
+    if len(parts) >= 3:
+        return parts[1]
+    return None
+
+
+def ensure_analytics_columns(conn: sqlite3.Connection) -> None:
+    """Ensure command analytics columns exist in activities table."""
+    cursor = conn.cursor()
+    columns = cursor.execute("PRAGMA table_info(activities)").fetchall()
+    column_names = [col[1] for col in columns]
+
+    new_columns = [
+        ("command_name", "TEXT"),
+        ("command_scope", "TEXT"),
+        ("mcp_server", "TEXT"),
+        ("skill_name", "TEXT"),
+        ("summary", "TEXT"),
+        ("summary_detail", "TEXT"),
+    ]
+
+    for col_name, col_type in new_columns:
+        if col_name not in column_names:
+            cursor.execute(f"ALTER TABLE activities ADD COLUMN {col_name} {col_type}")
+
+    conn.commit()
+
+
+def generate_summary(tool_name: str, tool_input: dict, success: bool) -> tuple:
+    """Generate short and detailed summaries for an activity.
+
+    Returns:
+        Tuple of (summary, summary_detail)
+    """
+    if not tool_name:
+        return None, None
+
+    input_data = tool_input if isinstance(tool_input, dict) else {}
+    short = ""
+    detail = ""
+
+    if tool_name == "Read":
+        path = input_data.get("file_path", "unknown")
+        filename = Path(path).name if path else "file"
+        short = f"Read file: {filename}"
+        detail = f"Reading contents of {path}"
+
+    elif tool_name == "Write":
+        path = input_data.get("file_path", "unknown")
+        filename = Path(path).name if path else "file"
+        short = f"Write file: {filename}"
+        detail = f"Writing/creating file at {path}"
+
+    elif tool_name == "Edit":
+        path = input_data.get("file_path", "unknown")
+        filename = Path(path).name if path else "file"
+        short = f"Edit file: {filename}"
+        detail = f"Editing {path}"
+
+    elif tool_name == "Bash":
+        cmd = str(input_data.get("command", ""))[:50]
+        short = f"Run: {cmd}..."
+        detail = f"Executing: {input_data.get('command', 'unknown')}"
+
+    elif tool_name == "Grep":
+        pattern = input_data.get("pattern", "")
+        short = f"Search: {pattern[:30]}"
+        detail = f"Searching for pattern: {pattern}"
+
+    elif tool_name == "Glob":
+        pattern = input_data.get("pattern", "")
+        short = f"Find files: {pattern[:30]}"
+        detail = f"Finding files matching: {pattern}"
+
+    elif tool_name == "Skill":
+        skill = input_data.get("skill", "unknown")
+        short = f"Run skill: /{skill}"
+        detail = f"Executing slash command /{skill}"
+
+    elif tool_name == "Task":
+        desc = input_data.get("description", "task")
+        short = f"Spawn agent: {desc[:30]}"
+        detail = f"Launching sub-agent: {desc}"
+
+    elif tool_name == "TodoWrite":
+        todos = input_data.get("todos", [])
+        count = len(todos) if isinstance(todos, list) else 0
+        short = f"Update todo: {count} items"
+        detail = f"Managing task list with {count} items"
+
+    elif tool_name.startswith("mcp__"):
+        parts = tool_name.split("__")
+        server = parts[1] if len(parts) > 1 else "unknown"
+        tool = parts[2] if len(parts) > 2 else tool_name
+        short = f"MCP: {server}/{tool}"
+        detail = f"Calling {tool} from MCP server {server}"
+
+    else:
+        short = f"Tool: {tool_name}"
+        detail = f"Using tool {tool_name}"
+
+    if not success:
+        short = f"[FAILED] {short}"
+        detail = f"[FAILED] {detail}"
+
+    return short, detail
+
+
+def main():
+    """Process PostToolUse hook."""
+    try:
+        # Read all input at once (more reliable than json.load on stdin)
+        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", {})
+        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
+        # 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)
+
+        # Ensure analytics columns exist
+        ensure_analytics_columns(conn)
+
+        # 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
+        safe_output = redact_sensitive_fields(tool_output) if isinstance(tool_output, dict) else tool_output
+
+        # Extract command analytics
+        skill_name = None
+        command_scope = None
+        mcp_server = None
+
+        # Extract skill info from Skill tool calls
+        if tool_name == "Skill" and isinstance(tool_input, dict):
+            skill_name, command_scope = extract_skill_info(tool_input, project_path)
+
+        # Extract MCP server from tool name (mcp__servername__toolname pattern)
+        if tool_name and tool_name.startswith("mcp__"):
+            mcp_server = extract_mcp_server(tool_name)
+
+        # Generate summary for activity
+        summary = None
+        summary_detail = None
+        try:
+            summary, summary_detail = generate_summary(tool_name, safe_input, not is_error)
+        except Exception:
+            pass
+
+        # Insert activity record with analytics columns
+        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,
+                skill_name, command_scope, mcp_server, summary, summary_detail
+            ) VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)
+            """,
+            (
+                generate_id(),
+                session_id,
+                agent_id,
+                datetime.now(timezone.utc).isoformat(),
+                "post_tool_use",
+                tool_name,
+                truncate(json.dumps(safe_input, default=str)),
+                truncate(json.dumps(safe_output, default=str)),
+                0 if is_error else 1,
+                error_message,
+                project_path,
+                skill_name,
+                command_scope,
+                mcp_server,
+                summary,
+                summary_detail,
+            ),
+        )
+        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.5.0 → omni_cortex-1.7.0}/hooks/pre_tool_use.py

@@ -25,6 +25,9 @@ import sqlite3
 from datetime import datetime, timezone
 from pathlib import Path
 
+# Import shared session management
+from session_utils import get_or_create_session
+
 
 # Patterns for sensitive field names that should be redacted
 SENSITIVE_FIELD_PATTERNS = [
@@ -157,13 +160,15 @@ def main():
             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)
 
+        # 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