omni-cortex 1.13.0__tar.gz → 1.15.0__tar.gz

{omni_cortex-1.13.0 → omni_cortex-1.15.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: omni-cortex
-Version: 1.13.0
+Version: 1.15.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 → omni_cortex-1.15.0}/dashboard/backend/chat_service.py

@@ -42,9 +42,13 @@ def is_available() -> bool:
         return False
 
 
-def build_style_context_prompt(style_profile: dict) -> str:
+def build_style_context_prompt(style_profile: dict | None) -> str:
     """Build a prompt section describing user's communication style."""
 
+    # Return empty string if no style profile provided
+    if not style_profile:
+        return ""
+
     # 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"
@@ -416,6 +420,8 @@ def build_compose_prompt(
     template: Optional[str],
     tone_level: int,
     memory_context: str,
+    custom_instructions: Optional[str] = None,
+    include_explanation: bool = False,
 ) -> str:
     """Build the prompt for composing a response in user's style.
 
@@ -426,6 +432,8 @@ def build_compose_prompt(
         template: Optional response template (answer, guide, redirect, acknowledge)
         tone_level: Tone formality level (0-100)
         memory_context: Relevant memories formatted as context
+        custom_instructions: Optional specific instructions from the user
+        include_explanation: Whether to explain the incoming message first
 
     Returns:
         Complete prompt for response generation
@@ -480,7 +488,37 @@ Use this information naturally in your response if relevant. Don't explicitly ci
 
 """
 
-    prompt += """
+    # Add custom instructions if provided
+    if custom_instructions:
+        prompt += f"""
+## CUSTOM INSTRUCTIONS FROM USER
+
+The user has provided these specific instructions for the response:
+
+<custom_instructions>
+{xml_escape(custom_instructions)}
+</custom_instructions>
+
+Please incorporate these requirements while maintaining the user's voice.
+
+"""
+
+    # Build task instructions based on explanation mode
+    if include_explanation:
+        prompt += """
+**Your Task:**
+1. FIRST, provide a clear explanation of what the incoming message means or is asking
+   Format: "**Understanding:** [your explanation in user's voice]"
+2. THEN, write a response to the incoming message in YOUR voice
+   Format: "**Response:** [your response]"
+3. Use the knowledge from your memories naturally if relevant
+4. Match the tone level specified above
+5. Follow the platform context guidelines
+6. Sound exactly like something you would write yourself
+
+Write the explanation and response now:"""
+    else:
+        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
@@ -501,6 +539,8 @@ async def compose_response(
     tone_level: int = 50,
     include_memories: bool = True,
     style_profile: Optional[dict] = None,
+    custom_instructions: Optional[str] = None,
+    include_explanation: bool = False,
 ) -> dict:
     """Compose a response to an incoming message in the user's style.
 
@@ -512,6 +552,8 @@ async def compose_response(
         tone_level: Tone formality level (0-100)
         include_memories: Whether to include relevant memories
         style_profile: User's style profile dictionary
+        custom_instructions: Optional specific instructions from the user
+        include_explanation: Whether to explain the incoming message first
 
     Returns:
         Dict with response, sources, and metadata
@@ -550,6 +592,8 @@ async def compose_response(
         template=template,
         tone_level=tone_level,
         memory_context=memory_context,
+        custom_instructions=custom_instructions,
+        include_explanation=include_explanation,
     )
 
     try:
@@ -563,10 +607,25 @@ async def compose_response(
             "response": f"Failed to generate response: {str(e)}",
             "sources": sources,
             "error": "generation_failed",
+            "explanation": None,
         }
 
+    # Parse explanation if requested
+    explanation = None
+    if include_explanation:
+        # Try to extract explanation and response parts
+        import re
+        understanding_match = re.search(r'\*\*Understanding:\*\*\s*(.+?)(?=\*\*Response:\*\*)', composed_response, re.DOTALL)
+        response_match = re.search(r'\*\*Response:\*\*\s*(.+)', composed_response, re.DOTALL)
+
+        if understanding_match and response_match:
+            explanation = understanding_match.group(1).strip()
+            composed_response = response_match.group(1).strip()
+        # If parsing fails, leave explanation as None and return full response
+
     return {
         "response": composed_response,
         "sources": sources,
         "error": None,
+        "explanation": explanation,
     }

{omni_cortex-1.13.0 → omni_cortex-1.15.0}/dashboard/backend/database.py

@@ -1651,3 +1651,123 @@ def compute_style_profile_from_messages(db_path: str) -> Optional[dict]:
         "styleMarkers": style_markers,
         "sampleMessages": sample_messages,
     }
