claude-mpm 4.1.6__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/__init__.py

@@ -0,0 +1,10 @@
+"""
+Tools package for Claude MPM.
+
+This package contains utility tools and debugging modules for Claude MPM,
+including code analysis tools, SocketIO debugging utilities, and other
+development helpers.
+
+This __init__.py file is required to make this directory recognizable as a
+Python package by setuptools for proper distribution and imports.
+"""

claude_mpm/tools/__main__.py

@@ -0,0 +1,208 @@
+#!/usr/bin/env python3
+"""
+Code Tree Analyzer CLI Module
+==============================
+
+WHY: Provides command-line interface for the code tree analyzer,
+allowing it to be run as a subprocess from the dashboard.
+
+DESIGN DECISIONS:
+- Support JSON streaming output for real-time event processing
+- Provide both file output and stdout streaming modes
+- Include comprehensive error handling and logging
+"""
+
+import argparse
+import json
+import sys
+from pathlib import Path
+
+from .code_tree_analyzer import CodeTreeAnalyzer
+
+
+def parse_arguments():
+    """Parse command-line arguments."""
+    parser = argparse.ArgumentParser(
+        description="Analyze code structure and emit events"
+    )
+
+    parser.add_argument(
+        "--path", type=str, required=True, help="Directory path to analyze"
+    )
+
+    parser.add_argument(
+        "--languages",
+        type=str,
+        help="Comma-separated list of languages to include (e.g., python,javascript)",
+    )
+
+    parser.add_argument(
+        "--max-depth", type=int, help="Maximum directory depth to traverse"
+    )
+
+    parser.add_argument(
+        "--ignore",
+        action="append",
+        help="Patterns to ignore (can be specified multiple times)",
+    )
+
+    parser.add_argument(
+        "--emit-events", action="store_true", help="Enable Socket.IO event emission"
+    )
+
+    parser.add_argument(
+        "--output-format",
+        choices=["json", "json-stream", "summary"],
+        default="summary",
+        help="Output format (default: summary)",
+    )
+
+    parser.add_argument(
+        "--output-file", type=str, help="Output file path (stdout if not specified)"
+    )
+
+    parser.add_argument(
+        "--cache-dir", type=str, help="Directory for caching analysis results"
+    )
+
+    return parser.parse_args()
+
+
+def emit_json_event(event_type: str, data: dict, file=None):
+    """Emit a JSON event to stdout or file.
+
+    Args:
+        event_type: Type of event
+        data: Event data
+        file: Output file handle (stdout if None)
+    """
+    event = {"type": event_type, "data": data}
+
+    output = json.dumps(event)
+    if file:
+        file.write(output + "\n")
+        file.flush()
+    else:
+        print(output, flush=True)
+
+
+def main():
+    """Main entry point for the analyzer CLI."""
+    args = parse_arguments()
+
+    # Parse path
+    path = Path(args.path).resolve()
+    if not path.exists():
+        emit_json_event(
+            "code:analysis:error", {"message": f"Path does not exist: {args.path}"}
+        )
+        sys.exit(1)
+
+    if not path.is_dir():
+        emit_json_event(
+            "code:analysis:error", {"message": f"Path is not a directory: {args.path}"}
+        )
+        sys.exit(1)
+
+    # Parse languages
+    languages = None
+    if args.languages:
+        languages = [lang.strip() for lang in args.languages.split(",")]
+
+    # Parse cache directory
+    cache_dir = None
+    if args.cache_dir:
+        cache_dir = Path(args.cache_dir)
+
+    # Open output file if specified
+    output_file = None
+    if args.output_file:
+        try:
+            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}"}
+            )
+            sys.exit(1)
+
+    try:
+        # Create analyzer
+        analyzer = CodeTreeAnalyzer(emit_events=args.emit_events, cache_dir=cache_dir)
+
+        # Emit start event for JSON stream format
+        if args.output_format == "json-stream":
+            emit_json_event(
+                "code:analysis:start",
+                {
+                    "path": str(path),
+                    "languages": languages,
+                    "max_depth": args.max_depth,
+                },
+                output_file,
+            )
+
+        # Run analysis
+        result = analyzer.analyze_directory(
+            directory=path,
+            languages=languages,
+            ignore_patterns=args.ignore,
+            max_depth=args.max_depth,
+        )
+
+        # Output results based on format
+        if args.output_format == "json":
+            # Full JSON output
+            output = json.dumps(result, indent=2, default=str)
+            if output_file:
+                output_file.write(output)
+            else:
+                print(output)
+
+        elif args.output_format == "json-stream":
+            # Streaming JSON events (already emitted during analysis)
+            emit_json_event(
+                "code:analysis:complete",
+                {"path": str(path), "stats": result.get("stats", {})},
+                output_file,
+            )
+
+        else:  # summary
+            # Human-readable summary
+            stats = result.get("stats", {})
+            summary = f"""
+Code Analysis Summary
+=====================
+Path: {path}
+Files processed: {stats.get('files_processed', 0)}
+Total nodes: {stats.get('total_nodes', 0)}
+Classes: {stats.get('classes', 0)}
+Functions: {stats.get('functions', 0)}
+Imports: {stats.get('imports', 0)}
+Languages: {', '.join(stats.get('languages', []))}
+Average complexity: {stats.get('avg_complexity', 0):.2f}
+Duration: {stats.get('duration', 0):.2f}s
+"""
+            if output_file:
+                output_file.write(summary)
+            else:
+                print(summary)
+
+    except KeyboardInterrupt:
+        emit_json_event(
+            "code:analysis:cancelled",
+            {"message": "Analysis cancelled by user"},
+            output_file,
+        )
+        sys.exit(130)
+
+    except Exception as e:
+        emit_json_event("code:analysis:error", {"message": str(e)}, output_file)
+        sys.exit(1)
+
+    finally:
+        if output_file:
+            output_file.close()
+
+
+if __name__ == "__main__":
+    main()

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