claude-mpm 4.1.1__py3-none-any.whl → 4.1.2__py3-none-any.whl

claude_mpm/cli/commands/aggregate.py

@@ -17,7 +17,6 @@ import sys
 from typing import Optional
 
 from ...core.logger import get_logger
-from ...models.agent_session import AgentSession
 from ...services.event_aggregator import (
     aggregator_status,
     get_aggregator,
@@ -37,7 +36,7 @@ class AggregateCommand(BaseCommand):
 
     def validate_args(self, args) -> Optional[str]:
         """Validate command arguments."""
-        if not hasattr(args, 'aggregate_subcommand') or not args.aggregate_subcommand:
+        if not hasattr(args, "aggregate_subcommand") or not args.aggregate_subcommand:
             return "No aggregate subcommand specified"
 
         valid_commands = ["start", "stop", "status", "sessions", "view", "export"]
@@ -62,11 +61,15 @@ class AggregateCommand(BaseCommand):
             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}")
+                    return CommandResult.success_result(
+                        f"Aggregate {args.aggregate_subcommand} completed successfully"
+                    )
+                return CommandResult.error_result(
+                    f"Aggregate {args.aggregate_subcommand} failed", exit_code=exit_code
+                )
+            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)
@@ -107,7 +110,7 @@ def aggregate_command(args):
     result = command.execute(args)
 
     # Print result if structured output format is requested
-    if hasattr(args, 'format') and args.format in ['json', 'yaml']:
+    if hasattr(args, "format") and args.format in ["json", "yaml"]:
         command.print_result(result, args)
 
     return result.exit_code
@@ -123,19 +126,18 @@ def aggregate_command_legacy(args):
 
     if subcommand == "start":
         return start_command_legacy(args)
-    elif subcommand == "stop":
+    if subcommand == "stop":
         return stop_command_legacy(args)
-    elif subcommand == "status":
+    if subcommand == "status":
         return status_command_legacy(args)
-    elif subcommand == "sessions":
+    if subcommand == "sessions":
         return sessions_command_legacy(args)
-    elif subcommand == "view":
+    if subcommand == "view":
         return view_command_legacy(args)
-    elif subcommand == "export":
+    if subcommand == "export":
         return export_command_legacy(args)
-    else:
-        print(f"Unknown subcommand: {subcommand}", file=sys.stderr)
-        return 1
+    print(f"Unknown subcommand: {subcommand}", file=sys.stderr)
+    return 1
 
 
 def start_command_legacy(args):
@@ -165,12 +167,12 @@ def start_command_legacy(args):
     # Start the aggregator
     if start_aggregator():
         print("✅ Event Aggregator started successfully")
-        print(f"Capturing events from localhost:8765")
-        print(f"Sessions will be saved to: .claude-mpm/sessions/")
+        print("Capturing events from localhost:8765")
+        print("Sessions will be saved to: .claude-mpm/sessions/")
 
         # Show initial status
         status = aggregator_status()
-        print(f"\nStatus:")
+        print("\nStatus:")
         print(f"  Connected: {status['connected']}")
         print(f"  Active sessions: {status['active_sessions']}")
 
@@ -191,10 +193,9 @@ def start_command_legacy(args):
                 stop_aggregator()
 
         return 0
-    else:
-        print("❌ Failed to start Event Aggregator")
-        print("Check that python-socketio is installed: pip install python-socketio")
-        return 1
+    print("❌ Failed to start Event Aggregator")
+    print("Check that python-socketio is installed: pip install python-socketio")
+    return 1
 
 
 def stop_command_legacy(args):
@@ -216,10 +217,10 @@ def stop_command_legacy(args):
 
     # Show final statistics
     if status["total_events"] > 0:
-        print(f"\nStatistics:")
+        print("\nStatistics:")
         print(f"  Total events captured: {status['total_events']}")
         print(f"  Sessions completed: {status['sessions_completed']}")
-        print(f"  Events by type:")
+        print("  Events by type:")
         for event_type, count in sorted(
             status["events_by_type"].items(), key=lambda x: x[1], reverse=True
         )[:5]:
@@ -285,7 +286,7 @@ def sessions_command_legacy(args):
         print(f"   Delegations: {session['delegations']}")
         print(f"   Prompt: {session['initial_prompt']}")
 
-    print(f"\nUse 'claude-mpm aggregate view <session_id>' to view details")
+    print("\nUse 'claude-mpm aggregate view <session_id>' to view details")
 
     return 0
 
@@ -315,7 +316,7 @@ def view_command_legacy(args):
     if session.git_branch:
         print(f"Git branch: {session.git_branch}")
 
-    print(f"\nInitial prompt:")
+    print("\nInitial prompt:")
     print("-" * 40)
     if session.initial_prompt:
         print(session.initial_prompt[:500])
@@ -324,7 +325,7 @@ def view_command_legacy(args):
     else:
         print("(No prompt captured)")
 
-    print(f"\nMetrics:")
+    print("\nMetrics:")
     print("-" * 40)
     metrics = session.metrics
     print(f"Total events: {metrics.total_events}")
@@ -376,7 +377,7 @@ def view_command_legacy(args):
                     print(f"  Correlation: {event.correlation_id}")
 
     if session.final_response and not args.no_response:
-        print(f"\nFinal response:")
+        print("\nFinal response:")
         print("-" * 40)
         print(session.final_response[:1000])
         if len(session.final_response) > 1000:

claude_mpm/cli/commands/cleanup.py

@@ -154,12 +154,12 @@ def analyze_claude_json(file_path: Path) -> Tuple[Dict[str, Any], List[str]]:
     stats["file_size"] = file_stat.st_size
 
     # Count lines
-    with open(file_path, "r") as f:
+    with open(file_path) as f:
         stats["line_count"] = sum(1 for _ in f)
 
     # Try to parse JSON structure
     try:
-        with open(file_path, "r") as f:
+        with open(file_path) as f:
             data = json.load(f)
 
         # Analyze conversation structure
@@ -279,14 +279,14 @@ class CleanupCommand(BaseCommand):
     def validate_args(self, args) -> str:
         """Validate command arguments."""
         # Validate max_size format
-        max_size = getattr(args, 'max_size', '500KB')
+        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)
+        days = getattr(args, "days", 30)
         if days < 0:
             return "Days must be a positive number"
 
@@ -298,20 +298,22 @@ class CleanupCommand(BaseCommand):
             # Gather cleanup information
             cleanup_data = self._analyze_cleanup_needs(args)
 
-            output_format = getattr(args, 'format', 'text')
+            output_format = getattr(args, "format", "text")
 
-            if output_format in ['json', 'yaml']:
+            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")
+                if getattr(args, "dry_run", False):
+                    return CommandResult.success_result(
+                        "Cleanup analysis completed (dry run)", data=cleanup_data
+                    )
+                # Perform actual cleanup
+                result_data = self._perform_cleanup(args, cleanup_data)
+                return CommandResult.success_result(
+                    "Cleanup completed", data=result_data
+                )
+            # 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)
@@ -327,14 +329,14 @@ class CleanupCommand(BaseCommand):
                 "file_exists": False,
                 "file_path": str(claude_json),
                 "needs_cleanup": False,
-                "message": "No .claude.json file found - nothing to clean up"
+                "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'))
+        max_size = parse_size(getattr(args, "max_size", "500KB"))
         needs_cleanup = stats["file_size"] > max_size
 
         return {
@@ -348,11 +350,11 @@ class CleanupCommand(BaseCommand):
             "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)
-            }
+                "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]:
@@ -366,11 +368,14 @@ class CleanupCommand(BaseCommand):
             "original_size": cleanup_data["stats"]["file_size"],
             "new_size": cleanup_data["stats"]["file_size"],
             "savings": 0,
-            "old_archives_removed": 0
+            "old_archives_removed": 0,
         }
 
         # Create archive if requested
-        if cleanup_data["settings"]["archive"] and not cleanup_data["settings"]["dry_run"]:
+        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
@@ -382,7 +387,7 @@ class CleanupCommand(BaseCommand):
         original_size, new_size = clean_claude_json(
             claude_json,
             keep_days=cleanup_data["settings"]["days"],
-            dry_run=cleanup_data["settings"]["dry_run"]
+            dry_run=cleanup_data["settings"]["dry_run"],
         )
 
         result["original_size"] = original_size
