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

omni_cortex/_bundled/dashboard/backend/project_scanner.py

@@ -0,0 +1,164 @@
+"""Scanner to discover all omni-cortex databases on the system."""
+
+import sqlite3
+from datetime import datetime
+from pathlib import Path
+
+from models import ProjectInfo
+from project_config import load_config
+
+
+def get_global_db_path() -> Path:
+    """Get path to the global index database."""
+    return Path.home() / ".omni-cortex" / "global.db"
+
+
+def get_memory_count(db_path: Path) -> int:
+    """Get the number of memories in a database."""
+    try:
+        conn = sqlite3.connect(str(db_path))
+        cursor = conn.execute("SELECT COUNT(*) FROM memories")
+        count = cursor.fetchone()[0]
+        conn.close()
+        return count
+    except Exception:
+        return 0
+
+
+def get_projects_from_global_db() -> list[str]:
+    """Get unique project paths from the global index."""
+    global_path = get_global_db_path()
+    if not global_path.exists():
+        return []
+
+    try:
+        conn = sqlite3.connect(str(global_path))
+        cursor = conn.execute("SELECT DISTINCT source_project FROM global_memories")
+        paths = [row[0] for row in cursor.fetchall() if row[0]]
+        conn.close()
+        return paths
+    except Exception:
+        return []
+
+
+def scan_directory_for_cortex(base_dir: Path) -> list[Path]:
+    """Scan a directory for .omni-cortex/cortex.db files."""
+    found = []
+    try:
+        for item in base_dir.iterdir():
+            if item.is_dir():
+                cortex_dir = item / ".omni-cortex"
+                cortex_db = cortex_dir / "cortex.db"
+                if cortex_db.exists():
+                    found.append(cortex_db)
+    except PermissionError:
+        pass
+    return found
+
+
+def scan_projects() -> list[ProjectInfo]:
+    """
+    Scan for all omni-cortex databases.
+
+    Returns list of ProjectInfo with name, path, db_path, last_modified, memory_count.
+    """
+    projects: list[ProjectInfo] = []
+    seen_paths: set[str] = set()
+
+    # Load user config
+    config = load_config()
+
+    # 1. Add global index if exists
+    global_path = get_global_db_path()
+    if global_path.exists():
+        stat = global_path.stat()
+        global_project_path = str(global_path.parent)
+        projects.append(
+            ProjectInfo(
+                name="Global Index",
+                path=global_project_path,
+                db_path=str(global_path),
+                last_modified=datetime.fromtimestamp(stat.st_mtime),
+                memory_count=get_memory_count(global_path),
+                is_global=True,
+                is_favorite=global_project_path in config.favorites,
+            )
+        )
+        seen_paths.add(str(global_path))
+
+    # 2. Use CONFIGURABLE scan directories
+    for scan_dir in config.scan_directories:
+        scan_path = Path(scan_dir).expanduser()
+        if scan_path.exists():
+            for db_path in scan_directory_for_cortex(scan_path):
+                if str(db_path) not in seen_paths:
+                    project_dir = db_path.parent.parent
+                    stat = db_path.stat()
+                    project_path = str(project_dir)
+                    projects.append(
+                        ProjectInfo(
+                            name=project_dir.name,
+                            path=project_path,
+                            db_path=str(db_path),
+                            last_modified=datetime.fromtimestamp(stat.st_mtime),
+                            memory_count=get_memory_count(db_path),
+                            is_global=False,
+                            is_favorite=project_path in config.favorites,
+                        )
+                    )
+                    seen_paths.add(str(db_path))
+
+    # 3. Add REGISTERED projects (manual additions)
+    for reg in config.registered_projects:
+        db_path = Path(reg.path) / ".omni-cortex" / "cortex.db"
+        if db_path.exists() and str(db_path) not in seen_paths:
+            stat = db_path.stat()
+            projects.append(
+                ProjectInfo(
+                    name=Path(reg.path).name,
+                    path=reg.path,
+                    db_path=str(db_path),
+                    last_modified=datetime.fromtimestamp(stat.st_mtime),
+                    memory_count=get_memory_count(db_path),
+                    is_global=False,
+                    is_favorite=reg.path in config.favorites,
+                    is_registered=True,
+                    display_name=reg.display_name,
+                )
+            )
+            seen_paths.add(str(db_path))
+
+    # 4. Add paths from global db that we haven't seen
+    for project_path in get_projects_from_global_db():
+        db_path = Path(project_path) / ".omni-cortex" / "cortex.db"
+        if db_path.exists() and str(db_path) not in seen_paths:
+            stat = db_path.stat()
+            projects.append(
+                ProjectInfo(
+                    name=Path(project_path).name,
+                    path=project_path,
+                    db_path=str(db_path),
+                    last_modified=datetime.fromtimestamp(stat.st_mtime),
+                    memory_count=get_memory_count(db_path),
+                    is_global=False,
+                    is_favorite=project_path in config.favorites,
+                )
+            )
+            seen_paths.add(str(db_path))
+
+    # Sort: favorites first, then by last_modified (most recent first), with global always first
+    projects.sort(
+        key=lambda p: (
+            not p.is_global,
+            not p.is_favorite,
+            -(p.last_modified.timestamp() if p.last_modified else 0),
+        )
+    )
+
+    return projects
+
+
+if __name__ == "__main__":
+    # Test the scanner
+    for project in scan_projects():
+        print(f"{project.name}: {project.db_path} ({project.memory_count} memories)")

