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

claude_mpm/services/framework_claude_md_generator/content_validator.py

@@ -5,122 +5,126 @@ Validates generated content structure and completeness.
 """
 
 import re
-from typing import Tuple, List, Set
+from typing import List, Set, Tuple
 
 
 class ContentValidator:
     """Validates framework CLAUDE.md content for completeness and correctness."""
-    
+
     # Required sections that must be present
     REQUIRED_SECTIONS = [
-        (r'CLAUDE_MD_VERSION:', 'Version metadata'),
-        (r'## 🤖 AI ASSISTANT ROLE DESIGNATION', 'Role designation section'),
-        (r'## A\) AGENTS', 'Agents section'),
-        (r'## B\) TODO AND TASK TOOLS', 'Todo/Task tools section'),
-        (r'## C\) CLAUDE-PM INIT', 'Claude-PM init section'),
-        (r'## 🚨 CORE ORCHESTRATION PRINCIPLES', 'Orchestration principles'),
-        (r'## 🔥🚨 CRITICAL: SUBPROCESS VALIDATION PROTOCOL', 'Subprocess validation'),
-        (r'## 🚨 CRITICAL DELEGATION CONSTRAINTS', 'Delegation constraints'),
-        (r'## 🚨 TROUBLESHOOTING', 'Troubleshooting section'),
-        (r'## Core Responsibilities', 'Core responsibilities'),
+        (r"CLAUDE_MD_VERSION:", "Version metadata"),
+        (r"## 🤖 AI ASSISTANT ROLE DESIGNATION", "Role designation section"),
+        (r"## A\) AGENTS", "Agents section"),
+        (r"## B\) TODO AND TASK TOOLS", "Todo/Task tools section"),
+        (r"## C\) CLAUDE-PM INIT", "Claude-PM init section"),
+        (r"## 🚨 CORE ORCHESTRATION PRINCIPLES", "Orchestration principles"),
+        (r"## 🔥🚨 CRITICAL: SUBPROCESS VALIDATION PROTOCOL", "Subprocess validation"),
+        (r"## 🚨 CRITICAL DELEGATION CONSTRAINTS", "Delegation constraints"),
+        (r"## 🚨 TROUBLESHOOTING", "Troubleshooting section"),
+        (r"## Core Responsibilities", "Core responsibilities"),
     ]
-    
+
     # Template variables that are allowed to remain unsubstituted for runtime
     ALLOWED_RUNTIME_VARS = {
-        '{{DEPLOYMENT_ID}}',
-        '{{PLATFORM}}',
-        '{{PYTHON_CMD}}',
-        '{{PLATFORM_NOTES}}'
+        "{{DEPLOYMENT_ID}}",
+        "{{PLATFORM}}",
+        "{{PYTHON_CMD}}",
+        "{{PLATFORM_NOTES}}",
     }
-    
+
     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)
         """
         issues = []
-        
+
         # Check for required sections
         for pattern, section_name in self.REQUIRED_SECTIONS:
             if not re.search(pattern, content):
                 issues.append(f"Missing required section: {section_name}")
-        
+
         # Check for unsubstituted template variables
-        unsubstituted = re.findall(r'\{\{[^}]+\}\}', content)
-        unexpected_vars = [var for var in unsubstituted if var not in self.ALLOWED_RUNTIME_VARS]
+        unsubstituted = re.findall(r"\{\{[^}]+\}\}", content)
+        unexpected_vars = [
+            var for var in unsubstituted if var not in self.ALLOWED_RUNTIME_VARS
+        ]
         if unexpected_vars:
-            issues.append(f"Unsubstituted template variables: {', '.join(set(unexpected_vars))}")
-        
+            issues.append(
+                f"Unsubstituted template variables: {', '.join(set(unexpected_vars))}"
+            )
+
         # Validate version format - now accepts simple serial numbers
-        version_match = re.search(r'CLAUDE_MD_VERSION:\s*(\d+)(?:-(\d+))?', content)
+        version_match = re.search(r"CLAUDE_MD_VERSION:\s*(\d+)(?:-(\d+))?", content)
         if not version_match:
             issues.append("Invalid or missing CLAUDE_MD_VERSION format")
