claude-mpm 4.0.23__py3-none-any.whl → 4.0.28__py3-none-any.whl

claude_mpm/cli/commands/aggregate.py

@@ -4,10 +4,17 @@ from pathlib import Path
 
 WHY: Provides command-line interface for managing the event aggregator service
 that captures Socket.IO events and saves them as structured session documents.
+
+DESIGN DECISIONS:
+- Use BaseCommand for consistent CLI patterns
+- Leverage shared utilities for argument parsing and output formatting
+- Maintain backward compatibility with existing event aggregator integration
+- Support multiple output formats (json, yaml, table, text)
 """
 
 import json
 import sys
+from typing import Optional
 
 from ...core.logger import get_logger
 from ...models.agent_session import AgentSession
@@ -17,36 +24,121 @@ from ...services.event_aggregator import (
     start_aggregator,
     stop_aggregator,
 )
+from ..shared import BaseCommand, CommandResult
 
 logger = get_logger("cli.aggregate")
 
 
+class AggregateCommand(BaseCommand):
+    """Aggregate command using shared utilities."""
+
+    def __init__(self):
+        super().__init__("aggregate")
+
+    def validate_args(self, args) -> Optional[str]:
+        """Validate command arguments."""
+        if not hasattr(args, 'aggregate_subcommand') or not args.aggregate_subcommand:
+            return "No aggregate subcommand specified"
+
+        valid_commands = ["start", "stop", "status", "sessions", "view", "export"]
+        if args.aggregate_subcommand not in valid_commands:
+            return f"Unknown aggregate command: {args.aggregate_subcommand}. Valid commands: {', '.join(valid_commands)}"
+
+        return None
+
+    def run(self, args) -> CommandResult:
+        """Execute the aggregate command."""
+        try:
+            # Route to specific subcommand handlers
+            command_map = {
+                "start": self._start_command,
+                "stop": self._stop_command,
+                "status": self._status_command,
+                "sessions": self._sessions_command,
+                "view": self._view_command,
+                "export": self._export_command,
+            }
+
+            if args.aggregate_subcommand in command_map:
+                exit_code = command_map[args.aggregate_subcommand](args)
+                if exit_code == 0:
+                    return CommandResult.success_result(f"Aggregate {args.aggregate_subcommand} completed successfully")
+                else:
+                    return CommandResult.error_result(f"Aggregate {args.aggregate_subcommand} failed", exit_code=exit_code)
+            else:
+                return CommandResult.error_result(f"Unknown aggregate command: {args.aggregate_subcommand}")
+
+        except Exception as e:
+            self.logger.error(f"Error executing aggregate command: {e}", exc_info=True)
+            return CommandResult.error_result(f"Error executing aggregate command: {e}")
+
+    def _start_command(self, args) -> int:
+        """Start the event aggregator service."""
+        return start_command_legacy(args)
+
+    def _stop_command(self, args) -> int:
+        """Stop the event aggregator service."""
+        return stop_command_legacy(args)
+
+    def _status_command(self, args) -> int:
+        """Show status of the event aggregator service."""
+        return status_command_legacy(args)
+
+    def _sessions_command(self, args) -> int:
+        """List captured sessions."""
+        return sessions_command_legacy(args)
+
+    def _view_command(self, args) -> int:
+        """View details of a specific session."""
+        return view_command_legacy(args)
+
+    def _export_command(self, args) -> int:
+        """Export a session to a file."""
+        return export_command_legacy(args)
+
+
 def aggregate_command(args):
-    """Main entry point for aggregate commands.
+    """
+    Main entry point for aggregate command.
+
+    This function maintains backward compatibility while using the new BaseCommand pattern.
+    """
+    command = AggregateCommand()
+    result = command.execute(args)
+
+    # Print result if structured output format is requested
+    if hasattr(args, 'format') and args.format in ['json', 'yaml']:
+        command.print_result(result, args)
+
+    return result.exit_code
+
+
+def aggregate_command_legacy(args):
+    """Legacy aggregate command dispatcher.
 
-    WHY: Routes subcommands to appropriate handlers for managing the
-    event aggregator service.
+    WHY: This contains the original aggregate_command logic, preserved during migration
+    to BaseCommand pattern. Will be gradually refactored into the AggregateCommand class.
     """
     subcommand = args.aggregate_subcommand
 
     if subcommand == "start":
