claude-mpm 3.4.10__py3-none-any.whl → 5.4.85__py3-none-any.whl

claude_mpm/services/framework_claude_md_generator/__init__.py

@@ -1,3 +1,5 @@
+from pathlib import Path
+
 """
 Framework INSTRUCTIONS.md Generator Service
 
@@ -5,128 +7,129 @@ This service provides structured generation of the framework INSTRUCTIONS.md tem
 (legacy: CLAUDE.md) with auto-versioning, section management, and deployment capabilities.
 """
 
-from typing import Dict, Optional, Any, List, Tuple
-from pathlib import Path
+from typing import Any, Dict, List, Optional, Tuple
 
-from .version_manager import VersionManager
-from .content_validator import ContentValidator
 from .content_assembler import ContentAssembler
+from .content_validator import ContentValidator
 from .deployment_manager import DeploymentManager
-from .section_manager import SectionManager
 from .section_generators import section_registry
+from .section_manager import SectionManager
+from .version_manager import VersionManager
 
 
 class FrameworkClaudeMdGenerator:
     """
-    Generates and manages the framework INSTRUCTIONS.md template (legacy: CLAUDE.md) 
+    Generates and manages the framework INSTRUCTIONS.md template (legacy: CLAUDE.md)
     with structured sections, auto-versioning, and deployment capabilities.
-    
+
     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()
         self.assembler = ContentAssembler()
         self.section_manager = SectionManager()
-        
+
         # Initialize deployment manager with dependencies
         self.deployment_manager = DeploymentManager(
-            self.version_manager, 
-            self.validator
+            self.version_manager, self.validator, target_filename=target_filename
         )
-        
+
         # Get framework version
         self.framework_version = self.version_manager.framework_version
-        
+
         # Initialize sections
         self._initialize_sections()
-    
+
     def _initialize_sections(self):
         """Initialize all sections in the required order."""
         # Register all default sections with their generators
         section_order = [
-            'header',
-            'role_designation',
-            'agents',
-            'todo_task_tools',
-            'claude_pm_init',
-            'orchestration_principles',
-            'subprocess_validation',
-            'delegation_constraints',
-            'environment_config',
-            'troubleshooting',
-            'core_responsibilities',
-            'footer'
+            "header",
+            "role_designation",
+            "agents",
+            "todo_task_tools",
+            "claude_pm_init",
+            "orchestration_principles",
+            "subprocess_validation",
+            "delegation_constraints",
+            "environment_config",
+            "troubleshooting",
+            "core_responsibilities",
+            "footer",
         ]
-        
+
         for section_name in section_order:
             generator_class = section_registry.get(section_name)
             if generator_class:
                 generator_instance = generator_class(self.framework_version)
                 self.section_manager.register_section(
-                    section_name,
-                    generator_instance.generate
+                    section_name, generator_instance.generate
                 )
-    
-    def generate(self, 
-                current_content: Optional[str] = None,
-                template_variables: Optional[Dict[str, str]] = None) -> str:
+
+    def generate(
+        self,
+        current_content: Optional[str] = None,
+        template_variables: Optional[Dict[str, str]] = None,
+    ) -> str:
         """
         Generate the complete INSTRUCTIONS.md/CLAUDE.md content.
-        
+
         Args:
             current_content: Current INSTRUCTIONS.md/CLAUDE.md content for version parsing
             template_variables: Variables to substitute in the template
-            
+
         Returns:
             str: Complete INSTRUCTIONS.md/CLAUDE.md content
         """
         # Auto-increment version if current content provided
         version = self.version_manager.auto_increment_version(current_content)
-        
+
         # Create metadata for header
         metadata = self.assembler.create_metadata_dict(
-            version=version,
-            framework_version=self.framework_version
+            version=version, framework_version=self.framework_version
         )
-        
+
         # Update header section with metadata
         sections = self.section_manager.get_sections()
-        if 'header' in sections:
-            generator_func, _ = sections['header']
-            sections['header'] = (generator_func, metadata)
-        
+        if "header" in sections:
+            generator_func, _ = sections["header"]
+            sections["header"] = (generator_func, metadata)
+
         # Assemble content
-        content = self.assembler.assemble_content(
-            sections,
-            template_variables
-        )
-        
-        return content
-    
+        return self.assembler.assemble_content(sections, template_variables)
+
     def validate_content(self, content: str) -> Tuple[bool, List[str]]:
         """
         Validate that generated content has all required sections.
-        
+
         Args:
             content: Content to validate
-            
+
         Returns:
             Tuple of (is_valid, list_of_issues)
         """
         return self.validator.validate_content(content)
-    
-    def deploy_to_parent(self, parent_path: Path, force: bool = False) -> Tuple[bool, str]:
+
+    def deploy_to_parent(
+        self, parent_path: Path, force: bool = False
+    ) -> Tuple[bool, str]:
         """
         Deploy generated content to a parent directory.
-        
+
         Args:
             parent_path: Path to parent directory
             force: Force deployment even if versions match
