omni-cortex 1.1.0__tar.gz → 1.2.0__tar.gz

{omni_cortex-1.1.0 → omni_cortex-1.2.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: omni-cortex
-Version: 1.1.0
+Version: 1.2.0
 Summary: Give Claude Code a perfect memory - auto-logs everything, searches smartly, and gets smarter over time
 Project-URL: Homepage, https://github.com/AllCytes/Omni-Cortex
 Project-URL: Repository, https://github.com/AllCytes/Omni-Cortex

omni_cortex-1.2.0/dashboard/backend/image_service.py

@@ -0,0 +1,533 @@
+"""Image generation service using Nano Banana Pro (gemini-3-pro-image-preview)."""
+
+import base64
+import os
+import uuid
+from dataclasses import dataclass, field
+from enum import Enum
+from typing import Optional
+
+from dotenv import load_dotenv
+
+from database import get_memory_by_id
+
+load_dotenv()
+
+
+class ImagePreset(str, Enum):
+    """Preset templates for common image types."""
+    INFOGRAPHIC = "infographic"
+    KEY_INSIGHTS = "key_insights"
+    TIPS_TRICKS = "tips_tricks"
+    QUOTE_CARD = "quote_card"
+    WORKFLOW = "workflow"
+    COMPARISON = "comparison"
+    SUMMARY_CARD = "summary_card"
+    CUSTOM = "custom"
+
+
+# Preset system prompts
+PRESET_PROMPTS = {
+    ImagePreset.INFOGRAPHIC: """Create a professional infographic with:
+- Clear visual hierarchy with icons and sections
+- Bold header/title at top
+- 3-5 key points with visual elements
+- Clean, modern design with good use of whitespace
+- Professional color scheme""",
+
+    ImagePreset.KEY_INSIGHTS: """Create a clean insights card showing:
+- "Key Insights" or similar header
+- 3-5 bullet points with key takeaways
+- Each insight is concise (1-2 lines max)
+- Clean typography, easy to read
+- Subtle design elements""",
+
+    ImagePreset.TIPS_TRICKS: """Create a tips card showing:
+- Numbered tips (1, 2, 3, etc.) with icons
+- Each tip is actionable and clear
+- Visual styling that's engaging
+- Good contrast and readability""",
+
+    ImagePreset.QUOTE_CARD: """Create a quote card with:
+- The key quote in large, styled text
+- Attribution below the quote
+- Elegant, minimalist design
+- Suitable for social media sharing""",
+
+    ImagePreset.WORKFLOW: """Create a workflow diagram showing:
+- Step-by-step process with arrows/connectors
+- Each step clearly labeled
+- Visual flow from start to finish
+- Professional diagrammatic style""",
+
+    ImagePreset.COMPARISON: """Create a comparison visual showing:
+- Side-by-side or pros/cons layout
+- Clear distinction between options
+- Visual indicators (checkmarks, icons)
+- Balanced, professional presentation""",
+
+    ImagePreset.SUMMARY_CARD: """Create a summary card with:
+- Brief title/header
+- Key stats or metrics highlighted
+- Concise overview text
+- Clean, scannable layout""",
+
+    ImagePreset.CUSTOM: ""  # User provides full prompt
+}
+
+# Default aspect ratios for presets
+PRESET_ASPECT_RATIOS = {
+    ImagePreset.INFOGRAPHIC: "9:16",
+    ImagePreset.KEY_INSIGHTS: "1:1",
+    ImagePreset.TIPS_TRICKS: "4:5",
+    ImagePreset.QUOTE_CARD: "1:1",
+    ImagePreset.WORKFLOW: "16:9",
+    ImagePreset.COMPARISON: "16:9",
+    ImagePreset.SUMMARY_CARD: "4:3",
+    ImagePreset.CUSTOM: "16:9",
+}
+
+
+@dataclass
+class SingleImageRequest:
+    """Request for a single image within a batch."""
+    preset: ImagePreset = ImagePreset.CUSTOM
+    custom_prompt: str = ""
+    aspect_ratio: str = "16:9"
+    image_size: str = "2K"
+
+
+@dataclass
+class ImageGenerationResult:
+    """Result for a single generated image."""
+    success: bool
+    image_data: Optional[str] = None  # Base64 encoded
+    mime_type: str = "image/png"
+    text_response: Optional[str] = None
+    thought_signature: Optional[str] = None
+    error: Optional[str] = None
+    index: int = 0  # Position in batch
+    image_id: Optional[str] = None
+
+
+@dataclass
+class BatchImageResult:
+    """Result for batch image generation."""
+    success: bool
+    images: list[ImageGenerationResult] = field(default_factory=list)
+    errors: list[str] = field(default_factory=list)
+
+
+@dataclass
+class ConversationTurn:
+    role: str  # "user" or "model"
+    text: Optional[str] = None
+    image_data: Optional[str] = None
+    thought_signature: Optional[str] = None
+
+
+class ImageGenerationService:
+    def __init__(self):
+        self._api_key = os.getenv("GEMINI_API_KEY") or os.getenv("GOOGLE_API_KEY")
+        self._client = None
+        # Per-image conversation history for multi-turn editing
+        self._image_conversations: dict[str, list[ConversationTurn]] = {}
+
+    def _get_client(self):
+        """Get or create the Gemini client."""
+        if self._client is None and self._api_key:
+            try:
+                from google import genai
+                self._client = genai.Client(api_key=self._api_key)
+            except ImportError:
+                return None
+        return self._client
+
+    def is_available(self) -> bool:
+        """Check if image generation service is available."""
+        if not self._api_key:
+            return False
+        try:
+            from google import genai
+            return True
+        except ImportError:
+            return False
+
+    def build_memory_context(self, db_path: str, memory_ids: list[str]) -> str:
+        """Build context string from selected memories."""
+        memories = []
+        for mem_id in memory_ids:
+            memory = get_memory_by_id(db_path, mem_id)
+            if memory:
+                memories.append(f"""
+Memory: {memory.memory_type}
+Content: {memory.content}
+Context: {memory.context or 'N/A'}
+Tags: {', '.join(memory.tags) if memory.tags else 'N/A'}
+""")
+        return "\n---\n".join(memories)
+
+    def build_chat_context(self, chat_messages: list[dict]) -> str:
+        """Build context string from recent chat conversation."""
+        if not chat_messages:
+            return ""
+
+        context_parts = ["Recent conversation context:"]
+        for msg in chat_messages[-10:]:  # Last 10 messages
+            role = msg.get("role", "user")
+            content = msg.get("content", "")
+            context_parts.append(f"{role}: {content}")
+
+        return "\n".join(context_parts)
+
+    def _build_prompt_with_preset(
+        self,
+        request: SingleImageRequest,
+        memory_context: str,
+        chat_context: str
+    ) -> str:
+        """Build full prompt combining preset, custom prompt, and context."""
+        parts = []
+
+        # Add memory context
+        if memory_context:
+            parts.append(f"Based on the following memories:\n\n{memory_context}")
+
+        # Add chat context
+        if chat_context:
+            parts.append(f"\n{chat_context}")
+
+        # Add preset prompt (if not custom)
+        if request.preset != ImagePreset.CUSTOM:
+            preset_prompt = PRESET_PROMPTS.get(request.preset, "")
+            if preset_prompt:
+                parts.append(f"\nImage style guidance:\n{preset_prompt}")
+
+        # Add user's custom prompt
+        if request.custom_prompt:
+            parts.append(f"\nUser request: {request.custom_prompt}")
+
+        parts.append("\nGenerate a professional, high-quality image optimized for social media sharing.")
+
+        return "\n".join(parts)
+
+    async def generate_single_image(
+        self,
+        request: SingleImageRequest,
+        memory_context: str,
+        chat_context: str = "",
+        conversation_history: list[dict] = None,
+        use_search_grounding: bool = False,
+        image_id: str = None,
+    ) -> ImageGenerationResult:
+        """Generate a single image based on request and context."""
+        client = self._get_client()
+        if not client:
+            return ImageGenerationResult(
+                success=False,
+                error="API key not configured or google-genai not installed"
+            )
+
+        try:
+            from google.genai import types
+        except ImportError:
+            return ImageGenerationResult(
+                success=False,
+                error="google-genai package not installed"
+            )
+
+        # Generate image ID if not provided
+        if not image_id:
+            image_id = f"img_{uuid.uuid4().hex[:8]}"
+
+        # Build the full prompt
+        full_prompt = self._build_prompt_with_preset(
+            request, memory_context, chat_context
+        )
+
+        # Build contents with conversation history for multi-turn editing
+        contents = []
+
+        # Use image-specific conversation history if editing
+        if image_id and image_id in self._image_conversations:
+            for turn in self._image_conversations[image_id]:
+                parts = []
+                if turn.text:
+                    part = {"text": turn.text}
+                    if turn.thought_signature:
+                        part["thoughtSignature"] = turn.thought_signature
+                    parts.append(part)
+                if turn.image_data:
+                    part = {
+                        "inlineData": {
+                            "mimeType": "image/png",
+                            "data": turn.image_data
+                        }
+                    }
+                    if turn.thought_signature:
+                        part["thoughtSignature"] = turn.thought_signature
+                    parts.append(part)
+                contents.append({
+                    "role": turn.role,
+                    "parts": parts
+                })
+        elif conversation_history:
+            # Use provided conversation history
+            for turn in conversation_history:
+                parts = []
+                if turn.get("text"):
+                    part = {"text": turn["text"]}
+                    if turn.get("thought_signature"):
+                        part["thoughtSignature"] = turn["thought_signature"]
+                    parts.append(part)
+                if turn.get("image_data"):
+                    part = {
+                        "inlineData": {
+                            "mimeType": "image/png",
+                            "data": turn["image_data"]
+                        }
+                    }
+                    if turn.get("thought_signature"):
+                        part["thoughtSignature"] = turn["thought_signature"]
+                    parts.append(part)
+                contents.append({
+                    "role": turn["role"],
+                    "parts": parts
+                })
+
+        # Add current prompt
+        contents.append({
+            "role": "user",
+            "parts": [{"text": full_prompt}]
+        })
+
+        # Configure image settings
+        config = types.GenerateContentConfig(
+            response_modalities=["IMAGE", "TEXT"],
+        )
+
+        if use_search_grounding:
+            config.tools = [{"google_search": {}}]
+
+        try:
+            response = client.models.generate_content(
+                model="gemini-2.0-flash-preview-image-generation",
+                contents=contents,
+                config=config
+            )
+
+            # Extract image and thought signatures
+            image_data = None
+            text_response = None
+            thought_signature = None
+
+            if response.candidates and response.candidates[0].content:
+                for part in response.candidates[0].content.parts:
+                    if hasattr(part, 'inline_data') and part.inline_data:
+                        image_data = base64.b64encode(part.inline_data.data).decode()
+                    if hasattr(part, 'text') and part.text:
+                        text_response = part.text
+                    if hasattr(part, 'thought_signature') and part.thought_signature:
+                        thought_signature = part.thought_signature
+
+            # Store conversation for this image (for editing)
+            if image_id and image_data:
+                if image_id not in self._image_conversations:
+                    self._image_conversations[image_id] = []
+                self._image_conversations[image_id].append(
+                    ConversationTurn(role="user", text=full_prompt)
+                )
+                self._image_conversations[image_id].append(
+                    ConversationTurn(
+                        role="model",
+                        text=text_response,
+                        image_data=image_data,
+                        thought_signature=thought_signature
+                    )
+                )
+
+            return ImageGenerationResult(
+                success=image_data is not None,
+                image_data=image_data,
+                text_response=text_response,
+                thought_signature=thought_signature,
+                image_id=image_id,
+                error=None if image_data else "No image generated"
+            )
+
+        except Exception as e:
+            return ImageGenerationResult(
+                success=False,
+                error=str(e),
+                image_id=image_id
+            )
+
+    async def generate_batch(
+        self,
+        requests: list[SingleImageRequest],
+        memory_context: str,
+        chat_context: str = "",
+        use_search_grounding: bool = False,
+    ) -> BatchImageResult:
+        """Generate multiple images with different settings."""
+        results = []
+        errors = []
+
+        for i, request in enumerate(requests):
+            # Generate unique ID for each image in batch
+            image_id = f"batch_{uuid.uuid4().hex[:8]}_{i}"
+
+            result = await self.generate_single_image(
+                request=request,
+                memory_context=memory_context,
+                chat_context=chat_context,
+                use_search_grounding=use_search_grounding,
+                image_id=image_id
+            )
+            result.index = i
+            results.append(result)
+
+            if not result.success:
+                errors.append(f"Image {i+1}: {result.error}")
+
+        return BatchImageResult(
+            success=len(errors) == 0,
+            images=results,
+            errors=errors
+        )
+
+    async def refine_image(
+        self,
+        image_id: str,
+        refinement_prompt: str,
+        aspect_ratio: str = None,
+        image_size: str = None
+    ) -> ImageGenerationResult:
+        """Refine an existing image using its conversation history."""
+        client = self._get_client()
+        if not client:
+            return ImageGenerationResult(
+                success=False,
+                error="API key not configured"
+            )
+
+        if image_id not in self._image_conversations:
+            return ImageGenerationResult(
+                success=False,
+                error="No conversation history found for this image"
+            )
+
+        try:
+            from google.genai import types
+        except ImportError:
+            return ImageGenerationResult(
+                success=False,
+                error="google-genai package not installed"
+            )
+
+        # Build contents from conversation history
+        contents = []
+
+        for turn in self._image_conversations[image_id]:
+            parts = []
+            if turn.text:
+                part = {"text": turn.text}
+                if turn.thought_signature:
+                    part["thoughtSignature"] = turn.thought_signature
+                parts.append(part)
+            if turn.image_data:
+                part = {
+                    "inlineData": {
+                        "mimeType": "image/png",
+                        "data": turn.image_data
+                    }
+                }
+                if turn.thought_signature:
+                    part["thoughtSignature"] = turn.thought_signature
+                parts.append(part)
+            contents.append({
+                "role": turn.role,
+                "parts": parts
+            })
+
+        # Add refinement prompt
+        contents.append({
+            "role": "user",
+            "parts": [{"text": refinement_prompt}]
+        })
+
+        # Configure - use defaults or provided values
+        config = types.GenerateContentConfig(
+            response_modalities=["IMAGE", "TEXT"],
+        )
+
+        try:
+            response = client.models.generate_content(
+                model="gemini-2.0-flash-preview-image-generation",
+                contents=contents,
+                config=config
+            )
+
+            image_data = None
+            text_response = None
+            thought_signature = None
+
+            if response.candidates and response.candidates[0].content:
+                for part in response.candidates[0].content.parts:
+                    if hasattr(part, 'inline_data') and part.inline_data:
+                        image_data = base64.b64encode(part.inline_data.data).decode()
+                    if hasattr(part, 'text') and part.text:
+                        text_response = part.text
+                    if hasattr(part, 'thought_signature') and part.thought_signature:
+                        thought_signature = part.thought_signature
+
+            # Update conversation history
+            self._image_conversations[image_id].append(
+                ConversationTurn(role="user", text=refinement_prompt)
+            )
+            self._image_conversations[image_id].append(
+                ConversationTurn(
+                    role="model",
+                    text=text_response,
+                    image_data=image_data,
+                    thought_signature=thought_signature
+                )
+            )
+
+            return ImageGenerationResult(
+                success=image_data is not None,
+                image_data=image_data,
+                text_response=text_response,
+                thought_signature=thought_signature,
+                image_id=image_id,
+                error=None if image_data else "No image generated"
+            )
+
+        except Exception as e:
+            return ImageGenerationResult(
+                success=False,
+                error=str(e),
+                image_id=image_id
+            )
+
+    def clear_conversation(self, image_id: str = None):
+        """Clear conversation history. If image_id provided, clear only that image."""
+        if image_id:
+            self._image_conversations.pop(image_id, None)
+        else:
+            self._image_conversations.clear()
+
+    def get_presets(self) -> list[dict]:
+        """Get available presets with their default settings."""
+        return [
+            {
+                "value": preset.value,
+                "label": preset.value.replace("_", " ").title(),
+                "default_aspect": PRESET_ASPECT_RATIOS.get(preset, "16:9")
+            }
+            for preset in ImagePreset
+        ]
+
+
+# Singleton instance
+image_service = ImageGenerationService()

{omni_cortex-1.1.0 → omni_cortex-1.2.0}/dashboard/backend/main.py

@@ -39,7 +39,21 @@ from database import (
     update_memory,
 )
 from logging_config import log_success, log_error
-from models import ChatRequest, ChatResponse, ConversationSaveRequest, ConversationSaveResponse, FilterParams, MemoryUpdate, ProjectInfo, ProjectRegistration
+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,
@@ -51,6 +65,7 @@ from project_config import (
 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):
@@ -630,6 +645,109 @@ async def save_chat_conversation(
         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.1.0 → omni_cortex-1.2.0}/dashboard/backend/models.py

@@ -186,3 +186,48 @@ class ConversationSaveResponse(BaseModel):
 
     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.1.0 → omni_cortex-1.2.0}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "hatchling.build"
 
 [project]
 name = "omni-cortex"
-version = "1.1.0"
+version = "1.2.0"
 description = "Give Claude Code a perfect memory - auto-logs everything, searches smartly, and gets smarter over time"
 readme = "README.md"
 license = "MIT"