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

{omni_cortex-1.0.4.data → omni_cortex-1.2.0.data}/data/share/omni-cortex/dashboard/backend/main.py

@@ -3,6 +3,7 @@
 
 import asyncio
 import json
+import traceback
 from contextlib import asynccontextmanager
 from datetime import datetime
 from pathlib import Path
@@ -37,10 +38,34 @@ from database import (
     search_memories,
     update_memory,
 )
-from models import ChatRequest, ChatResponse, FilterParams, MemoryUpdate, ProjectInfo
+from logging_config import log_success, log_error
+from models import (
+    ChatRequest,
+    ChatResponse,
+    ConversationSaveRequest,
+    ConversationSaveResponse,
+    FilterParams,
+    MemoryUpdate,
+    ProjectInfo,
+    ProjectRegistration,
+    BatchImageGenerationRequest,
+    BatchImageGenerationResponse,
+    ImageRefineRequest,
+    SingleImageRequestModel,
+    SingleImageResponseModel,
+)
+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
+from image_service import image_service, ImagePreset, SingleImageRequest
 
 
 class DatabaseChangeHandler(FileSystemEventHandler):
@@ -145,6 +170,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"),
@@ -160,23 +249,30 @@ async def list_memories(
     offset: int = 0,
 ):
     """Get memories with filtering and pagination."""
-    if not Path(project).exists():
-        raise HTTPException(status_code=404, detail="Database not found")
-
-    filters = FilterParams(
-        memory_type=memory_type,
-        status=status,
-        tags=tags.split(",") if tags else None,
-        search=search,
-        min_importance=min_importance,
-        max_importance=max_importance,
-        sort_by=sort_by,
-        sort_order=sort_order,
-        limit=limit,
-        offset=offset,
-    )
+    try:
+        if not Path(project).exists():
+            log_error("/api/memories", FileNotFoundError("Database not found"), project=project)
+            raise HTTPException(status_code=404, detail="Database not found")
+
+        filters = FilterParams(
+            memory_type=memory_type,
+            status=status,
+            tags=tags.split(",") if tags else None,
+            search=search,
+            min_importance=min_importance,
+            max_importance=max_importance,
+            sort_by=sort_by,
+            sort_order=sort_order,
+            limit=limit,
+            offset=offset,
+        )
 
-    return get_memories(project, filters)
+        memories = get_memories(project, filters)
+        log_success("/api/memories", count=len(memories), offset=offset, filters=bool(search or memory_type))
+        return memories
+    except Exception as e:
+        log_error("/api/memories", e, project=project)
+        raise
 
 
 # NOTE: These routes MUST be defined before /api/memories/{memory_id} to avoid path conflicts
@@ -237,16 +333,25 @@ async def update_memory_endpoint(
     project: str = Query(..., description="Path to the database file"),
 ):
     """Update a memory."""
-    if not Path(project).exists():
-        raise HTTPException(status_code=404, detail="Database not found")
-
-    updated = update_memory(project, memory_id, updates)
-    if not updated:
-        raise HTTPException(status_code=404, detail="Memory not found")
-
-    # Notify connected clients
-    await manager.broadcast("memory_updated", updated.model_dump(by_alias=True))
-    return updated
+    try:
+        if not Path(project).exists():
+            log_error("/api/memories/update", FileNotFoundError("Database not found"), memory_id=memory_id)
+            raise HTTPException(status_code=404, detail="Database not found")
+
+        updated = update_memory(project, memory_id, updates)
+        if not updated:
+            log_error("/api/memories/update", ValueError("Memory not found"), memory_id=memory_id)
+            raise HTTPException(status_code=404, detail="Memory not found")
+
+        # Notify connected clients
+        await manager.broadcast("memory_updated", updated.model_dump(by_alias=True))
+        log_success("/api/memories/update", memory_id=memory_id, fields_updated=len(updates.model_dump(exclude_unset=True)))
+        return updated
+    except HTTPException:
+        raise
+    except Exception as e:
+        log_error("/api/memories/update", e, memory_id=memory_id)
+        raise
 
 
 @app.delete("/api/memories/{memory_id}")