-            
+
         Returns:
             Tuple of (success, message)
         """
@@ -136,71 +139,69 @@ class FrameworkClaudeMdGenerator:
         if not target_file.exists() and (parent_path / "CLAUDE.md").exists():
             target_file = parent_path / "CLAUDE.md"
         current_content = None
-        
+
         if target_file.exists():
-            with open(target_file, 'r') as f:
+            with target_file.open() as f:
                 current_content = f.read()
-        
+
         # Generate new content
         new_content = self.generate(current_content=current_content)
-        
+
         # Deploy using deployment manager
-        return self.deployment_manager.deploy_to_parent(
-            new_content,
-            parent_path,
-            force
-        )
-    
+        return self.deployment_manager.deploy_to_parent(new_content, parent_path, force)
+
     def get_section_list(self) -> List[str]:
         """
         Get list of all section names in order.
-        
+
         Returns:
             List of section names
         """
         return self.section_manager.get_section_list()
-    
+
     def update_section(self, section_name: str, content: str) -> bool:
         """
         Update a specific section's generator to return custom content.
-        
+
         Args:
             section_name: Name of section to update
             content: New content for the section
-            
+
         Returns:
             bool: Success status
         """
         return self.section_manager.update_section(section_name, content)
-    
-    def add_custom_section(self, section_name: str, content: str, after: Optional[str] = None):
+
+    def add_custom_section(
+        self, section_name: str, content: str, after: Optional[str] = None
+    ):
         """
         Add a custom section to the generator.
-        
+
         Args:
             section_name: Name for the new section
             content: Content for the section
             after: Section name to insert after (None = append at end)
         """
         self.section_manager.add_custom_section(section_name, content, after)
-    
+
     # Compatibility methods to match original API
     def _get_framework_version(self) -> str:
         """Get framework version (compatibility method)."""
         return self.version_manager._get_framework_version()
-    
+
     def _parse_current_version(self, content: str) -> Tuple[str, int]:
         """Parse current version (compatibility method)."""
         return self.version_manager.parse_current_version(content)
-    
+
     def _auto_increment_version(self, current_content: Optional[str] = None) -> str:
         """Auto-increment version (compatibility method)."""
         return self.version_manager.auto_increment_version(current_content)
-    
+
     def _generate_content_hash(self) -> str:
         """Generate content hash (compatibility method)."""
         return self.assembler.generate_content_hash()
 
 
 # Export the main class
-__all__ = ['FrameworkClaudeMdGenerator']
+__all__ = ["FrameworkClaudeMdGenerator"]

claude_mpm/services/framework_claude_md_generator/content_assembler.py

@@ -5,81 +5,81 @@ Assembles sections and applies template variable substitution.
 """
 
 import hashlib
-from datetime import datetime
-from typing import Dict, List, Optional, Any
 from collections import OrderedDict
-import logging
+from datetime import datetime, timezone
+from typing import Any, Dict, Optional
 
-from claude_mpm.services.deployed_agent_discovery import DeployedAgentDiscovery
-from claude_mpm.services.agent_capabilities_generator import AgentCapabilitiesGenerator
+from claude_mpm.core.logging_utils import get_logger
+from claude_mpm.services.agents.management import AgentCapabilitiesGenerator
+from claude_mpm.services.agents.registry import DeployedAgentDiscovery
 
-logger = logging.getLogger(__name__)
+logger = get_logger(__name__)
 
 
 class ContentAssembler:
     """Assembles framework CLAUDE.md content from sections."""
-    
+
     def __init__(self):
         """Initialize content assembler."""
         self.template_variables = {}
         self.agent_discovery = DeployedAgentDiscovery()
         self.capabilities_generator = AgentCapabilitiesGenerator()
-        logger.debug("Initialized ContentAssembler with dynamic agent capabilities support")
-    
+        logger.debug(
+            "Initialized ContentAssembler with dynamic agent capabilities support"
+        )
+
     def generate_content_hash(self) -> str:
         """
         Generate a content hash for integrity verification.
-        
+
         Returns:
             str: 16-character hash of content
         """
-        timestamp = datetime.utcnow().isoformat()
+        timestamp = datetime.now(timezone.utc).isoformat()
         hash_obj = hashlib.sha256(timestamp.encode())
         return hash_obj.hexdigest()[:16]
-    
-    def assemble_content(self, 
-                        sections: OrderedDict,
-                        template_variables: Optional[Dict[str, str]] = None) -> str:
+
+    def assemble_content(
+        self, sections: OrderedDict, template_variables: Optional[Dict[str, str]] = None
+    ) -> str:
         """
         Assemble complete content from sections.
-        
+
         Args:
             sections: OrderedDict of section_name -> (generator_func, section_data)
             template_variables: Variables to substitute in the template
-            
+
         Returns:
             str: Complete assembled content
         """
         # Store template variables
         if template_variables:
             self.template_variables = template_variables
