omni-cortex 1.0.4__py3-none-any.whl

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

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

omni_cortex-1.0.4.data/data/share/omni-cortex/dashboard/backend/project_scanner.py

@@ -0,0 +1,141 @@
+"""Scanner to discover all omni-cortex databases on the system."""
+
+import os
+import sqlite3
+from datetime import datetime
+from pathlib import Path
+
+from models import ProjectInfo
+
+
+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()
+
+    # 1. Add global index if exists
+    global_path = get_global_db_path()
+    if global_path.exists():
+        stat = global_path.stat()
+        projects.append(
+            ProjectInfo(
+                name="Global Index",
+                path=str(global_path.parent),
+                db_path=str(global_path),
+                last_modified=datetime.fromtimestamp(stat.st_mtime),
+                memory_count=get_memory_count(global_path),
+                is_global=True,
+            )
+        )
+        seen_paths.add(str(global_path))
+
+    # 2. Scan common project directories
+    scan_dirs = [
+        Path("D:/Projects"),
+        Path.home() / "projects",
+        Path.home() / "Projects",
+        Path.home() / "code",
+        Path.home() / "Code",
+        Path.home() / "dev",
+        Path.home() / "Dev",
+        Path.home() / "src",
+        Path.home() / "workspace",
+    ]
+
+    for scan_dir in scan_dirs:
+        if scan_dir.exists():
+            for db_path in scan_directory_for_cortex(scan_dir):
+                if str(db_path) not in seen_paths:
+                    project_dir = db_path.parent.parent
+                    stat = db_path.stat()
+                    projects.append(
+                        ProjectInfo(
+                            name=project_dir.name,
+                            path=str(project_dir),
+                            db_path=str(db_path),
+                            last_modified=datetime.fromtimestamp(stat.st_mtime),
+                            memory_count=get_memory_count(db_path),
+                            is_global=False,
+                        )
+                    )
+                    seen_paths.add(str(db_path))
+
+    # 3. 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,
+                )
+            )
+            seen_paths.add(str(db_path))
+
+    # Sort by last_modified (most recent first), with global always first
+    projects.sort(key=lambda p: (not p.is_global, -(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.0.4.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"]