claude-mpm 3.9.11__py3-none-any.whl → 4.0.3__py3-none-any.whl

claude_mpm/cli/commands/cleanup.py

@@ -1,3 +1,5 @@
+from pathlib import Path
+
 """
 Memory cleanup command implementation for claude-mpm.
 
@@ -12,98 +14,89 @@ DESIGN DECISIONS:
 - Keep recent conversations (30 days by default) in active memory
 """
 
-import os
-import sys
 import json
 import shutil
-from pathlib import Path
+import sys
 from datetime import datetime, timedelta
-from typing import Dict, Any, List, Tuple
+from typing import Any, Dict, List, Tuple
 
 from ...core.logger import get_logger
 
 
 def add_cleanup_parser(subparsers):
     """Add cleanup command parser.
-    
+
     WHY: This command addresses the memory leak issue caused by large .claude.json files.
     It provides users with tools to manage conversation history and prevent memory issues.
     """
     parser = subparsers.add_parser(
-        'cleanup-memory',
-        aliases=['cleanup', 'clean'],
-        help='Clean up Claude conversation history to reduce memory usage'
+        "cleanup-memory",
+        aliases=["cleanup", "clean"],
+        help="Clean up Claude conversation history to reduce memory usage",
     )
-    
+
     parser.add_argument(
-        '--days',
+        "--days",
         type=int,
         default=30,
-        help='Keep conversations from the last N days (default: 30)'
+        help="Keep conversations from the last N days (default: 30)",
     )
-    
+
     parser.add_argument(
-        '--max-size',
+        "--max-size",
         type=str,
-        default='500KB',
-        help='Maximum size for .claude.json file (e.g., 500KB, 1MB, default: 500KB)'
+        default="500KB",
+        help="Maximum size for .claude.json file (e.g., 500KB, 1MB, default: 500KB)",
     )
-    
+
     parser.add_argument(
-        '--archive',
-        action='store_true',
+        "--archive",
+        action="store_true",
         default=True,
-        help='Archive old conversations instead of deleting (default: True)'
+        help="Archive old conversations instead of deleting (default: True)",
     )
-    
+
     parser.add_argument(
-        '--no-archive',
-        dest='archive',
-        action='store_false',
-        help='Delete old conversations without archiving'
+        "--no-archive",
+        dest="archive",
+        action="store_false",
+        help="Delete old conversations without archiving",
     )
-    
+
     parser.add_argument(
-        '--force',
-        action='store_true',
-        help='Skip confirmation prompts'
+        "--force", action="store_true", help="Skip confirmation prompts"
     )
-    
+
     parser.add_argument(
-        '--dry-run',
-        action='store_true',
-        help='Show what would be cleaned without making changes'
+        "--dry-run",
+        action="store_true",
+        help="Show what would be cleaned without making changes",
     )
-    
+
     parser.set_defaults(func=cleanup_memory)
 
 
 def parse_size(size_str: str) -> int:
     """Parse human-readable size string to bytes.
-    
+
     Args:
         size_str: Size string like "500KB", "1MB", "2GB"
-        
+
     Returns:
         Size in bytes
     """
     size_str = size_str.upper().strip()
-    
-    multipliers = {
-        'B': 1,
-        'KB': 1024,
-        'MB': 1024 * 1024,
-        'GB': 1024 * 1024 * 1024
-    }
-    
+
+    multipliers = {"B": 1, "KB": 1024, "MB": 1024 * 1024, "GB": 1024 * 1024 * 1024}
+
     for suffix, multiplier in multipliers.items():
         if size_str.endswith(suffix):
             try:
-                number = float(size_str[:-len(suffix)])
+                number = float(size_str[: -len(suffix)])
                 return int(number * multiplier)
             except ValueError:
                 pass
-    
+
     # Try to parse as raw number (assume bytes)
     try:
         return int(size_str)
@@ -113,14 +106,14 @@ def parse_size(size_str: str) -> int:
 
 def format_size(size_bytes: int) -> str:
     """Format bytes as human-readable size.
-    
+
     Args:
         size_bytes: Size in bytes
-        
+
     Returns:
         Human-readable size string
     """
