omni-cortex 1.0.0__tar.gz → 1.0.2__tar.gz

{omni_cortex-1.0.0 → omni_cortex-1.0.2}/.gitignore

@@ -151,7 +151,6 @@ test_*.py
 !tests/test_*.py
 
 # Development files
-HANDOFF.md
 PROMPT.md
 memories.json
 .claude/

{omni_cortex-1.0.0 → omni_cortex-1.0.2}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: omni-cortex
-Version: 1.0.0
+Version: 1.0.2
 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
@@ -43,7 +43,7 @@ A universal memory system for Claude Code that combines activity logging with in
 
 - **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
+- **18 MCP Tools**: Full-featured API for memory management, activity tracking, session continuity, and cross-project search
 - **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
@@ -163,6 +163,14 @@ pip uninstall omni-cortex
 | `cortex_review_memories` | Review and update memory freshness |
 | `cortex_export` | Export data to markdown or JSON |
 
+### Global Tools (3)
+
+| Tool | Description |
+|------|-------------|
+| `cortex_global_search` | Search memories across all projects |
+| `cortex_global_stats` | Get global index statistics |
+| `cortex_sync_to_global` | Manually sync to global index |
+
 ## Memory Types
 
 Memories are automatically categorized into:
@@ -197,6 +205,11 @@ auto_provide_context: true
 context_depth: 3
 ```
 
+## Documentation
+
+- [Tool Reference](docs/TOOLS.md) - Complete documentation for all 15 tools with examples
+- [Configuration Guide](docs/CONFIGURATION.md) - Configuration options and troubleshooting
+
 ## Development
 
 ```bash
@@ -211,6 +224,14 @@ black src tests
 ruff check src tests
 ```
 
+## Security
+
+Omni Cortex v1.0.3 has been security reviewed:
+- All SQL queries use parameterized statements
+- Input validation via Pydantic models
+- Model name validation prevents code injection
+- YAML loading uses `safe_load()`
+
 ## License
 
 MIT

{omni_cortex-1.0.0 → omni_cortex-1.0.2}/README.md

@@ -6,7 +6,7 @@ A universal memory system for Claude Code that combines activity logging with in
 
 - **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
+- **18 MCP Tools**: Full-featured API for memory management, activity tracking, session continuity, and cross-project search
 - **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
@@ -126,6 +126,14 @@ pip uninstall omni-cortex
 | `cortex_review_memories` | Review and update memory freshness |
 | `cortex_export` | Export data to markdown or JSON |
 
+### Global Tools (3)
+
+| Tool | Description |
+|------|-------------|
+| `cortex_global_search` | Search memories across all projects |
+| `cortex_global_stats` | Get global index statistics |
+| `cortex_sync_to_global` | Manually sync to global index |
+
 ## Memory Types
 
 Memories are automatically categorized into:
@@ -160,6 +168,11 @@ auto_provide_context: true
 context_depth: 3
 ```
 
+## Documentation
+
+- [Tool Reference](docs/TOOLS.md) - Complete documentation for all 15 tools with examples
+- [Configuration Guide](docs/CONFIGURATION.md) - Configuration options and troubleshooting
+
 ## Development
 
 ```bash
@@ -174,6 +187,14 @@ black src tests
 ruff check src tests
 ```
 
+## Security
+
+Omni Cortex v1.0.3 has been security reviewed:
+- All SQL queries use parameterized statements
+- Input validation via Pydantic models
+- Model name validation prevents code injection
+- YAML loading uses `safe_load()`
+
 ## License
 
 MIT

{omni_cortex-1.0.0 → omni_cortex-1.0.2}/hooks/post_tool_use.py

@@ -87,8 +87,13 @@ def truncate(text: str, max_length: int = 10000) -> str:
 def main():
     """Process PostToolUse hook."""
     try:
-        # Read input from stdin
-        input_data = json.load(sys.stdin)
+        # 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")
@@ -103,7 +108,8 @@ def main():
             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_"):
+        # 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
 

{omni_cortex-1.0.0 → omni_cortex-1.0.2}/hooks/pre_tool_use.py

@@ -87,8 +87,22 @@ def truncate(text: str, max_length: int = 10000) -> str:
 def main():
     """Process PreToolUse hook."""
     try:
-        # Read input from stdin
-        input_data = json.load(sys.stdin)
+        # 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")
@@ -96,7 +110,8 @@ def main():
         agent_id = input_data.get("agent_id")
 
         # Skip logging our own tools to prevent recursion
