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

{omni_cortex-1.12.1.data → omni_cortex-1.14.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.14.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,64 @@ 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,
+            custom_instructions=request.custom_instructions,
+            include_explanation=request.include_explanation,
+        )
+
+        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(),
+            custom_instructions=request.custom_instructions,
+            explanation=result.get("explanation"),
+        )
+
+        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 +1332,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 +1340,7 @@ async def list_user_messages(
             total_count=total_count,
             limit=limit,
             offset=offset,
+            has_more=has_more,
         )
     except HTTPException:
         raise
@@ -1321,79 +1393,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.14.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,34 @@ 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)
+    custom_instructions: Optional[str] = Field(default=None, max_length=2000)
+    include_explanation: bool = Field(default=False)
+
+
+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
+    custom_instructions: Optional[str] = None
+    explanation: Optional[str] = None

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

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

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