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

claude_mpm/services/agents/deployment/agent_deployment.py

@@ -110,12 +110,13 @@ class AgentDeploymentService(AgentDeploymentInterface):
         }
         
         # Determine the actual working directory
-        # Priority: working_directory param > CLAUDE_MPM_USER_PWD env var > current directory
+        # For deployment, we need to track the working directory but NOT use it
+        # for determining where system agents go (they always go to ~/.claude/agents/)
+        # Priority: working_directory param > current directory
         if working_directory:
             self.working_directory = Path(working_directory)
-        elif 'CLAUDE_MPM_USER_PWD' in os.environ:
-            self.working_directory = Path(os.environ['CLAUDE_MPM_USER_PWD'])
         else:
+            # Use current directory but don't let CLAUDE_MPM_USER_PWD affect system agent deployment
             self.working_directory = Path.cwd()
         
         self.logger.info(f"Working directory for deployment: {self.working_directory}")
@@ -139,7 +140,7 @@ class AgentDeploymentService(AgentDeploymentInterface):
         self.logger.info(f"Templates directory: {self.templates_dir}")
         self.logger.info(f"Base agent path: {self.base_agent_path}")
         
-    def deploy_agents(self, target_dir: Optional[Path] = None, force_rebuild: bool = False, deployment_mode: str = "update", config: Optional[Config] = None, use_async: bool = True) -> Dict[str, Any]:
+    def deploy_agents(self, target_dir: Optional[Path] = None, force_rebuild: bool = False, deployment_mode: str = "update", config: Optional[Config] = None, use_async: bool = False) -> Dict[str, Any]:
         """
         Build and deploy agents by combining base_agent.md with templates.
         Also deploys system instructions for PM framework.
@@ -278,6 +279,9 @@ class AgentDeploymentService(AgentDeploymentInterface):
                     results=results
                 )
             
+            # Deploy system instructions and framework files
+            self._deploy_system_instructions(agents_dir, force_rebuild, results)
+            
             self.logger.info(
                 f"Deployed {len(results['deployed'])} agents, "
                 f"updated {len(results['updated'])}, "
@@ -1668,7 +1672,11 @@ temperature: {temperature}"""
 
     def _deploy_system_instructions(self, target_dir: Path, force_rebuild: bool, results: Dict[str, Any]) -> None:
         """
-        Deploy system instructions for PM framework.
+        Deploy system instructions and framework files for PM framework.
+        
+        Deploys INSTRUCTIONS.md, WORKFLOW.md, and MEMORY.md files following hierarchy:
+        - System/User versions → Deploy to ~/.claude/
+        - Project-specific versions → Deploy to <project>/.claude/
         
         Args:
             target_dir: Target directory for deployment
@@ -1676,47 +1684,64 @@ temperature: {temperature}"""
             results: Results dictionary to update
         """
         try:
-            # Find the INSTRUCTIONS.md file
-            module_path = Path(__file__).parent.parent
-            instructions_path = module_path / "agents" / "INSTRUCTIONS.md"
-            
-            if not instructions_path.exists():
-                self.logger.warning(f"System instructions not found: {instructions_path}")
-                return
-            
-            # Target file for system instructions - use CLAUDE.md in user's home .claude directory
-            target_file = Path("~/.claude/CLAUDE.md").expanduser()
+            # Determine target location based on deployment type
+            if self._is_project_specific_deployment():
+                # Project-specific files go to project's .claude directory
+                claude_dir = self.working_directory / ".claude"
+            else:
+                # System and user files go to home ~/.claude directory
+                claude_dir = Path.home() / ".claude"
             
             # Ensure .claude directory exists
-            target_file.parent.mkdir(exist_ok=True)
+            claude_dir.mkdir(parents=True, exist_ok=True)
             
-            # Check if update needed
-            if not force_rebuild and target_file.exists():
-                # Compare modification times
-                if target_file.stat().st_mtime >= instructions_path.stat().st_mtime:
-                    results["skipped"].append("CLAUDE.md")
-                    self.logger.debug("System instructions up to date")
-                    return
+            # Framework files to deploy
+            framework_files = [
+                ("INSTRUCTIONS.md", "CLAUDE.md"),  # INSTRUCTIONS.md deploys as CLAUDE.md
+                ("WORKFLOW.md", "WORKFLOW.md"),
+                ("MEMORY.md", "MEMORY.md")
+            ]
             
-            # Read and deploy system instructions
-            instructions_content = instructions_path.read_text()
-            target_file.write_text(instructions_content)
+            # Find the agents directory with framework files
+            # Use centralized paths for consistency
+            from claude_mpm.config.paths import paths
+            agents_path = paths.agents_dir
             
-            is_update = target_file.exists()
-            if is_update:
-                results["updated"].append({
-                    "name": "CLAUDE.md", 
-                    "template": str(instructions_path),
-                    "target": str(target_file)
-                })
-                self.logger.info("Updated system instructions")
-            else:
-                results["deployed"].append({
-                    "name": "CLAUDE.md",
-                    "template": str(instructions_path), 
+            for source_name, target_name in framework_files:
+                source_path = agents_path / source_name
+                
+                if not source_path.exists():
+                    self.logger.warning(f"Framework file not found: {source_path}")
+                    continue
+                
+                target_file = claude_dir / target_name
+                
+                # Check if update needed
+                if not force_rebuild and target_file.exists():
+                    # Compare modification times
+                    if target_file.stat().st_mtime >= source_path.stat().st_mtime:
+                        results["skipped"].append(target_name)
+                        self.logger.debug(f"Framework file {target_name} up to date")
+                        continue
+                
+                # Read and deploy framework file
+                file_content = source_path.read_text()
+                target_file.write_text(file_content)
+                
+                # Track deployment
+                file_existed = target_file.exists()
+                deployment_info = {
+                    "name": target_name,
+                    "template": str(source_path),
                     "target": str(target_file)
-                })
-                self.logger.info("Deployed system instructions")
+                }
+                
+                if file_existed:
+                    results["updated"].append(deployment_info)
+                    self.logger.info(f"Updated framework file: {target_name}")
+                else:
+                    results["deployed"].append(deployment_info)
+                    self.logger.info(f"Deployed framework file: {target_name}")
                 
         except Exception as e:
             error_msg = f"Failed to deploy system instructions: {e}"
@@ -2026,6 +2051,11 @@ metadata:
         WHY: Different deployment scenarios require different directory
         structures. This method centralizes the logic for consistency.
         
+        HIERARCHY:
+        - System agents → Deploy to ~/.claude/agents/ (user's home directory)
+        - User custom agents from ~/.claude-mpm/agents/ → Deploy to ~/.claude/agents/
+        - Project-specific agents from <project>/.claude-mpm/agents/ → Deploy to <project>/.claude/agents/
+        
         Args:
             target_dir: Optional target directory
             
@@ -2033,9 +2063,17 @@ metadata:
             Path to agents directory
         """
         if not target_dir:
-            # Default to working directory's .claude/agents directory (not home)
-            # This ensures we deploy to the user's project directory
-            return self.working_directory / ".claude" / "agents"
+            # Default deployment location depends on agent source
+            # Check if we're deploying system agents or user/project agents
+            if self._is_system_agent_deployment():
+                # System agents go to user's home ~/.claude/agents/
+                return Path.home() / ".claude" / "agents"
+            elif self._is_project_specific_deployment():
+                # Project agents stay in project directory
+                return self.working_directory / ".claude" / "agents"
+            else:
+                # Default: User custom agents go to home ~/.claude/agents/
+                return Path.home() / ".claude" / "agents"
         
         # If target_dir provided, use it directly (caller decides structure)
         target_dir = Path(target_dir)
@@ -2054,6 +2092,69 @@ metadata:
             # Assume it's a project directory, add .claude/agents
             return target_dir / ".claude" / "agents"
     
+    def _is_system_agent_deployment(self) -> bool:
+        """
+        Check if this is a deployment of system agents.
+        
+        System agents are those provided by the claude-mpm package itself,
+        located in the package's agents/templates directory.
+        
+        Returns:
+            True if deploying system agents, False otherwise
+        """
+        # Check if templates_dir points to the system templates
+        if self.templates_dir and self.templates_dir.exists():
+            # System agents are in the package's agents/templates directory
+            try:
+                # Check if templates_dir is within the claude_mpm package structure
+                templates_str = str(self.templates_dir.resolve())
+                return ("site-packages/claude_mpm" in templates_str or 
+                        "src/claude_mpm/agents/templates" in templates_str or
+                        (paths.agents_dir / "templates").resolve() == self.templates_dir.resolve())
+            except Exception:
+                pass
+        return False
+    
+    def _is_project_specific_deployment(self) -> bool:
+        """
+        Check if deploying project-specific agents.
+        
+        Project-specific agents are those found in the project's
+        .claude-mpm/agents/ directory.
+        
+        Returns:
+            True if deploying project-specific agents, False otherwise
+        """
+        # Check if we're in a project directory with .claude-mpm/agents
+        project_agents_dir = self.working_directory / ".claude-mpm" / "agents"
+        if project_agents_dir.exists():
+            # Check if templates_dir points to project agents
+            if self.templates_dir and self.templates_dir.exists():
+                try:
+                    return project_agents_dir.resolve() == self.templates_dir.resolve()
+                except Exception:
+                    pass
+        return False
+    
+    def _is_user_custom_deployment(self) -> bool:
+        """
+        Check if deploying user custom agents.
+        
+        User custom agents are those in ~/.claude-mpm/agents/
+        
+        Returns:
+            True if deploying user custom agents, False otherwise
+        """
+        user_agents_dir = Path.home() / ".claude-mpm" / "agents"
+        if user_agents_dir.exists():
+            # Check if templates_dir points to user agents
+            if self.templates_dir and self.templates_dir.exists():
+                try:
+                    return user_agents_dir.resolve() == self.templates_dir.resolve()
+                except Exception:
+                    pass
+        return False
+
     def _initialize_deployment_results(self, agents_dir: Path, deployment_start_time: float) -> Dict[str, Any]:
         """
         Initialize the deployment results dictionary.

claude_mpm/services/agents/memory/agent_memory_manager.py

@@ -44,13 +44,14 @@ class AgentMemoryManager(MemoryServiceInterface):
     to keep them organized and separate from other project files. Files follow a
     standardized markdown format with enforced size limits to prevent unbounded growth.
     
-    The 8KB limit (~2000 tokens) balances comprehensive knowledge storage with
+    The 80KB limit (~20k tokens) balances comprehensive knowledge storage with
     reasonable context size for agent prompts.
     """
     
     # Default limits - will be overridden by configuration
+    # Updated to support 20k tokens (~80KB) for enhanced memory capacity
     DEFAULT_MEMORY_LIMITS = {
-        'max_file_size_kb': 8,
+        'max_file_size_kb': 80,  # Increased from 8KB to 80KB (20k tokens)
         'max_sections': 10,
         'max_items_per_section': 15,
         'max_line_length': 120
@@ -1365,7 +1366,7 @@ Feel free to edit these files to:
 - Add domain-specific knowledge
 
 ## Memory Limits
-- Max file size: 8KB (~2000 tokens)
+- Max file size: 80KB (~20k tokens)
 - Max sections: 10
 - Max items per section: 15
 - Files auto-truncate when limits exceeded

claude_mpm/services/framework_claude_md_generator/__init__.py

@@ -24,8 +24,14 @@ class FrameworkClaudeMdGenerator:
     This is the main facade class that coordinates all the submodules.
     """
     
-    def __init__(self):
-        """Initialize the generator with current framework version."""
+    def __init__(self, target_filename: str = "INSTRUCTIONS.md"):
+        """
+        Initialize the generator with current framework version.
+        
+        Args:
+            target_filename: Target filename for deployment (default: "INSTRUCTIONS.md")
+                           Can be set to "CLAUDE.md" for legacy compatibility
+        """
         # Initialize managers
         self.version_manager = VersionManager()
         self.validator = ContentValidator()
@@ -35,7 +41,8 @@ class FrameworkClaudeMdGenerator:
         # Initialize deployment manager with dependencies
         self.deployment_manager = DeploymentManager(
             self.version_manager, 
-            self.validator
+            self.validator,
+            target_filename=target_filename
         )
         
         # Get framework version

claude_mpm/services/framework_claude_md_generator/deployment_manager.py

@@ -6,7 +6,7 @@ Handles deployment operations to parent directories.
 
 from pathlib import Path
 from typing import Tuple, Optional
-from datetime import datetime
+from datetime import datetime, timezone
 from .version_manager import VersionManager
 from .content_validator import ContentValidator
 
@@ -17,16 +17,20 @@ from ...utils.framework_detection import is_framework_source_directory
 class DeploymentManager:
     """Manages deployment of framework CLAUDE.md to parent directories."""
     
-    def __init__(self, version_manager: VersionManager, validator: ContentValidator):
+    def __init__(self, version_manager: VersionManager, validator: ContentValidator, 
+                 target_filename: str = "INSTRUCTIONS.md"):
         """
         Initialize deployment manager.
         
         Args:
             version_manager: Version management instance
             validator: Content validator instance
+            target_filename: Target filename for deployment (default: "INSTRUCTIONS.md")
+                           Can be set to "CLAUDE.md" for legacy compatibility
         """
         self.version_manager = version_manager
         self.validator = validator
+        self.target_filename = target_filename
     
     def deploy_to_parent(self, 
                         content: str,
@@ -53,9 +57,8 @@ class DeploymentManager:
         if is_framework:
             return True, f"Skipping deployment - detected framework source directory (markers: {', '.join(markers)})"
         
-        # Use INSTRUCTIONS.md as primary, with CLAUDE.md as fallback
-        target_file = parent_path / "INSTRUCTIONS.md"
-        # TODO: Make this configurable via parameter
+        # Use configured target filename
+        target_file = parent_path / self.target_filename
         
         # Check if content contains template variables that need processing
         if '{{capabilities-list}}' in content:
@@ -115,10 +118,10 @@ class DeploymentManager:
         Returns:
             Tuple of (needed, reason)
         """
-        target_file = parent_path / "CLAUDE.md"
+        target_file = parent_path / self.target_filename
         
         if not target_file.exists():
-            return True, "CLAUDE.md does not exist"
+            return True, f"{self.target_filename} does not exist"
         
         try:
             with open(target_file, 'r') as f:
@@ -134,7 +137,7 @@ class DeploymentManager:
     
     def backup_existing(self, parent_path: Path) -> Optional[Path]:
         """
-        Create a backup of existing CLAUDE.md before deployment.
+        Create a backup of existing target file before deployment.
         
         Args:
             parent_path: Path to parent directory
@@ -142,14 +145,14 @@ class DeploymentManager:
         Returns:
             Path to backup file if created, None otherwise
         """
-        target_file = parent_path / "CLAUDE.md"
+        target_file = parent_path / self.target_filename
         
         if not target_file.exists():
             return None
         
         # Create backup filename with timestamp
-        timestamp = datetime.utcnow().strftime("%Y%m%d_%H%M%S")
-        backup_file = parent_path / f"CLAUDE.md.backup.{timestamp}"
+        timestamp = datetime.now(timezone.utc).strftime("%Y%m%d_%H%M%S")
+        backup_file = parent_path / f"{self.target_filename}.backup.{timestamp}"
         
         try:
             import shutil

claude_mpm/services/response_tracker.py

@@ -71,11 +71,9 @@ class ResponseTracker:
                 if not base_dir:
                     base_dir = response_logging_config.get('session_directory', '.claude-mpm/responses')
                 
-                # Create session logger with proper configuration
-                self.session_logger = ClaudeSessionLogger(
-                    base_dir=Path(base_dir),
-                    config=config
-                )
+                # Use singleton session logger for proper sharing
+                from claude_mpm.services.claude_session_logger import get_session_logger
+                self.session_logger = get_session_logger(config)
                 logger.info(f"Response tracker initialized with base directory: {base_dir}")
             except Exception as e:
                 logger.error(f"Failed to initialize session logger: {e}")

claude_mpm/services/ticket_manager.py

@@ -49,7 +49,7 @@ class TicketManager(TicketManagerInterface):
             # Check if config exists, create if needed
             if not config_file.exists():
                 try:
-                    config = Config.create_default(str(config_file))
+                    config = Config.create_default(config_file)  # Pass Path object directly
                     config.set("paths.tickets_dir", "tickets")
                     config.set("paths.epics_dir", "tickets/epics")
                     config.set("paths.issues_dir", "tickets/issues")
@@ -64,7 +64,7 @@ class TicketManager(TicketManagerInterface):
             
             # Initialize TaskManager directly with the project path
             # TaskManager will handle project initialization internally
-            task_manager = TaskManager(str(self.project_path))
+            task_manager = TaskManager(self.project_path)  # Pass Path object directly
             
             # Verify it's using the right directory
             if hasattr(task_manager, 'tasks_dir'):

claude_mpm/services/ticket_manager_di.py

@@ -56,7 +56,7 @@ class AITrackdownAdapter(ITaskManagerAdapter):
             # Configure ai-trackdown if needed
             config_file = self.project_path / ".trackdown.yaml"
             if not config_file.exists():
-                config = TrackdownConfig.create_default(config_file)
+                config = TrackdownConfig.create_default(config_file)  # Already correct - using Path object
                 config.set("paths.tickets_dir", "tickets")
                 config.set("paths.epics_dir", "tickets/epics")
                 config.set("paths.issues_dir", "tickets/issues")

claude_mpm/services/version_control/semantic_versioning.py

@@ -334,11 +334,42 @@ class SemanticVersionManager:
 
     def get_current_version(self) -> Optional[SemanticVersion]:
         """
-        Get the current version from project files.
+        Get the current version from multiple sources with intelligent fallback.
+        
+        Uses the enhanced version parser to check:
+        1. Git tags (most recent)
+        2. VERSION file
+        3. package.json
+        4. pyproject.toml
+        5. Other configured version files
 
         Returns:
             Current SemanticVersion or None if not found
         """
+        try:
+            # Import here to avoid circular dependency
+            from claude_mpm.services.version_control.version_parser import get_version_parser
+            
+            # Use enhanced parser for current version
+            parser = get_version_parser(self.project_root)
+            version_meta = parser.get_current_version()
+            
+            if version_meta:
+                version = self.parse_version(version_meta.version)
+                if version:
+                    self.logger.info(f"Found version {version} from {version_meta.source}")
+                    # Optionally attach metadata
+                    if hasattr(version, '__dict__'):
+                        version.source = version_meta.source
+                    return version
+                
+        except ImportError:
+            # Fallback to original implementation
+            self.logger.debug("Enhanced version parser not available, using fallback")
+        except Exception as e:
+            self.logger.error(f"Error getting current version with enhanced parser: {e}")
+        
+        # Fallback to original implementation
         for filename, parser in self.version_files.items():
             file_path = self.project_root / filename
 
@@ -811,19 +842,61 @@ class SemanticVersionManager:
 
     def get_version_history(self) -> List[SemanticVersion]:
         """
-        Get version history from changelog or Git tags.
+        Get version history from multiple sources with intelligent fallback.
+        
+        Uses the enhanced version parser to retrieve version history from:
+        1. Git tags (primary source)
+        2. CHANGELOG.md (fallback)
+        3. VERSION files (current version only)
 
         Returns:
             List of versions in descending order
         """
+        try:
+            # Import here to avoid circular dependency
+            from claude_mpm.services.version_control.version_parser import get_version_parser
+            
+            # Use enhanced parser for comprehensive version history
+            parser = get_version_parser(self.project_root)
+            version_metadata = parser.get_version_history(include_prereleases=False)
+            
+            # Convert to SemanticVersion objects
+            versions = []
+            for meta in version_metadata:
+                version = self.parse_version(meta.version)
+                if version:
+                    # Optionally attach metadata to version
+                    if hasattr(version, '__dict__'):
+                        version.source = meta.source
+                        version.release_date = meta.release_date
+                        version.commit_hash = meta.commit_hash
+                    versions.append(version)
+            
+            return versions
+            
+        except ImportError:
+            # Fallback to original implementation if enhanced parser not available
+            self.logger.warning("Enhanced version parser not available, falling back to changelog parsing")
+            return self._parse_changelog_versions_fallback()
+        except Exception as e:
+            self.logger.error(f"Error getting version history: {e}")
+            # Fallback to original implementation
+            return self._parse_changelog_versions_fallback()
+
+    def _parse_changelog_versions_fallback(self) -> List[SemanticVersion]:
+        """Fallback method: Parse versions from changelog file only."""
         versions = []
 
         # Try to get versions from changelog
-        changelog_path = self.project_root / "docs" / "CHANGELOG.md"
-        if changelog_path.exists():
-            versions.extend(self._parse_changelog_versions(changelog_path))
-
-        # TODO: Add Git tag parsing if needed
+        changelog_paths = [
+            self.project_root / "CHANGELOG.md",
+            self.project_root / "docs" / "CHANGELOG.md"
+        ]
+        
+        for changelog_path in changelog_paths:
+            if changelog_path.exists():
+                versions.extend(self._parse_changelog_versions(changelog_path))
+                break
 
         # Sort versions in descending order
         versions.sort(reverse=True)