omni-cortex 1.17.0__py3-none-any.whl → 1.17.2__py3-none-any.whl

omni_cortex/utils/formatting.py

@@ -0,0 +1,282 @@
+"""Output formatting utilities for Omni Cortex."""
+
+import json
+import re
+from html import escape as html_escape
+from typing import Any, Optional
+from datetime import datetime
+
+from .timestamps import format_relative_time
+
+
+def xml_escape(text: str) -> str:
+    """Escape text for safe inclusion in XML-structured outputs.
+
+    Prevents prompt injection by escaping special characters that
+    could be interpreted as XML/instruction delimiters.
+    """
+    return html_escape(text, quote=True)
+
+
+# Known prompt injection patterns
+_INJECTION_PATTERNS = [
+    (r'(?i)(ignore|disregard|forget)\s+(all\s+)?(previous|prior|above)\s+instructions?',
+     'instruction override'),
+    (r'(?i)(new\s+)?system\s+(prompt|instruction|message)',
+     'system prompt manipulation'),
+    (r'(?i)\[/?system\]|\[/?inst\]|<\/?system>|<\/?instruction>',
+     'fake delimiter'),
+    (r'(?i)bypass|jailbreak|DAN|GODMODE',
+     'jailbreak signature'),
+]
+
+
+def detect_injection_patterns(content: str) -> list[str]:
+    """Detect potential prompt injection patterns in content."""
+    detected = []
+    for pattern, description in _INJECTION_PATTERNS:
+        if re.search(pattern, content):
+            detected.append(description)
+    return detected
+
+
+def format_memory_markdown(
+    memory: dict[str, Any],
+    related_memories: Optional[list[dict[str, Any]]] = None,
+) -> str:
+    """Format a memory as markdown.
+
+    Args:
+        memory: Memory dictionary
+        related_memories: Optional list of related memory dicts with relationship info
+
+    Returns:
+        Markdown formatted string
+    """
+    lines = []
+
+    # Header with ID and type
+    mem_type = memory.get("type", "general")
+    lines.append(f"## [{mem_type}] {memory.get('id', 'unknown')}")
+    lines.append("")
+
+    # Content - XML escape to prevent prompt injection when returned to Claude
+    content = memory.get("content", "")
+    # Detect and flag potential injection patterns
+    injections = detect_injection_patterns(content)
+    if injections:
+        lines.append(f"[Security Note: Content contains patterns that may be injection attempts: {', '.join(injections)}]")
+    lines.append(xml_escape(content))
+    lines.append("")
+
+    # Metadata
+    lines.append("---")
+
+    # Tags
+    tags = memory.get("tags")
+    if tags:
+        if isinstance(tags, str):
+            tags = json.loads(tags)
+        if tags:
+            lines.append(f"**Tags:** {', '.join(tags)}")
+
+    # Context - also escape
+    context = memory.get("context")
+    if context:
+        lines.append(f"**Context:** {xml_escape(context)}")
+
+    # Timestamps
+    created = memory.get("created_at")
+    if created:
+        lines.append(f"**Created:** {format_relative_time(created)}")
+
+    accessed = memory.get("last_accessed")
+    if accessed:
+        lines.append(f"**Last accessed:** {format_relative_time(accessed)}")
+
+    # Importance
+    importance = memory.get("importance_score", 50)
+    lines.append(f"**Importance:** {importance:.0f}/100")
+
+    # Status
+    status = memory.get("status", "fresh")
+    lines.append(f"**Status:** {status}")
+
+    # Related memories
+    if related_memories:
+        lines.append("")
+        lines.append("**Related:**")
+        for related in related_memories[:3]:  # Limit to 3
+            rel_type = related.get("relationship_type", "related_to")
+            rel_id = related.get("id", "unknown")
+            rel_content = xml_escape(related.get("content", "")[:50])
+            lines.append(f"  - [{rel_type}] {rel_id}: {rel_content}...")
+
+    return "\n".join(lines)
+
+
+def format_memories_list_markdown(
+    memories: list[dict[str, Any]],
+    total: int = 0,
+    related_map: Optional[dict[str, list[dict[str, Any]]]] = None,
+) -> str:
+    """Format a list of memories as markdown.
+
+    Args:
+        memories: List of memory dictionaries
+        total: Total count (for pagination info)
+        related_map: Optional dict mapping memory IDs to their related memories
+
+    Returns:
+        Markdown formatted string
+    """
+    if not memories:
+        return "No memories found."
+
+    lines = []
+    lines.append(f"# Memories ({len(memories)}" + (f" of {total})" if total > len(memories) else ")"))
+    lines.append("")
+
+    for memory in memories:
+        # Get related memories for this memory if available
+        memory_id = memory.get("id")
+        related = related_map.get(memory_id) if related_map and memory_id else None
+        lines.append(format_memory_markdown(memory, related_memories=related))
+        lines.append("")
+
+    return "\n".join(lines)
+
+
+def format_activity_markdown(activity: dict[str, Any]) -> str:
+    """Format an activity as markdown.
+
+    Args:
+        activity: Activity dictionary
+
+    Returns:
+        Markdown formatted string
+    """
+    lines = []
+
+    timestamp = activity.get("timestamp", "")
+    event_type = activity.get("event_type", "")
+    tool_name = activity.get("tool_name", "")
+
+    # Header
+    header = f"**{event_type}**"
+    if tool_name:
+        header += f": `{tool_name}`"
+    lines.append(header)
+
+    lines.append(f"  - Time: {format_relative_time(timestamp)}")
+
+    # Success/Error
+    success = activity.get("success", 1)
+    if not success:
+        error = activity.get("error_message", "Unknown error")
+        lines.append(f"  - Status: Failed - {error}")
+    elif activity.get("duration_ms"):
+        lines.append(f"  - Duration: {activity['duration_ms']}ms")
+
+    return "\n".join(lines)
+
+
+def format_timeline_markdown(
+    activities: list[dict[str, Any]],
+    memories: list[dict[str, Any]],
+    group_by: str = "hour"
+) -> str:
+    """Format a timeline as markdown.
+
+    Args:
+        activities: List of activity dictionaries
+        memories: List of memory dictionaries
+        group_by: How to group items (hour, day, session)
+
+    Returns:
+        Markdown formatted string
+    """
+    lines = []
+    lines.append("# Timeline")
+    lines.append("")
+
+    # Combine and sort by timestamp
+    items = []
+    for act in activities:
+        items.append({
+            "type": "activity",
+            "timestamp": act.get("timestamp"),
+            "data": act
+        })
+    for mem in memories:
+        items.append({
+            "type": "memory",
+            "timestamp": mem.get("created_at"),
+            "data": mem
+        })
+
+    items.sort(key=lambda x: x.get("timestamp", ""), reverse=True)
+
+    if not items:
+        return "# Timeline\n\nNo items found."
+
+    for item in items:
+        if item["type"] == "activity":
+            lines.append(format_activity_markdown(item["data"]))
+        else:
+            mem = item["data"]
+            lines.append(f"**Memory created**: [{mem.get('type')}] {mem.get('id')}")
+            content = xml_escape(mem.get("content", "")[:100])
+            lines.append(f"  > {content}...")
+        lines.append("")
+
+    return "\n".join(lines)
+
+
+def format_session_context_markdown(
+    sessions: list[dict[str, Any]],
+    learnings: list[str],
+    decisions: list[str],
+    errors: list[str]
+) -> str:
+    """Format session context as markdown for continuity.
+
+    Args:
+        sessions: Recent sessions
+        learnings: Key learnings
+        decisions: Key decisions
+        errors: Key errors encountered
+
+    Returns:
+        Markdown formatted context string
+    """
+    lines = []
+    lines.append("# Session Context")
+    lines.append("")
+
+    if sessions:
+        last = sessions[0]
+        ended = last.get("ended_at")
+        if ended:
+            lines.append(f"Last session ended {format_relative_time(ended)}")
+            lines.append("")
+
+    if learnings:
+        lines.append("## Key Learnings")
+        for learning in learnings[:5]:
+            lines.append(f"- {learning}")
+        lines.append("")
+
+    if decisions:
+        lines.append("## Key Decisions")
+        for decision in decisions[:5]:
+            lines.append(f"- {decision}")
+        lines.append("")
+
+    if errors:
+        lines.append("## Errors Encountered")
+        for error in errors[:5]:
+            lines.append(f"- {error}")
+        lines.append("")
+
+    return "\n".join(lines)

omni_cortex/utils/ids.py

@@ -0,0 +1,72 @@
+"""ID generation utilities for Omni Cortex."""
+
+import os
+import time
+from typing import Literal
+
+
+IdPrefix = Literal["mem", "act", "sess", "rel", "emb", "sum"]
+
+
+def generate_id(prefix: IdPrefix) -> str:
+    """Generate a unique ID with timestamp and random suffix.
+
+    Format: {prefix}_{timestamp_ms}_{random_hex}
+
+    Args:
+        prefix: One of mem, act, sess, rel, emb, sum
+
+    Returns:
+        Unique ID string
+    """
+    timestamp_ms = int(time.time() * 1000)
+    random_hex = os.urandom(4).hex()
+    return f"{prefix}_{timestamp_ms}_{random_hex}"
+
+
+def generate_memory_id() -> str:
+    """Generate a memory ID."""
+    return generate_id("mem")
+
+
+def generate_activity_id() -> str:
+    """Generate an activity ID."""
+    return generate_id("act")
+
+
+def generate_session_id() -> str:
+    """Generate a session ID."""
+    return generate_id("sess")
+
+
+def generate_relationship_id() -> str:
+    """Generate a relationship ID."""
+    return generate_id("rel")
+
+
+def generate_embedding_id() -> str:
+    """Generate an embedding ID."""
+    return generate_id("emb")
+
+
+def generate_summary_id() -> str:
+    """Generate a session summary ID."""
+    return generate_id("sum")
+
+
+def parse_id_timestamp(id_str: str) -> int:
+    """Extract timestamp from an ID.
+
+    Args:
+        id_str: ID string in format prefix_timestamp_random
+
+    Returns:
+        Timestamp in milliseconds
+    """
+    try:
+        parts = id_str.split("_")
+        if len(parts) >= 2:
+            return int(parts[1])
+    except (ValueError, IndexError):
+        pass
+    return 0

