omni-cortex 1.17.1__py3-none-any.whl → 1.17.3__py3-none-any.whl

omni_cortex/models/activity.py

@@ -0,0 +1,265 @@
+"""Activity model and CRUD operations."""
+
+import json
+import sqlite3
+from typing import Optional, Any
+from pydantic import BaseModel, Field, ConfigDict
+
+from ..utils.ids import generate_activity_id
+from ..utils.timestamps import now_iso
+from ..utils.truncation import truncate_json
+
+
+class ActivityCreate(BaseModel):
+    """Input model for creating an activity."""
+
+    model_config = ConfigDict(
+        str_strip_whitespace=True,
+        validate_assignment=True,
+    )
+
+    event_type: str = Field(
+        ..., description="Event type: pre_tool_use, post_tool_use, decision, observation"
+    )
+    tool_name: Optional[str] = Field(None, description="Tool name if applicable")
+    tool_input: Optional[str] = Field(None, description="Tool input (JSON)")
+    tool_output: Optional[str] = Field(None, description="Tool output (JSON)")
+    duration_ms: Optional[int] = Field(None, description="Duration in milliseconds", ge=0)
+    success: bool = Field(True, description="Whether the operation succeeded")
+    error_message: Optional[str] = Field(None, description="Error message if failed")
+    file_path: Optional[str] = Field(None, description="File path if relevant")
+    agent_id: Optional[str] = Field(None, description="Agent ID")
+    # Command analytics fields
+    command_name: Optional[str] = Field(None, description="Slash command name (e.g., 'commit', 'build')")
+    command_scope: Optional[str] = Field(None, description="Command scope: 'universal' or 'project'")
+    mcp_server: Optional[str] = Field(None, description="MCP server name (e.g., 'grep-mcp')")
+    skill_name: Optional[str] = Field(None, description="Skill name from Skill tool calls")
+
+
+class Activity(BaseModel):
+    """Full activity model from database."""
+
+    id: str
+    session_id: Optional[str] = None
+    agent_id: Optional[str] = None
+    timestamp: str
+    event_type: str
+    tool_name: Optional[str] = None
+    tool_input: Optional[str] = None
+    tool_output: Optional[str] = None
+    duration_ms: Optional[int] = None
+    success: bool = True
+    error_message: Optional[str] = None
+    project_path: Optional[str] = None
+    file_path: Optional[str] = None
+    metadata: Optional[dict[str, Any]] = None
+    # Command analytics fields
+    command_name: Optional[str] = None
+    command_scope: Optional[str] = None
+    mcp_server: Optional[str] = None
+    skill_name: Optional[str] = None
+
+
+def create_activity(
+    conn: sqlite3.Connection,
+    data: ActivityCreate,
+    session_id: Optional[str] = None,
+    project_path: Optional[str] = None,
+) -> Activity:
+    """Create a new activity in the database.
+
+    Args:
+        conn: Database connection
+        data: Activity creation data
+        session_id: Current session ID
+        project_path: Current project path
+
+    Returns:
+        Created activity object
+    """
+    activity_id = generate_activity_id()
+    timestamp = now_iso()
+
+    # Truncate large inputs/outputs
+    tool_input = data.tool_input
+    if tool_input and len(tool_input) > 10000:
+        tool_input = truncate_json(tool_input, 10000)
+
+    tool_output = data.tool_output
+    if tool_output and len(tool_output) > 10000:
+        tool_output = truncate_json(tool_output, 10000)
+
+    cursor = conn.cursor()
+
+    # Upsert agent BEFORE inserting activity (foreign key constraint)
+    if data.agent_id:
+        cursor.execute(
+            """
+            INSERT INTO agents (id, type, first_seen, last_seen, total_activities)
+            VALUES (?, 'main', ?, ?, 1)
+            ON CONFLICT(id) DO UPDATE SET
+                last_seen = ?,
+                total_activities = total_activities + 1
+            """,
+            (data.agent_id, timestamp, timestamp, timestamp),
+        )
+
+    cursor.execute(
+        """
+        INSERT INTO activities (
+            id, session_id, agent_id, timestamp, event_type,
+            tool_name, tool_input, tool_output, duration_ms,
+            success, error_message, project_path, file_path,
+            command_name, command_scope, mcp_server, skill_name
+        ) VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)
+        """,
+        (
+            activity_id,
+            session_id,
+            data.agent_id,
+            timestamp,
+            data.event_type,
+            data.tool_name,
+            tool_input,
+            tool_output,
+            data.duration_ms,
+            1 if data.success else 0,
+            data.error_message,
+            project_path,
+            data.file_path,
+            data.command_name,
+            data.command_scope,
+            data.mcp_server,
+            data.skill_name,
+        ),
+    )
+
+    conn.commit()
+
+    return Activity(
+        id=activity_id,
+        session_id=session_id,
+        agent_id=data.agent_id,
+        timestamp=timestamp,
+        event_type=data.event_type,
+        tool_name=data.tool_name,
+        tool_input=tool_input,
+        tool_output=tool_output,
+        duration_ms=data.duration_ms,
+        success=data.success,
+        error_message=data.error_message,
+        project_path=project_path,
+        file_path=data.file_path,
+        command_name=data.command_name,
+        command_scope=data.command_scope,
+        mcp_server=data.mcp_server,
+        skill_name=data.skill_name,
+    )
+
+
+def get_activity(conn: sqlite3.Connection, activity_id: str) -> Optional[Activity]:
+    """Get an activity by ID."""
+    cursor = conn.cursor()
+    cursor.execute("SELECT * FROM activities WHERE id = ?", (activity_id,))
+    row = cursor.fetchone()
+    return _row_to_activity(row) if row else None
+
+
+def get_activities(
+    conn: sqlite3.Connection,
+    session_id: Optional[str] = None,
+    agent_id: Optional[str] = None,
+    event_type: Optional[str] = None,
+    tool_name: Optional[str] = None,
+    since: Optional[str] = None,
+    until: Optional[str] = None,
+    limit: int = 50,
+    offset: int = 0,
+) -> tuple[list[Activity], int]:
+    """Get activities with filters.
+
+    Returns:
+        Tuple of (activities list, total count)
+    """
+    where_clauses = []
+    params: list[Any] = []
+
+    if session_id:
+        where_clauses.append("session_id = ?")
+        params.append(session_id)
+
+    if agent_id:
+        where_clauses.append("agent_id = ?")
+        params.append(agent_id)
+
+    if event_type:
+        where_clauses.append("event_type = ?")
+        params.append(event_type)
+
+    if tool_name:
+        where_clauses.append("tool_name = ?")
+        params.append(tool_name)
+
+    if since:
+        where_clauses.append("timestamp >= ?")
+        params.append(since)
+
+    if until:
+        where_clauses.append("timestamp <= ?")
+        params.append(until)
+
+    where_sql = ""
+    if where_clauses:
+        where_sql = "WHERE " + " AND ".join(where_clauses)
+
+    cursor = conn.cursor()
+
+    # Get total count
+    cursor.execute(f"SELECT COUNT(*) FROM activities {where_sql}", params)
+    total = cursor.fetchone()[0]
+
+    # Get page
+    params_page = params + [limit, offset]
+    cursor.execute(
+        f"""
+        SELECT * FROM activities {where_sql}
+        ORDER BY timestamp DESC
+        LIMIT ? OFFSET ?
+        """,
+        params_page,
+    )
+
+    activities = [_row_to_activity(row) for row in cursor.fetchall()]
+    return activities, total
+
+
+def _row_to_activity(row: sqlite3.Row) -> Activity:
+    """Convert database row to Activity object."""
+    metadata = row["metadata"]
+    if metadata and isinstance(metadata, str):
+        metadata = json.loads(metadata)
+
+    # Get row keys for checking column existence (for older databases)
+    row_keys = row.keys() if hasattr(row, "keys") else []
+
+    return Activity(
+        id=row["id"],
+        session_id=row["session_id"],
+        agent_id=row["agent_id"],
+        timestamp=row["timestamp"],
+        event_type=row["event_type"],
+        tool_name=row["tool_name"],
+        tool_input=row["tool_input"],
+        tool_output=row["tool_output"],
+        duration_ms=row["duration_ms"],
+        success=bool(row["success"]),
+        error_message=row["error_message"],
+        project_path=row["project_path"],
+        file_path=row["file_path"],
+        metadata=metadata,
+        # Command analytics fields (may not exist in older databases)
+        command_name=row["command_name"] if "command_name" in row_keys else None,
+        command_scope=row["command_scope"] if "command_scope" in row_keys else None,
+        mcp_server=row["mcp_server"] if "mcp_server" in row_keys else None,
+        skill_name=row["skill_name"] if "skill_name" in row_keys else None,
+    )