omni_cortex/_bundled/dashboard/backend/prompt_security.py

@@ -0,0 +1,111 @@
+"""Prompt injection protection for Omni-Cortex."""
+
+import re
+import logging
+from html import escape as html_escape
+from typing import Optional
+
+logger = logging.getLogger(__name__)
+
+
+def xml_escape(text: str) -> str:
+    """Escape text for safe inclusion in XML-structured prompts.
+
+    Converts special characters to prevent prompt injection via
+    XML/HTML-like delimiters.
+    """
+    return html_escape(text, quote=True)
+
+
+def build_safe_prompt(
+    system_instruction: str,
+    user_data: dict[str, str],
+    user_question: str
+) -> str:
+    """Build a prompt with clear instruction/data separation.
+
+    Uses XML tags to separate trusted instructions from untrusted data,
+    making it harder for injected content to be interpreted as instructions.
+
+    Args:
+        system_instruction: Trusted system prompt (not escaped)
+        user_data: Dict of data sections to include (escaped)
+        user_question: User's question (escaped)
+
+    Returns:
+        Safely structured prompt string
+    """
+    parts = [system_instruction, ""]
+
+    # Add data sections with XML escaping
+    for section_name, content in user_data.items():
+        if content:
+            parts.append(f"<{section_name}>")
+            parts.append(xml_escape(content))
+            parts.append(f"</{section_name}>")
+            parts.append("")
+
+    # Add user question
+    parts.append("<user_question>")
+    parts.append(xml_escape(user_question))
+    parts.append("</user_question>")
+
+    return "\n".join(parts)
+
+
+# Known prompt injection patterns
+INJECTION_PATTERNS = [
+    (r'(?i)(ignore|disregard|forget)\s+(all\s+)?(previous|prior|above)\s+instructions?',
+     'instruction override attempt'),
+    (r'(?i)(new\s+)?system\s+(prompt|instruction|message)',
+     'system prompt manipulation'),
+    (r'(?i)you\s+(must|should|will|are\s+required\s+to)\s+now',
+     'imperative command injection'),
+    (r'(?i)(hidden|secret|special)\s+instruction',
+     'hidden instruction claim'),
+    (r'(?i)\[/?system\]|\[/?inst\]|<\/?system>|<\/?instruction>',
+     'fake delimiter injection'),
+    (r'(?i)bypass|jailbreak|DAN|GODMODE',
+     'known jailbreak signature'),
+]
+
+
+def detect_injection_patterns(content: str) -> list[str]:
+    """Detect potential prompt injection patterns in content.
+
+    Returns list of detected patterns (empty if clean).
+    """
+    detected = []
+    for pattern, description in INJECTION_PATTERNS:
+        if re.search(pattern, content):
+            detected.append(description)
+
+    return detected
+
+
+def sanitize_memory_content(content: str, warn_on_detection: bool = True) -> tuple[str, list[str]]:
+    """Sanitize memory content and detect injection attempts.
+
+    Args:
+        content: Raw memory content
+        warn_on_detection: If True, log warnings for detected patterns
+
+    Returns:
+        Tuple of (sanitized_content, list_of_detected_patterns)
+    """
+    detected = detect_injection_patterns(content)
+
+    if detected and warn_on_detection:
+        logger.warning(f"Potential injection patterns detected: {detected}")
+
+    # Content is still returned - we sanitize via XML escaping when used in prompts
+    return content, detected
+
+
+def sanitize_context_data(data: str) -> str:
+    """Escape context data for safe inclusion in prompts.
+
+    This is the primary defense - all user-supplied data should be
+    escaped before inclusion in prompts to prevent injection.
+    """
+    return xml_escape(data)

omni_cortex/_bundled/dashboard/backend/pyproject.toml