omni_cortex/utils/timestamps.py

@@ -0,0 +1,129 @@
+"""Timestamp utilities for Omni Cortex."""
+
+from datetime import datetime, timezone, timedelta
+from typing import Optional
+
+
+def now_iso() -> str:
+    """Get current time as ISO 8601 string with timezone.
+
+    Returns:
+        ISO 8601 formatted timestamp with UTC timezone
+    """
+    return datetime.now(timezone.utc).isoformat()
+
+
+def parse_iso(iso_string: str) -> datetime:
+    """Parse an ISO 8601 string to datetime.
+
+    Args:
+        iso_string: ISO 8601 formatted string
+
+    Returns:
+        datetime object with timezone info
+    """
+    # Handle various ISO formats
+    dt = datetime.fromisoformat(iso_string.replace("Z", "+00:00"))
+    if dt.tzinfo is None:
+        dt = dt.replace(tzinfo=timezone.utc)
+    return dt
+
+
+def format_relative_time(dt: datetime | str) -> str:
+    """Format a datetime as relative time (e.g., '2 hours ago').
+
+    Args:
+        dt: datetime object or ISO string
+
+    Returns:
+        Human-readable relative time string
+    """
+    if isinstance(dt, str):
+        dt = parse_iso(dt)
+
+    now = datetime.now(timezone.utc)
+    if dt.tzinfo is None:
+        dt = dt.replace(tzinfo=timezone.utc)
+
+    diff = now - dt
+
+    if diff < timedelta(minutes=1):
+        return "just now"
+    elif diff < timedelta(hours=1):
+        minutes = int(diff.total_seconds() / 60)
+        return f"{minutes} minute{'s' if minutes != 1 else ''} ago"
+    elif diff < timedelta(days=1):
+        hours = int(diff.total_seconds() / 3600)
+        return f"{hours} hour{'s' if hours != 1 else ''} ago"
+    elif diff < timedelta(days=7):
+        days = diff.days
+        return f"{days} day{'s' if days != 1 else ''} ago"
+    elif diff < timedelta(days=30):
+        weeks = diff.days // 7
+        return f"{weeks} week{'s' if weeks != 1 else ''} ago"
+    elif diff < timedelta(days=365):
+        months = diff.days // 30
+        return f"{months} month{'s' if months != 1 else ''} ago"
+    else:
+        years = diff.days // 365
+        return f"{years} year{'s' if years != 1 else ''} ago"
+
+
+def format_duration(ms: int) -> str:
+    """Format milliseconds as human-readable duration.
+
+    Args:
+        ms: Duration in milliseconds
+
+    Returns:
+        Human-readable duration string
+    """
+    if ms < 1000:
+        return f"{ms}ms"
+    elif ms < 60000:
+        seconds = ms / 1000
+        return f"{seconds:.1f}s"
+    elif ms < 3600000:
+        minutes = ms / 60000
+        return f"{minutes:.1f}m"
+    else:
+        hours = ms / 3600000
+        return f"{hours:.1f}h"
+
+
+def days_since(dt: datetime | str) -> int:
+    """Calculate days since a given datetime.
+
+    Args:
+        dt: datetime object or ISO string
+
+    Returns:
+        Number of days since the datetime
+    """
+    if isinstance(dt, str):
+        dt = parse_iso(dt)
+
+    now = datetime.now(timezone.utc)
+    if dt.tzinfo is None:
+        dt = dt.replace(tzinfo=timezone.utc)
+
+    return (now - dt).days
+
+
+def hours_since(dt: datetime | str) -> float:
+    """Calculate hours since a given datetime.
+
+    Args:
+        dt: datetime object or ISO string
+
+    Returns:
+        Number of hours since the datetime
+    """
+    if isinstance(dt, str):
+        dt = parse_iso(dt)
+
+    now = datetime.now(timezone.utc)
+    if dt.tzinfo is None:
+        dt = dt.replace(tzinfo=timezone.utc)
+
+    return (now - dt).total_seconds() / 3600