omni_cortex/models/agent.py

@@ -0,0 +1,144 @@
+"""Agent model and CRUD operations."""
+
+import json
+import sqlite3
+from typing import Optional, Any
+from pydantic import BaseModel
+
+from ..utils.timestamps import now_iso
+
+
+class Agent(BaseModel):
+    """Agent model from database."""
+
+    id: str
+    name: Optional[str] = None
+    type: str = "main"  # main, subagent, tool
+    first_seen: str
+    last_seen: str
+    total_activities: int = 0
+    metadata: Optional[dict[str, Any]] = None
+
+
+def get_or_create_agent(
+    conn: sqlite3.Connection,
+    agent_id: str,
+    agent_type: str = "main",
+    name: Optional[str] = None,
+) -> Agent:
+    """Get an existing agent or create a new one.
+
+    Args:
+        conn: Database connection
+        agent_id: Agent ID
+        agent_type: Type of agent (main, subagent, tool)
+        name: Optional agent name
+
+    Returns:
+        Agent object
+    """
+    now = now_iso()
+    cursor = conn.cursor()
+
+    # Try to get existing
+    cursor.execute("SELECT * FROM agents WHERE id = ?", (agent_id,))
+    row = cursor.fetchone()
+
+    if row:
+        # Update last_seen
+        cursor.execute(
+            "UPDATE agents SET last_seen = ? WHERE id = ?",
+            (now, agent_id),
+        )
+        conn.commit()
+        return _row_to_agent(row)
+
+    # Create new
+    cursor.execute(
+        """
+        INSERT INTO agents (id, name, type, first_seen, last_seen, total_activities)
+        VALUES (?, ?, ?, ?, ?, 0)
+        """,
+        (agent_id, name, agent_type, now, now),
+    )
+    conn.commit()
+
+    return Agent(
+        id=agent_id,
+        name=name,
+        type=agent_type,
+        first_seen=now,
+        last_seen=now,
+        total_activities=0,
+    )
+
+
+def get_agent(conn: sqlite3.Connection, agent_id: str) -> Optional[Agent]:
+    """Get an agent by ID."""
+    cursor = conn.cursor()
+    cursor.execute("SELECT * FROM agents WHERE id = ?", (agent_id,))
+    row = cursor.fetchone()
+    return _row_to_agent(row) if row else None
+
+
+def list_agents(
+    conn: sqlite3.Connection,
+    agent_type: Optional[str] = None,
+    limit: int = 50,
+) -> list[Agent]:
+    """List agents with optional type filter."""
+    cursor = conn.cursor()
+
+    if agent_type:
+        cursor.execute(
+            """
+            SELECT * FROM agents
+            WHERE type = ?
+            ORDER BY last_seen DESC
+            LIMIT ?
+            """,
+            (agent_type, limit),
+        )
+    else:
+        cursor.execute(
+            """
+            SELECT * FROM agents
+            ORDER BY last_seen DESC
+            LIMIT ?
+            """,
+            (limit,),
+        )
+
+    return [_row_to_agent(row) for row in cursor.fetchall()]
+
+
+def increment_agent_activities(conn: sqlite3.Connection, agent_id: str) -> None:
+    """Increment an agent's activity count."""
+    now = now_iso()
+    cursor = conn.cursor()
+    cursor.execute(
+        """
+        UPDATE agents
+        SET total_activities = total_activities + 1, last_seen = ?
+        WHERE id = ?
+        """,
+        (now, agent_id),
+    )
+    conn.commit()
+
+
+def _row_to_agent(row: sqlite3.Row) -> Agent:
+    """Convert database row to Agent object."""
+    metadata = row["metadata"]
+    if metadata and isinstance(metadata, str):
+        metadata = json.loads(metadata)
+
+    return Agent(
+        id=row["id"],
+        name=row["name"],
+        type=row["type"],
+        first_seen=row["first_seen"],
+        last_seen=row["last_seen"],
+        total_activities=row["total_activities"],
+        metadata=metadata,
+    )