+
+
+# --- Agent Query Functions ---
+
+
+def get_agents(
+    db_path: str,
+    agent_type: Optional[str] = None,
+    limit: int = 50,
+    active_only: bool = False
+) -> list[dict]:
+    """Get agents with recent activity counts."""
+    conn = get_connection(db_path)
+
+    query = """
+        SELECT
+            a.*,
+            COALESCE(recent.count, 0) as recent_activity_count,
+            CASE WHEN a.last_seen > datetime('now', '-5 minutes') THEN 1 ELSE 0 END as is_active
+        FROM agents a
+        LEFT JOIN (
+            SELECT agent_id, COUNT(*) as count
+            FROM activities
+            WHERE timestamp > datetime('now', '-1 hour')
+            GROUP BY agent_id
+        ) recent ON recent.agent_id = a.id
+        WHERE 1=1
+    """
+    params = []
+
+    if agent_type:
+        query += " AND a.type = ?"
+        params.append(agent_type)
+
+    if active_only:
+        query += " AND a.last_seen > datetime('now', '-5 minutes')"
+
+    query += " ORDER BY a.last_seen DESC LIMIT ?"
+    params.append(limit)
+
+    cursor = conn.execute(query, params)
+    results = [dict(row) for row in cursor.fetchall()]
+    conn.close()
+    return results
+
+
+def get_agent_by_id(db_path: str, agent_id: str) -> Optional[dict]:
+    """Get single agent by ID."""
+    conn = get_connection(db_path)
+
+    cursor = conn.execute("""
+        SELECT
+            a.*,
+            CASE WHEN a.last_seen > datetime('now', '-5 minutes') THEN 1 ELSE 0 END as is_active
+        FROM agents a
+        WHERE a.id = ?
+    """, (agent_id,))
+
+    row = cursor.fetchone()
+    conn.close()
+    return dict(row) if row else None
+
+
+def get_agent_tool_breakdown(db_path: str, agent_id: str) -> list[dict]:
+    """Get tool usage breakdown for an agent."""
+    conn = get_connection(db_path)
+
+    cursor = conn.execute("""
+        SELECT
+            tool_name,
+            COUNT(*) as count,
+            AVG(duration_ms) as avg_duration_ms,
+            SUM(CASE WHEN success = 1 THEN 1 ELSE 0 END) * 100.0 / COUNT(*) as success_rate
+        FROM activities
+        WHERE agent_id = ? AND tool_name IS NOT NULL
+        GROUP BY tool_name
+        ORDER BY count DESC
+    """, (agent_id,))
+
+    results = [dict(row) for row in cursor.fetchall()]
+    conn.close()
+    return results
+
+
+def get_agent_files_touched(db_path: str, agent_id: str, limit: int = 50) -> list[str]:
+    """Get list of files an agent has touched."""
+    conn = get_connection(db_path)
+
+    # Files from file_path column
+    cursor = conn.execute("""
+        SELECT DISTINCT file_path
+        FROM activities
+        WHERE agent_id = ?
+          AND file_path IS NOT NULL
+          AND file_path != ''
+        LIMIT ?
+    """, (agent_id, limit))
+
+    files = [row[0] for row in cursor.fetchall()]
+    conn.close()
+    return files
+
+
+def get_agent_parent(db_path: str, agent_id: str) -> Optional[str]:
+    """Find which agent spawned this subagent (via Task tool)."""
+    conn = get_connection(db_path)
+
+    # Look for Task tool call that created this agent
+    cursor = conn.execute("""
+        SELECT agent_id
+        FROM activities
+        WHERE tool_name = 'Task'
+          AND tool_output LIKE ?
+        ORDER BY timestamp DESC
+        LIMIT 1
+    """, (f'%{agent_id}%',))
+
+    row = cursor.fetchone()
+    conn.close()
+    return row[0] if row else None

