omni-cortex 1.12.1__py3-none-any.whl → 1.13.0__py3-none-any.whl

{omni_cortex-1.12.1.data → omni_cortex-1.13.0.data}/data/share/omni-cortex/dashboard/backend/chat_service.py

@@ -45,31 +45,51 @@ def is_available() -> bool:
 def build_style_context_prompt(style_profile: dict) -> str:
     """Build a prompt section describing user's communication style."""
 
-    tone_dist = style_profile.get("tone_distribution", {})
+    # Handle both camelCase (new format) and snake_case (old format)
+    tone_dist = style_profile.get("toneDistribution") or style_profile.get("tone_distribution", {})
     tone_list = ", ".join(tone_dist.keys()) if tone_dist else "neutral"
-    avg_words = style_profile.get("avg_word_count", 20)
-    question_freq = style_profile.get("question_frequency", 0)
+    avg_words = style_profile.get("avgWordCount") or style_profile.get("avg_word_count", 20)
+    question_pct = style_profile.get("questionPercentage") or (style_profile.get("question_frequency", 0) * 100)
+    primary_tone = style_profile.get("primaryTone") or style_profile.get("primary_tone", "direct")
 
-    markers = style_profile.get("key_markers", [])
+    markers = style_profile.get("styleMarkers") or style_profile.get("key_markers", [])
     markers_text = "\n".join(f"- {m}" for m in markers) if markers else "- Direct and clear"
 
+    # Get sample messages for concrete examples
+    samples = style_profile.get("sampleMessages") or style_profile.get("sample_messages", [])
+    samples_text = ""
+    if samples:
+        samples_text = "\n**Examples of how the user actually writes:**\n"
+        for i, sample in enumerate(samples[:3], 1):
+            # Truncate long samples
+            truncated = sample[:200] + "..." if len(sample) > 200 else sample
+            samples_text += f'{i}. "{truncated}"\n'
+
     return f"""
-## User Communication Style Profile
+## IMPORTANT: User Communication Style Mode ENABLED
 
-When the user requests content "in their style" or "like they write", follow these patterns:
+You MUST write ALL responses in the user's personal communication style. This is NOT optional - every response should sound like the user wrote it themselves.
 
-**Typical Message Length:** ~{int(avg_words)} words
-**Common Tones:** {tone_list}
-**Question Frequency:** {int(question_freq * 100)}% of messages include questions
+**User's Writing Profile:**
+- Primary Tone: {primary_tone}
+- Typical Message Length: ~{int(avg_words)} words per message
+- Common Tones: {tone_list}
+- Question Usage: {int(question_pct)}% of their messages include questions
 
-**Key Style Markers:**
+**Style Markers to Emulate:**
 {markers_text}
-
-**Guidelines:**
-- Match the user's typical message length and structure
-- Use their common vocabulary patterns
-- Mirror their tone and formality level
-- If they're typically direct, be concise; if detailed, be comprehensive
+{samples_text}
+**MANDATORY Guidelines:**
+1. Write as if YOU are the user speaking - use their voice, not a formal assistant voice
+2. Match their casual/formal level - if they use contractions and slang, you should too
+3. Mirror their sentence structure and rhythm
+4. Use similar vocabulary and expressions they would use
+5. If their style is conversational, be conversational (e.g., "Right, so here's the deal...")
+6. If their style is direct, be direct and skip unnecessary pleasantries
+7. Do NOT use phrases like "Based on the memories" or "According to the data" if that's not how they write
+8. Study the example messages above and mimic that exact writing style
+
+Remember: The user has enabled "Write in My Style" mode. Your response should sound EXACTLY like something they would write themselves.
 """
 
 
@@ -369,3 +389,184 @@ async def ask_about_memories(
         "sources": sources,
         "error": None,
     }
