claude-mpm 4.1.26__py3-none-any.whl → 4.24.0__py3-none-any.whl

claude_mpm/tools/code_tree_analyzer/python_analyzer.py

@@ -0,0 +1,284 @@
+#!/usr/bin/env python3
+"""
+Python Analyzer
+===============
+
+Analyzes Python source code using AST.
+
+WHY: Python's built-in AST module provides rich structural information
+that we can leverage for detailed analysis.
+"""
+
+import ast
+from pathlib import Path
+from typing import List, Optional
+
+from ...core.logging_config import get_logger
+from ..code_tree_events import CodeNodeEvent, CodeTreeEventEmitter
+from .models import CodeNode
+
+
+class PythonAnalyzer:
+    """Analyzes Python source code using AST."""
+
+    def __init__(self, emitter: Optional[CodeTreeEventEmitter] = None):
+        self.logger = get_logger(__name__)
+        self.emitter = emitter
+
+    def analyze_file(self, file_path: Path) -> List[CodeNode]:
+        """Analyze a Python file and extract code structure.
+
+        Args:
+            file_path: Path to Python file
+
+        Returns:
+            List of code nodes found in the file
+        """
+        nodes = []
+
+        try:
+            with Path(file_path).open(
+                encoding="utf-8",
+            ) as f:
+                source = f.read()
+
+            tree = ast.parse(source, filename=str(file_path))
+            nodes = self._extract_nodes(tree, file_path, source)
+
+        except SyntaxError as e:
+            self.logger.warning(f"Syntax error in {file_path}: {e}")
+            if self.emitter:
+                self.emitter.emit_error(str(file_path), f"Syntax error: {e}")
+        except Exception as e:
+            self.logger.error(f"Error analyzing {file_path}: {e}")
+            if self.emitter:
+                self.emitter.emit_error(str(file_path), str(e))
+
+        return nodes
+
+    def _extract_nodes(
+        self, tree: ast.AST, file_path: Path, source: str
+    ) -> List[CodeNode]:
+        """Extract code nodes from AST tree.
+
+        Args:
+            tree: AST tree
+            file_path: Source file path
+            source: Source code text
+
+        Returns:
+            List of extracted code nodes
+        """
+        nodes = []
+        source.splitlines()
+
+        class NodeVisitor(ast.NodeVisitor):
+            def __init__(self, parent_name: Optional[str] = None):
+                self.parent_name = parent_name
+                self.current_class = None
+
+            def visit_ClassDef(self, node):
+                # Extract class information
+                class_node = CodeNode(
+                    file_path=str(file_path),
+                    node_type="class",
+                    name=node.name,
+                    line_start=node.lineno,
+                    line_end=node.end_lineno or node.lineno,
+                    has_docstring=bool(ast.get_docstring(node)),
+                    decorators=[self._decorator_name(d) for d in node.decorator_list],
+                    parent=self.parent_name,
+                    complexity=self._calculate_complexity(node),
+                    signature=self._get_class_signature(node),
+                )
+
+                nodes.append(class_node)
+
+                # Emit event if emitter is available
+                if self.emitter:
+                    self.emitter.emit_node(
+                        CodeNodeEvent(
+                            file_path=str(file_path),
+                            node_type="class",
+                            name=node.name,
+                            line_start=node.lineno,
+                            line_end=node.end_lineno or node.lineno,
+                            complexity=class_node.complexity,
+                            has_docstring=class_node.has_docstring,
+                            decorators=class_node.decorators,
+                            parent=self.parent_name,
+                            children_count=len(node.body),
+                        )
+                    )
+
+                # Visit class members
+                old_class = self.current_class
+                self.current_class = node.name
+                for child in node.body:
+                    if isinstance(child, (ast.FunctionDef, ast.AsyncFunctionDef)):
+                        self.visit_FunctionDef(child, is_method=True)
+                self.current_class = old_class
+
+            def visit_FunctionDef(self, node, is_method=False):
+                # Determine node type
+                node_type = "method" if is_method else "function"
+                parent = self.current_class if is_method else self.parent_name
+
+                # Extract function information
+                func_node = CodeNode(
+                    file_path=str(file_path),
+                    node_type=node_type,
+                    name=node.name,
+                    line_start=node.lineno,
+                    line_end=node.end_lineno or node.lineno,
+                    has_docstring=bool(ast.get_docstring(node)),
+                    decorators=[self._decorator_name(d) for d in node.decorator_list],
+                    parent=parent,
+                    complexity=self._calculate_complexity(node),
+                    signature=self._get_function_signature(node),
+                )
+
+                nodes.append(func_node)
+
+                # Emit event if emitter is available
+                if self.emitter:
+                    self.emitter.emit_node(
+                        CodeNodeEvent(
+                            file_path=str(file_path),
+                            node_type=node_type,
+                            name=node.name,
+                            line_start=node.lineno,
+                            line_end=node.end_lineno or node.lineno,
+                            complexity=func_node.complexity,
+                            has_docstring=func_node.has_docstring,
+                            decorators=func_node.decorators,
+                            parent=parent,
+                            children_count=0,
+                        )
+                    )
+
+            def visit_Assign(self, node):
+                # Handle module-level variable assignments
+                if self.current_class is None:  # Only module-level assignments
+                    for target in node.targets:
+                        if isinstance(target, ast.Name):
+                            var_node = CodeNode(
+                                file_path=str(file_path),
+                                node_type="variable",
+                                name=target.id,
+                                line_start=node.lineno,
+                                line_end=node.end_lineno or node.lineno,
+                                parent=self.parent_name,
+                                complexity=0,
+                                signature=f"{target.id} = ...",
+                            )
+                            nodes.append(var_node)
+
+                            # Emit event if emitter is available
+                            if self.emitter:
+                                self.emitter.emit_node(
+                                    CodeNodeEvent(
+                                        file_path=str(file_path),
+                                        node_type="variable",
+                                        name=target.id,
+                                        line_start=node.lineno,
+                                        line_end=node.end_lineno or node.lineno,
+                                        parent=self.parent_name,
+                                    )
+                                )
+
+            def visit_AsyncFunctionDef(self, node):
+                self.visit_FunctionDef(node)
+
+            def _decorator_name(self, decorator):
+                """Extract decorator name from AST node."""
+                if isinstance(decorator, ast.Name):
+                    return decorator.id
+                if isinstance(decorator, ast.Call):
+                    if isinstance(decorator.func, ast.Name):
+                        return decorator.func.id
+                    if isinstance(decorator.func, ast.Attribute):
+                        return decorator.func.attr
+                return "unknown"
+
+            def _calculate_complexity(self, node):
+                """Calculate cyclomatic complexity of a node."""
+                complexity = 1  # Base complexity
+
+                for child in ast.walk(node):
+                    if isinstance(
+                        child, (ast.If, ast.While, ast.For, ast.ExceptHandler)
+                    ):
+                        complexity += 1
+                    elif isinstance(child, ast.BoolOp):
+                        complexity += len(child.values) - 1
+
+                return complexity
+
+            def _get_function_signature(self, node):
+                """Extract function signature."""
+                args = []
+                for arg in node.args.args:
+                    args.append(arg.arg)
+                return f"{node.name}({', '.join(args)})"
+
+            def _get_class_signature(self, node):
+                """Extract class signature."""
+                bases = []
+                for base in node.bases:
+                    if isinstance(base, ast.Name):
+                        bases.append(base.id)
+                base_str = f"({', '.join(bases)})" if bases else ""
+                return f"class {node.name}{base_str}"
+
+        # Extract imports
+        for node in ast.walk(tree):
+            if isinstance(node, ast.Import):
+                for alias in node.names:
+                    import_node = CodeNode(
+                        file_path=str(file_path),
+                        node_type="import",
+                        name=alias.name,
+                        line_start=node.lineno,
+                        line_end=node.end_lineno or node.lineno,
+                        signature=f"import {alias.name}",
+                    )
+                    nodes.append(import_node)
+
+            elif isinstance(node, ast.ImportFrom):
+                module = node.module or ""
+                for alias in node.names:
+                    import_node = CodeNode(
+                        file_path=str(file_path),
+                        node_type="import",
+                        name=f"{module}.{alias.name}",
+                        line_start=node.lineno,
+                        line_end=node.end_lineno or node.lineno,
+                        signature=f"from {module} import {alias.name}",
+                    )
+                    nodes.append(import_node)
+
+        # Visit all nodes
+        visitor = NodeVisitor()
+        visitor.emitter = self.emitter
+        visitor.visit(tree)
+
+        return nodes
+
+    def _get_assignment_signature(self, node: ast.Assign, var_name: str) -> str:
+        """Get assignment signature string."""
+        try:
+            # Try to get a simple representation of the value
+            if isinstance(node.value, ast.Constant):
+                if isinstance(node.value.value, str):
+                    return f'{var_name} = "{node.value.value}"'
+                return f"{var_name} = {node.value.value}"
+            if isinstance(node.value, ast.Name):
+                return f"{var_name} = {node.value.id}"
+            if isinstance(node.value, ast.List):
+                return f"{var_name} = [...]"
+            if isinstance(node.value, ast.Dict):
+                return f"{var_name} = {{...}}"
+            return f"{var_name} = ..."
+        except Exception:
+            return f"{var_name} = ..."

