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

omni_cortex/dashboard.py

@@ -0,0 +1,232 @@
+"""Dashboard CLI for Omni-Cortex.
+
+Starts the web dashboard server for viewing and managing memories.
+"""
+
+import argparse
+import os
+import subprocess
+import sys
+import webbrowser
+from pathlib import Path
+from time import sleep
+
+
+def check_editable_install() -> bool:
+    """Check if package is installed in editable (development) mode.
+
+    Returns True if editable, False if installed from PyPI.
+    """
+    try:
+        import importlib.metadata as metadata
+        dist = metadata.distribution("omni-cortex")
+        # Editable installs have a direct_url.json with editable=true
+        # or are installed via .egg-link
+        direct_url = dist.read_text("direct_url.json")
+        if direct_url and '"editable":true' in direct_url.replace(" ", ""):
+            return True
+    except Exception:
+        pass
+
+    # Alternative check: see if we're running from source directory
+    package_dir = Path(__file__).parent
+    repo_root = package_dir.parent.parent
+    if (repo_root / "pyproject.toml").exists() and (repo_root / ".git").exists():
+        # We're in a repo, check if there's an egg-link or editable marker
+        import site
+        for site_dir in [site.getusersitepackages()] + site.getsitepackages():
+            egg_link = Path(site_dir) / "omni-cortex.egg-link"
+            if egg_link.exists():
+                return True
+            # Check for __editable__ marker (PEP 660) - any version
+            for pth_file in Path(site_dir).glob("__editable__.omni_cortex*.pth"):
+                return True
+
+    return False
+
+
+def warn_non_editable_install() -> None:
+    """Warn if not running in editable mode during development."""
+    if not check_editable_install():
+        # Check if we appear to be in a development context
+        package_dir = Path(__file__).parent
+        repo_root = package_dir.parent.parent
+        if (repo_root / "pyproject.toml").exists() and (repo_root / ".git").exists():
+            print("[Dashboard] Note: Package may not be in editable mode.")
+            print("[Dashboard] If you see import errors, run: pip install -e .")
+            print()
+
+
+def find_dashboard_dir() -> Path | None:
+    """Find the dashboard directory.
+
+    Searches in order:
+    1. Development directory (cloned repo)
+    2. Package shared-data (installed via pip)
+    3. Site-packages share location
+    """
+    package_dir = Path(__file__).parent
+
+    # Check for development directory (repo structure)
+    # Go up from src/omni_cortex to repo root, then dashboard
+    repo_root = package_dir.parent.parent
+    dashboard_in_repo = repo_root / "dashboard"
+    if dashboard_in_repo.exists() and (dashboard_in_repo / "backend" / "main.py").exists():
+        return dashboard_in_repo
+
+    # Check pip shared-data location
+    # On Unix: ~/.local/share/omni-cortex/dashboard
+    # On Windows: %APPDATA%/Python/share/omni-cortex/dashboard
+    import site
+    for site_dir in site.getsitepackages() + [site.getusersitepackages()]:
+        share_dir = Path(site_dir).parent / "share" / "omni-cortex" / "dashboard"
+        if share_dir.exists() and (share_dir / "backend" / "main.py").exists():
+            return share_dir
+
+    # Check relative to sys.prefix (virtualenv)
+    share_in_prefix = Path(sys.prefix) / "share" / "omni-cortex" / "dashboard"
+    if share_in_prefix.exists() and (share_in_prefix / "backend" / "main.py").exists():
+        return share_in_prefix
+
+    return None
+
+
+def check_dependencies() -> bool:
+    """Check if dashboard dependencies are installed."""
+    try:
+        import uvicorn  # noqa: F401
+        import fastapi  # noqa: F401
+        return True
+    except ImportError:
+        return False
+
+
+def install_dependencies() -> bool:
+    """Install dashboard dependencies."""
+    required_packages = ["uvicorn", "fastapi"]
+
+    print("[Dashboard] Installing dependencies...")
+    try:
+        subprocess.check_call(
+            [sys.executable, "-m", "pip", "install", *required_packages, "-q"],
+            stdout=subprocess.DEVNULL,
+            stderr=subprocess.DEVNULL,
+        )
+        return True
+    except subprocess.CalledProcessError:
+        return False
+
+
+def start_server(dashboard_dir: Path, host: str, port: int, no_browser: bool) -> None:
+    """Start the dashboard server."""
+    backend_dir = dashboard_dir / "backend"
+
+    # Add backend to path
+    sys.path.insert(0, str(backend_dir))
+
+    # Change to backend directory for relative imports
+    original_cwd = os.getcwd()
+    os.chdir(backend_dir)
+
+    try:
+        import uvicorn
+
+        print(f"\n[Dashboard] Starting Omni-Cortex Dashboard")
+        print(f"[Dashboard] URL: http://{host}:{port}")
+        print(f"[Dashboard] API Docs: http://{host}:{port}/docs")
+        print(f"[Dashboard] Press Ctrl+C to stop\n")
+
+        # Open browser after short delay
+        if not no_browser:
+            def open_browser():
+                sleep(1.5)
+                webbrowser.open(f"http://{host}:{port}")
+
+            import threading
+            threading.Thread(target=open_browser, daemon=True).start()
+
+        # Run the server
+        uvicorn.run(
+            "main:app",
+            host=host,
+            port=port,
+            reload=False,
+            log_level="info",
+        )
+    finally:
+        os.chdir(original_cwd)
+
+
+def main():
+    """Main entry point for omni-cortex dashboard command."""
+    # Check for potential editable install issues early
+    warn_non_editable_install()
+
+    parser = argparse.ArgumentParser(
+        description="Start the Omni-Cortex web dashboard",
+        formatter_class=argparse.RawDescriptionHelpFormatter,
+        epilog="""
+Examples:
+  omni-cortex dashboard              Start on default port 8765
+  omni-cortex dashboard --port 9000  Start on custom port
+  omni-cortex dashboard --no-browser Don't auto-open browser
+        """
+    )
+    parser.add_argument(
+        "--host",
+        default="127.0.0.1",
+        help="Host to bind to (default: 127.0.0.1)"
+    )
+    parser.add_argument(
+        "--port", "-p",
+        type=int,
+        default=8765,
+        help="Port to run on (default: 8765)"
+    )
+    parser.add_argument(
+        "--no-browser",
+        action="store_true",
+        help="Don't automatically open browser"
+    )
+
+    args = parser.parse_args()
+
+    # Find dashboard directory
+    dashboard_dir = find_dashboard_dir()
+    if not dashboard_dir:
+        print("[Dashboard] Error: Dashboard files not found.")
+        print("[Dashboard] If you installed via pip, try reinstalling:")
+        print("  pip install --force-reinstall omni-cortex")
+        print("\nOr clone the repository:")
+        print("  git clone https://github.com/AllCytes/Omni-Cortex.git")
+        sys.exit(1)
+
+    print(f"[Dashboard] Found dashboard at: {dashboard_dir}")
+
+    # Check/install dependencies
+    if not check_dependencies():
+        print("[Dashboard] Installing required dependencies...")
+        if not install_dependencies():
+            print("[Dashboard] Error: Failed to install dependencies.")
+            print("[Dashboard] Try manually: pip install uvicorn fastapi")
+            sys.exit(1)
+
+    # Check if dist exists (built frontend)
+    dist_dir = dashboard_dir / "frontend" / "dist"
+    if not dist_dir.exists():
+        print(f"[Dashboard] Warning: Frontend not built ({dist_dir})")
+        print("[Dashboard] API will work but web UI may not be available.")
+        print("[Dashboard] To build: cd dashboard/frontend && npm install && npm run build")
+
+    # Start the server
+    try:
+        start_server(dashboard_dir, args.host, args.port, args.no_browser)
+    except KeyboardInterrupt:
+        print("\n[Dashboard] Stopped")
+    except Exception as e:
+        print(f"[Dashboard] Error: {e}")
+        sys.exit(1)
+
+
+if __name__ == "__main__":
+    main()

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/database/connection.py

@@ -0,0 +1,137 @@
+"""SQLite connection management for Omni Cortex."""
+
+import sqlite3
+import threading
+from pathlib import Path
+from typing import Optional
+from contextlib import contextmanager
+
+from ..config import get_project_db_path, get_global_db_path, get_project_db_dir, get_global_db_dir
+from .schema import get_schema_sql, SCHEMA_VERSION
+
+
+# Thread-local storage for connections
+_local = threading.local()
+
+# Connection cache by path
+_connections: dict[str, sqlite3.Connection] = {}
+_lock = threading.Lock()
+
+
+def _configure_connection(conn: sqlite3.Connection) -> None:
+    """Configure a SQLite connection with optimal settings."""
+    conn.row_factory = sqlite3.Row
+    conn.execute("PRAGMA foreign_keys = ON")
+    conn.execute("PRAGMA journal_mode = WAL")
+    conn.execute("PRAGMA synchronous = NORMAL")
+    conn.execute("PRAGMA cache_size = -64000")  # 64MB cache
+
+
+def get_connection(db_path: Optional[Path] = None, is_global: bool = False) -> sqlite3.Connection:
+    """Get a database connection, creating it if necessary.
+
+    Args:
+        db_path: Explicit path to database file
+        is_global: If True and no db_path, use global database
+
+    Returns:
+        SQLite connection
+    """
+    if db_path is None:
+        db_path = get_global_db_path() if is_global else get_project_db_path()
+
+    path_str = str(db_path)
+
+    with _lock:
+        if path_str not in _connections:
+            # Ensure directory exists
+            db_path.parent.mkdir(parents=True, exist_ok=True)
+
+            # Create connection
+            conn = sqlite3.connect(path_str, check_same_thread=False)
+            _configure_connection(conn)
+            _connections[path_str] = conn
+
+        return _connections[path_str]
+
+
+def init_database(db_path: Optional[Path] = None, is_global: bool = False) -> sqlite3.Connection:
+    """Initialize the database with schema.
+
+    Args:
+        db_path: Explicit path to database file
+        is_global: If True and no db_path, use global database
+
+    Returns:
+        SQLite connection
+    """
+    if db_path is None:
+        if is_global:
+            db_path = get_global_db_path()
+            db_dir = get_global_db_dir()
+        else:
+            db_path = get_project_db_path()
+            db_dir = get_project_db_dir()
+    else:
+        db_dir = db_path.parent
+
+    # Ensure directory exists
+    db_dir.mkdir(parents=True, exist_ok=True)
+
+    conn = get_connection(db_path)
+
+    # Check if schema needs initialization
+    cursor = conn.cursor()
+
+    # Check if tables exist
+    cursor.execute("SELECT name FROM sqlite_master WHERE type='table' AND name='memories'")
+    if cursor.fetchone() is None:
+        # Apply schema
+        conn.executescript(get_schema_sql())
+
+        # Record schema version
+        from ..utils.timestamps import now_iso
+        cursor.execute(
+            "INSERT OR REPLACE INTO schema_migrations (version, applied_at) VALUES (?, ?)",
+            (SCHEMA_VERSION, now_iso())
+        )
+        conn.commit()
+
+    return conn
+
+
+def close_connection(db_path: Optional[Path] = None, is_global: bool = False) -> None:
+    """Close a database connection.
+
+    Args:
+        db_path: Explicit path to database file
+        is_global: If True and no db_path, use global database
+    """
+    if db_path is None:
+        db_path = get_global_db_path() if is_global else get_project_db_path()
+
+    path_str = str(db_path)
+
+    with _lock:
+        if path_str in _connections:
+            _connections[path_str].close()
+            del _connections[path_str]
+
+
+def close_all_connections() -> None:
+    """Close all database connections."""
+    with _lock:
+        for conn in _connections.values():
+            conn.close()
+        _connections.clear()
+
+
+@contextmanager
+def transaction(conn: sqlite3.Connection):
+    """Context manager for database transactions."""
+    try:
+        yield conn
+        conn.commit()
+    except Exception:
+        conn.rollback()
+        raise

omni_cortex/database/migrations.py

@@ -0,0 +1,210 @@
+"""Database migration management for Omni Cortex."""
+
+import sqlite3
+from typing import Optional
+from pathlib import Path
+
+from .schema import SCHEMA_VERSION, get_schema_sql
+from .connection import get_connection
+from ..utils.timestamps import now_iso
+
+
+# Migration definitions: version -> SQL
+MIGRATIONS: dict[str, str] = {
+    # Command analytics columns for slash command/skill tracking
+    "1.1": """
+        -- Add command analytics columns to activities table
+        ALTER TABLE activities ADD COLUMN command_name TEXT;
+        ALTER TABLE activities ADD COLUMN command_scope TEXT;
+        ALTER TABLE activities ADD COLUMN mcp_server TEXT;
+        ALTER TABLE activities ADD COLUMN skill_name TEXT;
+
+        -- Create indexes for new columns
+        CREATE INDEX IF NOT EXISTS idx_activities_command ON activities(command_name);
+        CREATE INDEX IF NOT EXISTS idx_activities_mcp ON activities(mcp_server);
+        CREATE INDEX IF NOT EXISTS idx_activities_skill ON activities(skill_name);
+    """,
+    # Natural language summary columns for activity display
+    "1.2": """
+        -- Add natural language summary columns to activities table
+        ALTER TABLE activities ADD COLUMN summary TEXT;
+        ALTER TABLE activities ADD COLUMN summary_detail TEXT;
+    """,
+    # Duration tracking columns for concrete time analysis
+    "1.3": """
+        -- Add duration tracking to sessions table
+        ALTER TABLE sessions ADD COLUMN duration_ms INTEGER;
+
+        -- Add duration tracking to session_summaries table
+        ALTER TABLE session_summaries ADD COLUMN duration_ms INTEGER;
+        ALTER TABLE session_summaries ADD COLUMN tool_duration_breakdown TEXT;
+
+        -- Create index for duration queries
+        CREATE INDEX IF NOT EXISTS idx_activities_duration ON activities(duration_ms);
+        CREATE INDEX IF NOT EXISTS idx_sessions_duration ON sessions(duration_ms);
+    """,
+    # User message tracking for style analysis
+    "1.4": """
+        -- User messages table for tracking all user prompts
+        CREATE TABLE IF NOT EXISTS user_messages (
+            id TEXT PRIMARY KEY,                          -- msg_{timestamp}_{random}
+            session_id TEXT,
+            timestamp TEXT NOT NULL,                      -- ISO 8601
+            content TEXT NOT NULL,                        -- The full user message
+            word_count INTEGER,
+            char_count INTEGER,
+            line_count INTEGER,
+            has_code_blocks INTEGER DEFAULT 0,
+            has_questions INTEGER DEFAULT 0,
+            has_commands INTEGER DEFAULT 0,               -- Starts with /
+            tone_indicators TEXT,                         -- JSON: detected tone markers
+            project_path TEXT,
+            metadata TEXT,                                -- JSON for extensibility
+            FOREIGN KEY (session_id) REFERENCES sessions(id)
+        );
+
+        -- User style profile for aggregated style analysis
+        CREATE TABLE IF NOT EXISTS user_style_profiles (
+            id TEXT PRIMARY KEY,                          -- profile_{timestamp}_{random}
+            project_path TEXT,                            -- NULL for global profile
+            total_messages INTEGER DEFAULT 0,
+            avg_word_count REAL,
+            avg_char_count REAL,
+            common_phrases TEXT,                          -- JSON array of frequent phrases
+            vocabulary_richness REAL,                     -- Type-token ratio
+            formality_score REAL,                         -- 0-100 scale
+            question_frequency REAL,                      -- % of messages with questions
+            command_frequency REAL,                       -- % of messages starting with /
+            code_block_frequency REAL,                    -- % with code blocks
+            punctuation_style TEXT,                       -- JSON: punctuation patterns
+            greeting_patterns TEXT,                       -- JSON: how user starts conversations
+            instruction_style TEXT,                       -- JSON: how user gives instructions
+            sample_messages TEXT,                         -- JSON array of representative samples
+            created_at TEXT NOT NULL,
+            updated_at TEXT NOT NULL,
+            metadata TEXT
+        );
+
+        -- Indexes for user message queries
+        CREATE INDEX IF NOT EXISTS idx_user_messages_session ON user_messages(session_id);
+        CREATE INDEX IF NOT EXISTS idx_user_messages_timestamp ON user_messages(timestamp DESC);
+        CREATE INDEX IF NOT EXISTS idx_user_messages_project ON user_messages(project_path);
+        CREATE INDEX IF NOT EXISTS idx_user_style_project ON user_style_profiles(project_path);
+    """,
+}
+
+
+def get_current_version(conn: sqlite3.Connection) -> Optional[str]:
+    """Get the current schema version from the database."""
+    try:
+        cursor = conn.execute(
+            "SELECT version FROM schema_migrations ORDER BY applied_at DESC LIMIT 1"
+        )
+        row = cursor.fetchone()
+        return row[0] if row else None
+    except sqlite3.OperationalError:
+        # Table doesn't exist yet
+        return None
+
+
+def strip_sql_comments(sql: str) -> str:
+    """Strip SQL comments from a statement while preserving inline comments in strings."""
+    import re
+    lines = sql.split('\n')
+    cleaned_lines = []
+    for line in lines:
+        # Remove line comments (-- ...) but only if not inside a string
+        # Simple approach: just strip everything after -- if not in CREATE TABLE definition
+        # For CREATE TABLE, we need to keep the structure
+        stripped = line.strip()
+        if stripped.startswith('--'):
+            continue  # Skip pure comment lines
+        # Keep lines that have SQL content (even if they have trailing comments)
+        cleaned_lines.append(line)
+    return '\n'.join(cleaned_lines)
+
+
+def apply_migration(conn: sqlite3.Connection, version: str, sql: str) -> None:
+    """Apply a single migration.
+
+    Handles ALTER TABLE ADD COLUMN gracefully - if column exists, skips it.
+    """
+    # First, strip pure comment lines from the SQL
+    sql = strip_sql_comments(sql)
+
+    # Split into individual statements and apply each
+    for statement in sql.strip().split(';'):
+        statement = statement.strip()
+        if not statement:
+            continue
+
+        # Skip if the remaining statement is just whitespace or pure comments
+        non_comment_content = '\n'.join(
+            line for line in statement.split('\n')
+            if line.strip() and not line.strip().startswith('--')
+        ).strip()
+        if not non_comment_content:
+            continue
+
+        try:
+            conn.execute(statement)
+            conn.commit()  # Commit each statement so next one sees the change
+        except sqlite3.OperationalError as e:
+            error_msg = str(e).lower()
+            # Ignore "duplicate column" errors - column already exists
+            if "duplicate column" in error_msg:
+                continue
+            # Ignore "index already exists" errors
+            if "already exists" in error_msg:
+                continue
+            # Ignore "no such column" for indexes on columns that may not exist yet
+            # (will be created in a later migration)
+            if "no such column" in error_msg and "CREATE INDEX" in statement.upper():
+                continue
+            # Ignore "table already exists" errors
+            if "already exists" in error_msg:
+                continue
+            raise
+
+    conn.execute(
+        "INSERT INTO schema_migrations (version, applied_at) VALUES (?, ?)",
+        (version, now_iso())
+    )
+    conn.commit()
+
+
+def migrate(db_path: Optional[Path] = None, is_global: bool = False) -> str:
+    """Run all pending migrations.
+
+    Returns:
+        The final schema version
+    """
+    conn = get_connection(db_path, is_global)
+    current = get_current_version(conn)
+
+    if current is None:
+        # Fresh database - apply full schema
+        conn.executescript(get_schema_sql())
+        conn.execute(
+            "INSERT INTO schema_migrations (version, applied_at) VALUES (?, ?)",
+            (SCHEMA_VERSION, now_iso())
+        )
+        conn.commit()
+        return SCHEMA_VERSION
+
+    # Apply pending migrations in order
+    versions = sorted(MIGRATIONS.keys())
+    for version in versions:
+        if version > current:
+            apply_migration(conn, version, MIGRATIONS[version])
+            current = version
+
+    return current
+
+
+def needs_migration(conn: sqlite3.Connection) -> bool:
+    """Check if database needs migration."""
+    current = get_current_version(conn)
+    if current is None:
+        return True
+    return any(v > current for v in MIGRATIONS.keys())