-        return start_command(args)
+        return start_command_legacy(args)
     elif subcommand == "stop":
-        return stop_command(args)
+        return stop_command_legacy(args)
     elif subcommand == "status":
-        return status_command(args)
+        return status_command_legacy(args)
     elif subcommand == "sessions":
-        return sessions_command(args)
+        return sessions_command_legacy(args)
     elif subcommand == "view":
-        return view_command(args)
+        return view_command_legacy(args)
     elif subcommand == "export":
-        return export_command(args)
+        return export_command_legacy(args)
     else:
         print(f"Unknown subcommand: {subcommand}", file=sys.stderr)
         return 1
 
 
-def start_command(args):
+def start_command_legacy(args):
     """Start the event aggregator service.
 
     WHY: Starts capturing events from the Socket.IO dashboard server
@@ -105,7 +197,7 @@ def start_command(args):
         return 1
 
 
-def stop_command(args):
+def stop_command_legacy(args):
     """Stop the event aggregator service.
 
     WHY: Gracefully stops the aggregator and saves any active sessions.
@@ -136,7 +228,7 @@ def stop_command(args):
     return 0
 
 
-def status_command(args):
+def status_command_legacy(args):
     """Show status of the event aggregator service.
 
     WHY: Provides visibility into what the aggregator is doing and
@@ -169,7 +261,7 @@ def status_command(args):
     return 0
 
 
-def sessions_command(args):
+def sessions_command_legacy(args):
     """List captured sessions.
 
     WHY: Shows what sessions have been captured for analysis.
@@ -198,7 +290,7 @@ def sessions_command(args):
     return 0
 
 
-def view_command(args):
+def view_command_legacy(args):
     """View details of a specific session.
 
     WHY: Allows detailed inspection of what happened during a session.
@@ -293,7 +385,7 @@ def view_command(args):
     return 0
 
 
-def export_command(args):
+def export_command_legacy(args):
     """Export a session to a file.
 
     WHY: Allows sessions to be exported for external analysis or sharing.

claude_mpm/cli/commands/cleanup.py

@@ -1,5 +1,3 @@
-from pathlib import Path
-
 """
 Memory cleanup command implementation for claude-mpm.
 
@@ -8,19 +6,22 @@ Claude Desktop loads the entire conversation history into memory, leading to 2GB
 consumption. This command helps users manage and clean up their conversation history.
 
 DESIGN DECISIONS:
+- Use BaseCommand for consistent CLI patterns
 - Archive old conversations instead of deleting them
 - Provide clear feedback about space savings
 - Default to safe operations with confirmation prompts
 - Keep recent conversations (30 days by default) in active memory
+- Support multiple output formats (json, yaml, table, text)
 """
 
 import json
 import shutil
 import sys
 from datetime import datetime, timedelta
+from pathlib import Path
 from typing import Any, Dict, List, Tuple
 
-from ...core.logger import get_logger
+from ..shared import BaseCommand, CommandResult
 
 
 def add_cleanup_parser(subparsers):
