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

omni_cortex/database/schema.py

@@ -0,0 +1,212 @@
+"""Database schema definitions for Omni Cortex."""
+
+SCHEMA_VERSION = "1.0"
+
+# Main schema SQL
+SCHEMA_SQL = """
+-- ============================================
+-- OMNI CORTEX MCP DATABASE SCHEMA v1.0
+-- ============================================
+
+-- Sessions Table
+CREATE TABLE IF NOT EXISTS sessions (
+    id TEXT PRIMARY KEY,                          -- sess_{timestamp}_{random}
+    project_path TEXT NOT NULL,
+    started_at TEXT NOT NULL,                     -- ISO 8601
+    ended_at TEXT,
+    summary TEXT,
+    tags TEXT,                                    -- JSON array
+    metadata TEXT                                 -- JSON object
+);
+
+-- Agents Table
+CREATE TABLE IF NOT EXISTS agents (
+    id TEXT PRIMARY KEY,                          -- Agent ID from Claude Code
+    name TEXT,
+    type TEXT NOT NULL DEFAULT 'main',            -- main, subagent, tool
+    first_seen TEXT NOT NULL,
+    last_seen TEXT NOT NULL,
+    total_activities INTEGER DEFAULT 0,
+    metadata TEXT
+);
+
+-- Activities Table (Layer 1)
+CREATE TABLE IF NOT EXISTS activities (
+    id TEXT PRIMARY KEY,                          -- act_{timestamp}_{random}
+    session_id TEXT,
+    agent_id TEXT,
+    timestamp TEXT NOT NULL,                      -- ISO 8601 with timezone
+    event_type TEXT NOT NULL,                     -- pre_tool_use, post_tool_use, etc.
+    tool_name TEXT,
+    tool_input TEXT,                              -- JSON (truncated to 10KB)
+    tool_output TEXT,                             -- JSON (truncated to 10KB)
+    duration_ms INTEGER,
+    success INTEGER DEFAULT 1,
+    error_message TEXT,
+    project_path TEXT,
+    file_path TEXT,
+    metadata TEXT,
+    -- Command analytics columns (v1.1)
+    command_name TEXT,
+    command_scope TEXT,
+    mcp_server TEXT,
+    skill_name TEXT,
+    -- Natural language summaries (v1.2)
+    summary TEXT,
+    summary_detail TEXT,
+    FOREIGN KEY (session_id) REFERENCES sessions(id),
+    FOREIGN KEY (agent_id) REFERENCES agents(id)
+);
+
+-- Memories Table (Layer 2)
+CREATE TABLE IF NOT EXISTS memories (
+    id TEXT PRIMARY KEY,                          -- mem_{timestamp}_{random}
+    content TEXT NOT NULL,
+    type TEXT NOT NULL DEFAULT 'general',
+    tags TEXT,                                    -- JSON array
+    context TEXT,
+
+    -- Timestamps
+    created_at TEXT NOT NULL,
+    updated_at TEXT NOT NULL,
+    last_accessed TEXT NOT NULL,
+    last_verified TEXT,
+
+    -- Usage
+    access_count INTEGER DEFAULT 0,
+
+    -- Importance/Decay
+    importance_score REAL DEFAULT 50.0,           -- 0-100
+    manual_importance INTEGER,                    -- User override
+
+    -- Freshness
+    status TEXT DEFAULT 'fresh',                  -- fresh, needs_review, outdated, archived
+
+    -- Attribution
+    source_session_id TEXT,
+    source_agent_id TEXT,
+    source_activity_id TEXT,
+
+    -- Project
+    project_path TEXT,
+    file_context TEXT,                            -- JSON array
+
+    -- Embedding
+    has_embedding INTEGER DEFAULT 0,
+
+    metadata TEXT,
+
+    FOREIGN KEY (source_session_id) REFERENCES sessions(id),
+    FOREIGN KEY (source_agent_id) REFERENCES agents(id),
+    FOREIGN KEY (source_activity_id) REFERENCES activities(id)
+);
+
+-- FTS5 for Full-Text Search
+CREATE VIRTUAL TABLE IF NOT EXISTS memories_fts USING fts5(
+    content, context, tags,
+    content=memories,
+    content_rowid=rowid,
+    tokenize='porter unicode61'
+);
+
+-- Triggers to keep FTS in sync with memories table
+CREATE TRIGGER IF NOT EXISTS memories_ai AFTER INSERT ON memories BEGIN
+    INSERT INTO memories_fts(rowid, content, context, tags)
+    VALUES (NEW.rowid, NEW.content, NEW.context, NEW.tags);
+END;
+
+CREATE TRIGGER IF NOT EXISTS memories_ad AFTER DELETE ON memories BEGIN
+    INSERT INTO memories_fts(memories_fts, rowid, content, context, tags)
+    VALUES ('delete', OLD.rowid, OLD.content, OLD.context, OLD.tags);
+END;
+
+CREATE TRIGGER IF NOT EXISTS memories_au AFTER UPDATE ON memories BEGIN
+    INSERT INTO memories_fts(memories_fts, rowid, content, context, tags)
+    VALUES ('delete', OLD.rowid, OLD.content, OLD.context, OLD.tags);
+    INSERT INTO memories_fts(rowid, content, context, tags)
+    VALUES (NEW.rowid, NEW.content, NEW.context, NEW.tags);
+END;
+
+-- Memory Relationships
+CREATE TABLE IF NOT EXISTS memory_relationships (
+    id TEXT PRIMARY KEY,
+    source_memory_id TEXT NOT NULL,
+    target_memory_id TEXT NOT NULL,
+    relationship_type TEXT NOT NULL,              -- related_to, supersedes, derived_from, contradicts
+    strength REAL DEFAULT 1.0,
+    created_at TEXT NOT NULL,
+    metadata TEXT,
+    FOREIGN KEY (source_memory_id) REFERENCES memories(id) ON DELETE CASCADE,
+    FOREIGN KEY (target_memory_id) REFERENCES memories(id) ON DELETE CASCADE,
+    UNIQUE(source_memory_id, target_memory_id, relationship_type)
+);
+
+-- Activity-Memory Links
+CREATE TABLE IF NOT EXISTS activity_memory_links (
+    activity_id TEXT NOT NULL,
+    memory_id TEXT NOT NULL,
+    link_type TEXT NOT NULL,                      -- created, accessed, updated, referenced
+    created_at TEXT NOT NULL,
+    PRIMARY KEY (activity_id, memory_id, link_type),
+    FOREIGN KEY (activity_id) REFERENCES activities(id) ON DELETE CASCADE,
+    FOREIGN KEY (memory_id) REFERENCES memories(id) ON DELETE CASCADE
+);
+
+-- Embeddings
+CREATE TABLE IF NOT EXISTS embeddings (
+    id TEXT PRIMARY KEY,
+    memory_id TEXT NOT NULL UNIQUE,
+    model_name TEXT NOT NULL,                     -- 'all-MiniLM-L6-v2'
+    vector BLOB NOT NULL,                         -- float32 array
+    dimensions INTEGER NOT NULL,                  -- 384
+    created_at TEXT NOT NULL,
+    FOREIGN KEY (memory_id) REFERENCES memories(id) ON DELETE CASCADE
+);
+
+-- Session Summaries
+CREATE TABLE IF NOT EXISTS session_summaries (
+    id TEXT PRIMARY KEY,
+    session_id TEXT NOT NULL UNIQUE,
+    key_learnings TEXT,                           -- JSON array
+    key_decisions TEXT,                           -- JSON array
+    key_errors TEXT,                              -- JSON array
+    files_modified TEXT,                          -- JSON array
+    tools_used TEXT,                              -- JSON object
+    total_activities INTEGER DEFAULT 0,
+    total_memories_created INTEGER DEFAULT 0,
+    created_at TEXT NOT NULL,
+    FOREIGN KEY (session_id) REFERENCES sessions(id) ON DELETE CASCADE
+);
+
+-- Configuration
+CREATE TABLE IF NOT EXISTS config (
+    key TEXT PRIMARY KEY,
+    value TEXT NOT NULL,
+    updated_at TEXT NOT NULL
+);
+
+-- Schema Migrations
+CREATE TABLE IF NOT EXISTS schema_migrations (
+    version TEXT PRIMARY KEY,
+    applied_at TEXT NOT NULL
+);
+
+-- Indexes
+CREATE INDEX IF NOT EXISTS idx_activities_session ON activities(session_id);
+CREATE INDEX IF NOT EXISTS idx_activities_agent ON activities(agent_id);
+CREATE INDEX IF NOT EXISTS idx_activities_timestamp ON activities(timestamp DESC);
+CREATE INDEX IF NOT EXISTS idx_activities_tool ON activities(tool_name);
+CREATE INDEX IF NOT EXISTS idx_memories_type ON memories(type);
+CREATE INDEX IF NOT EXISTS idx_memories_status ON memories(status);
+CREATE INDEX IF NOT EXISTS idx_memories_project ON memories(project_path);
+CREATE INDEX IF NOT EXISTS idx_memories_importance ON memories(importance_score DESC);
+CREATE INDEX IF NOT EXISTS idx_memories_accessed ON memories(last_accessed DESC);
+CREATE INDEX IF NOT EXISTS idx_memories_created ON memories(created_at DESC);
+CREATE INDEX IF NOT EXISTS idx_relationships_source ON memory_relationships(source_memory_id);
+CREATE INDEX IF NOT EXISTS idx_relationships_target ON memory_relationships(target_memory_id);
+"""
+
+
+def get_schema_sql() -> str:
+    """Get the complete schema SQL."""
+    return SCHEMA_SQL

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

omni_cortex/decay/__init__.py

@@ -0,0 +1,7 @@
+"""Importance decay algorithms."""
+
+from .importance import calculate_decayed_importance
+
+__all__ = [
+    "calculate_decayed_importance",
+]