{omni_cortex-1.13.0 → omni_cortex-1.15.0}/dashboard/backend/main.py

@@ -39,6 +39,11 @@ from database import (
     get_activities,
     get_activity_detail,
     get_activity_heatmap,
+    get_agents,
+    get_agent_by_id,
+    get_agent_files_touched,
+    get_agent_parent,
+    get_agent_tool_breakdown,
     get_all_tags,
     get_command_usage,
     get_mcp_usage,
@@ -1146,6 +1151,8 @@ async def compose_response_endpoint(
             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"):
@@ -1165,6 +1172,8 @@ async def compose_response_endpoint(
             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)
@@ -1621,6 +1630,174 @@ async def export_memories(
         raise HTTPException(status_code=400, detail=f"Unsupported format: {format}. Use json, markdown, or csv.")
 
 
+# --- Agent Endpoints ---
+
+
+@app.get("/api/agents")
+async def list_agents(
+    project: str = Query(..., description="Path to the database file"),
+    type: Optional[str] = Query(None, description="Filter by agent type: main, subagent, tool"),
+    active_only: bool = Query(False, description="Show only active agents (last 5 minutes)"),
+    limit: int = Query(50, ge=1, le=200),
+):
+    """List all agents with filtering."""
+    if not Path(project).exists():
+        raise HTTPException(status_code=404, detail="Database not found")
+
+    agents = get_agents(project, agent_type=type, limit=limit, active_only=active_only)
+    return {"agents": agents, "count": len(agents)}
+
+
+@app.get("/api/agents/{agent_id}")
+async def get_agent(
+    agent_id: str,
+    project: str = Query(..., description="Path to the database file"),
+):
+    """Get single agent details."""
+    if not Path(project).exists():
+        raise HTTPException(status_code=404, detail="Database not found")
+
+    agent = get_agent_by_id(project, agent_id)
+    if not agent:
+        raise HTTPException(status_code=404, detail="Agent not found")
+
+    return agent
+
+
+@app.get("/api/agents/{agent_id}/stats")
+async def get_agent_stats_endpoint(
+    agent_id: str,
+    project: str = Query(..., description="Path to the database file"),
+):
+    """Get detailed stats for an agent."""
+    if not Path(project).exists():
+        raise HTTPException(status_code=404, detail="Database not found")
+
+    agent = get_agent_by_id(project, agent_id)
+    if not agent:
+        raise HTTPException(status_code=404, detail="Agent not found")
+
+    tool_breakdown = get_agent_tool_breakdown(project, agent_id)
+    files_touched = get_agent_files_touched(project, agent_id)
+    parent_agent = get_agent_parent(project, agent_id) if agent.get('type') == 'subagent' else None
+
+    return {
+        "agent": agent,
+        "tool_breakdown": tool_breakdown,
+        "files_touched": files_touched,
+        "parent_agent_id": parent_agent,
+        "adw_phase": None  # Will be populated in Part 2 with ADW integration
+    }
+
+
+# --- ADW Endpoints ---
+
+
+def scan_adw_folder() -> list[dict]:
+    """Scan agents/ folder for ADW runs."""
+    agents_dir = Path("agents")
+    if not agents_dir.exists():
+        return []
+
+    adw_runs = []
+    for adw_dir in agents_dir.iterdir():
+        if adw_dir.is_dir() and adw_dir.name.startswith("adw_"):
+            state_file = adw_dir / "adw_state.json"
+            if state_file.exists():
+                try:
+                    state = json.loads(state_file.read_text())
+                    adw_runs.append({
+                        "adw_id": state.get("adw_id", adw_dir.name),
+                        "created_at": state.get("created_at"),
+                        "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
+                    })
+                except json.JSONDecodeError:
+                    pass
+
+    # Sort by created_at descending
+    adw_runs.sort(key=lambda x: x.get("created_at", ""), reverse=True)
+    return adw_runs
+
+
+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}")
+    state_file = adw_dir / "adw_state.json"
+
+    if not state_file.exists():
+        return None
+
+    state = json.loads(state_file.read_text())
+
+    # Build phase info with agent correlation
+    phases = []
+    all_phases = ["plan", "build", "validate", "release"]
+    completed = state.get("completed_phases", [])
+    current = state.get("current_phase")
+
+    for phase_name in all_phases:
+        phase_dir = adw_dir / phase_name
+
+        # Determine status
+        if phase_name in completed:
+            status = "completed"
+        elif phase_name == current:
+            status = "running"
+        else:
+            status = "pending"
+
+        # Find agents that ran in this phase (from output files)
+        agent_ids = []
+        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)
+
+        phases.append({
+            "name": phase_name,
+            "status": status,
+            "agent_ids": agent_ids,
+            "duration_seconds": None  # Could be computed from timestamps if needed
+        })
+
+    return {
+        "adw_id": state.get("adw_id", adw_id),
+        "task_description": state.get("task_description", ""),
+        "created_at": state.get("created_at"),
+        "current_phase": current,
+        "completed_phases": completed,
+        "status": state.get("status", "unknown"),
+        "phases": phases,
+        "project_path": state.get("project_path", "")
+    }
+
+
+@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]
+    return {"adw_runs": adw_runs, "count": len(adw_runs)}
+
+
+@app.get("/api/adw/{adw_id}")
+async def get_adw_details(
+    adw_id: str,
+    project: str = Query(..., description="Path to the database file"),
+):
+    """Get ADW state with agent correlation."""
+    if not Path(project).exists():
+        raise HTTPException(status_code=404, detail="Database not found")
+
+    state = get_adw_state_with_agents(adw_id, project)
+    if not state:
+        raise HTTPException(status_code=404, detail="ADW not found")
+
+    return state
+
+
 # --- Health Check ---
 
 