+
+
+# Platform-specific formatting guidance
+PLATFORM_FORMATS = {
+    "skool_post": "Skool community post - can be longer, use formatting, be educational",
+    "dm": "Direct message - conversational, personal, concise",
+    "email": "Email - professional greeting/closing, clear structure",
+    "comment": "Comment reply - brief, direct, engaging",
+    "general": "General response - balanced approach",
+}
+
+# Response templates with structural guidance
+TEMPLATES = {
+    "answer": "Directly answer their question with clear explanation",
+    "guide": "Provide step-by-step guidance or recommendations",
+    "redirect": "Acknowledge and redirect to a relevant resource",
+    "acknowledge": "Acknowledge their point and add follow-up question",
+}
+
+
+def build_compose_prompt(
+    incoming_message: str,
+    style_profile: dict,
+    context_type: str,
+    template: Optional[str],
+    tone_level: int,
+    memory_context: str,
+) -> str:
+    """Build the prompt for composing a response in user's style.
+
+    Args:
+        incoming_message: The message to respond to
+        style_profile: User's style profile dictionary
+        context_type: Platform context (skool_post, dm, email, comment, general)
+        template: Optional response template (answer, guide, redirect, acknowledge)
+        tone_level: Tone formality level (0-100)
+        memory_context: Relevant memories formatted as context
+
+    Returns:
+        Complete prompt for response generation
+    """
+    # Get platform-specific formatting guidance
+    platform_guidance = PLATFORM_FORMATS.get(context_type, PLATFORM_FORMATS["general"])
+
+    # Get template guidance
+    template_guidance = ""
+    if template:
+        template_guidance = f"\n**Response Structure:** {TEMPLATES.get(template, '')}"
+
+    # Convert tone level to guidance
+    if tone_level < 25:
+        tone_guidance = "Very casual and relaxed - use slang, contractions, informal language"
+    elif tone_level < 50:
+        tone_guidance = "Casual but clear - conversational with some structure"
+    elif tone_level < 75:
+        tone_guidance = "Professional but approachable - clear and organized"
+    else:
+        tone_guidance = "Very professional and formal - polished and structured"
+
+    # Build style context
+    style_context = build_style_context_prompt(style_profile)
+
+    # Build the complete prompt
+    prompt = f"""{style_context}
+
+## RESPONSE COMPOSITION TASK
+
+You need to respond to the following message:
+
+<incoming_message>
+{xml_escape(incoming_message)}
+</incoming_message>
+
+**Context:** {platform_guidance}
+**Tone Level:** {tone_guidance}{template_guidance}
+
+"""
+
+    # Add memory context if provided
+    if memory_context:
+        prompt += f"""
+**Relevant Knowledge from Your Memories:**
+
+<memories>
+{memory_context}
+</memories>
+
+Use this information naturally in your response if relevant. Don't explicitly cite "memories" - just use the knowledge as if you remember it.
+
+"""
+
+    prompt += """
+**Your Task:**
+1. Write a response to the incoming message in YOUR voice (the user's voice)
+2. Use the knowledge from your memories naturally if relevant
+3. Match the tone level specified above
+4. Follow the platform context guidelines
+5. Sound exactly like something you would write yourself
+
+Write the response now:"""
+
+    return prompt
+
+
+async def compose_response(
+    db_path: str,
+    incoming_message: str,
+    context_type: str = "general",
+    template: Optional[str] = None,
+    tone_level: int = 50,
+    include_memories: bool = True,
+    style_profile: Optional[dict] = None,
+) -> dict:
+    """Compose a response to an incoming message in the user's style.
+
+    Args:
+        db_path: Path to the database file
+        incoming_message: The message to respond to
+        context_type: Platform context (skool_post, dm, email, comment, general)
+        template: Optional response template (answer, guide, redirect, acknowledge)
+        tone_level: Tone formality level (0-100)
+        include_memories: Whether to include relevant memories
+        style_profile: User's style profile dictionary
+
+    Returns:
+        Dict with response, sources, and metadata
+    """
+    if not is_available():
+        return {
+            "response": "Chat is not available. Please configure GEMINI_API_KEY or GOOGLE_API_KEY environment variable.",
+            "sources": [],
+            "error": "api_key_missing",
+        }
+
+    client = get_client()
+    if not client:
+        return {
+            "response": "Failed to initialize Gemini client.",
+            "sources": [],
+            "error": "client_init_failed",
+        }
+
+    # Get relevant memories if requested
+    memory_context = ""
+    sources = []
+    if include_memories:
+        memory_context, sources = _get_memories_and_sources(db_path, incoming_message, max_memories=5)
+
+    # Get or compute style profile
+    if not style_profile:
+        from database import compute_style_profile_from_messages
+        style_profile = compute_style_profile_from_messages(db_path)
+
+    # Build the compose prompt
+    prompt = build_compose_prompt(
+        incoming_message=incoming_message,
+        style_profile=style_profile,
+        context_type=context_type,
+        template=template,
+        tone_level=tone_level,
+        memory_context=memory_context,
+    )
+
+    try:
+        response = client.models.generate_content(
+            model="gemini-2.0-flash",
+            contents=prompt,
+        )
+        composed_response = response.text
+    except Exception as e:
+        return {
+            "response": f"Failed to generate response: {str(e)}",
+            "sources": sources,
+            "error": "generation_failed",
+        }
+
+    return {
+        "response": composed_response,
+        "sources": sources,
+        "error": None,
+    }

{omni_cortex-1.12.1.data → omni_cortex-1.13.0.data}/data/share/omni-cortex/dashboard/backend/database.py