@@ -0,0 +1,23 @@
+[project]
+name = "omni-cortex-dashboard"
+version = "0.1.0"
+description = "Web dashboard for Omni-Cortex memory system"
+requires-python = ">=3.11"
+dependencies = [
+    "fastapi>=0.115.0",
+    "uvicorn[standard]>=0.30.0",
+    "websockets>=12.0",
+    "watchdog>=4.0.0",
+    "google-generativeai>=0.8.0",
+    "python-dotenv>=1.0.0",
+]
+
+[project.optional-dependencies]
+dev = ["pytest", "ruff", "httpx"]
+
+[tool.ruff]
+line-length = 100
+target-version = "py311"
+
+[tool.ruff.lint]
+select = ["E", "F", "I", "W"]

omni_cortex/_bundled/dashboard/backend/security.py

@@ -0,0 +1,104 @@
+"""Security utilities for Omni-Cortex Dashboard."""
+
+import os
+import re
+from pathlib import Path
+from typing import Optional
+
+
+class PathValidator:
+    """Validate and sanitize file paths to prevent traversal attacks."""
+
+    # Pattern for valid omni-cortex database paths
+    VALID_DB_PATTERN = re.compile(r'^.*[/\\]\.omni-cortex[/\\]cortex\.db$')
+    GLOBAL_DB_PATTERN = re.compile(r'^.*[/\\]\.omni-cortex[/\\]global\.db$')
+
+    @staticmethod
+    def is_valid_project_db(path: str) -> bool:
+        """Check if path is a valid omni-cortex project database."""
+        try:
+            resolved = Path(path).resolve()
+            path_str = str(resolved)
+
+            # Must match expected patterns
+            if PathValidator.VALID_DB_PATTERN.match(path_str):
+                return resolved.exists() and resolved.is_file()
+            if PathValidator.GLOBAL_DB_PATTERN.match(path_str):
+                return resolved.exists() and resolved.is_file()
+
+            return False
+        except (ValueError, OSError):
+            return False
+
+    @staticmethod
+    def validate_project_path(path: str) -> Path:
+        """Validate and return resolved path, or raise ValueError."""
+        if not PathValidator.is_valid_project_db(path):
+            raise ValueError(f"Invalid project database path: {path}")
+        return Path(path).resolve()
+
+    @staticmethod
+    def is_safe_static_path(base_dir: Path, requested_path: str) -> Optional[Path]:
+        """Validate static file path is within base directory.
+
+        Returns resolved path if safe, None if traversal detected.
+        """
+        try:
+            # Resolve both paths to absolute
+            base_resolved = base_dir.resolve()
+            requested = (base_dir / requested_path).resolve()
+
+            # Check if requested path is under base directory
+            if base_resolved in requested.parents or requested == base_resolved:
+                if requested.exists() and requested.is_file():
+                    return requested
+
+            return None
+        except (ValueError, OSError):
+            return None
+
+
+def sanitize_log_input(value: str, max_length: int = 200) -> str:
+    """Sanitize user input for safe logging.
+
+    Prevents log injection by:
+    - Escaping newlines
+    - Limiting length
+    - Removing control characters
+    """
+    if not isinstance(value, str):
+        value = str(value)
+
+    # Remove control characters except spaces
+    sanitized = ''.join(c if c.isprintable() or c == ' ' else '?' for c in value)
+
+    # Escape potential log injection patterns
+    sanitized = sanitized.replace('\n', '\\n').replace('\r', '\\r')
+
+    # Truncate
+    if len(sanitized) > max_length:
+        sanitized = sanitized[:max_length] + '...'
+
+    return sanitized
+
+
+# Environment-based configuration
+IS_PRODUCTION = os.getenv("ENVIRONMENT", "development") == "production"
+
+
+def get_cors_config():
+    """Get CORS configuration based on environment."""
+    if IS_PRODUCTION:
+        origins = os.getenv("CORS_ORIGINS", "").split(",")
+        origins = [o.strip() for o in origins if o.strip()]
+        return {
+            "allow_origins": origins,
+            "allow_methods": ["GET", "POST", "PUT", "DELETE"],
+            "allow_headers": ["Content-Type", "Authorization", "X-API-Key"],
+        }
+    else:
+        return {
+            "allow_origins": ["http://localhost:5173", "http://127.0.0.1:5173"],
+            "allow_methods": ["*"],
+            "allow_headers": ["*"],
+        }

omni_cortex/_bundled/dashboard/backend/test_database.py

