omni-cortex 1.6.0__py3-none-any.whl

omni_cortex-1.6.0.data/data/share/omni-cortex/dashboard/backend/models.py

@@ -0,0 +1,241 @@
+"""Pydantic models for the dashboard API."""
+
+from datetime import datetime
+from typing import Optional
+
+from pydantic import BaseModel, Field
+
+
+class ProjectInfo(BaseModel):
+    """Information about a project with omni-cortex database."""
+
+    name: str
+    path: str
+    db_path: str
+    last_modified: Optional[datetime] = None
+    memory_count: int = 0
+    is_global: bool = False
+    is_favorite: bool = False
+    is_registered: bool = False
+    display_name: Optional[str] = None
+
+
+class ScanDirectory(BaseModel):
+    """A directory being scanned for projects."""
+
+    path: str
+    project_count: int = 0
+
+
+class ProjectRegistration(BaseModel):
+    """Request to register a project."""
+
+    path: str
+    display_name: Optional[str] = None
+
+
+class ProjectConfigResponse(BaseModel):
+    """Response with project configuration."""
+
+    scan_directories: list[str]
+    registered_count: int
+    favorites_count: int
+
+
+class Memory(BaseModel):
+    """Memory record from the database."""
+
+    id: str
+    content: str
+    context: Optional[str] = None
+    memory_type: str = Field(default="other", validation_alias="type")
+    status: str = "fresh"
+    importance_score: int = 50
+    access_count: int = 0
+    created_at: datetime
+    last_accessed: Optional[datetime] = None
+    tags: list[str] = []
+
+    model_config = {"populate_by_name": True}
+
+
+class MemoryStats(BaseModel):
+    """Statistics about memories in a database."""
+
+    total_count: int
+    by_type: dict[str, int]
+    by_status: dict[str, int]
+    avg_importance: float
+    total_access_count: int
+    tags: list[dict[str, int | str]]
+
+
+class Activity(BaseModel):
+    """Activity log record."""
+
+    id: str
+    session_id: Optional[str] = None
+    event_type: str
+    tool_name: Optional[str] = None
+    tool_input: Optional[str] = None
+    tool_output: Optional[str] = None
+    success: bool = True
+    error_message: Optional[str] = None
+    duration_ms: Optional[int] = None
+    file_path: Optional[str] = None
+    timestamp: datetime
+    # Command analytics fields
+    command_name: Optional[str] = None
+    command_scope: Optional[str] = None
+    mcp_server: Optional[str] = None
+    skill_name: Optional[str] = None
+    # Natural language summary fields
+    summary: Optional[str] = None
+    summary_detail: Optional[str] = None
+
+
+class Session(BaseModel):
+    """Session record."""
+
+    id: str
+    project_path: str
+    started_at: datetime
+    ended_at: Optional[datetime] = None
+    summary: Optional[str] = None
+    activity_count: int = 0
+
+
+class TimelineEntry(BaseModel):
+    """Entry in the timeline view."""
+
+    timestamp: datetime
+    entry_type: str  # "memory" or "activity"
+    data: dict
+
+
+class FilterParams(BaseModel):
+    """Query filter parameters."""
+
+    memory_type: Optional[str] = None
+    status: Optional[str] = None
+    tags: Optional[list[str]] = None
+    search: Optional[str] = None
+    min_importance: Optional[int] = None
+    max_importance: Optional[int] = None
+    sort_by: str = "last_accessed"
+    sort_order: str = "desc"
+    limit: int = 50
+    offset: int = 0
+
+
+class MemoryUpdate(BaseModel):
+    """Update request for a memory."""
+
+    content: Optional[str] = None
+    context: Optional[str] = None
+    memory_type: Optional[str] = Field(None, validation_alias="type")
+    status: Optional[str] = None
+    importance_score: Optional[int] = Field(None, ge=1, le=100)
+    tags: Optional[list[str]] = None
+
+    model_config = {"populate_by_name": True}
+
+
+class WSEvent(BaseModel):
+    """WebSocket event message."""
+
+    event_type: str
+    data: dict
+    timestamp: datetime = Field(default_factory=datetime.now)
+
+
+class ChatRequest(BaseModel):
+    """Request for the chat endpoint."""
+
+    question: str = Field(..., min_length=1, max_length=2000)
+    max_memories: int = Field(default=10, ge=1, le=50)
+
+
+class ChatSource(BaseModel):
+    """Source memory reference in chat response."""
+
+    id: str
+    type: str
+    content_preview: str
+    tags: list[str]
+
+
+class ChatResponse(BaseModel):
+    """Response from the chat endpoint."""
+
+    answer: str
+    sources: list[ChatSource]
+    error: Optional[str] = None
+
+
+class ConversationMessage(BaseModel):
+    """A message in a conversation."""
+
+    role: str  # 'user' or 'assistant'
+    content: str
+    timestamp: str
+
+
+class ConversationSaveRequest(BaseModel):
+    """Request to save a conversation as memory."""
+
+    messages: list[ConversationMessage]
+    referenced_memory_ids: Optional[list[str]] = None
+    importance: Optional[int] = Field(default=60, ge=1, le=100)
+
+
+class ConversationSaveResponse(BaseModel):
+    """Response after saving a conversation."""
+
+    memory_id: str
+    summary: str
+
+
+# --- Image Generation Models ---
+
+
+class SingleImageRequestModel(BaseModel):
+    """Request for a single image in a batch."""
+    preset: str = "custom"  # Maps to ImagePreset enum
+    custom_prompt: str = ""
+    aspect_ratio: str = "16:9"
+    image_size: str = "2K"
+
+
+class BatchImageGenerationRequest(BaseModel):
+    """Request for generating multiple images."""
+    images: list[SingleImageRequestModel]  # 1, 2, or 4 images
+    memory_ids: list[str] = []
+    chat_messages: list[dict] = []  # Recent chat for context
+    use_search_grounding: bool = False
+
+
+class ImageRefineRequest(BaseModel):
+    """Request for refining an existing image."""
+    image_id: str
+    refinement_prompt: str
+    aspect_ratio: Optional[str] = None
+    image_size: Optional[str] = None
+
+
+class SingleImageResponseModel(BaseModel):
+    """Response for a single generated image."""
+    success: bool
+    image_data: Optional[str] = None  # Base64 encoded
+    text_response: Optional[str] = None
+    thought_signature: Optional[str] = None
+    image_id: Optional[str] = None
+    error: Optional[str] = None
+    index: int = 0
+
+
+class BatchImageGenerationResponse(BaseModel):
+    """Response for batch image generation."""
+    success: bool
+    images: list[SingleImageResponseModel] = []
+    errors: list[str] = []