-    for unit in ['B', 'KB', 'MB', 'GB']:
+    for unit in ["B", "KB", "MB", "GB"]:
         if size_bytes < 1024.0:
             return f"{size_bytes:.1f}{unit}"
         size_bytes /= 1024.0
@@ -129,139 +122,140 @@ def format_size(size_bytes: int) -> str:
 
 def analyze_claude_json(file_path: Path) -> Tuple[Dict[str, Any], List[str]]:
     """Analyze .claude.json file for cleanup opportunities.
-    
+
     WHY: We need to understand the structure of the conversation history
     to identify what can be safely cleaned up.
-    
+
     Args:
         file_path: Path to .claude.json file
-        
+
     Returns:
         Tuple of (stats dict, issues list)
     """
     stats = {
-        'file_size': 0,
-        'line_count': 0,
-        'conversation_count': 0,
-        'oldest_conversation': None,
-        'newest_conversation': None,
-        'large_conversations': [],
-        'duplicate_count': 0
+        "file_size": 0,
+        "line_count": 0,
+        "conversation_count": 0,
+        "oldest_conversation": None,
+        "newest_conversation": None,
+        "large_conversations": [],
+        "duplicate_count": 0,
     }
-    
+
     issues = []
-    
+
     if not file_path.exists():
         issues.append(f"File not found: {file_path}")
         return stats, issues
-    
+
     # Get file stats
     file_stat = file_path.stat()
-    stats['file_size'] = file_stat.st_size
-    
+    stats["file_size"] = file_stat.st_size
+
     # Count lines
-    with open(file_path, 'r') as f:
-        stats['line_count'] = sum(1 for _ in f)
-    
+    with open(file_path, "r") 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, "r") as f:
             data = json.load(f)
-            
+
         # Analyze conversation structure
         # Note: The actual structure may vary, this is a best-effort analysis
         if isinstance(data, dict):
             # Look for conversation-like structures
             for key, value in data.items():
-                if isinstance(value, dict) and 'messages' in value:
-                    stats['conversation_count'] += 1
-                    
+                if isinstance(value, dict) and "messages" in value:
+                    stats["conversation_count"] += 1
+
                     # Track conversation sizes
                     conv_size = len(json.dumps(value))
                     if conv_size > 100000:  # >100KB per conversation
-                        stats['large_conversations'].append({
-                            'id': key,
-                            'size': conv_size,
-                            'message_count': len(value.get('messages', []))
-                        })
-            
+                        stats["large_conversations"].append(
+                            {
+                                "id": key,
+                                "size": conv_size,
+                                "message_count": len(value.get("messages", [])),
+                            }
+                        )
+
             # Sort large conversations by size
-            stats['large_conversations'].sort(key=lambda x: x['size'], reverse=True)
-            
+            stats["large_conversations"].sort(key=lambda x: x["size"], reverse=True)
+
     except json.JSONDecodeError as e:
         issues.append(f"JSON parsing error: {e}")
     except Exception as e:
         issues.append(f"Error analyzing file: {e}")
-    
+
     return stats, issues
 
 
 def create_archive(source_path: Path, archive_dir: Path) -> Path:
     """Create an archive of the current .claude.json file.
-    
+
     WHY: We want to preserve conversation history in case users need to
     reference it later, while still cleaning up active memory usage.
-    
+
     Args:
         source_path: Path to source file
         archive_dir: Directory for archives
-        
+
     Returns:
         Path to created archive
     """
     archive_dir.mkdir(parents=True, exist_ok=True)
-    
+
     # Create timestamped archive name
     timestamp = datetime.now().strftime("%Y%m%d_%H%M%S")
     archive_name = f"claude_archive_{timestamp}.json"
     archive_path = archive_dir / archive_name
-    
+
     # Copy file to archive
     shutil.copy2(source_path, archive_path)
-    
+
     # Optionally compress large archives
     if archive_path.stat().st_size > 10 * 1024 * 1024:  # >10MB
         import gzip