-        if tool_name and tool_name.startswith("cortex_"):
+        # 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
 

{omni_cortex-1.0.0 → omni_cortex-1.0.2}/omni_cortex/config.py

@@ -15,9 +15,9 @@ class CortexConfig:
     # Database
     schema_version: str = "1.0"
 
-    # Embedding
+    # Embedding (disabled by default - model loading can be slow)
     embedding_model: str = "all-MiniLM-L6-v2"
-    embedding_enabled: bool = True
+    embedding_enabled: bool = False
 
     # Decay
     decay_rate_per_day: float = 0.5

omni_cortex-1.0.2/omni_cortex/database/__init__.py

@@ -0,0 +1,24 @@
+"""Database layer for Omni Cortex - SQLite with FTS5."""
+
+from .connection import get_connection, init_database, close_connection
+from .schema import SCHEMA_VERSION, get_schema_sql
+from .sync import (
+    sync_memory_to_global,
+    delete_memory_from_global,
+    search_global_memories,
+    get_global_stats,
+    sync_all_project_memories,
+)
+
+__all__ = [
+    "get_connection",
+    "init_database",
+    "close_connection",
+    "SCHEMA_VERSION",
+    "get_schema_sql",
+    "sync_memory_to_global",
+    "delete_memory_from_global",
+    "search_global_memories",
+    "get_global_stats",
+    "sync_all_project_memories",
+]

omni_cortex-1.0.2/omni_cortex/database/sync.py