omni_cortex-1.6.0.data/data/share/omni-cortex/dashboard/backend/project_config.py

@@ -0,0 +1,170 @@
+"""Project configuration manager for user preferences."""
+
+import json
+import platform
+from datetime import datetime
+from pathlib import Path
+from typing import Optional
+
+from pydantic import BaseModel
+
+
+class RegisteredProject(BaseModel):
+    """A manually registered project."""
+
+    path: str
+    display_name: Optional[str] = None
+    added_at: datetime
+
+
+class RecentProject(BaseModel):
+    """A recently accessed project."""
+
+    path: str
+    last_accessed: datetime
+
+
+class ProjectConfig(BaseModel):
+    """User project configuration."""
+
+    version: int = 1
+    scan_directories: list[str] = []
+    registered_projects: list[RegisteredProject] = []
+    favorites: list[str] = []
+    recent: list[RecentProject] = []
+
+
+CONFIG_PATH = Path.home() / ".omni-cortex" / "projects.json"
+
+
+def get_default_scan_dirs() -> list[str]:
+    """Return platform-appropriate default scan directories."""
+    home = Path.home()
+
+    dirs = [
+        str(home / "projects"),
+        str(home / "Projects"),
+        str(home / "code"),
+        str(home / "Code"),
+        str(home / "dev"),
+        str(home / "workspace"),
+    ]
+
+    if platform.system() == "Windows":
+        dirs.insert(0, "D:/Projects")
+
+    return [d for d in dirs if Path(d).exists()]
+
+
+def load_config() -> ProjectConfig:
+    """Load config from disk, creating defaults if missing."""
+    if CONFIG_PATH.exists():
+        try:
+            data = json.loads(CONFIG_PATH.read_text(encoding="utf-8"))
+            return ProjectConfig(**data)
+        except Exception:
+            pass
+
+    # Create default config
+    config = ProjectConfig(scan_directories=get_default_scan_dirs())
+    save_config(config)
+    return config
+
+
+def save_config(config: ProjectConfig) -> None:
+    """Save config to disk."""
+    CONFIG_PATH.parent.mkdir(parents=True, exist_ok=True)
+    CONFIG_PATH.write_text(config.model_dump_json(indent=2), encoding="utf-8")
+
+
+def add_registered_project(path: str, display_name: Optional[str] = None) -> bool:
+    """Register a new project by path."""
+    config = load_config()
+
+    # Validate path has cortex.db
+    db_path = Path(path) / ".omni-cortex" / "cortex.db"
+    if not db_path.exists():
+        return False
+
+    # Check if already registered
+    if any(p.path == path for p in config.registered_projects):
+        return False
+
+    config.registered_projects.append(
+        RegisteredProject(path=path, display_name=display_name, added_at=datetime.now())
+    )
+    save_config(config)
+    return True
+
+
+def remove_registered_project(path: str) -> bool:
+    """Remove a registered project."""
+    config = load_config()
+    original_len = len(config.registered_projects)
+    config.registered_projects = [
+        p for p in config.registered_projects if p.path != path
+    ]
+
+    if len(config.registered_projects) < original_len:
+        save_config(config)
+        return True
+    return False
+
+
+def toggle_favorite(path: str) -> bool:
+    """Toggle favorite status for a project. Returns new favorite status."""
+    config = load_config()
+
+    if path in config.favorites:
+        config.favorites.remove(path)
+        is_favorite = False
+    else:
+        config.favorites.append(path)
+        is_favorite = True
+
+    save_config(config)
+    return is_favorite
+
+
+def update_recent(path: str) -> None:
+    """Update recent projects list."""
+    config = load_config()
+
+    # Remove if already in list
+    config.recent = [r for r in config.recent if r.path != path]
+
+    # Add to front
+    config.recent.insert(0, RecentProject(path=path, last_accessed=datetime.now()))
+
+    # Keep only last 10
+    config.recent = config.recent[:10]
+
+    save_config(config)
+
+
+def add_scan_directory(directory: str) -> bool:
+    """Add a directory to scan list."""
+    config = load_config()
+
+    # Expand user path
+    expanded = str(Path(directory).expanduser())
+
+    if not Path(expanded).is_dir():
+        return False
+
+    if expanded not in config.scan_directories:
+        config.scan_directories.append(expanded)
+        save_config(config)
+        return True
+    return False
+
+
+def remove_scan_directory(directory: str) -> bool:
+    """Remove a directory from scan list."""
+    config = load_config()
+
+    if directory in config.scan_directories:
+        config.scan_directories.remove(directory)
+        save_config(config)
+        return True
+    return False

omni_cortex-1.6.0.data/data/share/omni-cortex/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-1.6.0.data/data/share/omni-cortex/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-1.6.0.data/data/share/omni-cortex/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"]