-        compressed_path = archive_path.with_suffix('.json.gz')
-        with open(archive_path, 'rb') as f_in:
-            with gzip.open(compressed_path, 'wb') as f_out:
+
+        compressed_path = archive_path.with_suffix(".json.gz")
+        with open(archive_path, "rb") as f_in:
+            with gzip.open(compressed_path, "wb") as f_out:
                 shutil.copyfileobj(f_in, f_out)
         archive_path.unlink()  # Remove uncompressed version
         return compressed_path
-    
+
     return archive_path
 
 
-def clean_claude_json(file_path: Path, keep_days: int, dry_run: bool = False) -> Tuple[int, int]:
+def clean_claude_json(
+    file_path: Path, keep_days: int, dry_run: bool = False
+) -> Tuple[int, int]:
     """Clean up old conversations from .claude.json file.
-    
+
     WHY: This function removes old conversation data while preserving recent
     conversations, reducing memory usage when Claude loads the file.
-    
+
     Args:
         file_path: Path to .claude.json file
         keep_days: Number of days of history to keep
         dry_run: If True, don't make actual changes
-        
+
     Returns:
         Tuple of (original_size, new_size) in bytes
     """
     if not file_path.exists():
         return 0, 0
-    
+
     original_size = file_path.stat().st_size
-    
+
     # For now, return a simple implementation
     # In a real implementation, we would:
     # 1. Parse the JSON structure
     # 2. Filter conversations by date
     # 3. Remove old conversations
     # 4. Write back the cleaned data
-    
-    # Since we don't know the exact structure of .claude.json,
-    # we'll implement a safer approach: create a new minimal file
-    # if the current one is too large
-    
+
     if dry_run:
         # Estimate new size (roughly 10% of original for very large files)
         if original_size > 1024 * 1024:  # >1MB
@@ -269,7 +263,7 @@ def clean_claude_json(file_path: Path, keep_days: int, dry_run: bool = False) ->
         else:
             estimated_new_size = original_size
         return original_size, estimated_new_size
-    
+
     # For actual cleanup, we would need to understand the file structure better
     # For now, we'll just report the size without making changes
     return original_size, original_size
@@ -277,40 +271,40 @@ def clean_claude_json(file_path: Path, keep_days: int, dry_run: bool = False) ->
 
 def cleanup_memory(args):
     """Clean up Claude conversation history to reduce memory usage.
-    
+
     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.
-    
+
     Args:
         args: Parsed command line arguments
     """
     logger = get_logger("cleanup")
-    
+
     # File paths
     claude_json = Path.home() / ".claude.json"
     archive_dir = Path.home() / ".claude-mpm" / "archives"
-    
+
     print("🧹 Claude Memory Cleanup Tool")
     print("=" * 50)
-    
+
     # Check if .claude.json exists
     if not claude_json.exists():
         print("✅ No .claude.json file found - nothing to clean up")
         return
-    
+
     # Analyze current state
     print("\n📊 Analyzing current conversation history...")
     stats, issues = analyze_claude_json(claude_json)
-    
+
     # Display current status
     print(f"\n📁 File: {claude_json}")
     print(f"📏 Size: {format_size(stats['file_size'])} ({stats['line_count']:,} lines)")
-    
+
     # Check if cleanup is needed
     max_size = parse_size(args.max_size)
-    needs_cleanup = stats['file_size'] > max_size
-    
+    needs_cleanup = stats["file_size"] > max_size
+
     if not needs_cleanup:
         print(f"✅ File size is within limits ({format_size(max_size)})")
         if not args.force:
@@ -319,13 +313,15 @@ def cleanup_memory(args):
     else:
         print(f"⚠️  File size exceeds recommended limit of {format_size(max_size)}")
         print(f"   This can cause memory issues when using --resume")
-    
+
     # Show large conversations if any
-    if stats['large_conversations']:
+    if stats["large_conversations"]:
         print(f"\n🔍 Found {len(stats['large_conversations'])} large conversations:")