omni_cortex/utils/truncation.py

@@ -0,0 +1,111 @@
+"""Output truncation utilities for Omni Cortex."""
+
+import json
+from typing import Any
+
+
+DEFAULT_MAX_LENGTH = 10000
+TRUNCATION_SUFFIX = "\n... [truncated]"
+
+
+def truncate_output(text: str, max_length: int = DEFAULT_MAX_LENGTH) -> str:
+    """Truncate text to maximum length.
+
+    Args:
+        text: Text to truncate
+        max_length: Maximum allowed length
+
+    Returns:
+        Truncated text with suffix if truncated
+    """
+    if len(text) <= max_length:
+        return text
+
+    # Reserve space for truncation suffix
+    cut_length = max_length - len(TRUNCATION_SUFFIX)
+    if cut_length <= 0:
+        return text[:max_length]
+
+    return text[:cut_length] + TRUNCATION_SUFFIX
+
+
+def truncate_json(data: Any, max_length: int = DEFAULT_MAX_LENGTH) -> str:
+    """Serialize to JSON and truncate if necessary.
+
+    Args:
+        data: Data to serialize
+        max_length: Maximum allowed length
+
+    Returns:
+        JSON string, truncated if necessary
+    """
+    json_str = json.dumps(data, default=str)
+    return truncate_output(json_str, max_length)
+
+
+def truncate_dict_values(
+    data: dict[str, Any],
+    max_value_length: int = 1000
+) -> dict[str, Any]:
+    """Truncate string values in a dictionary.
+
+    Args:
+        data: Dictionary with values to truncate
+        max_value_length: Maximum length for each string value
+
+    Returns:
+        Dictionary with truncated string values
+    """
+    result = {}
+    for key, value in data.items():
+        if isinstance(value, str) and len(value) > max_value_length:
+            result[key] = value[:max_value_length] + "..."
+        elif isinstance(value, dict):
+            result[key] = truncate_dict_values(value, max_value_length)
+        elif isinstance(value, list):
+            result[key] = [
+                truncate_dict_values(item, max_value_length) if isinstance(item, dict)
+                else (item[:max_value_length] + "..." if isinstance(item, str) and len(item) > max_value_length else item)
+                for item in value
+            ]
+        else:
+            result[key] = value
+    return result
+
+
+def smart_truncate(text: str, max_length: int = DEFAULT_MAX_LENGTH) -> str:
+    """Truncate text at a sensible boundary (newline, sentence, word).
+
+    Args:
+        text: Text to truncate
+        max_length: Maximum allowed length
+
+    Returns:
+        Truncated text at a natural boundary
+    """
+    if len(text) <= max_length:
+        return text
+
+    # Reserve space for suffix
+    cut_length = max_length - len(TRUNCATION_SUFFIX)
+    if cut_length <= 0:
+        return text[:max_length]
+
+    # Try to cut at a newline
+    last_newline = text.rfind("\n", 0, cut_length)
+    if last_newline > cut_length * 0.7:  # Only if reasonably close to the end
+        return text[:last_newline] + TRUNCATION_SUFFIX
+
+    # Try to cut at a sentence boundary
+    for char in [". ", "! ", "? "]:
+        last_sentence = text.rfind(char, 0, cut_length)
+        if last_sentence > cut_length * 0.7:
+            return text[:last_sentence + 1] + TRUNCATION_SUFFIX
+
+    # Try to cut at a word boundary
+    last_space = text.rfind(" ", 0, cut_length)
+    if last_space > cut_length * 0.8:
+        return text[:last_space] + TRUNCATION_SUFFIX
+
+    # Fall back to hard cut
+    return text[:cut_length] + TRUNCATION_SUFFIX