-        
+
         # Check for proper structure
         if not content.strip():
             issues.append("Content is empty")
-        
+
         # Validate agent section completeness
-        if '## A) AGENTS' in content:
+        if "## A) AGENTS" in content:
             required_agents = [
-                'Documentation Agent',
-                'Ticketing Agent',
-                'Version Control Agent',
-                'QA Agent',
-                'Research Agent',
-                'Ops Agent',
-                'Security Agent',
-                'Engineer Agent',
-                'Data Engineer Agent'
+                "Documentation Agent",
+                "Ticketing Agent",
+                "Version Control Agent",
+                "QA Agent",
+                "Research Agent",
+                "Ops Agent",
+                "Security Agent",
+                "Engineer Agent",
+                "Data Engineer Agent",
             ]
             for agent in required_agents:
                 if agent not in content:
                     issues.append(f"Missing core agent: {agent}")
-        
+
         return len(issues) == 0, issues
-    
+
     def validate_section_order(self, sections: List[str]) -> Tuple[bool, List[str]]:
         """
         Validate that sections are in the correct order.
-        
+
         Args:
             sections: List of section names in order
-            
+
         Returns:
             Tuple of (is_valid, list_of_issues)
         """
         expected_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",
         ]
-        
+
         issues = []
-        
+
         # Check that all expected sections are present
         missing = set(expected_order) - set(sections)
         if missing:
             issues.append(f"Missing sections: {', '.join(missing)}")
-        
+
         # Check order (only for sections that exist in both lists)
         common_sections = [s for s in sections if s in expected_order]
         expected_common = [s for s in expected_order if s in sections]
-        
+
         if common_sections != expected_common:
             issues.append("Sections are not in the expected order")
-        
-        return len(issues) == 0, issues
+
+        return len(issues) == 0, issues

claude_mpm/services/framework_claude_md_generator/deployment_manager.py

@@ -1,27 +1,32 @@
+from pathlib import Path
+
 """
 Deployment management for framework CLAUDE.md templates.
 
 Handles deployment operations to parent directories.
 """
 
-from pathlib import Path
-from typing import Tuple, Optional
 from datetime import datetime, timezone
-from .version_manager import VersionManager
-from .content_validator import ContentValidator
+from typing import Optional, Tuple
 
 # Import framework detection utilities
 from ...utils.framework_detection import is_framework_source_directory
+from .content_validator import ContentValidator
+from .version_manager import VersionManager
 
 
 class DeploymentManager:
     """Manages deployment of framework CLAUDE.md to parent directories."""
-    
-    def __init__(self, version_manager: VersionManager, validator: ContentValidator, 
-                 target_filename: str = "INSTRUCTIONS.md"):
+
+    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
@@ -31,49 +36,55 @@ class DeploymentManager:
         self.version_manager = version_manager
         self.validator = validator
         self.target_filename = target_filename
-    
-    def deploy_to_parent(self, 
-                        content: str,
-                        parent_path: Path, 
-                        force: bool = False) -> Tuple[bool, str]:
+
+    def deploy_to_parent(
+        self, content: str, parent_path: Path, force: bool = False
+    ) -> Tuple[bool, str]:
         """
         Deploy generated content to a parent directory.
-        
+
         WHY: Enhanced to ensure fresh agent capabilities generation on each deployment.
         - Checks for template variables that need processing
         - Re-processes content to get current deployed agents
         - Ensures INSTRUCTIONS.md always reflects latest agent configuration
-        
+
         Args:
             content: Content to deploy
             parent_path: Path to parent directory
             force: Force deployment even if versions match
-            
+
         Returns:
             Tuple of (success, message)
         """
         # Check if we're in the framework source directory
         is_framework, markers = is_framework_source_directory(parent_path)
         if is_framework:
-            return True, f"Skipping deployment - detected framework source directory (markers: {', '.join(markers)})"
-        
+            return (
+                True,
+                f"Skipping deployment - detected framework source directory (markers: {', '.join(markers)})",
+            )
+
         # 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:
+        if "{{capabilities-list}}" in content:
             # Content needs processing - let ContentAssembler handle it
             from .content_assembler import ContentAssembler
+
             assembler = ContentAssembler()