@@ -0,0 +1,421 @@
+"""Global index synchronization for cross-project memory search.
+
+This module handles syncing memories from project-local databases to the
+global database at ~/.omni-cortex/global.db, enabling cross-project search.
+"""
+
+import json
+import logging
+import sqlite3
+from pathlib import Path
+from typing import Optional
+
+from .connection import get_connection, init_database
+from ..config import get_global_db_path, get_project_path, load_config
+from ..utils.timestamps import now_iso
+
+logger = logging.getLogger(__name__)
+
+
+def sync_memory_to_global(
+    memory_id: str,
+    content: str,
+    memory_type: str,
+    tags: list[str],
+    context: Optional[str],
+    importance_score: float,
+    status: str,
+    project_path: str,
+    created_at: str,
+    updated_at: str,
+) -> bool:
+    """Sync a single memory to the global index.
+
+    Args:
+        memory_id: The memory ID
+        content: Memory content
+        memory_type: Memory type
+        tags: List of tags
+        context: Optional context
+        importance_score: Importance score
+        status: Memory status
+        project_path: Source project path
+        created_at: Creation timestamp
+        updated_at: Update timestamp
+
+    Returns:
+        True if synced successfully
+    """
+    config = load_config()
+    if not config.global_sync_enabled:
+        return False
+
+    try:
+        global_conn = init_database(is_global=True)
+
+        cursor = global_conn.cursor()
+
+        # Upsert the memory to global index
+        cursor.execute(
+            """
+            INSERT INTO memories (
+                id, content, type, tags, context,
+                created_at, updated_at, last_accessed,
+                access_count, importance_score, status,
+                project_path, has_embedding
+            ) VALUES (?, ?, ?, ?, ?, ?, ?, ?, 0, ?, ?, ?, 0)
+            ON CONFLICT(id) DO UPDATE SET
+                content = excluded.content,
+                type = excluded.type,
+                tags = excluded.tags,
+                context = excluded.context,
+                updated_at = excluded.updated_at,
+                importance_score = excluded.importance_score,
+                status = excluded.status
+            """,
+            (
+                memory_id,
+                content,
+                memory_type,
+                json.dumps(tags),
+                context,
+                created_at,
+                updated_at,
+                now_iso(),
+                importance_score,
+                status,
+                project_path,
+            ),
+        )
+
+        global_conn.commit()
+        logger.debug(f"Synced memory {memory_id} to global index")
+        return True
+
+    except Exception as e:
+        logger.warning(f"Failed to sync memory {memory_id} to global: {e}")
+        return False
+
+
+def delete_memory_from_global(memory_id: str) -> bool:
+    """Remove a memory from the global index.
+
+    Args:
+        memory_id: The memory ID to remove
+
+    Returns:
+        True if removed successfully
+    """
+    config = load_config()
+    if not config.global_sync_enabled:
+        return False
+
+    try:
+        global_conn = init_database(is_global=True)
+        cursor = global_conn.cursor()
+
+        cursor.execute("DELETE FROM memories WHERE id = ?", (memory_id,))
+        global_conn.commit()
+
+        if cursor.rowcount > 0:
+            logger.debug(f"Removed memory {memory_id} from global index")
+            return True
+        return False
+
+    except Exception as e:
+        logger.warning(f"Failed to remove memory {memory_id} from global: {e}")
+        return False
+
+
+def search_global_memories(
+    query: str,
+    type_filter: Optional[str] = None,
+    tags_filter: Optional[list[str]] = None,
+    project_filter: Optional[str] = None,
+    limit: int = 20,
+) -> list[dict]:
+    """Search memories across all projects via global index.
+
+    Args:
+        query: Search query
+        type_filter: Filter by memory type
+        tags_filter: Filter by tags
+        project_filter: Filter by project path (substring match)
+        limit: Maximum results
+
+    Returns:
+        List of memory dicts with project_path included
+    """
+    try:
+        global_conn = init_database(is_global=True)
+        cursor = global_conn.cursor()
+
+        # Escape FTS5 special characters
+        fts_query = _escape_fts_query(query)
+
+        # Build WHERE conditions
+        where_conditions = []
+        params: list = [fts_query]
+
+        if type_filter:
+            where_conditions.append("m.type = ?")
+            params.append(type_filter)
+
+        if project_filter:
+            where_conditions.append("m.project_path LIKE ?")
+            params.append(f"%{project_filter}%")
+
+        where_conditions.append("m.status != 'archived'")
+
+        if tags_filter:
+            tag_conditions = []
+            for tag in tags_filter:
+                tag_conditions.append("m.tags LIKE ?")
+                params.append(f'%"{tag}"%')
+            where_conditions.append(f"({' OR '.join(tag_conditions)})")
+
+        where_sql = ""
+        if where_conditions:
+            where_sql = "AND " + " AND ".join(where_conditions)
+
+        params.append(limit)
+
+        try:
+            cursor.execute(
+                f"""
+                SELECT m.*, bm25(memories_fts) as score
+                FROM memories_fts fts
+                JOIN memories m ON fts.rowid = m.rowid
+                WHERE memories_fts MATCH ?
+                {where_sql}
+                ORDER BY score
+                LIMIT ?
+                """,
+                params,
+            )
+        except sqlite3.OperationalError:
+            # Fallback to LIKE search if FTS fails
+            return _fallback_global_search(
+                global_conn, query, type_filter, tags_filter, project_filter, limit
+            )
+
+        results = []
+        for row in cursor.fetchall():
+            tags = row["tags"]
+            if tags and isinstance(tags, str):
+                try:
+                    tags = json.loads(tags)
+                except json.JSONDecodeError:
+                    tags = []
+
+            results.append({
+                "id": row["id"],
+                "content": row["content"],
+                "type": row["type"],
+                "tags": tags,
+                "context": row["context"],
+                "importance_score": row["importance_score"],
+                "status": row["status"],
+                "project_path": row["project_path"],
+                "created_at": row["created_at"],
+                "updated_at": row["updated_at"],
+                "score": -row["score"],  # bm25 returns negative scores
+            })
+
+        return results
+
+    except Exception as e:
+        logger.error(f"Global search failed: {e}")
+        return []
+
+
+def _escape_fts_query(query: str) -> str:
+    """Escape special characters for FTS5 query."""
+    special_chars = ['"', "'", "(", ")", "*", ":", "^", "-", "+"]
+    escaped = query
+    for char in special_chars:
+        escaped = escaped.replace(char, " ")
+
+    words = escaped.split()
+    if not words:
+        return '""'
+
+    if len(words) == 1:
+        return f'"{words[0]}"'
+
+    return " OR ".join(f'"{word}"' for word in words)
+
+
+def _fallback_global_search(
+    conn: sqlite3.Connection,
+    query: str,
+    type_filter: Optional[str],
+    tags_filter: Optional[list[str]],
+    project_filter: Optional[str],
+    limit: int,
+) -> list[dict]:
+    """Fallback to LIKE search if FTS5 fails."""
+    words = query.lower().split()
+    if not words:
+        return []
+
+    where_conditions = []
+    params: list = []
+
+    # Match any word in content or context
+    word_conditions = []
+    for word in words:
+        word_conditions.append("(LOWER(content) LIKE ? OR LOWER(context) LIKE ?)")
+        params.extend([f"%{word}%", f"%{word}%"])
+    where_conditions.append(f"({' OR '.join(word_conditions)})")
+
+    if type_filter:
+        where_conditions.append("type = ?")
+        params.append(type_filter)
+
+    if project_filter:
+        where_conditions.append("project_path LIKE ?")
+        params.append(f"%{project_filter}%")
+
+    where_conditions.append("status != 'archived'")
+
+    if tags_filter:
+        tag_conds = []
+        for tag in tags_filter:
+            tag_conds.append("tags LIKE ?")
+            params.append(f'%"{tag}"%')
+        where_conditions.append(f"({' OR '.join(tag_conds)})")
+
+    params.append(limit)
+
+    cursor = conn.cursor()
+    cursor.execute(
+        f"""
+        SELECT *
+        FROM memories
+        WHERE {' AND '.join(where_conditions)}
+        ORDER BY importance_score DESC, updated_at DESC
+        LIMIT ?
+        """,
+        params,
+    )
+
+    results = []
+    for row in cursor.fetchall():
+        tags = row["tags"]
+        if tags and isinstance(tags, str):
+            try:
+                tags = json.loads(tags)
+            except json.JSONDecodeError:
+                tags = []
+
+        content = (row["content"] + " " + (row["context"] or "")).lower()
+        score = sum(1 for word in words if word in content)
+
+        results.append({
+            "id": row["id"],
+            "content": row["content"],
+            "type": row["type"],
+            "tags": tags,
+            "context": row["context"],
+            "importance_score": row["importance_score"],
+            "status": row["status"],
+            "project_path": row["project_path"],
+            "created_at": row["created_at"],
+            "updated_at": row["updated_at"],
+            "score": float(score),
+        })
+
+    return results
+
+
+def get_global_stats() -> dict:
+    """Get statistics from the global index.
+
+    Returns:
+        Dict with counts by project, type, etc.
+    """
+    try:
+        global_conn = init_database(is_global=True)
+        cursor = global_conn.cursor()
+
+        stats = {}
+
+        # Total memories
+        cursor.execute("SELECT COUNT(*) FROM memories")
+        stats["total_memories"] = cursor.fetchone()[0]
+
+        # By project
+        cursor.execute("""
+            SELECT project_path, COUNT(*) as cnt
+            FROM memories
+            GROUP BY project_path
+            ORDER BY cnt DESC
+        """)
+        stats["by_project"] = {row["project_path"]: row["cnt"] for row in cursor.fetchall()}
+
+        # By type
+        cursor.execute("""
+            SELECT type, COUNT(*) as cnt
+            FROM memories
+            GROUP BY type
+            ORDER BY cnt DESC
+        """)
+        stats["by_type"] = {row["type"]: row["cnt"] for row in cursor.fetchall()}
+
+        return stats
+
+    except Exception as e:
+        logger.error(f"Failed to get global stats: {e}")
+        return {"error": str(e)}
+
+
+def sync_all_project_memories() -> int:
+    """Sync all memories from current project to global index.
+
+    Returns:
+        Number of memories synced
+    """
+    config = load_config()
+    if not config.global_sync_enabled:
+        return 0
+
+    try:
+        project_conn = init_database()
+        project_path = str(get_project_path())
+
+        cursor = project_conn.cursor()
+        cursor.execute("SELECT * FROM memories WHERE status != 'archived'")
+
+        count = 0
+        for row in cursor.fetchall():
+            tags = row["tags"]
+            if tags and isinstance(tags, str):
+                try:
+                    tags = json.loads(tags)
+                except json.JSONDecodeError:
+                    tags = []
+            else:
+                tags = []
+
+            synced = sync_memory_to_global(
+                memory_id=row["id"],
+                content=row["content"],
+                memory_type=row["type"],
+                tags=tags,
+                context=row["context"],
+                importance_score=row["importance_score"],
+                status=row["status"],
+                project_path=project_path,
+                created_at=row["created_at"],
+                updated_at=row["updated_at"],
+            )
+            if synced:
+                count += 1
+
+        logger.info(f"Synced {count} memories to global index")
+        return count
+
+    except Exception as e:
+        logger.error(f"Failed to sync project memories: {e}")
+        return 0