@@ -255,16 +360,25 @@ async def delete_memory_endpoint(
     project: str = Query(..., description="Path to the database file"),
 ):
     """Delete a memory."""
-    if not Path(project).exists():
-        raise HTTPException(status_code=404, detail="Database not found")
-
-    deleted = delete_memory(project, memory_id)
-    if not deleted:
-        raise HTTPException(status_code=404, detail="Memory not found")
-
-    # Notify connected clients
-    await manager.broadcast("memory_deleted", {"id": memory_id})
-    return {"message": "Memory deleted", "id": memory_id}
+    try:
+        if not Path(project).exists():
+            log_error("/api/memories/delete", FileNotFoundError("Database not found"), memory_id=memory_id)
+            raise HTTPException(status_code=404, detail="Database not found")
+
+        deleted = delete_memory(project, memory_id)
+        if not deleted:
+            log_error("/api/memories/delete", ValueError("Memory not found"), memory_id=memory_id)
+            raise HTTPException(status_code=404, detail="Memory not found")
+
+        # Notify connected clients
+        await manager.broadcast("memory_deleted", {"id": memory_id})
+        log_success("/api/memories/delete", memory_id=memory_id)
+        return {"message": "Memory deleted", "id": memory_id}
+    except HTTPException:
+        raise
+    except Exception as e:
+        log_error("/api/memories/delete", e, memory_id=memory_id)
+        raise
 
 
 @app.get("/api/memories/stats/summary")
@@ -454,16 +568,184 @@ async def chat_with_memories(
     project: str = Query(..., description="Path to the database file"),
 ):
     """Ask a natural language question about memories."""
+    try:
+        if not Path(project).exists():
+            log_error("/api/chat", FileNotFoundError("Database not found"), question=request.question[:50])
+            raise HTTPException(status_code=404, detail="Database not found")
+
+        result = await chat_service.ask_about_memories(
+            project,
+            request.question,
+            request.max_memories,
+        )
+
+        log_success("/api/chat", question_len=len(request.question), sources=len(result.get("sources", [])))
+        return ChatResponse(**result)
+    except HTTPException:
+        raise
+    except Exception as e:
+        log_error("/api/chat", e, question=request.question[:50])
+        raise
+
+
+@app.get("/api/chat/stream")
+async def stream_chat(
+    project: str = Query(..., description="Path to the database file"),
+    question: str = Query(..., description="The question to ask"),
+    max_memories: int = Query(10, ge=1, le=50),
+):
+    """SSE endpoint for streaming chat responses."""
+    from fastapi.responses import StreamingResponse
+
     if not Path(project).exists():
         raise HTTPException(status_code=404, detail="Database not found")
 