@@ -269,16 +270,147 @@ def clean_claude_json(
     return original_size, original_size
 
 
-def cleanup_memory(args):
-    """Clean up Claude conversation history to reduce memory usage.
+class CleanupCommand(BaseCommand):
+    """Memory cleanup command using shared utilities."""
 
-    WHY: This command addresses the 2GB memory leak issue when using --resume
-    with large .claude.json files. It provides users with tools to manage
-    their conversation history and prevent memory issues.
+    def __init__(self):
+        super().__init__("cleanup")
 
-    Args:
-        args: Parsed command line arguments
+    def validate_args(self, args) -> str:
+        """Validate command arguments."""
+        # Validate max_size format
+        max_size = getattr(args, 'max_size', '500KB')
+        try:
+            parse_size(max_size)
+        except ValueError as e:
+            return str(e)
+
+        # Validate days
+        days = getattr(args, 'days', 30)
+        if days < 0:
+            return "Days must be a positive number"
+
+        return None
+
+    def run(self, args) -> CommandResult:
+        """Execute the cleanup command."""
+        try:
+            # Gather cleanup information
+            cleanup_data = self._analyze_cleanup_needs(args)
+
+            output_format = getattr(args, 'format', 'text')
+
+            if output_format in ['json', 'yaml']:
+                # Structured output
+                if getattr(args, 'dry_run', False):
+                    return CommandResult.success_result("Cleanup analysis completed (dry run)", data=cleanup_data)
+                else:
+                    # Perform actual cleanup
+                    result_data = self._perform_cleanup(args, cleanup_data)
+                    return CommandResult.success_result("Cleanup completed", data=result_data)
+            else:
+                # Text output using existing function
+                cleanup_memory(args)
+                return CommandResult.success_result("Cleanup completed")
+
+        except Exception as e:
+            self.logger.error(f"Error during cleanup: {e}", exc_info=True)
+            return CommandResult.error_result(f"Error during cleanup: {e}")
+
+    def _analyze_cleanup_needs(self, args) -> Dict[str, Any]:
+        """Analyze what needs to be cleaned up."""
+        claude_json = Path.home() / ".claude.json"
+        archive_dir = Path.home() / ".claude-mpm" / "archives"
+
+        if not claude_json.exists():
+            return {
+                "file_exists": False,
+                "file_path": str(claude_json),
+                "needs_cleanup": False,
+                "message": "No .claude.json file found - nothing to clean up"
+            }
+
+        # Analyze current state
+        stats, issues = analyze_claude_json(claude_json)
+
+        # Check if cleanup is needed
+        max_size = parse_size(getattr(args, 'max_size', '500KB'))
+        needs_cleanup = stats["file_size"] > max_size
+
+        return {
+            "file_exists": True,
+            "file_path": str(claude_json),
+            "archive_dir": str(archive_dir),
+            "stats": stats,
+            "issues": issues,
+            "needs_cleanup": needs_cleanup,
+            "max_size_bytes": max_size,
+            "max_size_formatted": format_size(max_size),
+            "current_size_formatted": format_size(stats["file_size"]),
+            "settings": {
+                "days": getattr(args, 'days', 30),
+                "archive": getattr(args, 'archive', True),
+                "force": getattr(args, 'force', False),
+                "dry_run": getattr(args, 'dry_run', False)
+            }
+        }
+
+    def _perform_cleanup(self, args, cleanup_data: Dict[str, Any]) -> Dict[str, Any]:
+        """Perform the actual cleanup operation."""
+        claude_json = Path(cleanup_data["file_path"])
+        archive_dir = Path(cleanup_data["archive_dir"])
+
+        result = {
+            "archive_created": False,
+            "archive_path": None,
+            "original_size": cleanup_data["stats"]["file_size"],
+            "new_size": cleanup_data["stats"]["file_size"],
+            "savings": 0,
+            "old_archives_removed": 0
+        }
+
+        # Create archive if requested
+        if cleanup_data["settings"]["archive"] and not cleanup_data["settings"]["dry_run"]:
+            try:
+                archive_path = create_archive(claude_json, archive_dir)
+                result["archive_created"] = True
+                result["archive_path"] = str(archive_path)
+            except Exception as e:
+                raise Exception(f"Failed to create archive: {e}")
+
+        # Perform cleanup
+        original_size, new_size = clean_claude_json(
+            claude_json,
+            keep_days=cleanup_data["settings"]["days"],
+            dry_run=cleanup_data["settings"]["dry_run"]
+        )
+
+        result["original_size"] = original_size
+        result["new_size"] = new_size
+        result["savings"] = original_size - new_size
+
+        # Clean up old archives
+        if cleanup_data["settings"]["archive"] and not cleanup_data["settings"]["dry_run"]:
+            old_archives = clean_old_archives(archive_dir, keep_days=90)
+            result["old_archives_removed"] = len(old_archives)
+
+        return result
+
+
+def cleanup_memory(args):
+    """
+    Main entry point for cleanup command.
+
+    This function maintains backward compatibility while using the new BaseCommand pattern.
     """
+    # For complex interactive commands like this, we'll delegate to the original implementation
+    # but could be refactored to use the new pattern in the future
+    _cleanup_memory_original(args)
+
+
+def _cleanup_memory_original(args):
+    """Original cleanup implementation for backward compatibility."""
+    from ...core.logger import get_logger
     logger = get_logger("cleanup")
 
     # File paths