@@ -0,0 +1,301 @@
+"""Unit tests for dashboard database functions.
+
+Run with: cd dashboard/backend && .venv/Scripts/python -m pytest test_database.py -v
+"""
+
+import json
+import os
+import sqlite3
+import tempfile
+from pathlib import Path
+
+import pytest
+
+from database import create_memory, get_memories
+
+
+@pytest.fixture
+def test_db():
+    """Create a temporary database with the required schema."""
+    with tempfile.NamedTemporaryFile(suffix=".db", delete=False) as f:
+        db_path = f.name
+
+    # Create the database schema
+    conn = sqlite3.connect(db_path)
+    conn.execute("""
+        CREATE TABLE memories (
+            id TEXT PRIMARY KEY,
+            content TEXT NOT NULL,
+            context TEXT,
+            type TEXT DEFAULT 'other',
+            status TEXT DEFAULT 'fresh',
+            importance_score INTEGER DEFAULT 50,
+            access_count INTEGER DEFAULT 0,
+            created_at TEXT NOT NULL,
+            last_accessed TEXT NOT NULL,
+            updated_at TEXT NOT NULL,
+            tags TEXT
+        )
+    """)
+    conn.execute("""
+        CREATE TABLE memory_relationships (
+            source_memory_id TEXT NOT NULL,
+            target_memory_id TEXT NOT NULL,
+            relationship_type TEXT NOT NULL,
+            strength REAL DEFAULT 0.5,
+            PRIMARY KEY (source_memory_id, target_memory_id)
+        )
+    """)
+    conn.commit()
+    conn.close()
+
+    yield db_path
+
+    # Cleanup
+    os.unlink(db_path)
+
+
+class TestCreateMemory:
+    """Tests for the create_memory function."""
+
+    def test_create_memory_basic(self, test_db):
+        """Test basic memory creation with minimal fields."""
+        memory_id = create_memory(
+            db_path=test_db,
+            content="Test memory content",
+        )
+
+        assert memory_id is not None
+        assert memory_id.startswith("mem_")
+
+    def test_create_memory_with_type(self, test_db):
+        """Test memory creation with custom type."""
+        memory_id = create_memory(
+            db_path=test_db,
+            content="A decision was made",
+            memory_type="decision",
+        )
+
+        # Verify the type was saved
+        conn = sqlite3.connect(test_db)
+        conn.row_factory = sqlite3.Row
+        row = conn.execute(
+            "SELECT * FROM memories WHERE id = ?", (memory_id,)
+        ).fetchone()
+        conn.close()
+
+        assert row["type"] == "decision"
+
+    def test_create_memory_with_tags(self, test_db):
+        """Test memory creation with tags."""
+        tags = ["python", "testing", "database"]
+        memory_id = create_memory(
+            db_path=test_db,
+            content="Tagged memory",
+            tags=tags,
+        )
+
+        # Verify tags were saved as JSON
+        conn = sqlite3.connect(test_db)
+        conn.row_factory = sqlite3.Row
+        row = conn.execute(
+            "SELECT * FROM memories WHERE id = ?", (memory_id,)
+        ).fetchone()
+        conn.close()
+
+        saved_tags = json.loads(row["tags"])
+        assert saved_tags == tags
+
+    def test_create_memory_with_importance(self, test_db):
+        """Test memory creation with custom importance score."""
+        memory_id = create_memory(
+            db_path=test_db,
+            content="Important memory",
+            importance_score=95,
+        )
+
+        conn = sqlite3.connect(test_db)
+        conn.row_factory = sqlite3.Row
+        row = conn.execute(
+            "SELECT * FROM memories WHERE id = ?", (memory_id,)
+        ).fetchone()
+        conn.close()
+
+        assert row["importance_score"] == 95
+
+    def test_create_memory_has_updated_at(self, test_db):
+        """Test that created memory has updated_at field (regression test for bug)."""
+        memory_id = create_memory(
+            db_path=test_db,
+            content="Memory with updated_at",
+        )
+
+        conn = sqlite3.connect(test_db)
+        conn.row_factory = sqlite3.Row
+        row = conn.execute(
+            "SELECT * FROM memories WHERE id = ?", (memory_id,)
+        ).fetchone()
+        conn.close()
+
+        # This was the bug - updated_at was missing from INSERT
+        assert row["updated_at"] is not None
+        assert len(row["updated_at"]) > 0
+
+    def test_create_memory_with_context(self, test_db):
+        """Test memory creation with context."""
+        memory_id = create_memory(
+            db_path=test_db,
+            content="Memory with context",
+            context="This is additional context",
+        )
+
+        conn = sqlite3.connect(test_db)
+        conn.row_factory = sqlite3.Row
+        row = conn.execute(
+            "SELECT * FROM memories WHERE id = ?", (memory_id,)
+        ).fetchone()
+        conn.close()
+
+        assert row["context"] == "This is additional context"
+
+    def test_create_memory_default_status_is_fresh(self, test_db):
+        """Test that new memories have 'fresh' status by default."""
+        memory_id = create_memory(
+            db_path=test_db,
+            content="Fresh memory",
+        )
+
+        conn = sqlite3.connect(test_db)
+        conn.row_factory = sqlite3.Row
+        row = conn.execute(
+            "SELECT * FROM memories WHERE id = ?", (memory_id,)
+        ).fetchone()
+        conn.close()
+
+        assert row["status"] == "fresh"
+
+    def test_create_memory_default_access_count_is_zero(self, test_db):
+        """Test that new memories have access_count of 0."""
+        memory_id = create_memory(
+            db_path=test_db,
+            content="New memory",
+        )
+
+        conn = sqlite3.connect(test_db)
+        conn.row_factory = sqlite3.Row
+        row = conn.execute(
+            "SELECT * FROM memories WHERE id = ?", (memory_id,)
+        ).fetchone()
+        conn.close()
+
+        assert row["access_count"] == 0
+
+    def test_create_memory_all_fields(self, test_db):
+        """Test memory creation with all fields populated."""
+        memory_id = create_memory(
+            db_path=test_db,
+            content="Complete memory",
+            memory_type="solution",
+            context="Full context here",
+            tags=["tag1", "tag2"],
+            importance_score=80,
+        )
+
+        conn = sqlite3.connect(test_db)
+        conn.row_factory = sqlite3.Row
+        row = conn.execute(
+            "SELECT * FROM memories WHERE id = ?", (memory_id,)
+        ).fetchone()
+        conn.close()
+
+        assert row["content"] == "Complete memory"
+        assert row["type"] == "solution"
+        assert row["context"] == "Full context here"
+        assert json.loads(row["tags"]) == ["tag1", "tag2"]
+        assert row["importance_score"] == 80
+        assert row["status"] == "fresh"
+        assert row["access_count"] == 0
+        assert row["created_at"] is not None
+        assert row["last_accessed"] is not None
+        assert row["updated_at"] is not None
+
+
+class TestCreateMemoryEdgeCases:
+    """Edge case tests for create_memory."""
+
+    def test_create_memory_empty_tags_list(self, test_db):
+        """Test memory creation with empty tags list.
+
+        Note: Current behavior stores empty list as None (falsy check in code).
+        This is intentional - empty tags are treated same as no tags.
+        """
+        memory_id = create_memory(
+            db_path=test_db,
+            content="Memory with empty tags",
+            tags=[],
+        )
+
+        conn = sqlite3.connect(test_db)
+        conn.row_factory = sqlite3.Row
+        row = conn.execute(
+            "SELECT * FROM memories WHERE id = ?", (memory_id,)
+        ).fetchone()
+        conn.close()
+
+        # Empty list is treated as None (falsy) in the code
+        assert row["tags"] is None
+
+    def test_create_memory_none_tags(self, test_db):
+        """Test memory creation with None tags (default)."""
+        memory_id = create_memory(
+            db_path=test_db,
+            content="Memory with no tags",
+            tags=None,
+        )
+
+        conn = sqlite3.connect(test_db)
+        conn.row_factory = sqlite3.Row
+        row = conn.execute(
+            "SELECT * FROM memories WHERE id = ?", (memory_id,)
+        ).fetchone()
+        conn.close()
+
+        assert row["tags"] is None
+
+    def test_create_memory_unicode_content(self, test_db):
+        """Test memory creation with unicode content."""
+        content = "Memory with unicode: 日本語 🚀 émojis"
+        memory_id = create_memory(
+            db_path=test_db,
+            content=content,
+        )
+
+        conn = sqlite3.connect(test_db)
+        conn.row_factory = sqlite3.Row
+        row = conn.execute(
+            "SELECT * FROM memories WHERE id = ?", (memory_id,)
+        ).fetchone()
+        conn.close()
+
+        assert row["content"] == content
+
+    def test_create_memory_long_content(self, test_db):
+        """Test memory creation with very long content."""
+        content = "A" * 100000  # 100KB of content
+        memory_id = create_memory(
+            db_path=test_db,
+            content=content,
+        )
+
+        conn = sqlite3.connect(test_db)
+        conn.row_factory = sqlite3.Row
+        row = conn.execute(
+            "SELECT * FROM memories WHERE id = ?", (memory_id,)
+        ).fetchone()
+        conn.close()
+
+        assert len(row["content"]) == 100000
+
+
+if __name__ == "__main__":
+    pytest.main([__file__, "-v"])