claude_mpm/tools/code_tree_builder.py

@@ -17,7 +17,7 @@ import fnmatch
 import hashlib
 import json
 from dataclasses import dataclass, field
-from datetime import datetime
+from datetime import datetime, timezone
 from pathlib import Path
 from typing import Any, Dict, List, Optional, Set
 
@@ -81,7 +81,7 @@ class GitignoreParser:
 
         if gitignore_path.exists():
             try:
-                with open(gitignore_path) as f:
+                with gitignore_path.open() as f:
                     for line in f:
                         line = line.strip()
                         # Skip comments and empty lines
@@ -481,7 +481,7 @@ class CodeTreeBuilder:
         hasher = hashlib.md5()
 
         try:
-            with open(path, "rb") as f:
+            with path.open("rb") as f:
                 # Read in chunks for large files
                 while chunk := f.read(8192):
                     hasher.update(chunk)
@@ -505,10 +505,10 @@ class CodeTreeBuilder:
             "files_ignored": self.stats["files_ignored"],
             "total_size": self.stats["total_size"],
             "languages": list(self.stats["languages"]),
-            "generated_at": datetime.utcnow().isoformat(),
+            "generated_at": datetime.now(timezone.utc).isoformat(),
         }
 
-        with open(output_path, "w") as f:
+        with output_path.open("w") as f:
             json.dump(tree_dict, f, indent=2)
 
         self.logger.info(f"Saved tree to {output_path}")