@@ -1189,10 +1189,14 @@ def get_user_messages(
             except (json.JSONDecodeError, TypeError):
                 pass
 
+        # Get primary tone (first in the list) for frontend compatibility
+        primary_tone = tone_indicators[0] if tone_indicators else None
+
         messages.append({
             "id": row["id"],
             "session_id": row["session_id"],
-            "timestamp": row["timestamp"],
+            "created_at": row["timestamp"],  # Frontend expects created_at
+            "timestamp": row["timestamp"],   # Keep for backward compatibility
             "content": row["content"],
             "word_count": row["word_count"],
             "char_count": row["char_count"],
@@ -1200,6 +1204,7 @@ def get_user_messages(
             "has_code_blocks": bool(row["has_code_blocks"]),
             "has_questions": bool(row["has_questions"]),
             "has_commands": bool(row["has_commands"]),
+            "tone": primary_tone,            # Frontend expects single tone string
             "tone_indicators": tone_indicators,
             "project_path": row["project_path"],
         })
@@ -1428,3 +1433,221 @@ def _row_to_sample(row) -> dict:
         "has_questions": bool(row["has_questions"]),
         "tone_indicators": tone_indicators,
     }
+
+
+def get_style_samples_by_category(db_path: str, samples_per_tone: int = 3) -> dict:
+    """Get sample user messages grouped by style category.
+
+    Maps tone_indicators to frontend categories:
+    - professional: direct, polite, formal tones
+    - casual: casual tones
+    - technical: technical tones
+    - creative: unique patterns, inquisitive tones
+
+    Args:
+        db_path: Path to database
+        samples_per_tone: Max samples per category
+
+    Returns:
+        Dict with professional, casual, technical, creative lists
+    """
+    conn = get_connection(db_path)
+
+    # Check if user_messages table exists
+    table_check = conn.execute(
+        "SELECT name FROM sqlite_master WHERE type='table' AND name='user_messages'"
+    ).fetchone()
+
+    if not table_check:
+        conn.close()
+        return {
+            "professional": [],
+            "casual": [],
+            "technical": [],
+            "creative": []
+        }
+
+    result = {
+        "professional": [],
+        "casual": [],
+        "technical": [],
+        "creative": []
+    }
+
+    # Mapping from tone_indicators to categories
+    tone_to_category = {
+        "direct": "professional",
+        "polite": "professional",
+        "formal": "professional",
+        "casual": "casual",
+        "technical": "technical",
+        "inquisitive": "creative",
+        "urgent": "professional",
+    }
+
+    # Get all messages with tone indicators
+    cursor = conn.execute(
+        """SELECT content, tone_indicators FROM user_messages
+           WHERE tone_indicators IS NOT NULL AND tone_indicators != '[]'
+           ORDER BY timestamp DESC LIMIT 200"""
+    )
+
+    for row in cursor.fetchall():
+        content = row["content"]
+        try:
+            tones = json.loads(row["tone_indicators"]) if row["tone_indicators"] else []
+        except (json.JSONDecodeError, TypeError):
+            tones = []
+
+        # Map to categories
+        for tone in tones:
+            category = tone_to_category.get(tone.lower(), "creative")
+            if len(result[category]) < samples_per_tone:
+                # Truncate content for preview
+                preview = content[:200] + "..." if len(content) > 200 else content
+                if preview not in result[category]:
+                    result[category].append(preview)
+                    break  # Only add to first matching category
+
+    # Fill any empty categories with recent messages
+    if any(len(v) == 0 for v in result.values()):
+        cursor = conn.execute(
+            "SELECT content FROM user_messages ORDER BY timestamp DESC LIMIT ?",
+            (samples_per_tone * 4,)
+        )
+        fallback_messages = [
+            row["content"][:200] + "..." if len(row["content"]) > 200 else row["content"]
+            for row in cursor.fetchall()
+        ]
+
+        for category in result:
+            if len(result[category]) == 0 and fallback_messages:
+                # Take messages for empty categories
+                for msg in fallback_messages[:samples_per_tone]:
+                    if msg not in [m for v in result.values() for m in v]:
+                        result[category].append(msg)
+
+    conn.close()
+    return result
+
+
+def compute_style_profile_from_messages(db_path: str) -> Optional[dict]:
+    """Compute a style profile from user_messages table.
+
+    This is used when no pre-computed profile exists.
+
+    Returns format expected by frontend StyleProfileCard:
+    - total_messages: int
+    - avg_word_count: float
+    - primary_tone: str
+    - question_percentage: float
+    - tone_distribution: dict[str, int]
+    - style_markers: list[str]
+    """
+    conn = get_connection(db_path)
+
+    # Check if user_messages table exists
+    table_check = conn.execute(
+        "SELECT name FROM sqlite_master WHERE type='table' AND name='user_messages'"
+    ).fetchone()
+
+    if not table_check:
+        conn.close()
+        return None
+
+    # Get total count and averages
+    stats = conn.execute(
+        """SELECT
+           COUNT(*) as total,
+           AVG(word_count) as avg_words,
+           AVG(char_count) as avg_chars,
+           SUM(CASE WHEN has_questions = 1 THEN 1 ELSE 0 END) as question_count
+           FROM user_messages"""
+    ).fetchone()
+
+    if not stats or stats["total"] == 0:
+        conn.close()
+        return None
+
+    total_messages = stats["total"]
+    avg_word_count = stats["avg_words"] or 0
+    question_percentage = (stats["question_count"] / total_messages * 100) if total_messages > 0 else 0
+
+    # Compute tone distribution
+    tone_distribution = {}
+    cursor = conn.execute(
+        "SELECT tone_indicators FROM user_messages WHERE tone_indicators IS NOT NULL AND tone_indicators != '[]'"
+    )
+    for row in cursor.fetchall():
+        try:
+            tones = json.loads(row["tone_indicators"]) if row["tone_indicators"] else []
+            for tone in tones:
+                tone_lower = tone.lower()
+                tone_distribution[tone_lower] = tone_distribution.get(tone_lower, 0) + 1
+        except (json.JSONDecodeError, TypeError):
+            pass
+
+    # Determine primary tone (most common)
+    primary_tone = "direct"
+    if tone_distribution:
+        primary_tone = max(tone_distribution, key=tone_distribution.get)
+
+    # Generate style markers based on the data
+    style_markers = []
+
+    if avg_word_count < 15:
+        style_markers.append("Concise")
+    elif avg_word_count > 40:
+        style_markers.append("Detailed")
+    else:
+        style_markers.append("Balanced length")
+
+    if question_percentage > 40:
+        style_markers.append("Question-driven")
+    elif question_percentage < 10:
+        style_markers.append("Statement-focused")
+
+    # Check for code usage
+    code_stats = conn.execute(
+        "SELECT SUM(CASE WHEN has_code_blocks = 1 THEN 1 ELSE 0 END) * 100.0 / COUNT(*) as code_pct FROM user_messages"
+    ).fetchone()
+    if code_stats and code_stats["code_pct"] and code_stats["code_pct"] > 20:
+        style_markers.append("Code-heavy")
+
+    # Add primary tone to markers
+    tone_labels = {
+        "direct": "Direct",
+        "polite": "Polite",
+        "technical": "Technical",
+        "casual": "Casual",
+        "inquisitive": "Inquisitive",
+        "urgent": "Urgent",
+    }
+    if primary_tone in tone_labels:
+        style_markers.append(tone_labels[primary_tone])
+
+    if not style_markers:
+        style_markers.append("Building profile...")
+
+    # Get sample messages to show the AI how the user actually writes
+    sample_messages = []
+    cursor = conn.execute(
+        """SELECT content FROM user_messages
+           WHERE length(content) > 20 AND length(content) < 500
+           AND has_commands = 0
+           ORDER BY timestamp DESC LIMIT 5"""
+    )
+    for row in cursor.fetchall():
+        sample_messages.append(row["content"])
+
+    conn.close()
+
+    return {
+        "totalMessages": total_messages,
+        "avgWordCount": round(avg_word_count, 1),
+        "primaryTone": primary_tone,
+        "questionPercentage": round(question_percentage, 1),
+        "toneDistribution": tone_distribution,
+        "styleMarkers": style_markers,
+        "sampleMessages": sample_messages,
+    }

{omni_cortex-1.12.1.data → omni_cortex-1.13.0.data}/data/share/omni-cortex/dashboard/backend/main.py

@@ -54,6 +54,8 @@ from database import (
     get_skill_usage,
     get_style_profile,
     get_style_samples,
+    get_style_samples_by_category,
+    compute_style_profile_from_messages,
     get_timeline,
     get_tool_usage,
     get_type_distribution,
@@ -73,6 +75,8 @@ from models import (
     BulkDeleteRequest,
     ChatRequest,
     ChatResponse,
+    ComposeRequest,
+    ComposeResponse,
     ConversationSaveRequest,
     ConversationSaveResponse,
     FilterParams,
@@ -1023,7 +1027,11 @@ async def chat_with_memories(
         style_context = None
         if request.use_style:
             try:
-                style_context = get_style_profile(project)
+                # First try computed profile from user_messages (richer data)
+                style_context = compute_style_profile_from_messages(project)
+                # Fall back to stored profile if no user_messages
+                if not style_context:
+                    style_context = get_style_profile(project)
             except Exception:
                 pass  # Graceful fallback if no style data
 
@@ -1061,7 +1069,11 @@ async def stream_chat(
     style_context = None
     if use_style:
         try:
-            style_context = get_style_profile(project)
+            # First try computed profile from user_messages (richer data)
+            style_context = compute_style_profile_from_messages(project)
+            # Fall back to stored profile if no user_messages
+            if not style_context:
+                style_context = get_style_profile(project)
         except Exception:
             pass  # Graceful fallback if no style data
 
@@ -1110,6 +1122,60 @@ async def save_chat_conversation(
         raise
 
 
+@app.post("/api/compose-response", response_model=ComposeResponse)
+@rate_limit("10/minute")
+async def compose_response_endpoint(
+    request: ComposeRequest,
+    project: str = Query(..., description="Path to the database file"),
+):
+    """Compose a response to an incoming message in the user's style."""
+    try:
+        if not Path(project).exists():
+            log_error("/api/compose-response", FileNotFoundError("Database not found"))
+            raise HTTPException(status_code=404, detail="Database not found")
+
+        # Get style profile
+        style_profile = compute_style_profile_from_messages(project)
+
+        # Compose the response
+        result = await chat_service.compose_response(
+            db_path=project,
+            incoming_message=request.incoming_message,
+            context_type=request.context_type,
+            template=request.template,
+            tone_level=request.tone_level,
+            include_memories=request.include_memories,
+            style_profile=style_profile,
+        )
+
+        if result.get("error"):
+            log_error("/api/compose-response", Exception(result["error"]))
+            raise HTTPException(status_code=500, detail=result["error"])
+
+        # Build response model
+        import uuid
+        from datetime import datetime
+        response = ComposeResponse(
+            id=str(uuid.uuid4()),
+            response=result["response"],
+            sources=result["sources"],
+            style_applied=bool(style_profile and style_profile.get("total_messages", 0) > 0),
+            tone_level=request.tone_level,
+            template_used=request.template,
+            incoming_message=request.incoming_message,
+            context_type=request.context_type,
+            created_at=datetime.now().isoformat(),
+        )
+
+        log_success("/api/compose-response", context=request.context_type, tone=request.tone_level)
+        return response
+    except HTTPException:
+        raise
+    except Exception as e:
+        log_error("/api/compose-response", e)
+        raise HTTPException(status_code=500, detail=str(e))
+
+
 # --- Image Generation Endpoints ---
 
 
@@ -1262,6 +1328,7 @@ async def list_user_messages(
         )
 
         total_count = get_user_message_count(project, session_id=session_id)
+        has_more = (offset + len(messages)) < total_count
 
         log_success("/api/user-messages", count=len(messages), total=total_count)
         return UserMessagesResponse(
@@ -1269,6 +1336,7 @@ async def list_user_messages(
             total_count=total_count,
             limit=limit,
             offset=offset,
+            has_more=has_more,
         )
     except HTTPException:
         raise
@@ -1321,79 +1389,100 @@ async def delete_user_messages_bulk_endpoint(
         raise HTTPException(status_code=500, detail=str(e))
 
 
-@app.get("/api/style-profile")
+@app.get("/api/style/profile")
 async def get_style_profile_endpoint(
     project: str = Query(..., description="Path to the database file"),
     project_path: Optional[str] = Query(None, description="Project-specific profile path, or None for global"),
 ):
     """Get user style profile for style analysis.
 
-    Returns aggregated style metrics including:
-    - Average word/char counts
-    - Common phrases
-    - Formality score
-    - Question/command frequencies
-    - Greeting and instruction patterns
+    Returns style metrics computed from user messages:
+    - total_messages: Total message count
+    - avg_word_count: Average words per message
+    - primary_tone: Most common tone (direct, polite, technical, etc.)
+    - question_percentage: Percentage of messages containing questions
+    - tone_distribution: Count of messages by tone
+    - style_markers: Descriptive labels for writing style
     """
     try:
         if not Path(project).exists():
             raise HTTPException(status_code=404, detail="Database not found")
 
+        # First try to get pre-computed profile from user_style_profiles table
         profile = get_style_profile(project, project_path=project_path)
 
+        # If no stored profile, compute from user_messages
+        if not profile:
+            profile = compute_style_profile_from_messages(project)
+
+        # If still no profile (no user_messages), return empty structure
         if not profile:
-            # Return empty profile structure if none exists
             return {
-                "id": None,
-                "project_path": project_path,
-                "total_messages": 0,
-                "avg_word_count": None,
-                "avg_char_count": None,
-                "common_phrases": [],
-                "vocabulary_richness": None,
-                "formality_score": None,
-                "question_frequency": None,
-                "command_frequency": None,
-                "code_block_frequency": None,
-                "punctuation_style": None,
-                "greeting_patterns": [],
-                "instruction_style": None,
-                "sample_messages": [],
-                "created_at": None,
-                "updated_at": None,
+                "totalMessages": 0,
+                "avgWordCount": 0,
+                "primaryTone": "direct",
+                "questionPercentage": 0,
+                "toneDistribution": {},
+                "styleMarkers": ["No data available yet"],
+            }
+
+        # Convert stored profile format to frontend expected format if needed
+        if "totalMessages" in profile:
+            # Already in camelCase format from compute_style_profile_from_messages
+            pass
+        elif "id" in profile:
+            # Convert stored profile (from user_style_profiles table) to frontend format
+            tone_dist = {}
+            # Stored profile doesn't have tone_distribution, so compute it
+            computed = compute_style_profile_from_messages(project)
+            if computed:
+                tone_dist = computed.get("toneDistribution", {})
+                primary_tone = computed.get("primaryTone", "direct")
+                style_markers = computed.get("styleMarkers", [])
+            else:
+                primary_tone = "direct"
+                style_markers = []
+
+            profile = {
+                "totalMessages": profile.get("total_messages", 0),
+                "avgWordCount": profile.get("avg_word_count", 0) or 0,
+                "primaryTone": primary_tone,
+                "questionPercentage": (profile.get("question_frequency", 0) or 0) * 100,
+                "toneDistribution": tone_dist,
+                "styleMarkers": style_markers or profile.get("greeting_patterns", []) or [],
             }
 
-        log_success("/api/style-profile", has_profile=True)
+        log_success("/api/style/profile", has_profile=True, total_messages=profile.get("totalMessages", 0))
         return profile
     except HTTPException:
         raise
     except Exception as e:
-        log_error("/api/style-profile", e)
+        log_error("/api/style/profile", e)
         raise HTTPException(status_code=500, detail=str(e))
 
 
-@app.get("/api/style-samples", response_model=list[StyleSample])
+@app.get("/api/style/samples")
 async def get_style_samples_endpoint(
     project: str = Query(..., description="Path to the database file"),
-    limit: int = Query(10, ge=1, le=50),
+    samples_per_tone: int = Query(3, ge=1, le=10, description="Max samples per tone category"),
 ):
     """Get sample user messages for style analysis preview.
 
-    Returns a diverse selection of messages showcasing different writing styles,
-    including recent messages, messages with code blocks, and longer messages.
+    Returns messages grouped by style category (professional, casual, technical, creative).
     """
     try:
         if not Path(project).exists():
             raise HTTPException(status_code=404, detail="Database not found")
 
-        samples = get_style_samples(project, limit=limit)
+        samples = get_style_samples_by_category(project, samples_per_tone=samples_per_tone)
 
-        log_success("/api/style-samples", count=len(samples))
-        return [StyleSample(**s) for s in samples]
+        total_count = sum(len(v) for v in samples.values())
+        log_success("/api/style/samples", count=total_count)
+        return samples
     except HTTPException:
         raise
     except Exception as e:
-        log_error("/api/style-samples", e)
+        log_error("/api/style/samples", e)
         raise HTTPException(status_code=500, detail=str(e))
 
 

{omni_cortex-1.12.1.data → omni_cortex-1.13.0.data}/data/share/omni-cortex/dashboard/backend/models.py

@@ -294,7 +294,8 @@ class UserMessage(BaseModel):
 
     id: str
     session_id: Optional[str] = None
-    timestamp: str
+    timestamp: Optional[str] = None  # Backward compatibility
+    created_at: Optional[str] = None  # Frontend expects created_at
     content: str
     word_count: Optional[int] = None
     char_count: Optional[int] = None
@@ -302,6 +303,7 @@ class UserMessage(BaseModel):
     has_code_blocks: bool = False
     has_questions: bool = False
     has_commands: bool = False
+    tone: Optional[str] = None  # Primary tone for frontend
     tone_indicators: list[str] = []
     project_path: Optional[str] = None
 
@@ -328,6 +330,7 @@ class UserMessagesResponse(BaseModel):
     total_count: int
     limit: int
     offset: int
+    has_more: bool = False  # Whether more results are available
 
 
 class StyleSample(BaseModel):
@@ -368,3 +371,30 @@ class BulkDeleteRequest(BaseModel):
     """Request body for bulk delete operations."""
 
     message_ids: list[str] = Field(..., min_length=1, max_length=100)
+
+
+# --- Response Composer Models ---
+
+
+class ComposeRequest(BaseModel):
+    """Request for composing a response in user's style."""
+
+    incoming_message: str = Field(..., min_length=1, max_length=5000)
+    context_type: str = Field(default="general")  # skool_post, dm, email, comment, general
+    template: Optional[str] = None  # answer, guide, redirect, acknowledge
+    tone_level: int = Field(default=50, ge=0, le=100)  # 0=casual, 100=professional
+    include_memories: bool = Field(default=True)
+
+
+class ComposeResponse(BaseModel):
+    """Response from compose endpoint."""
+
+    id: str
+    response: str
+    sources: list[ChatSource]
+    style_applied: bool
+    tone_level: int
+    template_used: Optional[str]
+    incoming_message: str
+    context_type: str
+    created_at: str

{omni_cortex-1.12.1.dist-info → omni_cortex-1.13.0.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: omni-cortex
-Version: 1.12.1
+Version: 1.13.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.13.0.dist-info/RECORD

@@ -0,0 +1,26 @@
+omni_cortex-1.13.0.data/data/share/omni-cortex/hooks/post_tool_use.py,sha256=zdaKChi8zOghRlHswisCBSQE3kW1MtmM6AFfI_ivvpI,16581
+omni_cortex-1.13.0.data/data/share/omni-cortex/hooks/pre_tool_use.py,sha256=3_V6Qw5m40eGrMmm5i94vINzeVxmcJvivdPa69H3AOI,8585
+omni_cortex-1.13.0.data/data/share/omni-cortex/hooks/session_utils.py,sha256=3SKPCytqWuRPOupWdzmwBoKBDJqtLcT1Nle_pueDQUY,5746
+omni_cortex-1.13.0.data/data/share/omni-cortex/hooks/stop.py,sha256=UroliJsyIS9_lj29-1d_r-80V4AfTMUFCaOjJZv3lwM,6976
+omni_cortex-1.13.0.data/data/share/omni-cortex/hooks/subagent_stop.py,sha256=V9HQSFGNOfkg8ZCstPEy4h5V8BP4AbrVr8teFzN1kNk,3314
+omni_cortex-1.13.0.data/data/share/omni-cortex/hooks/user_prompt.py,sha256=WNHJvhnkb9rXQ_HDpr6eLpM5vwy1Y1xl1EUoqyNC-x8,6859
+omni_cortex-1.13.0.data/data/share/omni-cortex/dashboard/backend/.env.example,sha256=9xS7-UiWlMddRwzlyyyKNHAMlNTsgH-2sPV266guJpQ,372
+omni_cortex-1.13.0.data/data/share/omni-cortex/dashboard/backend/backfill_summaries.py,sha256=ElchfcBv4pmVr2PsePCgFlCyuvf4_jDJj_C3AmMhu7U,8973
+omni_cortex-1.13.0.data/data/share/omni-cortex/dashboard/backend/chat_service.py,sha256=QGNxVX-9bJw4kot6mPieGD2QIbmzvPYSGDGOpv3p_-Y,18567
+omni_cortex-1.13.0.data/data/share/omni-cortex/dashboard/backend/database.py,sha256=_sWqLjx_mWOxqNpfbv-bChtPfQkHzUNzly1pGu_zPKI,54199
+omni_cortex-1.13.0.data/data/share/omni-cortex/dashboard/backend/image_service.py,sha256=NP6ojFpHb6iNTYRkXqYu1CL6WvooZpZ54mjLiWSWG_g,19205
+omni_cortex-1.13.0.data/data/share/omni-cortex/dashboard/backend/logging_config.py,sha256=WnunFGET9zlsn9WBpVsio2zI7BiUQanE0xzAQQxIhII,3944
+omni_cortex-1.13.0.data/data/share/omni-cortex/dashboard/backend/main.py,sha256=-GwRioHjuUaMiP1gNuyqzs6LUxvIgOUHyirCcfQ6pRs,59364
+omni_cortex-1.13.0.data/data/share/omni-cortex/dashboard/backend/models.py,sha256=_gQoBaavttuRgLIvhCQsZ0zmuON6aKWbAFhdB1YFVbM,11164
+omni_cortex-1.13.0.data/data/share/omni-cortex/dashboard/backend/project_config.py,sha256=ZxGoeRpHvN5qQyf2hRxrAZiHrPSwdQp59f0di6O1LKM,4352
+omni_cortex-1.13.0.data/data/share/omni-cortex/dashboard/backend/project_scanner.py,sha256=lwFXS8iJbOoxf7FAyo2TjH25neaMHiJ8B3jS57XxtDI,5713
+omni_cortex-1.13.0.data/data/share/omni-cortex/dashboard/backend/prompt_security.py,sha256=LcdZhYy1CfpSq_4BPO6lMJ15phc2ZXLUSBAnAvODVCI,3423
+omni_cortex-1.13.0.data/data/share/omni-cortex/dashboard/backend/pyproject.toml,sha256=9pbbGQXLe1Xd06nZAtDySCHIlfMWvPaB-C6tGZR6umc,502
+omni_cortex-1.13.0.data/data/share/omni-cortex/dashboard/backend/security.py,sha256=nQsoPE0n5dtY9ive00d33W1gL48GgK7C5Ae0BK2oW2k,3479
+omni_cortex-1.13.0.data/data/share/omni-cortex/dashboard/backend/uv.lock,sha256=miB9zGGSirBkjDE-OZTPCnv43Yc98xuAz_Ne8vTNFHg,186004
+omni_cortex-1.13.0.data/data/share/omni-cortex/dashboard/backend/websocket_manager.py,sha256=gNQLd94AcC-InumGQmUolREhiogCzilYWpLN8SRZjHI,3645
+omni_cortex-1.13.0.dist-info/METADATA,sha256=N9ZCvUc2F0jnkuXvtXl1ISgDipNbwvtsMHritpaSDVo,15712
+omni_cortex-1.13.0.dist-info/WHEEL,sha256=WLgqFyCfm_KASv4WHyYy0P3pM_m7J5L9k2skdKLirC8,87
+omni_cortex-1.13.0.dist-info/entry_points.txt,sha256=rohx4mFH2ffZmMb9QXPZmFf-ZGjA3jpKVDVeET-ttiM,150
+omni_cortex-1.13.0.dist-info/licenses/LICENSE,sha256=oG_397owMmi-Umxp5sYocJ6RPohp9_bDNnnEu9OUphg,1072
+omni_cortex-1.13.0.dist-info/RECORD,,

omni_cortex-1.12.1.dist-info/RECORD

@@ -1,26 +0,0 @@
-omni_cortex-1.12.1.data/data/share/omni-cortex/hooks/post_tool_use.py,sha256=zdaKChi8zOghRlHswisCBSQE3kW1MtmM6AFfI_ivvpI,16581
-omni_cortex-1.12.1.data/data/share/omni-cortex/hooks/pre_tool_use.py,sha256=3_V6Qw5m40eGrMmm5i94vINzeVxmcJvivdPa69H3AOI,8585
-omni_cortex-1.12.1.data/data/share/omni-cortex/hooks/session_utils.py,sha256=3SKPCytqWuRPOupWdzmwBoKBDJqtLcT1Nle_pueDQUY,5746
-omni_cortex-1.12.1.data/data/share/omni-cortex/hooks/stop.py,sha256=UroliJsyIS9_lj29-1d_r-80V4AfTMUFCaOjJZv3lwM,6976
-omni_cortex-1.12.1.data/data/share/omni-cortex/hooks/subagent_stop.py,sha256=V9HQSFGNOfkg8ZCstPEy4h5V8BP4AbrVr8teFzN1kNk,3314
-omni_cortex-1.12.1.data/data/share/omni-cortex/hooks/user_prompt.py,sha256=WNHJvhnkb9rXQ_HDpr6eLpM5vwy1Y1xl1EUoqyNC-x8,6859
-omni_cortex-1.12.1.data/data/share/omni-cortex/dashboard/backend/.env.example,sha256=9xS7-UiWlMddRwzlyyyKNHAMlNTsgH-2sPV266guJpQ,372
-omni_cortex-1.12.1.data/data/share/omni-cortex/dashboard/backend/backfill_summaries.py,sha256=ElchfcBv4pmVr2PsePCgFlCyuvf4_jDJj_C3AmMhu7U,8973
-omni_cortex-1.12.1.data/data/share/omni-cortex/dashboard/backend/chat_service.py,sha256=5vUzNL3AIfkqVMwooXEqCSkWAkN1HP0vToN1sn3x3Z4,11285
-omni_cortex-1.12.1.data/data/share/omni-cortex/dashboard/backend/database.py,sha256=WwxgXVo5gztFjaKj-iANYgK4tOGGPARsHg28hkJtADQ,46494
-omni_cortex-1.12.1.data/data/share/omni-cortex/dashboard/backend/image_service.py,sha256=NP6ojFpHb6iNTYRkXqYu1CL6WvooZpZ54mjLiWSWG_g,19205
-omni_cortex-1.12.1.data/data/share/omni-cortex/dashboard/backend/logging_config.py,sha256=WnunFGET9zlsn9WBpVsio2zI7BiUQanE0xzAQQxIhII,3944
-omni_cortex-1.12.1.data/data/share/omni-cortex/dashboard/backend/main.py,sha256=ezIgMX3WtwQoJnrxi3M1I-gRSPh69Qmv6F0va7tSbxs,55122
-omni_cortex-1.12.1.data/data/share/omni-cortex/dashboard/backend/models.py,sha256=VymhQz6GCPo5d7wyn_Yg1njKugGbzx5--bnVP42MyBg,10111
-omni_cortex-1.12.1.data/data/share/omni-cortex/dashboard/backend/project_config.py,sha256=ZxGoeRpHvN5qQyf2hRxrAZiHrPSwdQp59f0di6O1LKM,4352
-omni_cortex-1.12.1.data/data/share/omni-cortex/dashboard/backend/project_scanner.py,sha256=lwFXS8iJbOoxf7FAyo2TjH25neaMHiJ8B3jS57XxtDI,5713
-omni_cortex-1.12.1.data/data/share/omni-cortex/dashboard/backend/prompt_security.py,sha256=LcdZhYy1CfpSq_4BPO6lMJ15phc2ZXLUSBAnAvODVCI,3423
-omni_cortex-1.12.1.data/data/share/omni-cortex/dashboard/backend/pyproject.toml,sha256=9pbbGQXLe1Xd06nZAtDySCHIlfMWvPaB-C6tGZR6umc,502
-omni_cortex-1.12.1.data/data/share/omni-cortex/dashboard/backend/security.py,sha256=nQsoPE0n5dtY9ive00d33W1gL48GgK7C5Ae0BK2oW2k,3479
-omni_cortex-1.12.1.data/data/share/omni-cortex/dashboard/backend/uv.lock,sha256=miB9zGGSirBkjDE-OZTPCnv43Yc98xuAz_Ne8vTNFHg,186004
-omni_cortex-1.12.1.data/data/share/omni-cortex/dashboard/backend/websocket_manager.py,sha256=gNQLd94AcC-InumGQmUolREhiogCzilYWpLN8SRZjHI,3645
-omni_cortex-1.12.1.dist-info/METADATA,sha256=AOOi2hbe_RTrqeyPZvN9go13VyndPomtxhQw7lPGX7k,15712
-omni_cortex-1.12.1.dist-info/WHEEL,sha256=WLgqFyCfm_KASv4WHyYy0P3pM_m7J5L9k2skdKLirC8,87
-omni_cortex-1.12.1.dist-info/entry_points.txt,sha256=rohx4mFH2ffZmMb9QXPZmFf-ZGjA3jpKVDVeET-ttiM,150
-omni_cortex-1.12.1.dist-info/licenses/LICENSE,sha256=oG_397owMmi-Umxp5sYocJ6RPohp9_bDNnnEu9OUphg,1072
-omni_cortex-1.12.1.dist-info/RECORD,,