-        
+
         # Generate all sections
         content_parts = []
-        for section_name, (generator_func, section_data) in sections.items():
+        for _section_name, (generator_func, section_data) in sections.items():
             section_content = generator_func(section_data)
             content_parts.append(section_content)
-        
+
         # Join all sections
-        full_content = '\n'.join(content_parts)
-        
+        full_content = "\n".join(content_parts)
+
         # Apply template variable substitution
-        full_content = self.apply_template_variables(full_content)
-        
-        return full_content
-    
+        return self.apply_template_variables(full_content)
+
     def apply_template_variables(self, content: str) -> str:
         """
         Apply template variable substitution to content.
-        
+
         WHY: Enhanced to support dynamic agent capabilities generation.
         - Generates fresh agent capabilities on each call
         - Provides graceful fallback if generation fails
         - Ensures INSTRUCTIONS.md always reflects current deployed agents
-        
+
         Args:
             content: Content with template variables
-            
+
         Returns:
             str: Content with variables substituted
         """
@@ -89,55 +89,63 @@ class ContentAssembler:
                 # Discover deployed agents
                 deployed_agents = self.agent_discovery.discover_deployed_agents()
                 # Generate capabilities content
-                capabilities_content = self.capabilities_generator.generate_capabilities_section(deployed_agents)
+                capabilities_content = (
+                    self.capabilities_generator.generate_capabilities_section(
+                        deployed_agents
+                    )
+                )
                 # Add to template variables
-                self.template_variables['capabilities-list'] = capabilities_content
-                logger.info(f"Generated dynamic capabilities for {len(deployed_agents)} agents")
+                self.template_variables["capabilities-list"] = capabilities_content
+                logger.info(
+                    f"Generated dynamic capabilities for {len(deployed_agents)} agents"
+                )
             except Exception as e:
                 logger.error(f"Failed to generate dynamic capabilities: {e}")
                 # Fallback is handled by the generator's internal fallback mechanism
-        
+
         # Apply all template variables
         for var_name, var_value in self.template_variables.items():
             placeholder = f"{{{{{var_name}}}}}"
             content = content.replace(placeholder, var_value)
-        
+
         return content
-    
-    def merge_sections(self, 
-                      base_sections: OrderedDict,
-                      custom_sections: Dict[str, tuple]) -> OrderedDict:
+
+    def merge_sections(
+        self, base_sections: OrderedDict, custom_sections: Dict[str, tuple]
+    ) -> OrderedDict:
         """
         Merge custom sections with base sections.
-        
+
         Args:
             base_sections: Base section definitions
             custom_sections: Custom sections to merge
-            
+
         Returns:
             OrderedDict: Merged sections
         """
         merged = OrderedDict(base_sections)
-        
+
         for section_name, section_def in custom_sections.items():
             merged[section_name] = section_def
-        
+
         return merged
-    
-    def insert_section_after(self,
-                           sections: OrderedDict,
-                           new_section_name: str,
-                           new_section_def: tuple,
-                           after_section: str) -> OrderedDict:
+
+    def insert_section_after(
+        self,
+        sections: OrderedDict,
+        new_section_name: str,
+        new_section_def: tuple,
+        after_section: str,
+    ) -> OrderedDict:
         """
         Insert a new section after a specified section.
-        
+
         Args:
             sections: Current sections
             new_section_name: Name of new section
             new_section_def: Definition tuple for new section
             after_section: Section to insert after
-            
+
         Returns:
             OrderedDict: Updated sections
         """
@@ -145,36 +153,35 @@ class ContentAssembler:
             # If target section doesn't exist, just append
             sections[new_section_name] = new_section_def
             return sections
-        
+
         new_sections = OrderedDict()
         for key, value in sections.items():
             new_sections[key] = value
             if key == after_section:
                 new_sections[new_section_name] = new_section_def
-        
+
         return new_sections
-    
-    def create_metadata_dict(self, 
-                           version: str,
-                           framework_version: str,
-                           content_hash: Optional[str] = None) -> Dict[str, Any]:
+
+    def create_metadata_dict(
+        self, version: str, framework_version: str, content_hash: Optional[str] = None
+    ) -> Dict[str, Any]:
         """
         Create metadata dictionary for header generation.
-        
+
         Args:
             version: CLAUDE_MD_VERSION string
             framework_version: Framework version
             content_hash: Optional content hash
-            
+
         Returns:
             Dict: Metadata for header
         """
-        timestamp = datetime.utcnow().isoformat()
-        
+        timestamp = datetime.now(timezone.utc).isoformat()
+
         return {
-            'version': version,
-            'framework_version': framework_version,
-            'deployment_date': timestamp,
-            'last_updated': timestamp,
-            'content_hash': content_hash or self.generate_content_hash()
-        }
+            "version": version,
+            "framework_version": framework_version,
+            "deployment_date": timestamp,
+            "last_updated": timestamp,
+            "content_hash": content_hash or self.generate_content_hash(),
+        }