@@ -390,7 +395,10 @@ class CleanupCommand(BaseCommand):
         result["savings"] = original_size - new_size
 
         # Clean up old archives
-        if cleanup_data["settings"]["archive"] and not cleanup_data["settings"]["dry_run"]:
+        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)
 
@@ -411,6 +419,7 @@ def cleanup_memory(args):
 def _cleanup_memory_original(args):
     """Original cleanup implementation for backward compatibility."""
     from ...core.logger import get_logger
+
     logger = get_logger("cleanup")
 
     # File paths
@@ -444,7 +453,7 @@ def _cleanup_memory_original(args):
             return
     else:
         print(f"⚠️  File size exceeds recommended limit of {format_size(max_size)}")
-        print(f"   This can cause memory issues when using --resume")
+        print("   This can cause memory issues when using --resume")
 
     # Show large conversations if any
     if stats["large_conversations"]:
@@ -455,12 +464,12 @@ def _cleanup_memory_original(args):
             )
 
     # Show cleanup plan
-    print(f"\n📋 Cleanup Plan:")
+    print("\n📋 Cleanup Plan:")
     print(f"   • Keep conversations from last {args.days} days")
     if args.archive:
         print(f"   • Archive old conversations to: {archive_dir}")
     else:
-        print(f"   • Delete old conversations (no archive)")
+        print("   • Delete old conversations (no archive)")
 
     if args.dry_run:
         print("\n🔍 DRY RUN MODE - No changes will be made")
@@ -496,7 +505,7 @@ def _cleanup_memory_original(args):
 
     # Create backup/archive
     if args.archive and not args.dry_run:
-        print(f"\n📦 Creating archive...")
+        print("\n📦 Creating archive...")
         try:
             archive_path = create_archive(claude_json, archive_dir)
             archive_size = archive_path.stat().st_size
@@ -510,7 +519,7 @@ def _cleanup_memory_original(args):
                 return
 
     # Perform cleanup
-    print(f"\n🧹 Cleaning up conversation history...")
+    print("\n🧹 Cleaning up conversation history...")
 
     try:
         original_size, new_size = clean_claude_json(
@@ -522,18 +531,15 @@ def _cleanup_memory_original(args):
                 f"📊 Would reduce size from {format_size(original_size)} to ~{format_size(new_size)}"
             )
             print(f"💾 Estimated savings: {format_size(original_size - new_size)}")
+        elif new_size < original_size:
+            print("✅ Cleanup complete!")
+            print(
+                f"📊 Reduced size from {format_size(original_size)} to {format_size(new_size)}"
+            )
+            print(f"💾 Saved: {format_size(original_size - new_size)}")
         else:
-            if new_size < original_size:
-                print(f"✅ Cleanup complete!")
-                print(
-                    f"📊 Reduced size from {format_size(original_size)} to {format_size(new_size)}"
-                )
-                print(f"💾 Saved: {format_size(original_size - new_size)}")
-            else:
-                print(f"ℹ️  No conversations were old enough to clean up")
-                print(
-                    f"💡 Try using --days with a smaller value to clean more aggressively"
-                )
+            print("ℹ️  No conversations were old enough to clean up")
+            print("💡 Try using --days with a smaller value to clean more aggressively")
 
     except Exception as e:
         logger.error(f"Cleanup failed: {e}")
@@ -542,7 +548,7 @@ def _cleanup_memory_original(args):
 
     # Clean up old archive files
     if args.archive and not args.dry_run:
-        print(f"\n🗑️  Cleaning up old archives...")
+        print("\n🗑️  Cleaning up old archives...")
         old_archives = clean_old_archives(archive_dir, keep_days=90)
         if old_archives:
             print(f"✅ Removed {len(old_archives)} old archive files")

claude_mpm/cli/commands/cleanup_orphaned_agents.py

