omni-cortex 1.0.7__tar.gz → 1.0.9__tar.gz

{omni_cortex-1.0.7 → omni_cortex-1.0.9}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: omni-cortex
-Version: 1.0.7
+Version: 1.0.9
 Summary: Universal Memory MCP for Claude Code - dual-layer activity logging and knowledge storage
 Project-URL: Homepage, https://github.com/AllCytes/Omni-Cortex
 Project-URL: Repository, https://github.com/AllCytes/Omni-Cortex

{omni_cortex-1.0.7 → omni_cortex-1.0.9}/dashboard/backend/main.py

@@ -39,7 +39,15 @@ from database import (
     update_memory,
 )
 from logging_config import log_success, log_error
-from models import ChatRequest, ChatResponse, FilterParams, MemoryUpdate, ProjectInfo
+from models import ChatRequest, ChatResponse, FilterParams, MemoryUpdate, ProjectInfo, ProjectRegistration
+from project_config import (
+    load_config,
+    add_registered_project,
+    remove_registered_project,
+    toggle_favorite,
+    add_scan_directory,
+    remove_scan_directory,
+)
 from project_scanner import scan_projects
 from websocket_manager import manager
 import chat_service
@@ -147,6 +155,70 @@ async def list_projects():
     return scan_projects()
 
 
+# --- Project Management Endpoints ---
+
+
+@app.get("/api/projects/config")
+async def get_project_config():
+    """Get project configuration (scan dirs, counts)."""
+    config = load_config()
+    return {
+        "scan_directories": config.scan_directories,
+        "registered_count": len(config.registered_projects),
+        "favorites_count": len(config.favorites),
+    }
+
+
+@app.post("/api/projects/register")
+async def register_project(body: ProjectRegistration):
+    """Manually register a project by path."""
+    success = add_registered_project(body.path, body.display_name)
+    if not success:
+        raise HTTPException(400, "Invalid path or already registered")
+    return {"success": True}
+
+
+@app.delete("/api/projects/register")
+async def unregister_project(path: str = Query(..., description="Project path to unregister")):
+    """Remove a registered project."""
+    success = remove_registered_project(path)
+    if not success:
+        raise HTTPException(404, "Project not found")
+    return {"success": True}
+
+
+@app.post("/api/projects/favorite")
+async def toggle_project_favorite(path: str = Query(..., description="Project path to toggle favorite")):
+    """Toggle favorite status for a project."""
+    is_favorite = toggle_favorite(path)
+    return {"is_favorite": is_favorite}
+
+
+@app.post("/api/projects/scan-directories")
+async def add_scan_dir(directory: str = Query(..., description="Directory path to add")):
+    """Add a directory to auto-scan list."""
+    success = add_scan_directory(directory)
+    if not success:
+        raise HTTPException(400, "Invalid directory or already added")
+    return {"success": True}
+
+
+@app.delete("/api/projects/scan-directories")
+async def remove_scan_dir(directory: str = Query(..., description="Directory path to remove")):
+    """Remove a directory from auto-scan list."""
+    success = remove_scan_directory(directory)
+    if not success:
+        raise HTTPException(404, "Directory not found")
+    return {"success": True}
+
+
+@app.post("/api/projects/refresh")
+async def refresh_projects():
+    """Force rescan of all project directories."""
+    projects = scan_projects()
+    return {"count": len(projects)}
+
+
 @app.get("/api/memories")
 async def list_memories(
     project: str = Query(..., description="Path to the database file"),

{omni_cortex-1.0.7 → omni_cortex-1.0.9}/dashboard/backend/models.py

@@ -15,6 +15,31 @@ class ProjectInfo(BaseModel):
     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):

omni_cortex-1.0.9/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.7 → omni_cortex-1.0.9}/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
 

{omni_cortex-1.0.7 → omni_cortex-1.0.9}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "hatchling.build"
 
 [project]
 name = "omni-cortex"
-version = "1.0.7"
+version = "1.0.9"
 description = "Universal Memory MCP for Claude Code - dual-layer activity logging and knowledge storage"
 readme = "README.md"
 license = "MIT"