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

claude_mpm/storage/state_storage.py

@@ -16,7 +16,6 @@ import fcntl
 import gzip
 import hashlib
 import json
-import logging
 import os
 import pickle
 import platform
@@ -25,6 +24,10 @@ import time
 from contextlib import contextmanager, suppress
 from typing import Any, Dict, Optional, Tuple, Union
 
+from claude_mpm.core.logging_utils import get_logger
+
+logger = get_logger(__name__)
+
 
 class StateStorage:
     """Reliable state storage with atomic operations."""
@@ -38,9 +41,6 @@ class StateStorage:
         self.storage_dir = storage_dir or Path.home() / ".claude-mpm" / "storage"
         self.storage_dir.mkdir(parents=True, exist_ok=True)
 
-        # Logging
-        self.logger = logging.getLogger(__name__)
-
         # File locking support (Unix-like systems)
         self.supports_locking = platform.system() != "Windows"
 
@@ -79,14 +79,14 @@ class StateStorage:
                 with gzip.open(file_path, "wt", encoding="utf-8") as f:
                     json.dump(data, f, indent=2, default=str)
             else:
-                with open(file_path, "w") as f:
+                with file_path.open("w") as f:
                     json.dump(data, f, indent=2, default=str)
 
             self.write_count += 1
             return True
 
         except Exception as e:
-            self.logger.error(f"Failed to write JSON to {file_path}: {e}")
+            logger.error(f"Failed to write JSON to {file_path}: {e}")
             self.error_count += 1
             return False
 
@@ -106,7 +106,7 @@ class StateStorage:
             file_path = Path(file_path)
 
             if not file_path.exists():
-                self.logger.debug(f"File not found: {file_path}")
+                logger.debug(f"File not found: {file_path}")
                 return None
 
             # Auto-detect compression
@@ -118,14 +118,14 @@ class StateStorage:
                     with gzip.open(file_path, "rt", encoding="utf-8") as f:
                         data = json.load(f)
                 else:
-                    with open(file_path) as f:
+                    with file_path.open() as f:
                         data = json.load(f)
 
             self.read_count += 1
             return data
 
         except Exception as e:
-            self.logger.error(f"Failed to read JSON from {file_path}: {e}")
+            logger.error(f"Failed to read JSON from {file_path}: {e}")
             self.error_count += 1
             return None
 
@@ -159,14 +159,14 @@ class StateStorage:
                 with gzip.open(file_path, "wb") as f:
                     pickle.dump(data, f, protocol=pickle.HIGHEST_PROTOCOL)
             else:
-                with open(file_path, "wb") as f:
+                with file_path.open("wb") as f:
                     pickle.dump(data, f, protocol=pickle.HIGHEST_PROTOCOL)
 
             self.write_count += 1
             return True
 
         except Exception as e:
-            self.logger.error(f"Failed to write pickle to {file_path}: {e}")
+            logger.error(f"Failed to write pickle to {file_path}: {e}")
             self.error_count += 1
             return False
 
@@ -186,7 +186,7 @@ class StateStorage:
             file_path = Path(file_path)
 
             if not file_path.exists():
-                self.logger.debug(f"File not found: {file_path}")
+                logger.debug(f"File not found: {file_path}")
                 return None
 
             # Auto-detect compression
@@ -198,14 +198,14 @@ class StateStorage:
                     with gzip.open(file_path, "rb") as f:
                         data = pickle.load(f)
                 else:
-                    with open(file_path, "rb") as f:
+                    with file_path.open("rb") as f:
                         data = pickle.load(f)
 
             self.read_count += 1
             return data
 
         except Exception as e:
-            self.logger.error(f"Failed to read pickle from {file_path}: {e}")
+            logger.error(f"Failed to read pickle from {file_path}: {e}")
             self.error_count += 1
             return None
 
@@ -262,16 +262,16 @@ class StateStorage:
                 Path(temp_path).replace(file_path)
 
                 self.write_count += 1
-                self.logger.debug(f"Atomic write successful: {file_path}")
+                logger.debug(f"Atomic write successful: {file_path}")
                 return True
 
             finally:
                 # Clean up temp file if it still exists
                 if Path(temp_path).exists():
-                    os.unlink(temp_path)
+                    Path(temp_path).unlink()
 
         except Exception as e:
-            self.logger.error(f"Atomic write failed for {file_path}: {e}")
+            logger.error(f"Atomic write failed for {file_path}: {e}")
             self.error_count += 1
             return False
 