@@ -522,7 +522,7 @@ class CodeTreeBuilder:
         Returns:
             Root tree node
         """
-        with open(input_path) as f:
+        with input_path.open() as f:
             tree_dict = json.load(f)
 
         # Remove stats if present

claude_mpm/tools/code_tree_events.py

@@ -19,9 +19,11 @@ import threading
 import time
 from collections import deque
 from dataclasses import asdict, dataclass
-from datetime import datetime
+from datetime import datetime, timezone
 from typing import Any, Dict, List, Optional
 
+from ..core.enums import OperationResult
+
 try:
     import socketio
 
@@ -54,7 +56,7 @@ class CodeNodeEvent:
     def to_dict(self) -> Dict[str, Any]:
         """Convert to dictionary for JSON serialization."""
         data = asdict(self)
-        data["timestamp"] = datetime.utcnow().isoformat()
+        data["timestamp"] = datetime.now(timezone.utc).isoformat()
         return data
 
 
@@ -157,7 +159,7 @@ class CodeTreeEventEmitter:
 
     def start(self):
         """Start the event emitter and background tasks."""
-        self.stats["start_time"] = datetime.utcnow()
+        self.stats["start_time"] = datetime.now(timezone.utc)
         self._stop_event.clear()
 
         # Start background emit task
@@ -168,7 +170,7 @@ class CodeTreeEventEmitter:
         self.emit(
             self.EVENT_ANALYSIS_START,
             {
-                "timestamp": datetime.utcnow().isoformat(),
+                "timestamp": datetime.now(timezone.utc).isoformat(),
                 "batch_size": self.batch_size,
                 "batch_timeout": self.batch_timeout,
             },
@@ -183,9 +185,11 @@ class CodeTreeEventEmitter:
         self.emit(
             self.EVENT_ANALYSIS_COMPLETE,
             {
-                "timestamp": datetime.utcnow().isoformat(),
+                "timestamp": datetime.now(timezone.utc).isoformat(),
                 "duration": (
-                    (datetime.utcnow() - self.stats["start_time"]).total_seconds()
+                    (
+                        datetime.now(timezone.utc) - self.stats["start_time"]
+                    ).total_seconds()
                     if self.stats["start_time"]
                     else 0
                 ),
@@ -213,7 +217,7 @@ class CodeTreeEventEmitter:
         event = {
             "type": event_type,
             "data": data,
-            "timestamp": datetime.utcnow().isoformat(),
+            "timestamp": datetime.now(timezone.utc).isoformat(),
         }
 
         if batch:
@@ -266,7 +270,7 @@ class CodeTreeEventEmitter:
                 "name": Path(file_path).name,
                 "language": language or "unknown",
                 "type": "file",
-                "status": "analyzing",
+                "status": OperationResult.PENDING,
             },
         )
 
@@ -285,7 +289,7 @@ class CodeTreeEventEmitter:
                 "nodes_count": nodes_count,
                 "duration": duration,
                 "type": "file",
-                "status": "complete",
+                "status": OperationResult.COMPLETED,
             },
         )
 
@@ -393,7 +397,7 @@ class CodeTreeEventEmitter:
                     "events": list(self.event_buffer),
                     "count": len(self.event_buffer),
                 },
-                "timestamp": datetime.utcnow().isoformat(),
+                "timestamp": datetime.now(timezone.utc).isoformat(),
             }
 
             self._emit_event(batch_event)

claude_mpm/tools/socketio_debug.py

@@ -8,30 +8,30 @@ for developers working on the claude-mpm dashboard.
 
 import argparse
 import asyncio
+
+# Try to import Rich for enhanced output
+import importlib.util
 import json
 import signal
 import sys
 import time
 from dataclasses import dataclass, field
-from datetime import datetime
+from datetime import datetime, timezone
 from enum import Enum
 from pathlib import Path
 from typing import Any, Dict, List, Optional, Set
 
 import socketio
 
-# Try to import Rich for enhanced output
-try:
+if importlib.util.find_spec("rich"):
     from rich.console import Console
-    from rich.layout import Layout
-    from rich.live import Live
     from rich.panel import Panel
     from rich.table import Table
     from rich.text import Text
 
     RICH_AVAILABLE = True
     console = Console()
-except ImportError:
+else:
     RICH_AVAILABLE = False
     console = None
 
@@ -232,7 +232,7 @@ class SocketIODebugger:
 
     def _display_event(self, data: Dict[str, Any]):
         """Display an event based on current mode."""
-        timestamp = datetime.now().strftime("%H:%M:%S.%f")[:-3]
+        timestamp = datetime.now(timezone.utc).strftime("%H:%M:%S.%f")[:-3]
         event_type = data.get("type", "unknown")
         event_data = data.get("data", {})
 
@@ -266,7 +266,7 @@ class SocketIODebugger:
             "PostToolUse": "✅",
             "Error": "❌",
             "Warning": "⚠️",
-            "Info": "ℹ️",
+            "Info": "[INFO]️",
             "MemoryUpdate": "🧠",
             "ConfigChange": "⚙️",
         }
@@ -430,7 +430,7 @@ class SocketIODebugger:
             return
 
         try:
-            with open(self.output_file, "a") as f:
+            with self.output_file.open("a") as f:
                 f.write(json.dumps(data) + "\n")
         except Exception as e:
             self._log("error", f"Failed to write to file: {e}")
@@ -449,7 +449,7 @@ class SocketIODebugger:
         if self.quiet and level not in ["error", "critical"]:
             return
 
-        timestamp = datetime.now().strftime("%H:%M:%S")
+        timestamp = datetime.now(timezone.utc).strftime("%H:%M:%S")
 
         if RICH_AVAILABLE:
             styles = {
@@ -463,7 +463,7 @@ class SocketIODebugger:
             console.print(f"[{timestamp}] {message}", style=style)
         else:
             prefixes = {
-                "info": "ℹ️",
+                "info": "[INFO]️",
                 "success": "✅",
                 "warning": "⚠️",
                 "error": "❌",