-        for conv in stats['large_conversations'][:3]:
-            print(f"   • {format_size(conv['size'])} - {conv['message_count']} messages")
-    
+        for conv in stats["large_conversations"][:3]:
+            print(
+                f"   • {format_size(conv['size'])} - {conv['message_count']} messages"
+            )
+
     # Show cleanup plan
     print(f"\n📋 Cleanup Plan:")
     print(f"   • Keep conversations from last {args.days} days")
@@ -333,17 +329,17 @@ def cleanup_memory(args):
         print(f"   • Archive old conversations to: {archive_dir}")
     else:
         print(f"   • Delete old conversations (no archive)")
-    
+
     if args.dry_run:
         print("\n🔍 DRY RUN MODE - No changes will be made")
-    
+
     # Get confirmation unless forced
     if not args.force and not args.dry_run:
         print("\n⚠️  This will modify your conversation history")
-        
+
         # Ensure stdout is flushed before reading input
         sys.stdout.flush()
-        
+
         # Check if we're in a TTY environment
         if not sys.stdin.isatty():
             # In non-TTY environment (like pipes), we need special handling
@@ -352,20 +348,20 @@ def cleanup_memory(args):
                 # Use readline for better compatibility in non-TTY environments
                 response = sys.stdin.readline().strip().lower()
             except (EOFError, KeyboardInterrupt):
-                response = 'n'
+                response = "n"
         else:
             # In TTY environment, use normal input()
             try:
                 response = input("Continue? [y/N]: ").strip().lower()
             except (EOFError, KeyboardInterrupt):
-                response = 'n'
-        
+                response = "n"
+
         # Handle various line endings and control characters
-        response = response.replace('\r', '').replace('\n', '').strip()
-        if response != 'y':
+        response = response.replace("\r", "").replace("\n", "").strip()
+        if response != "y":
             print("❌ Cleanup cancelled")
             return
-    
+
     # Create backup/archive
     if args.archive and not args.dry_run:
         print(f"\n📦 Creating archive...")
@@ -380,71 +376,75 @@ def cleanup_memory(args):
             if not args.force:
                 print("❌ Cleanup cancelled for safety")
                 return
-    
+
     # Perform cleanup
     print(f"\n🧹 Cleaning up conversation history...")
-    
+
     try:
         original_size, new_size = clean_claude_json(
-            claude_json,
-            keep_days=args.days,
-            dry_run=args.dry_run
+            claude_json, keep_days=args.days, dry_run=args.dry_run
         )
-        
+
         if args.dry_run:
-            print(f"📊 Would reduce size from {format_size(original_size)} to ~{format_size(new_size)}")
+            print(
+                f"📊 Would reduce size from {format_size(original_size)} to ~{format_size(new_size)}"
+            )
             print(f"💾 Estimated savings: {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"📊 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(
+                    f"💡 Try using --days with a smaller value to clean more aggressively"
+                )
+
     except Exception as e:
         logger.error(f"Cleanup failed: {e}")
         print(f"❌ Cleanup failed: {e}")
         return
-    
+
     # Clean up old archive files
     if args.archive and not args.dry_run:
         print(f"\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")
-    
+
     print("\n✨ Memory cleanup complete!")
     print("💡 You can now use 'claude-mpm run --resume' without memory issues")
 
 
 def clean_old_archives(archive_dir: Path, keep_days: int = 90) -> List[Path]:
     """Clean up old archive files.
-    
+
     WHY: Archive files can accumulate over time. We keep them for a reasonable
     period (90 days by default) then clean them up to save disk space.
-    
+
     Args:
         archive_dir: Directory containing archives
         keep_days: Number of days to keep archives
-        
+
     Returns:
         List of removed archive paths
     """
     if not archive_dir.exists():
         return []
-    
+
     removed = []
     cutoff_date = datetime.now() - timedelta(days=keep_days)
-    
+
     for archive_file in archive_dir.glob("claude_archive_*.json*"):
         # Check file age
         file_stat = archive_file.stat()
         file_time = datetime.fromtimestamp(file_stat.st_mtime)
-        
+
         if file_time < cutoff_date:
             archive_file.unlink()
             removed.append(archive_file)
-    
-    return removed
+
+    return removed