@@ -288,14 +288,14 @@ class StateStorage:
         """
         if not self.supports_locking:
             # No locking on Windows
-            with open(file_path, mode) as f:
+            with Path(file_path).open(mode) as f:
                 yield f
             return
 
         # Unix-like systems with fcntl
         f = None
         try:
-            f = open(file_path, mode)
+            f = Path(file_path).open(mode)
 
             # Try to acquire lock (non-blocking)
             max_attempts = 50
@@ -327,7 +327,7 @@ class StateStorage:
 
             # Calculate checksum
             hasher = hashlib.sha256()
-            with open(file_path, "rb") as f:
+            with file_path.open("rb") as f:
                 for chunk in iter(lambda: f.read(4096), b""):
                     hasher.update(chunk)
 
@@ -335,11 +335,11 @@ class StateStorage:
 
             # Write checksum file
             checksum_path = file_path.with_suffix(file_path.suffix + ".sha256")
-            with open(checksum_path, "w") as f:
+            with checksum_path.open("w") as f:
                 f.write(checksum)
 
         except Exception as e:
-            self.logger.warning(f"Could not add checksum: {e}")
+            logger.warning(f"Could not add checksum: {e}")
 
     def verify_checksum(self, file_path: Union[str, Path]) -> bool:
         """Verify file checksum for integrity.
@@ -358,25 +358,25 @@ class StateStorage:
                 return True  # No checksum to verify
 
             # Read expected checksum
-            with open(checksum_path) as f:
+            with checksum_path.open() as f:
                 expected = f.read().strip()
 
             # Calculate actual checksum
             hasher = hashlib.sha256()
-            with open(file_path, "rb") as f:
+            with file_path.open("rb") as f:
                 for chunk in iter(lambda: f.read(4096), b""):
                     hasher.update(chunk)
 
             actual = hasher.hexdigest()
 
             if actual != expected:
-                self.logger.error(f"Checksum mismatch for {file_path}")
+                logger.error(f"Checksum mismatch for {file_path}")
                 return False
 
             return True
 
         except Exception as e:
-            self.logger.warning(f"Could not verify checksum: {e}")
+            logger.warning(f"Could not verify checksum: {e}")
             return True  # Assume valid if can't verify
 
     def cleanup_temp_files(self) -> int:
@@ -396,8 +396,8 @@ class StateStorage:
                     if age > 3600:
                         temp_file.unlink()
                         cleaned += 1
-                        self.logger.debug(f"Cleaned up temp file: {temp_file}")
-                except:
+                        logger.debug(f"Cleaned up temp file: {temp_file}")
+                except Exception:
                     pass
 
             # Clean up orphaned checksum files
@@ -408,12 +408,12 @@ class StateStorage:
                     cleaned += 1
 
             if cleaned > 0:
-                self.logger.info(f"Cleaned up {cleaned} temporary files")
+                logger.info(f"Cleaned up {cleaned} temporary files")
 
             return cleaned
 
         except Exception as e:
-            self.logger.error(f"Error cleaning up temp files: {e}")
+            logger.error(f"Error cleaning up temp files: {e}")
             return 0
 
     def get_storage_info(self) -> Dict[str, Any]:
@@ -447,7 +447,7 @@ class StateStorage:
             }
 
         except Exception as e:
-            self.logger.error(f"Error getting storage info: {e}")
+            logger.error(f"Error getting storage info: {e}")
             return {"storage_directory": str(self.storage_dir), "error": str(e)}
 
 

claude_mpm/tools/__main__.py

@@ -118,7 +118,7 @@ def main():
     output_file = None
     if args.output_file:
         try:
-            output_file = open(args.output_file, "w")
+            output_file = Path(args.output_file).open("w")
         except Exception as e:
             emit_json_event(
                 "code:analysis:error", {"message": f"Failed to open output file: {e}"}

claude_mpm/tools/code_tree_analyzer/__init__.py

@@ -0,0 +1,45 @@
+#!/usr/bin/env python3
+"""
+Code Tree Analyzer
+==================
+
+Analyzes source code using AST to extract structure and metrics,
+supporting multiple languages and emitting incremental events for visualization.
+
+This module has been refactored from a single 1,825-line file into focused,
+maintainable components while preserving complete backward compatibility.
+
+Public API:
+-----------
+- CodeTreeAnalyzer: Main analyzer class
+- CodeNode: Data structure for code nodes
+- GitignoreManager: Gitignore pattern matching
+- PythonAnalyzer: Python AST analysis
+- MultiLanguageAnalyzer: Multi-language support
+
+Example Usage:
+--------------
+    from claude_mpm.tools.code_tree_analyzer import CodeTreeAnalyzer
+
+    analyzer = CodeTreeAnalyzer(emit_events=True)
+    result = analyzer.analyze_directory(Path("/path/to/code"))
+    print(result['stats'])
+"""
+
+# Public API - Backward compatible imports
+from .core import CodeTreeAnalyzer
+from .gitignore import GitignoreManager
+from .models import CodeNode
+from .multilang_analyzer import MultiLanguageAnalyzer
+from .python_analyzer import PythonAnalyzer
+
+__all__ = [
+    "CodeNode",
+    "CodeTreeAnalyzer",
+    "GitignoreManager",
+    "MultiLanguageAnalyzer",
+    "PythonAnalyzer",
+]
+
+# Version info
+__version__ = "2.0.0"  # Major refactoring while maintaining API compatibility

claude_mpm/tools/code_tree_analyzer/analysis.py

@@ -0,0 +1,299 @@
+#!/usr/bin/env python3
+"""
+Analysis Module
+===============
+
+Coordinates file analysis across different language analyzers.
+
+WHY: Centralizes file analysis logic and result processing,
+separating it from directory traversal and caching concerns.
+"""
+
+import time
+from pathlib import Path
+from typing import Dict, List, Tuple
+
+from ...core.logging_config import get_logger
+from .cache import CacheManager
+from .events import EventManager
+from .models import CodeNode
+from .multilang_analyzer import MultiLanguageAnalyzer
+from .python_analyzer import PythonAnalyzer
+
+
+class FileAnalyzer:
+    """Coordinates file analysis using appropriate language analyzers."""
+
+    def __init__(
+        self,
+        python_analyzer: PythonAnalyzer,
+        multilang_analyzer: MultiLanguageAnalyzer,
+        cache_manager: CacheManager,
+        event_manager: EventManager,
+    ):
+        """Initialize file analyzer.
+
+        Args:
+            python_analyzer: Python analyzer instance
+            multilang_analyzer: Multi-language analyzer instance
+            cache_manager: Cache manager instance
+            event_manager: Event manager instance
+        """
+        self.logger = get_logger(__name__)
+        self.python_analyzer = python_analyzer
+        self.multilang_analyzer = multilang_analyzer
+        self.cache_manager = cache_manager
+        self.event_manager = event_manager
+
+    def analyze_file(self, file_path: str) -> Dict[str, any]:
+        """Analyze a specific file and return its AST structure.
+
+        Args:
+            file_path: Path to file to analyze
+
+        Returns:
+            Dictionary with file analysis results
+        """
+        path = Path(file_path)
+        if not path.exists() or not path.is_file():
+            return {"error": f"Invalid file: {file_path}"}
+
+        language = self._get_language(path)
+        self.event_manager.emit_analysis_start(path, language)
+
+        # Check cache
+        cache_key = self.cache_manager.get_cache_key(path)
+
+        if cached_nodes := self.cache_manager.get(cache_key):
+            self.event_manager.emit_cache_hit(path)
+            filtered_nodes = self._filter_nodes(cached_nodes)
+        else:
+            _nodes, filtered_nodes, duration = self._analyze_and_cache_file(
+                path, language, cache_key
+            )
+            self.event_manager.emit_analysis_complete(path, filtered_nodes, duration)
+
+        # Prepare final data structures
+        final_nodes = filtered_nodes if filtered_nodes else []
+        elements = self._convert_nodes_to_elements(final_nodes)
+
+        return self._build_result(file_path, language, final_nodes, elements)
+
+    def _analyze_and_cache_file(
+        self, path: Path, language: str, cache_key: str
+    ) -> Tuple[List[CodeNode], List[dict], float]:
+        """Analyze file content and cache results.
+
+        Args:
+            path: File path
+            language: Programming language
+            cache_key: Cache key for storing results
+
+        Returns:
+            Tuple of (all_nodes, filtered_nodes, duration)
+        """
+        self.event_manager.emit_cache_miss(path)
+        self.event_manager.emit_parsing_start(path)
+
+        # Select analyzer based on language
+        analyzer = self._select_analyzer(language)
+
+        # Perform analysis
+        start_time = time.time()
+        nodes = analyzer.analyze_file(path) if analyzer else []
+        duration = time.time() - start_time
+
+        # Cache results
+        self.cache_manager.set(cache_key, nodes)
+
+        # Filter and process nodes
+        filtered_nodes = self._filter_and_emit_nodes(nodes, path)
+
+        return nodes, filtered_nodes, duration
+
+    def _select_analyzer(self, language: str):
+        """Select appropriate analyzer for language.
+
+        Args:
+            language: Programming language
+
+        Returns:
+            Analyzer instance or None
+        """
+        if language == "python":
+            return self.python_analyzer
+        if language in {"javascript", "typescript"}:
+            return self.multilang_analyzer
+        return self.multilang_analyzer
+
+    def _filter_nodes(self, nodes: List[CodeNode]) -> List[dict]:
+        """Filter nodes without emitting events.
+
+        Args:
+            nodes: List of CodeNode objects
+
+        Returns:
+            List of filtered node dictionaries
+        """
+        return [self._node_to_dict(n) for n in nodes if not self._is_internal_node(n)]
+
+    def _filter_and_emit_nodes(self, nodes: List[CodeNode], path: Path) -> List[dict]:
+        """Filter nodes and emit events for each.
+
+        Args:
+            nodes: List of CodeNode objects
+            path: File path being analyzed
+
+        Returns:
+            List of filtered node dictionaries
+        """
+        filtered_nodes = []
+        for node in nodes:
+            if not self._is_internal_node(node):
+                self.event_manager.emit_node_found(node, path)
+                filtered_nodes.append(self._node_to_dict(node))
+        return filtered_nodes
+
+    def _node_to_dict(self, node: CodeNode) -> dict:
+        """Convert CodeNode to dictionary.
+
+        Args:
+            node: CodeNode object
+
+        Returns:
+            Dictionary representation
+        """
+        return {
+            "name": node.name,
+            "type": node.node_type,
+            "line_start": node.line_start,
+            "line_end": node.line_end,
+            "complexity": node.complexity,
+            "has_docstring": node.has_docstring,
+            "signature": node.signature,
+        }
+
+    def _convert_nodes_to_elements(self, final_nodes: List[dict]) -> List[dict]:
+        """Convert nodes to elements format for dashboard.
+
+        Args:
+            final_nodes: List of node dictionaries
+
+        Returns:
+            List of element dictionaries
+        """
+        elements = []
+        for node in final_nodes:
+            element = {
+                "name": node["name"],
+                "type": node["type"],
+                "line": node["line_start"],
+                "complexity": node["complexity"],
+                "signature": node.get("signature", ""),
+                "has_docstring": node.get("has_docstring", False),
+            }
+            if node["type"] == "class":
+                element["methods"] = []
+            elements.append(element)
+        return elements
+
+    def _build_result(
+        self,
+        file_path: str,
+        language: str,
+        final_nodes: List[dict],
+        elements: List[dict],
+    ) -> dict:
+        """Build final result dictionary.
+
+        Args:
+            file_path: File path
+            language: Programming language
+            final_nodes: List of node dictionaries
+            elements: List of element dictionaries
+
+        Returns:
+            Complete result dictionary
+        """
+        return {
+            "path": file_path,
+            "language": language,
+            "nodes": final_nodes,
+            "elements": elements,
+            "complexity": sum(e["complexity"] for e in elements),
+            "lines": len(elements),
+            "stats": {
+                "classes": len([e for e in elements if e["type"] == "class"]),
+                "functions": len([e for e in elements if e["type"] == "function"]),
+                "methods": len([e for e in elements if e["type"] == "method"]),
+                "variables": len([e for e in elements if e["type"] == "variable"]),
+                "imports": len([e for e in elements if e["type"] == "import"]),
+                "total": len(elements),
+            },
+        }
+
+    def _is_internal_node(self, node: CodeNode) -> bool:
+        """Check if node is an internal function that should be filtered.
+
+        Args:
+            node: CodeNode to check
+
+        Returns:
+            True if node should be filtered out
+        """
+        # Don't filter classes - always show them
+        if node.node_type == "class":
+            return False
+
+        # Don't filter variables or imports - they're useful for tree view
+        if node.node_type in ["variable", "import"]:
+            return False
+
+        name_lower = node.name.lower()
+
+        # Filter only very specific internal patterns
+        # Be more conservative - only filter obvious internal handlers
+        if name_lower.startswith(("handle_", "on_")):
+            return True
+
+        # Filter Python magic methods except important ones
+        if name_lower.startswith("__") and name_lower.endswith("__"):
+            # Keep important magic methods
+            important_magic = [
+                "__init__",
+                "__call__",
+                "__enter__",
+                "__exit__",
+                "__str__",
+                "__repr__",
+            ]
+            return node.name not in important_magic
+
+        # Filter very generic getters/setters only if they're trivial
+        if (name_lower.startswith(("get_", "set_"))) and len(node.name) <= 8:
+            return True
+
+        # Don't filter single underscore functions - they're often important
+        # (like _setup_logging, _validate_input, etc.)
+        return False
+
+    def _get_language(self, file_path: Path) -> str:
+        """Determine language from file extension.
+
+        Args:
+            file_path: Path to file
+
+        Returns:
+            Language string
+        """
+        ext = file_path.suffix.lower()
+        language_map = {
+            ".py": "python",
+            ".js": "javascript",
+            ".jsx": "javascript",
+            ".ts": "typescript",
+            ".tsx": "typescript",
+            ".mjs": "javascript",
+            ".cjs": "javascript",
+        }
+        return language_map.get(ext, "unknown")