-            
+
             # Re-process content to get fresh agent data
             # Pass content as a single section to preserve structure
             processed_content = assembler.apply_template_variables(content)
             content = processed_content
-        
+
         # Validate content before deployment
         # Skip validation for INSTRUCTIONS.md format (different from CLAUDE.md)
-        if "<!-- FRAMEWORK_VERSION:" in content and "# Claude Multi-Agent Project Manager Instructions" in content:
+        if (
+            "<!-- FRAMEWORK_VERSION:" in content
+            and "# Claude Multi-Agent Project Manager Instructions" in content
+        ):
             # This is INSTRUCTIONS.md format, skip CLAUDE.md validation
             pass
         else:
@@ -81,82 +92,90 @@ class DeploymentManager:
             is_valid, issues = self.validator.validate_content(content)
             if not is_valid:
                 return False, f"Validation failed: {'; '.join(issues)}"
-        
+
         # Check if file exists and compare versions
         if target_file.exists() and not force:
-            with open(target_file, 'r') as f:
+            with open(target_file, "r") as f:
                 existing_content = f.read()
-                existing_fw_ver = self.version_manager.parse_current_version(existing_content)
-                
+                existing_fw_ver = self.version_manager.parse_current_version(
+                    existing_content
+                )
+
             if existing_fw_ver == self.version_manager.framework_version:
                 return True, f"Version {existing_fw_ver} already deployed"
-        
+
         # Deploy
         try:
             # Ensure parent directory exists
             parent_path.mkdir(parents=True, exist_ok=True)
-            
+
             # Write content
-            with open(target_file, 'w') as f:
+            with open(target_file, "w") as f:
                 f.write(content)
-            
+
             # Get version info for success message
             fw_ver = self.version_manager.parse_current_version(content)
             version_str = fw_ver
-            
+
             return True, f"Successfully deployed version {version_str}"
         except Exception as e:
             return False, f"Deployment failed: {str(e)}"
-    
+
     def check_deployment_needed(self, parent_path: Path) -> Tuple[bool, str]:
         """
         Check if deployment is needed for a parent directory.
-        
+
         Args:
             parent_path: Path to parent directory
-            
+
         Returns:
             Tuple of (needed, reason)
         """
         target_file = parent_path / self.target_filename
-        
+
         if not target_file.exists():
             return True, f"{self.target_filename} does not exist"
-        
+
         try:
-            with open(target_file, 'r') as f:
+            with open(target_file, "r") as f:
                 existing_content = f.read()
-                existing_fw_ver = self.version_manager.parse_current_version(existing_content)
-            
+                existing_fw_ver = self.version_manager.parse_current_version(
+                    existing_content
+                )
+
             if existing_fw_ver != self.version_manager.framework_version:
-                return True, f"Version mismatch: {existing_fw_ver} vs {self.version_manager.framework_version}"
-            
+                return (
+                    True,
+                    f"Version mismatch: {existing_fw_ver} vs {self.version_manager.framework_version}",
+                )
+
             return False, "Already up to date"
         except Exception as e:
             return True, f"Error checking existing file: {str(e)}"
-    
+
     def backup_existing(self, parent_path: Path) -> Optional[Path]:
         """
         Create a backup of existing target file before deployment.
-        
+
         Args:
             parent_path: Path to parent directory
-            
+
         Returns:
             Path to backup file if created, None otherwise
         """
         target_file = parent_path / self.target_filename
-        
+
         if not target_file.exists():
             return None
-        
+
         # Create backup filename with 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
+
             shutil.copy2(target_file, backup_file)
             return backup_file
         except Exception:
-            return None
+            return None

claude_mpm/services/framework_claude_md_generator/section_generators/__init__.py

@@ -4,36 +4,36 @@ Section generators for framework CLAUDE.md template.
 This module provides base classes and registry for section generators.
 """
 
-from typing import Dict, Any, Optional
 from abc import ABC, abstractmethod
 from datetime import datetime
+from typing import Any, Dict, Optional
 
 
 class BaseSectionGenerator(ABC):
     """Base class for all section generators."""
-    
+
     def __init__(self, framework_version: str):
         """
         Initialize section generator.
