claude-mpm 3.9.11__py3-none-any.whl → 4.0.3__py3-none-any.whl

claude_mpm/hooks/claude_hooks/tool_analysis.py

@@ -0,0 +1,230 @@
+#!/usr/bin/env python3
+"""Tool analysis utilities for Claude Code hook handler.
+
+This module provides utilities for analyzing tool usage, extracting parameters,
+and assessing security risks.
+"""
+
+from typing import Any, Dict, List
+
+
+def extract_tool_parameters(tool_name: str, tool_input: dict) -> dict:
+    """Extract relevant parameters based on tool type.
+
+    WHY tool-specific extraction:
+    - Different tools have different important parameters
+    - Provides meaningful context for dashboard display
+    - Enables tool-specific analysis and monitoring
+    """
+    if not isinstance(tool_input, dict):
+        return {"raw_input": str(tool_input)}
+
+    # Common parameters across all tools
+    params = {
+        "input_type": type(tool_input).__name__,
+        "param_keys": list(tool_input.keys()) if tool_input else [],
+    }
+
+    # Tool-specific parameter extraction
+    if tool_name in [
+        "Write",
+        "Edit",
+        "MultiEdit",
+        "Read",
+        "NotebookRead",
+        "NotebookEdit",
+    ]:
+        params.update(
+            {
+                "file_path": tool_input.get("file_path")
+                or tool_input.get("notebook_path"),
+                "content_length": len(
+                    str(tool_input.get("content", tool_input.get("new_string", "")))
+                ),
+                "is_create": tool_name == "Write",
+                "is_edit": tool_name in ["Edit", "MultiEdit", "NotebookEdit"],
+            }
+        )
+    elif tool_name == "Bash":
+        command = tool_input.get("command", "")
+        params.update(
+            {
+                "command": command[:100],  # Truncate long commands
+                "command_length": len(command),
+                "has_pipe": "|" in command,
+                "has_redirect": ">" in command or "<" in command,
+                "timeout": tool_input.get("timeout"),
+            }
+        )
+    elif tool_name in ["Grep", "Glob"]:
+        params.update(
+            {
+                "pattern": tool_input.get("pattern", ""),
+                "path": tool_input.get("path", ""),
+                "output_mode": tool_input.get("output_mode"),
+            }
+        )
+    elif tool_name == "WebFetch":
+        params.update(
+            {
+                "url": tool_input.get("url", ""),
+                "prompt": tool_input.get("prompt", "")[:50],  # Truncate prompt
+            }
+        )
+    elif tool_name == "Task":
+        # Special handling for Task tool (agent delegations)
+        params.update(
+            {
+                "subagent_type": tool_input.get("subagent_type", "unknown"),
+                "description": tool_input.get("description", ""),
+                "prompt": tool_input.get("prompt", ""),
+                "prompt_preview": (
+                    tool_input.get("prompt", "")[:200]
+                    if tool_input.get("prompt")
+                    else ""
+                ),
+                "is_pm_delegation": tool_input.get("subagent_type") == "pm",
+                "is_research_delegation": tool_input.get("subagent_type") == "research",
+                "is_engineer_delegation": tool_input.get("subagent_type") == "engineer",
+            }
+        )
+    elif tool_name == "TodoWrite":
+        # Special handling for TodoWrite tool (task management)
+        todos = tool_input.get("todos", [])
+        params.update(
+            {
+                "todo_count": len(todos),
+                "todos": todos,  # Full todo list
+                "todo_summary": summarize_todos(todos),
+                "has_in_progress": any(t.get("status") == "in_progress" for t in todos),
+                "has_pending": any(t.get("status") == "pending" for t in todos),
+                "has_completed": any(t.get("status") == "completed" for t in todos),
+                "priorities": list(set(t.get("priority", "medium") for t in todos)),
+            }
+        )
+
+    return params
+
+
+def summarize_todos(todos: list) -> dict:
+    """Create a summary of the todo list for quick understanding."""
+    if not todos:
+        return {"total": 0, "summary": "Empty todo list"}
+
+    status_counts = {"pending": 0, "in_progress": 0, "completed": 0}
+    priority_counts = {"high": 0, "medium": 0, "low": 0}
+
+    for todo in todos:
+        status = todo.get("status", "pending")
+        priority = todo.get("priority", "medium")
+
+        if status in status_counts:
+            status_counts[status] += 1
+        if priority in priority_counts:
+            priority_counts[priority] += 1
+
+    # Create a text summary
+    summary_parts = []
+    if status_counts["completed"] > 0:
+        summary_parts.append(f"{status_counts['completed']} completed")
+    if status_counts["in_progress"] > 0:
+        summary_parts.append(f"{status_counts['in_progress']} in progress")
+    if status_counts["pending"] > 0:
+        summary_parts.append(f"{status_counts['pending']} pending")
+
+    return {
+        "total": len(todos),
+        "status_counts": status_counts,
+        "priority_counts": priority_counts,
+        "summary": ", ".join(summary_parts) if summary_parts else "No tasks",
+    }
+
+
+def classify_tool_operation(tool_name: str, tool_input: dict) -> str:
+    """Classify the type of operation being performed."""
+    if tool_name in ["Read", "LS", "Glob", "Grep", "NotebookRead"]:
+        return "read"
+    elif tool_name in ["Write", "Edit", "MultiEdit", "NotebookEdit"]:
+        return "write"
+    elif tool_name == "Bash":
+        return "execute"
+    elif tool_name in ["WebFetch", "WebSearch"]:
+        return "network"
+    elif tool_name == "TodoWrite":
+        return "task_management"
+    elif tool_name == "Task":
+        return "delegation"
+    else:
+        return "other"
+
+
+def assess_security_risk(tool_name: str, tool_input: dict) -> str:
+    """Assess the security risk level of the tool operation."""
+    if tool_name == "Bash":
+        command = tool_input.get("command", "").lower()
+        # Check for potentially dangerous commands
+        dangerous_patterns = [
+            "rm -rf",
+            "sudo",
+            "chmod 777",
+            "curl",
+            "wget",
+            "> /etc/",
+            "dd if=",
+        ]
+        if any(pattern in command for pattern in dangerous_patterns):
+            return "high"
+        elif any(word in command for word in ["install", "delete", "format", "kill"]):
+            return "medium"
+        else:
+            return "low"
+    elif tool_name in ["Write", "Edit", "MultiEdit"]:
+        file_path = tool_input.get("file_path", "")
+        # Check for system file modifications
+        if any(path in file_path for path in ["/etc/", "/usr/", "/var/", "/sys/"]):
+            return "high"
+        elif file_path.startswith("/"):
+            return "medium"
+        else:
+            return "low"
+    else:
+        return "low"
+
+
+def extract_tool_results(event: dict) -> dict:
+    """Extract and summarize tool execution results."""
+    result = {
+        "exit_code": event.get("exit_code", 0),
+        "has_output": False,
+        "has_error": False,
+    }
+
+    # Extract output if available
+    if "output" in event:
+        output = str(event["output"])
+        result.update(
+            {
+                "has_output": bool(output.strip()),
+                "output_preview": output[:200] if len(output) > 200 else output,
+                "output_lines": len(output.split("\n")) if output else 0,
+            }
+        )
+
+    # Extract error information
+    if "error" in event or event.get("exit_code", 0) != 0:
+        error = str(event.get("error", ""))
+        result.update(
+            {
+                "has_error": True,
+                "error_preview": error[:200] if len(error) > 200 else error,
+            }
+        )
+
+    return result
+
+
+def calculate_duration(event: dict) -> int:
+    """Calculate operation duration in milliseconds if timestamps are available."""
+    # This would require start/end timestamps from Claude Code
+    # For now, return None as we don't have this data
+    return None