claude-mpm 3.9.2__py3-none-any.whl → 3.9.5__py3-none-any.whl

claude_mpm/config/paths.py

@@ -33,6 +33,7 @@ class ClaudeMPMPaths:
     
     _instance: Optional['ClaudeMPMPaths'] = None
     _project_root: Optional[Path] = None
+    _is_installed: bool = False
     
     def __new__(cls) -> 'ClaudeMPMPaths':
         """Singleton pattern to ensure single instance."""
@@ -43,6 +44,7 @@ class ClaudeMPMPaths:
     def __init__(self):
         """Initialize paths if not already done."""
         if self._project_root is None:
+            self._is_installed = False
             self._detect_project_root()
     
     def _detect_project_root(self) -> None:
@@ -53,16 +55,29 @@ class ClaudeMPMPaths:
         1. Look for definitive project markers (pyproject.toml, setup.py)
         2. Look for combination of markers to ensure we're at the right level
         3. Walk up from current file location
+        4. Handle both development and installed environments
         """
         # Start from this file's location
         current = Path(__file__).resolve()
         
-        # Walk up the directory tree
+        # Check if we're in an installed environment (site-packages)
+        # In pip/pipx installs, the package is directly in site-packages
+        if 'site-packages' in str(current) or 'dist-packages' in str(current):
+            # We're in an installed environment
+            # The claude_mpm package directory itself is the "root" for resources
+            import claude_mpm
+            self._project_root = Path(claude_mpm.__file__).parent
+            self._is_installed = True
+            logger.debug(f"Installed environment detected, using package dir: {self._project_root}")
+            return
+        
+        # We're in a development environment, look for project markers
         for parent in current.parents:
             # Check for definitive project root indicators
             # Prioritize pyproject.toml and setup.py as they're only at root
             if (parent / 'pyproject.toml').exists() or (parent / 'setup.py').exists():
                 self._project_root = parent
+                self._is_installed = False
                 logger.debug(f"Project root detected at: {parent} (found pyproject.toml or setup.py)")
                 return
             
@@ -70,6 +85,7 @@ class ClaudeMPMPaths:
             # This combination is more likely to be the real project root
             if (parent / '.git').exists() and (parent / 'VERSION').exists():
                 self._project_root = parent
+                self._is_installed = False
                 logger.debug(f"Project root detected at: {parent} (found .git and VERSION)")
                 return
         
@@ -77,12 +93,14 @@ class ClaudeMPMPaths:
         for parent in current.parents:
             if parent.name == 'claude-mpm':
                 self._project_root = parent
+                self._is_installed = False
                 logger.debug(f"Project root detected at: {parent} (by directory name)")
                 return
         
         # Last resort fallback: 3 levels up from this file
         # paths.py is in src/claude_mpm/config/
         self._project_root = current.parent.parent.parent
+        self._is_installed = False
         logger.warning(f"Project root fallback to: {self._project_root}")
     
     @property
@@ -95,16 +113,26 @@ class ClaudeMPMPaths:
     @property
     def src_dir(self) -> Path:
         """Get the src directory."""
+        if hasattr(self, '_is_installed') and self._is_installed:
+            # In installed environment, there's no src directory
+            # Return the package directory itself
+            return self.project_root.parent
         return self.project_root / "src"
     
     @property
     def claude_mpm_dir(self) -> Path:
         """Get the main claude_mpm package directory."""
+        if hasattr(self, '_is_installed') and self._is_installed:
+            # In installed environment, project_root IS the claude_mpm directory
+            return self.project_root
         return self.src_dir / "claude_mpm"
     
     @property
     def agents_dir(self) -> Path:
         """Get the agents directory."""
+        if hasattr(self, '_is_installed') and self._is_installed:
+            # In installed environment, agents is directly under the package
+            return self.project_root / "agents"
         return self.claude_mpm_dir / "agents"
     
     @property
@@ -140,36 +168,58 @@ class ClaudeMPMPaths:
     @property
     def scripts_dir(self) -> Path:
         """Get the scripts directory."""
+        if hasattr(self, '_is_installed') and self._is_installed:
+            # In installed environment, scripts might be in a different location or not exist
+            # Return a path that won't cause issues but indicates it's not available
+            return Path.home() / '.claude-mpm' / 'scripts'
         return self.project_root / "scripts"
     
     @property
     def tests_dir(self) -> Path:
         """Get the tests directory."""
+        if hasattr(self, '_is_installed') and self._is_installed:
+            # Tests aren't distributed with installed packages
+            return Path.home() / '.claude-mpm' / 'tests'
         return self.project_root / "tests"
     
     @property
     def docs_dir(self) -> Path:
         """Get the documentation directory."""
+        if hasattr(self, '_is_installed') and self._is_installed:
+            # Docs might be installed separately or not at all
+            return Path.home() / '.claude-mpm' / 'docs'
         return self.project_root / "docs"
     
     @property
     def logs_dir(self) -> Path:
         """Get the logs directory (creates if doesn't exist)."""
-        logs = self.project_root / "logs"
-        logs.mkdir(exist_ok=True)
+        if hasattr(self, '_is_installed') and self._is_installed:
+            # Use user's home directory for logs in installed environment
+            logs = Path.home() / '.claude-mpm' / 'logs'
+        else:
+            logs = self.project_root / "logs"
+        logs.mkdir(parents=True, exist_ok=True)
         return logs
     
     @property
     def temp_dir(self) -> Path:
         """Get the temporary files directory (creates if doesn't exist)."""
-        temp = self.project_root / ".tmp"
-        temp.mkdir(exist_ok=True)
+        if hasattr(self, '_is_installed') and self._is_installed:
+            # Use user's home directory for temp files in installed environment
+            temp = Path.home() / '.claude-mpm' / '.tmp'
+        else:
+            temp = self.project_root / ".tmp"
+        temp.mkdir(parents=True, exist_ok=True)
         return temp
     
     @property
     def claude_mpm_dir_hidden(self) -> Path:
         """Get the hidden .claude-mpm directory (creates if doesn't exist)."""
-        hidden = self.project_root / ".claude-mpm"
+        if hasattr(self, '_is_installed') and self._is_installed:
+            # Use current working directory in installed environment
+            hidden = Path.cwd() / ".claude-mpm"
+        else:
+            hidden = self.project_root / ".claude-mpm"
         hidden.mkdir(exist_ok=True)
         return hidden
     

claude_mpm/constants.py

@@ -30,6 +30,7 @@ class CLICommands(str, Enum):
     MONITOR = "monitor"
     CONFIG = "config"
     AGGREGATE = "aggregate"
+    CLEANUP = "cleanup-memory"
     
     def with_prefix(self, prefix: CLIPrefix = CLIPrefix.MPM) -> str:
         """Get command with prefix."""

claude_mpm/core/claude_runner.py

@@ -1160,6 +1160,12 @@ Use these agents to delegate specialized work via the Task tool.
             version = __version__
             method_used = "package_import"
             self.logger.debug(f"Version obtained via package import: {version}")
+            # If version already includes build number (PEP 440 format), extract it
+            if '+build.' in version:
+                parts = version.split('+build.')
+                version = parts[0]  # Base version without build
+                build_number = int(parts[1]) if len(parts) > 1 else None
+                self.logger.debug(f"Extracted base version: {version}, build: {build_number}")
         except ImportError as e:
             self.logger.debug(f"Package import failed: {e}")
         except Exception as e:
@@ -1192,19 +1198,20 @@ Use these agents to delegate specialized work via the Task tool.
             except Exception as e:
                 self.logger.warning(f"Failed to read VERSION file: {e}")
         
-        # Try to read build number
-        try:
-            build_file = paths.project_root / "BUILDVERSION"
-            if build_file.exists():
-                build_content = build_file.read_text().strip()
-                build_number = int(build_content)
-                self.logger.debug(f"Build number obtained: {build_number}")
-        except (ValueError, IOError) as e:
-            self.logger.debug(f"Could not read BUILDVERSION: {e}")
-            build_number = None
-        except Exception as e:
-            self.logger.debug(f"Unexpected error reading BUILDVERSION: {e}")
-            build_number = None
+        # Try to read build number (only if not already obtained from version string)
+        if build_number is None:
+            try:
+                build_file = paths.project_root / "BUILD_NUMBER"
+                if build_file.exists():
+                    build_content = build_file.read_text().strip()
+                    build_number = int(build_content)
+                    self.logger.debug(f"Build number obtained from file: {build_number}")
+            except (ValueError, IOError) as e:
+                self.logger.debug(f"Could not read BUILD_NUMBER: {e}")
+                build_number = None
+            except Exception as e:
+                self.logger.debug(f"Unexpected error reading BUILD_NUMBER: {e}")
+                build_number = None
         
         # Log final result
         if version == "0.0.0":
@@ -1215,8 +1222,14 @@ Use these agents to delegate specialized work via the Task tool.
             self.logger.debug(f"Final version: {version} (method: {method_used})")
         
         # Format version with build number if available
+        # For development: Use PEP 440 format (e.g., "3.9.5+build.275")
+        # For UI/logging: Use dash format (e.g., "v3.9.5-build.275")
+        # For PyPI releases: Use clean version (e.g., "3.9.5")
+        
+        # Determine formatting context (default to UI format for claude_runner)
         if build_number is not None:
-            return f"v{version}-{build_number:05d}"
+            # UI/logging format with 'v' prefix and dash separator
+            return f"v{version}-build.{build_number}"
         else:
             return f"v{version}"
     

claude_mpm/core/config.py

@@ -281,6 +281,21 @@ class Config:
             # Task and issue tracking
             "enable_persistent_tracking": True,
             "fallback_tracking_method": "logging",  # Options: "logging", "file", "disabled"
+            # Memory management configuration
+            "memory_management": {
+                "enabled": True,
+                "claude_json_warning_threshold_kb": 500,  # Warn at 500KB
+                "claude_json_critical_threshold_kb": 1024,  # Critical at 1MB
+                "auto_archive_enabled": False,  # Don't auto-archive by default
+                "archive_retention_days": 90,  # Keep archives for 90 days
+                "session_retention_hours": 24,  # Keep active sessions for 24 hours
+                "conversation_retention_days": 30,  # Keep conversations for 30 days
+                "monitor_memory_usage": True,  # Monitor memory usage
+                "memory_usage_log_interval": 300,  # Log memory usage every 5 minutes
+                "max_memory_usage_mb": 2048,  # Warn if memory usage exceeds 2GB
+                "cleanup_on_startup": False,  # Don't auto-cleanup on startup
+                "compress_archives": True  # Compress archived files
+            },
             # Evaluation system - Phase 2 Mirascope integration
             "enable_evaluation": True,
             "evaluation_storage_path": str(ConfigPaths.get_user_config_dir() / "training"),

claude_mpm/core/session_manager.py

@@ -1,9 +1,11 @@
 """Session ID management for Claude subprocess optimization."""
 
 import uuid
-from typing import Optional, Dict, Any
+from typing import Optional, Dict, Any, List
 from datetime import datetime, timedelta
 import json
+import shutil
+import gzip
 from pathlib import Path
 
 from ..core.logger import get_logger
@@ -95,11 +97,15 @@ class SessionManager:
             self.active_sessions[session_id]["last_used"] = datetime.now().isoformat()
             self._save_sessions()
     
-    def cleanup_old_sessions(self, max_age_hours: int = 24):
+    def cleanup_old_sessions(self, max_age_hours: int = 24, archive: bool = True):
         """Remove sessions older than max_age_hours.
         
+        WHY: We archive old sessions instead of just deleting them to preserve
+        conversation history while reducing active memory usage.
+        
         Args:
             max_age_hours: Maximum age in hours
+            archive: Whether to archive sessions before removing
         """
         now = datetime.now()
         max_age = timedelta(hours=max_age_hours)
@@ -110,6 +116,10 @@ class SessionManager:
             if now - created > max_age:
                 expired.append(session_id)
         
+        # Archive sessions if requested
+        if archive and expired:
+            self._archive_sessions([self.active_sessions[sid] for sid in expired])
+        
         for session_id in expired:
             del self.active_sessions[session_id]
             logger.info(f"Cleaned up expired session: {session_id}")
@@ -180,11 +190,105 @@ class SessionManager:
                 with open(session_file, 'r') as f:
                     self.active_sessions = json.load(f)
                     
-                # Clean up old sessions on load
-                self.cleanup_old_sessions()
+                # Clean up old sessions on load (archive by default)
+                self.cleanup_old_sessions(archive=True)
+                
+                # Also check and clean .claude.json if needed
+                self._check_claude_json_size()
             except Exception as e:
                 logger.error(f"Failed to load sessions: {e}")
                 self.active_sessions = {}
+    
+    def _archive_sessions(self, sessions: List[Dict[str, Any]]):
+        """Archive sessions to compressed files.
+        
+        WHY: Archiving preserves conversation history while reducing the size
+        of active memory files like .claude.json.
+        
+        Args:
+            sessions: List of session data dictionaries to archive
+        """
+        if not sessions:
+            return
+        
+        archive_dir = self.session_dir.parent / "archives" / "sessions"
+        archive_dir.mkdir(parents=True, exist_ok=True)
+        
+        # Create timestamped archive file
+        timestamp = datetime.now().strftime("%Y%m%d_%H%M%S")
+        archive_name = f"sessions_archive_{timestamp}.json.gz"
+        archive_path = archive_dir / archive_name
+        
+        try:
+            # Compress and save sessions
+            with gzip.open(archive_path, 'wt', encoding='utf-8') as f:
+                json.dump(sessions, f, indent=2)
+            
+            logger.info(f"Archived {len(sessions)} sessions to {archive_path}")
+        except Exception as e:
+            logger.error(f"Failed to archive sessions: {e}")
+    
+    def _check_claude_json_size(self):
+        """Check .claude.json size and suggest cleanup if needed.
+        
+        WHY: Large .claude.json files cause memory issues. This provides
+        proactive monitoring and suggestions for cleanup.
+        """
+        claude_json_path = Path.home() / ".claude.json"
+        
+        if not claude_json_path.exists():
+            return
+        
+        file_size = claude_json_path.stat().st_size
+        warning_threshold = 500 * 1024  # 500KB
+        
+        if file_size > warning_threshold:
+            size_mb = file_size / (1024 * 1024)
+            logger.warning(f".claude.json is {size_mb:.1f}MB - consider running 'claude-mpm cleanup-memory'")
+    
+    def archive_claude_json(self, keep_days: int = 30) -> bool:
+        """Archive old conversations from .claude.json.
+        
+        WHY: This is called by the cleanup command to reduce memory usage
+        while preserving conversation history.
+        
+        Args:
+            keep_days: Number of days of history to keep
+            
+        Returns:
+            True if successful, False otherwise
+        """
+        claude_json_path = Path.home() / ".claude.json"
+        
+        if not claude_json_path.exists():
+            logger.info("No .claude.json file to archive")
+            return True
+        
+        try:
+            # Create backup first
+            archive_dir = Path.home() / ".claude-mpm" / "archives"
+            archive_dir.mkdir(parents=True, exist_ok=True)
+            
+            timestamp = datetime.now().strftime("%Y%m%d_%H%M%S")
+            backup_name = f"claude_json_backup_{timestamp}.json.gz"
+            backup_path = archive_dir / backup_name
+            
+            # Compress and backup current file
+            with open(claude_json_path, 'rb') as f_in:
+                with gzip.open(backup_path, 'wb') as f_out:
+                    shutil.copyfileobj(f_in, f_out)
+            
+            logger.info(f"Created backup at {backup_path}")
+            
+            # For now, we don't modify the original .claude.json
+            # as we don't know its exact structure.
+            # The cleanup command handles this.
+            
+            return True
+            
+        except Exception as e:
+            logger.error(f"Failed to archive .claude.json: {e}")
+            return False
 
 
 class OrchestrationSession: