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

omni_cortex/config.py

@@ -0,0 +1,141 @@
+"""Configuration management for Omni Cortex."""
+
+import os
+from pathlib import Path
+from typing import Optional
+from dataclasses import dataclass, field
+
+import yaml
+
+
+@dataclass
+class CortexConfig:
+    """Configuration settings for Omni Cortex."""
+
+    # Database
+    schema_version: str = "1.0"
+
+    # Embedding (disabled by default - model loading can be slow)
+    embedding_model: str = "all-MiniLM-L6-v2"
+    embedding_enabled: bool = False
+
+    # Decay
+    decay_rate_per_day: float = 0.5
+    freshness_review_days: int = 30
+
+    # Output
+    max_output_truncation: int = 10000
+    max_tool_input_size: int = 10000
+
+    # Session
+    auto_provide_context: bool = True
+    context_depth: int = 3
+
+    # Search (default to keyword since embeddings are disabled by default)
+    default_search_mode: str = "keyword"
+
+    # Global
+    global_sync_enabled: bool = True
+    api_fallback_enabled: bool = False
+    api_key: str = ""
+
+
+def get_project_path() -> Path:
+    """Get the current project path from environment or cwd."""
+    return Path(os.environ.get("CLAUDE_PROJECT_DIR", os.getcwd()))
+
+
+def get_project_db_dir() -> Path:
+    """Get the project-local .omni-cortex directory."""
+    return get_project_path() / ".omni-cortex"
+
+
+def get_project_db_path() -> Path:
+    """Get the path to the project database."""
+    return get_project_db_dir() / "cortex.db"
+
+
+def get_global_db_dir() -> Path:
+    """Get the global ~/.omni-cortex directory."""
+    return Path.home() / ".omni-cortex"
+
+
+def get_global_db_path() -> Path:
+    """Get the path to the global database."""
+    return get_global_db_dir() / "global.db"
+
+
+def get_session_id() -> Optional[str]:
+    """Get the current session ID from environment."""
+    return os.environ.get("CLAUDE_SESSION_ID")
+
+
+def load_config(project_path: Optional[Path] = None) -> CortexConfig:
+    """Load configuration from project and global config files.
+
+    Priority: project config > global config > defaults
+    """
+    config = CortexConfig()
+
+    # Load global config
+    global_config_path = get_global_db_dir() / "config.yaml"
+    if global_config_path.exists():
+        try:
+            with open(global_config_path, "r") as f:
+                global_cfg = yaml.safe_load(f) or {}
+                _apply_config(config, global_cfg)
+        except Exception:
+            pass
+
+    # Load project config
+    if project_path is None:
+        project_path = get_project_path()
+    project_config_path = project_path / ".omni-cortex" / "config.yaml"
+    if project_config_path.exists():
+        try:
+            with open(project_config_path, "r") as f:
+                project_cfg = yaml.safe_load(f) or {}
+                _apply_config(config, project_cfg)
+        except Exception:
+            pass
+
+    return config
+
+
+def _apply_config(config: CortexConfig, data: dict) -> None:
+    """Apply configuration data to config object."""
+    for key, value in data.items():
+        if hasattr(config, key) and value is not None:
+            setattr(config, key, value)
+
+
+def save_config(config: CortexConfig, project: bool = True) -> None:
+    """Save configuration to file.
+
+    Args:
+        config: Configuration to save
+        project: If True, save to project config; otherwise global
+    """
+    if project:
+        config_dir = get_project_db_dir()
+    else:
+        config_dir = get_global_db_dir()
+
+    config_dir.mkdir(parents=True, exist_ok=True)
+    config_path = config_dir / "config.yaml"
+
+    data = {
+        "schema_version": config.schema_version,
+        "embedding_model": config.embedding_model,
+        "embedding_enabled": config.embedding_enabled,
+        "decay_rate_per_day": config.decay_rate_per_day,
+        "freshness_review_days": config.freshness_review_days,
+        "max_output_truncation": config.max_output_truncation,
+        "auto_provide_context": config.auto_provide_context,
+        "context_depth": config.context_depth,
+        "default_search_mode": config.default_search_mode,
+        "global_sync_enabled": config.global_sync_enabled,
+    }
+
+    with open(config_path, "w") as f:
+        yaml.dump(data, f, default_flow_style=False)

omni_cortex/dashboard.py

@@ -0,0 +1,238 @@
+"""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. Bundled inside package (works for user and system installs)
+    2. Development directory (cloned repo)
+    3. Package shared-data (installed via pip system-wide)
+    4. Site-packages share location
+    """
+    package_dir = Path(__file__).parent
+
+    # Check for bundled dashboard inside package (most reliable for pip installs)
+    bundled_dashboard = package_dir / "_bundled" / "dashboard"
+    if bundled_dashboard.exists() and (bundled_dashboard / "backend" / "main.py").exists():
+        return bundled_dashboard
+
+    # 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 (for backwards compatibility)
+    # 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