{omni_cortex-1.13.0 → omni_cortex-1.15.0}/dashboard/backend/models.py

@@ -384,6 +384,8 @@ class ComposeRequest(BaseModel):
     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):
@@ -398,3 +400,73 @@ class ComposeResponse(BaseModel):
     incoming_message: str
     context_type: str
     created_at: str
+    custom_instructions: Optional[str] = None
+    explanation: Optional[str] = None
+
+
+# --- Agent & ADW Models ---
+
+
+class Agent(BaseModel):
+    """Agent from the agents table."""
+
+    id: str
+    name: Optional[str] = None
+    type: str  # 'main', 'subagent', 'tool'
+    first_seen: datetime
+    last_seen: datetime
+    total_activities: int
+    recent_activity_count: int = 0  # Activities in last hour
+    is_active: bool = False  # Has activity in last 5 minutes
+
+
+class AgentToolStats(BaseModel):
+    """Tool usage breakdown for an agent."""
+
+    tool_name: str
+    count: int
+    avg_duration_ms: float
+    success_rate: float
+
+
+class AgentStats(BaseModel):
+    """Detailed stats for a single agent."""
+
+    agent: Agent
+    tool_breakdown: list[AgentToolStats]
+    files_touched: list[str]
+    parent_agent_id: Optional[str] = None  # If subagent, who spawned it
+    adw_phase: Optional[str] = None  # Which ADW phase this agent ran in
+
+
+class ADWPhaseInfo(BaseModel):
+    """Info about a single ADW phase."""
+
+    name: str  # 'plan', 'build', 'validate', 'release'
+    status: str  # 'pending', 'running', 'completed', 'failed', 'skipped'
+    duration_seconds: Optional[float] = None
+    agent_ids: list[str] = []  # Agents that ran in this phase
+
+
+class ADWState(BaseModel):
+    """Full ADW state with agent correlation."""
+
+    adw_id: str
+    task_description: str
+    created_at: datetime
+    current_phase: str
+    completed_phases: list[str]
+    status: str  # 'running', 'completed', 'failed'
+    phases: list[ADWPhaseInfo]
+    project_path: str
+
+
+class ADWListItem(BaseModel):
+    """Summary for ADW list."""
+
+    adw_id: str
+    created_at: datetime
+    status: str
+    current_phase: str
+    phases_completed: int
+    phases_total: int

{omni_cortex-1.13.0 → omni_cortex-1.15.0}/omni_cortex/__init__.py

@@ -1,3 +1,3 @@
 """Omni Cortex MCP - Universal Memory System for Claude Code."""
 
-__version__ = "1.13.0"
+__version__ = "1.15.0"

{omni_cortex-1.13.0 → omni_cortex-1.15.0}/pyproject.toml

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