-    result = await chat_service.ask_about_memories(
-        project,
-        request.question,
-        request.max_memories,
+    async def event_generator():
+        try:
+            async for event in chat_service.stream_ask_about_memories(project, question, max_memories):
+                yield f"data: {json.dumps(event)}\n\n"
+        except Exception as e:
+            yield f"data: {json.dumps({'type': 'error', 'data': str(e)})}\n\n"
+
+    return StreamingResponse(
+        event_generator(),
+        media_type="text/event-stream",
+        headers={
+            "Cache-Control": "no-cache",
+            "Connection": "keep-alive",
+            "X-Accel-Buffering": "no",
+        }
     )
 
-    return ChatResponse(**result)
+
+@app.post("/api/chat/save", response_model=ConversationSaveResponse)
+async def save_chat_conversation(
+    request: ConversationSaveRequest,
+    project: str = Query(..., description="Path to the database file"),
+):
+    """Save a chat conversation as a memory."""
+    try:
+        if not Path(project).exists():
+            log_error("/api/chat/save", FileNotFoundError("Database not found"))
+            raise HTTPException(status_code=404, detail="Database not found")
+
+        result = await chat_service.save_conversation(
+            project,
+            [msg.model_dump() for msg in request.messages],
+            request.referenced_memory_ids,
+            request.importance or 60,
+        )
+
+        log_success("/api/chat/save", memory_id=result["memory_id"], messages=len(request.messages))
+        return ConversationSaveResponse(**result)
+    except HTTPException:
+        raise
+    except Exception as e:
+        log_error("/api/chat/save", e)
+        raise
+
+
+# --- Image Generation Endpoints ---
+
+
+@app.get("/api/image/status")
+async def get_image_status():
+    """Check if image generation is available."""
+    return {
+        "available": image_service.is_available(),
+        "message": "Image generation ready" if image_service.is_available()
+                   else "Configure GEMINI_API_KEY and install google-genai for image generation",
+    }
+
+
+@app.get("/api/image/presets")
+async def get_image_presets():
+    """Get available image preset templates."""
+    return {"presets": image_service.get_presets()}
+
+
+@app.post("/api/image/generate-batch", response_model=BatchImageGenerationResponse)
+async def generate_images_batch(
+    request: BatchImageGenerationRequest,
+    db_path: str = Query(..., alias="project", description="Path to the database file"),
+):
+    """Generate multiple images with different presets/prompts."""
+    # Validate image count
+    if len(request.images) not in [1, 2, 4]:
+        return BatchImageGenerationResponse(
+            success=False,
+            errors=["Must request 1, 2, or 4 images"]
+        )
+
+    # Build memory context
+    memory_context = ""
+    if request.memory_ids:
+        memory_context = image_service.build_memory_context(db_path, request.memory_ids)
+
+    # Build chat context
+    chat_context = image_service.build_chat_context(request.chat_messages)
+
+    # Convert request models to internal format
+    image_requests = [
+        SingleImageRequest(
+            preset=ImagePreset(img.preset),
+            custom_prompt=img.custom_prompt,
+            aspect_ratio=img.aspect_ratio,
+            image_size=img.image_size
+        )
+        for img in request.images
+    ]
+
+    result = await image_service.generate_batch(
+        requests=image_requests,
+        memory_context=memory_context,
+        chat_context=chat_context,
+        use_search_grounding=request.use_search_grounding
+    )
+
+    return BatchImageGenerationResponse(
+        success=result.success,
+        images=[
+            SingleImageResponseModel(
+                success=img.success,
+                image_data=img.image_data,
+                text_response=img.text_response,
+                thought_signature=img.thought_signature,
+                image_id=img.image_id,
+                error=img.error,
+                index=img.index
+            )
+            for img in result.images
+        ],
+        errors=result.errors
+    )
+
+
+@app.post("/api/image/refine", response_model=SingleImageResponseModel)
+async def refine_image(request: ImageRefineRequest):
+    """Refine an existing generated image with a new prompt."""
+    result = await image_service.refine_image(
+        image_id=request.image_id,
+        refinement_prompt=request.refinement_prompt,
+        aspect_ratio=request.aspect_ratio,
+        image_size=request.image_size
+    )
+
+    return SingleImageResponseModel(
+        success=result.success,
+        image_data=result.image_data,
+        text_response=result.text_response,
+        thought_signature=result.thought_signature,
+        image_id=result.image_id,
+        error=result.error
+    )
+
+
+@app.post("/api/image/clear-conversation")
+async def clear_image_conversation(image_id: Optional[str] = None):
+    """Clear image conversation history. If image_id provided, clear only that image."""
+    image_service.clear_conversation(image_id)
+    return {"status": "cleared", "image_id": image_id}
 
 
 # --- WebSocket Endpoint ---

{omni_cortex-1.0.4.data → omni_cortex-1.2.0.data}/data/share/omni-cortex/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):
@@ -138,3 +163,71 @@ class ChatResponse(BaseModel):
     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.2.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