-        
+
         Args:
             framework_version: Current framework version
         """
         self.framework_version = framework_version
-    
+
     @abstractmethod
     def generate(self, data: Dict[str, Any]) -> str:
         """
         Generate section content.
-        
+
         Args:
             data: Section-specific data
-            
+
         Returns:
             str: Generated section content
         """
         pass
-    
+
     def get_timestamp(self) -> str:
         """Get current UTC timestamp."""
         return datetime.utcnow().isoformat()
@@ -41,33 +41,33 @@ class BaseSectionGenerator(ABC):
 
 class SectionGeneratorRegistry:
     """Registry for section generators."""
-    
+
     def __init__(self):
         """Initialize registry."""
         self._generators = {}
-    
+
     def register(self, name: str, generator_class: type):
         """
         Register a section generator.
-        
+
         Args:
             name: Section name
             generator_class: Generator class
         """
         self._generators[name] = generator_class
-    
+
     def get(self, name: str) -> Optional[type]:
         """
         Get a section generator class.
-        
+
         Args:
             name: Section name
-            
+
         Returns:
             Generator class or None
         """
         return self._generators.get(name)
-    
+
     def list_sections(self) -> list:
         """Get list of registered section names."""
         return list(self._generators.keys())
@@ -76,31 +76,31 @@ class SectionGeneratorRegistry:
 # Global registry instance
 section_registry = SectionGeneratorRegistry()
 
+from .agents import AgentsGenerator
+from .claude_pm_init import ClaudePmInitGenerator
+from .core_responsibilities import CoreResponsibilitiesGenerator
+from .delegation_constraints import DelegationConstraintsGenerator
+from .environment_config import EnvironmentConfigGenerator
+from .footer import FooterGenerator
 
 # Import and register all section generators
 from .header import HeaderGenerator
-from .role_designation import RoleDesignationGenerator
-from .agents import AgentsGenerator
-from .todo_task_tools import TodoTaskToolsGenerator
-from .claude_pm_init import ClaudePmInitGenerator
 from .orchestration_principles import OrchestrationPrinciplesGenerator
+from .role_designation import RoleDesignationGenerator
 from .subprocess_validation import SubprocessValidationGenerator
-from .delegation_constraints import DelegationConstraintsGenerator
-from .environment_config import EnvironmentConfigGenerator
+from .todo_task_tools import TodoTaskToolsGenerator
 from .troubleshooting import TroubleshootingGenerator
-from .core_responsibilities import CoreResponsibilitiesGenerator
-from .footer import FooterGenerator
 
 # Register all generators
-section_registry.register('header', HeaderGenerator)
-section_registry.register('role_designation', RoleDesignationGenerator)
-section_registry.register('agents', AgentsGenerator)
-section_registry.register('todo_task_tools', TodoTaskToolsGenerator)
-section_registry.register('claude_pm_init', ClaudePmInitGenerator)
-section_registry.register('orchestration_principles', OrchestrationPrinciplesGenerator)
-section_registry.register('subprocess_validation', SubprocessValidationGenerator)
-section_registry.register('delegation_constraints', DelegationConstraintsGenerator)
-section_registry.register('environment_config', EnvironmentConfigGenerator)
-section_registry.register('troubleshooting', TroubleshootingGenerator)
-section_registry.register('core_responsibilities', CoreResponsibilitiesGenerator)
-section_registry.register('footer', FooterGenerator)
+section_registry.register("header", HeaderGenerator)
+section_registry.register("role_designation", RoleDesignationGenerator)
+section_registry.register("agents", AgentsGenerator)
+section_registry.register("todo_task_tools", TodoTaskToolsGenerator)
+section_registry.register("claude_pm_init", ClaudePmInitGenerator)
+section_registry.register("orchestration_principles", OrchestrationPrinciplesGenerator)
+section_registry.register("subprocess_validation", SubprocessValidationGenerator)
+section_registry.register("delegation_constraints", DelegationConstraintsGenerator)
+section_registry.register("environment_config", EnvironmentConfigGenerator)
+section_registry.register("troubleshooting", TroubleshootingGenerator)
+section_registry.register("core_responsibilities", CoreResponsibilitiesGenerator)
+section_registry.register("footer", FooterGenerator)