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

omni_cortex/database/schema.py

@@ -1,212 +0,0 @@
-"""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

@@ -1,421 +0,0 @@
-"""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

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