omni-cortex 1.14.0__tar.gz → 1.16.0__tar.gz

{omni_cortex-1.14.0 → omni_cortex-1.16.0}/.gitignore

@@ -164,4 +164,4 @@ nul
 
 # Claude Code temporary files
 tmpclaude-*-cwd
-agents/
+/agents/

{omni_cortex-1.14.0 → omni_cortex-1.16.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: omni-cortex
-Version: 1.14.0
+Version: 1.16.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 → omni_cortex-1.16.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.14.0 → omni_cortex-1.16.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,
@@ -1625,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.14.0 → omni_cortex-1.16.0}/dashboard/backend/models.py

@@ -402,3 +402,71 @@ class ComposeResponse(BaseModel):
     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.14.0 → omni_cortex-1.16.0}/omni_cortex/__init__.py

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

{omni_cortex-1.14.0 → omni_cortex-1.16.0}/pyproject.toml

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