omni-cortex 1.0.4__py3-none-any.whl → 1.3.0__py3-none-any.whl

omni_cortex-1.3.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.0.4.data → omni_cortex-1.3.0.data}/data/share/omni-cortex/dashboard/backend/project_scanner.py

@@ -1,11 +1,11 @@
 """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
+from project_config import load_config
 
 
 def get_global_db_path() -> Path:
@@ -65,54 +65,70 @@ def scan_projects() -> list[ProjectInfo]:
     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=str(global_path.parent),
+                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. 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):
+    # 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=str(project_dir),
+                            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 paths from global db that we haven't seen
+    # 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:
@@ -125,12 +141,19 @@ def scan_projects() -> list[ProjectInfo]:
                     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 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)))
+    # 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