{omni_cortex-1.17.0.data → omni_cortex-1.17.2.data}/data/share/omni-cortex/dashboard/backend/main.py

@@ -791,7 +791,8 @@ async def list_activities(
     # Ensure migrations are applied (adds summary columns if missing)
     ensure_migrations(project)
 
-    return get_activities(project, event_type, tool_name, limit, offset)
+    activities = get_activities(project, event_type, tool_name, limit, offset)
+    return {"activities": activities, "count": len(activities)}
 
 
 @app.get("/api/timeline")
@@ -1693,9 +1694,12 @@ async def get_agent_stats_endpoint(
 # --- ADW Endpoints ---
 
 
-def scan_adw_folder() -> list[dict]:
-    """Scan agents/ folder for ADW runs."""
-    agents_dir = Path("agents")
+def scan_adw_folder(project_path: str) -> list[dict]:
+    """Scan agents/ folder for ADW runs relative to project directory."""
+    # Get project directory from db path (e.g., /project/.cortex/cortex.db -> /project)
+    project_dir = Path(project_path).parent.parent if project_path.endswith(".db") else Path(project_path)
+    agents_dir = project_dir / "agents"
+
     if not agents_dir.exists():
         return []
 
@@ -1712,7 +1716,8 @@ def scan_adw_folder() -> list[dict]:
                         "status": state.get("status", "unknown"),
                         "current_phase": state.get("current_phase", "unknown"),
                         "phases_completed": len(state.get("completed_phases", [])),
-                        "phases_total": 4  # plan, build, validate, release
+                        "phases_total": 4,  # plan, build, validate, release
+                        "project_path": str(project_dir)
                     })
                 except json.JSONDecodeError:
                     pass
@@ -1724,7 +1729,9 @@ def scan_adw_folder() -> list[dict]:
 
 def get_adw_state_with_agents(adw_id: str, db_path: str) -> Optional[dict]:
     """Get ADW state with correlated agent activity."""
-    adw_dir = Path(f"agents/{adw_id}")
+    # Get project directory from db path
+    project_dir = Path(db_path).parent.parent if db_path.endswith(".db") else Path(db_path)
+    adw_dir = project_dir / "agents" / adw_id
     state_file = adw_dir / "adw_state.json"
 
     if not state_file.exists():
@@ -1749,17 +1756,37 @@ def get_adw_state_with_agents(adw_id: str, db_path: str) -> Optional[dict]:
         else:
             status = "pending"
 
-        # Find agents that ran in this phase (from output files)
-        agent_ids = []
+        # Find agents that ran in this phase (from output files) and count calls
+        phase_agents = []
+        total_phase_calls = 0
         if phase_dir.exists():
             for output_file in phase_dir.glob("*_output.jsonl"):
                 agent_name = output_file.stem.replace("_output", "")
-                agent_ids.append(agent_name)
+                # Count tool_use entries in the JSONL file
+                call_count = 0
+                try:
+                    with open(output_file, "r", encoding="utf-8") as f:
+                        for line in f:
+                            try:
+                                entry = json.loads(line)
+                                if entry.get("type") == "tool_use":
+                                    call_count += 1
+                            except json.JSONDecodeError:
+                                pass
+                except Exception:
+                    pass
+                phase_agents.append({
+                    "id": agent_name,
+                    "call_count": call_count
+                })
+                total_phase_calls += call_count
 
         phases.append({
             "name": phase_name,
             "status": status,
-            "agent_ids": agent_ids,
+            "agents": phase_agents,  # Now includes id and call_count
+            "agent_ids": [a["id"] for a in phase_agents],  # Keep for backwards compat
+            "call_count": total_phase_calls,
             "duration_seconds": None  # Could be computed from timestamps if needed
         })
 
@@ -1776,9 +1803,12 @@ def get_adw_state_with_agents(adw_id: str, db_path: str) -> Optional[dict]:
 
 
 @app.get("/api/adw/list")
-async def list_adw_runs(limit: int = Query(20, ge=1, le=100)):
-    """List all ADW runs from agents/ folder."""
-    adw_runs = scan_adw_folder()[:limit]
+async def list_adw_runs(
+    project: str = Query(..., description="Path to the database file"),
+    limit: int = Query(20, ge=1, le=100)
+):
+    """List all ADW runs from agents/ folder for the selected project."""
+    adw_runs = scan_adw_folder(project)[:limit]
     return {"adw_runs": adw_runs, "count": len(adw_runs)}