@@ -11,13 +11,13 @@ from typing import Optional
 
 from claude_mpm.core.logging_config import get_logger
 from claude_mpm.services.agents.deployment.multi_source_deployment_service import (
-    MultiSourceAgentDeploymentService
+    MultiSourceAgentDeploymentService,
 )
 
 
 def add_parser(subparsers: argparse._SubParsersAction) -> None:
     """Add the cleanup-orphaned-agents command parser.
-    
+
     Args:
         subparsers: The subparsers object from argparse
     """
@@ -30,46 +30,46 @@ def add_parser(subparsers: argparse._SubParsersAction) -> None:
             "from the system or when switching between agent sources."
         ),
     )
-    
+
     parser.add_argument(
         "--agents-dir",
         type=Path,
         help="Directory containing deployed agents (default: .claude/agents/)",
     )
-    
+
     parser.add_argument(
         "--dry-run",
         action="store_true",
         default=True,
         help="Only show what would be removed without actually removing (default)",
     )
-    
+
     parser.add_argument(
         "--force",
         action="store_true",
         help="Actually remove orphaned agents (disables dry-run)",
     )
-    
+
     parser.add_argument(
         "--quiet",
         action="store_true",
         help="Only show summary, not individual agents",
     )
-    
+
     parser.set_defaults(func=cleanup_orphaned_agents)
 
 
 def cleanup_orphaned_agents(args: argparse.Namespace) -> int:
     """Clean up orphaned agents.
-    
+
     Args:
         args: Command line arguments
-        
+
     Returns:
         Exit code (0 for success, non-zero for errors)
     """
     logger = get_logger(__name__)
-    
+
     # Determine agents directory
     if args.agents_dir:
         agents_dir = args.agents_dir
@@ -81,33 +81,33 @@ def cleanup_orphaned_agents(args: argparse.Namespace) -> int:
         else:
             # Fall back to user home directory
             agents_dir = Path.home() / ".claude" / "agents"
-    
+
     if not agents_dir.exists():
         logger.info(f"Agents directory not found: {agents_dir}")
         return 0
-    
+
     logger.info(f"Checking for orphaned agents in: {agents_dir}")
-    
+
     # Initialize service
     service = MultiSourceAgentDeploymentService()
-    
+
     # Determine if we're doing a dry run
     dry_run = args.dry_run and not args.force
-    
+
     try:
         # Perform cleanup
         results = service.cleanup_orphaned_agents(agents_dir, dry_run=dry_run)
-        
+
         # Handle results
         if not results["orphaned"]:
             logger.info("✅ No orphaned agents found")
             return 0
-        
+
         if not args.quiet:
             logger.info(f"\nFound {len(results['orphaned'])} orphaned agent(s):")
             for orphan in results["orphaned"]:
                 logger.info(f"  - {orphan['name']} v{orphan['version']}")
-        
+
         if dry_run:
             logger.info(
                 f"\n📝 This was a dry run. Use --force to actually remove "
@@ -118,15 +118,15 @@ def cleanup_orphaned_agents(args: argparse.Namespace) -> int:
                 logger.info(
                     f"\n✅ Successfully removed {len(results['removed'])} orphaned agent(s)"
                 )
-            
+
             if results["errors"]:
                 logger.error(f"\n❌ Encountered {len(results['errors'])} error(s):")
                 for error in results["errors"]:
                     logger.error(f"  - {error}")
                 return 1
-        
+
         return 0
-        
+
     except Exception as e:
         logger.error(f"Error during cleanup: {e}")
         return 1
@@ -135,10 +135,10 @@ def cleanup_orphaned_agents(args: argparse.Namespace) -> int:
 # For backward compatibility
 def main(args: Optional[argparse.Namespace] = None) -> int:
     """Main entry point for the command.
-    
+
     Args:
         args: Command line arguments
-        
+
     Returns:
         Exit code
     """
@@ -146,5 +146,5 @@ def main(args: Optional[argparse.Namespace] = None) -> int:
         parser = argparse.ArgumentParser()
         add_parser(parser.add_subparsers())
         args = parser.parse_args()
-    
-    return cleanup_orphaned_agents(args)
+
+    return cleanup_orphaned_agents(args)