claude-mpm 4.14.6__tar.gz → 4.14.8__tar.gz

claude_mpm-4.14.8/BUILD_NUMBER

@@ -0,0 +1 @@
+469

{claude_mpm-4.14.6 → claude_mpm-4.14.8}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: claude-mpm
-Version: 4.14.6
+Version: 4.14.8
 Summary: Claude Multi-Agent Project Manager - Orchestrate Claude with agent delegation and ticket tracking
 Author-email: Bob Matsuoka <bob@matsuoka.com>
 Maintainer: Claude MPM Team

claude_mpm-4.14.8/VERSION

@@ -0,0 +1 @@
+4.14.8

{claude_mpm-4.14.6 → claude_mpm-4.14.8}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "claude-mpm"
-version = "4.14.6"
+version = "4.14.8"
 description = "Claude Multi-Agent Project Manager - Orchestrate Claude with agent delegation and ticket tracking"
 readme = "README.md"
 requires-python = ">=3.8"
@@ -84,7 +84,7 @@ ignore-imports = false
 
 [tool.commitizen]
 name = "cz_conventional_commits"
-version = "4.14.6"
+version = "4.14.8"
 version_files = [ "VERSION", "src/claude_mpm/VERSION", "package.json:version",]
 tag_format = "v$version"
 update_changelog_on_bump = true

claude_mpm-4.14.8/src/claude_mpm/VERSION

@@ -0,0 +1 @@
+4.14.8

{claude_mpm-4.14.6 → claude_mpm-4.14.8}/src/claude_mpm/agents/frontmatter_validator.py

@@ -23,6 +23,7 @@ from typing import Any, Dict, List, Optional, Tuple
 
 import yaml
 
+from claude_mpm.core.enums import ModelTier
 from claude_mpm.core.logging_utils import get_logger
 
 logger = get_logger(__name__)
@@ -54,33 +55,8 @@ class FrontmatterValidator:
     - Logging of all corrections made
     """
 
-    # Model name mappings for normalization
-    MODEL_MAPPINGS = {
-        # Sonnet variations
-        "claude-3-5-sonnet-20241022": "sonnet",
-        "claude-3-5-sonnet-20240620": "sonnet",
-        "claude-sonnet-4-20250514": "sonnet",
-        "claude-4-sonnet-20250514": "sonnet",
-        "claude-3-sonnet-20240229": "sonnet",
-        "20241022": "sonnet",  # Common shorthand - maps to current Sonnet
-        "20240620": "sonnet",  # Previous Sonnet version
-        "3.5-sonnet": "sonnet",
-        "sonnet-3.5": "sonnet",
-        "sonnet-4": "sonnet",
-        # Opus variations
-        "claude-3-opus-20240229": "opus",
-        "claude-opus-4-20250514": "opus",
-        "claude-4-opus-20250514": "opus",
-        "3-opus": "opus",
-        "opus-3": "opus",
-        "opus-4": "opus",
-        # Haiku variations
-        "claude-3-haiku-20240307": "haiku",
-        "claude-3-5-haiku-20241022": "haiku",
-        "3-haiku": "haiku",
-        "haiku-3": "haiku",
-        "haiku-3.5": "haiku",
-    }
+    # NOTE: Model normalization now handled by ModelTier.normalize()
+    # This enum-based approach replaced 26 lines of manual mappings
 
     # Tool name corrections (case normalization)
     TOOL_CORRECTIONS = {
@@ -179,13 +155,44 @@ class FrontmatterValidator:
         Returns:
             ValidationResult with validation status and corrected frontmatter
         """
-        errors = []
-        warnings = []
-        corrections = []
+        errors: List[str] = []
+        warnings: List[str] = []
+        corrections: List[str] = []
         corrected = frontmatter.copy()
-        field_corrections = {}  # Track only the fields that actually need correction
+        field_corrections: Dict[str, Any] = {}
+
+        # Check required fields
+        self._validate_required_fields(corrected, errors)
+
+        # Validate and correct individual fields
+        self._validate_name_field(corrected, field_corrections, errors, corrections)
+        self._validate_model_field(corrected, field_corrections, errors, corrections)
+        self._validate_tools_field(corrected, field_corrections, warnings, corrections)
+        self._validate_version_fields(corrected, field_corrections, errors, corrections)
+        self._validate_description_field(corrected, errors, warnings)
+        self._validate_category_field(corrected, warnings)
+        self._validate_resource_tier_field(corrected, warnings)
+        self._validate_color_field(corrected, errors)
+        self._validate_author_field(corrected, errors, warnings)
+        self._validate_tags_field(corrected, errors, warnings)
+        self._validate_numeric_fields(corrected, errors, warnings)
+
+        # Determine if valid
+        is_valid = len(errors) == 0
+
+        return ValidationResult(
+            is_valid=is_valid,
+            errors=errors,
+            warnings=warnings,
+            corrections=corrections,
+            corrected_frontmatter=corrected if corrections else None,
+            field_corrections=field_corrections if field_corrections else None,
+        )
 
-        # Required fields check (from schema)
+    def _validate_required_fields(
+        self, corrected: Dict[str, Any], errors: List[str]
+    ) -> None:
+        """Check that all required fields are present."""
         required_fields = (
             self.schema.get("required", ["name", "description", "version", "model"])
             if self.schema
@@ -195,227 +202,271 @@ class FrontmatterValidator:
             if field not in corrected:
                 errors.append(f"Missing required field: {field}")
 
-        # Validate and correct name field
-        if "name" in corrected:
-            name = corrected["name"]
-            if not isinstance(name, str):
-                errors.append(
-                    f"Field 'name' must be a string, got {type(name).__name__}"
-                )
-            elif not re.match(r"^[a-z][a-z0-9_]*$", name):
-                # Try to fix the name
-                fixed_name = name.lower().replace("-", "_").replace(" ", "_")
-                fixed_name = re.sub(r"[^a-z0-9_]", "", fixed_name)
-                if fixed_name and fixed_name[0].isalpha():
-                    corrected["name"] = fixed_name
-                    field_corrections["name"] = fixed_name
-                    corrections.append(
-                        f"Corrected name from '{name}' to '{fixed_name}'"
-                    )
-                else:
-                    errors.append(f"Invalid name format: {name}")
-
-        # Validate and correct model field
-        if "model" in corrected:
-            model = corrected["model"]
-
-            # Convert to string if it's a number (YAML might parse dates as integers)
-            if isinstance(model, (int, float)):
-                model = str(model)
-                corrected["model"] = model
-                field_corrections["model"] = model
-                corrections.append(f"Converted model from number to string: {model}")
-
-            if not isinstance(model, str):
-                errors.append(
-                    f"Field 'model' must be a string, got {type(model).__name__}"
-                )
+    def _validate_name_field(
+        self,
+        corrected: Dict[str, Any],
+        field_corrections: Dict[str, Any],
+        errors: List[str],
+        corrections: List[str],
+    ) -> None:
+        """Validate and correct the name field."""
+        if "name" not in corrected:
+            return
+
+        name = corrected["name"]
+        if not isinstance(name, str):
+            errors.append(f"Field 'name' must be a string, got {type(name).__name__}")
+            return
+
+        if not re.match(r"^[a-z][a-z0-9_]*$", name):
+            # Try to fix the name
+            fixed_name = name.lower().replace("-", "_").replace(" ", "_")
+            fixed_name = re.sub(r"[^a-z0-9_]", "", fixed_name)
+            if fixed_name and fixed_name[0].isalpha():
+                corrected["name"] = fixed_name
+                field_corrections["name"] = fixed_name
+                corrections.append(f"Corrected name from '{name}' to '{fixed_name}'")
             else:
-                normalized_model = self._normalize_model(model)
-                if normalized_model != model:
-                    corrected["model"] = normalized_model
-                    field_corrections["model"] = normalized_model
-                    corrections.append(
-                        f"Normalized model from '{model}' to '{normalized_model}'"
-                    )
-
-                if normalized_model not in self.VALID_MODELS:
-                    errors.append(
-                        f"Invalid model: {model} (normalized to {normalized_model})"
-                    )
-
-        # Validate and correct tools field
-        if "tools" in corrected:
-            tools = corrected["tools"]
-            corrected_tools, tool_corrections = self._correct_tools(tools)
-            if tool_corrections:
-                corrected["tools"] = corrected_tools
-                field_corrections["tools"] = corrected_tools
-                corrections.extend(tool_corrections)
-
-            # Validate tool names
-            invalid_tools = []
-            for tool in corrected_tools:
-                if tool not in self.VALID_TOOLS:
-                    # Try to correct the tool name
-                    corrected_tool = self.TOOL_CORRECTIONS.get(tool.lower())
-                    if corrected_tool:
-                        idx = corrected_tools.index(tool)
-                        corrected_tools[idx] = corrected_tool
-                        corrected["tools"] = corrected_tools
-                        field_corrections["tools"] = corrected_tools
-                        corrections.append(
-                            f"Corrected tool '{tool}' to '{corrected_tool}'"
-                        )
-                    else:
-                        invalid_tools.append(tool)
-
-            if invalid_tools:
-                warnings.append(f"Unknown tools: {', '.join(invalid_tools)}")
+                errors.append(f"Invalid name format: {name}")
+
+    def _validate_model_field(
+        self,
+        corrected: Dict[str, Any],
+        field_corrections: Dict[str, Any],
+        errors: List[str],
+        corrections: List[str],
+    ) -> None:
+        """Validate and correct the model field."""
+        if "model" not in corrected:
+            return
+
+        model = corrected["model"]
+
+        # Convert to string if it's a number (YAML might parse dates as integers)
+        if isinstance(model, (int, float)):
+            model = str(model)
+            corrected["model"] = model
+            field_corrections["model"] = model
+            corrections.append(f"Converted model from number to string: {model}")
+
+        if not isinstance(model, str):
+            errors.append(f"Field 'model' must be a string, got {type(model).__name__}")
+            return
+
+        normalized_model = self._normalize_model(model)
+        if normalized_model != model:
+            corrected["model"] = normalized_model
+            field_corrections["model"] = normalized_model
+            corrections.append(
+                f"Normalized model from '{model}' to '{normalized_model}'"
+            )
 
-        # Validate version fields
+        if normalized_model not in self.VALID_MODELS:
+            errors.append(f"Invalid model: {model} (normalized to {normalized_model})")
+
+    def _validate_tools_field(
+        self,
+        corrected: Dict[str, Any],
+        field_corrections: Dict[str, Any],
+        warnings: List[str],
+        corrections: List[str],
+    ) -> None:
+        """Validate and correct the tools field."""
+        if "tools" not in corrected:
+            return
+
+        tools = corrected["tools"]
+        corrected_tools, tool_corrections = self._correct_tools(tools)
+        if tool_corrections:
+            corrected["tools"] = corrected_tools
+            field_corrections["tools"] = corrected_tools
+            corrections.extend(tool_corrections)
+
+        # Validate tool names
+        invalid_tools = []
+        for tool in corrected_tools:
+            if tool not in self.VALID_TOOLS:
+                # Try to correct the tool name
+                corrected_tool = self.TOOL_CORRECTIONS.get(tool.lower())
+                if corrected_tool:
+                    idx = corrected_tools.index(tool)
+                    corrected_tools[idx] = corrected_tool
+                    corrected["tools"] = corrected_tools
+                    field_corrections["tools"] = corrected_tools
+                    corrections.append(f"Corrected tool '{tool}' to '{corrected_tool}'")
+                else:
+                    invalid_tools.append(tool)
+
+        if invalid_tools:
+            warnings.append(f"Unknown tools: {', '.join(invalid_tools)}")
+
+    def _validate_version_fields(
+        self,
+        corrected: Dict[str, Any],
+        field_corrections: Dict[str, Any],
+        errors: List[str],
+        corrections: List[str],
+    ) -> None:
+        """Validate and correct version fields."""
         version_fields = ["version", "base_version"]
         for field in version_fields:
-            if field in corrected:
-                version = corrected[field]
-                if not isinstance(version, str):
-                    errors.append(
-                        f"Field '{field}' must be a string, got {type(version).__name__}"
-                    )
-                elif not re.match(r"^\d+\.\d+\.\d+$", version):
-                    # Try to fix common version issues
-                    if re.match(r"^\d+\.\d+$", version):
-                        fixed_version = f"{version}.0"
-                        corrected[field] = fixed_version
-                        field_corrections[field] = fixed_version
-                        corrections.append(
-                            f"Fixed {field} from '{version}' to '{fixed_version}'"
-                        )
-                    elif re.match(r"^v?\d+\.\d+\.\d+$", version):
-                        fixed_version = version.lstrip("v")
-                        corrected[field] = fixed_version
-                        field_corrections[field] = fixed_version
-                        corrections.append(
-                            f"Fixed {field} from '{version}' to '{fixed_version}'"
-                        )
-                    else:
-                        errors.append(f"Invalid {field} format: {version}")
+            if field not in corrected:
+                continue
 
-        # Validate description
-        if "description" in corrected:
-            desc = corrected["description"]
-            if not isinstance(desc, str):
+            version = corrected[field]
+            if not isinstance(version, str):
                 errors.append(
-                    f"Field 'description' must be a string, got {type(desc).__name__}"
-                )
-            elif len(desc) < 10:
-                warnings.append(
-                    f"Description too short ({len(desc)} chars, minimum 10)"
-                )
-            elif len(desc) > 200:
-                warnings.append(
-                    f"Description too long ({len(desc)} chars, maximum 200)"
+                    f"Field '{field}' must be a string, got {type(version).__name__}"
                 )
+                continue
 
-        # Validate optional fields
-        if "category" in corrected:
-            valid_categories = [
-                "engineering",
-                "research",
-                "quality",
-                "operations",
-                "specialized",
-            ]
-            if corrected["category"] not in valid_categories:
-                warnings.append(f"Invalid category: {corrected['category']}")
-
-        if "resource_tier" in corrected:
-            valid_tiers = ["basic", "standard", "intensive", "lightweight"]
-            if corrected["resource_tier"] not in valid_tiers:
-                warnings.append(f"Invalid resource_tier: {corrected['resource_tier']}")
-
-        # Validate color field
-        if "color" in corrected:
-            color = corrected["color"]
-            if not isinstance(color, str):
-                errors.append(
-                    f"Field 'color' must be a string, got {type(color).__name__}"
-                )
-            # Color validation could be expanded to check for valid color names/hex codes
+            if re.match(r"^\d+\.\d+\.\d+$", version):
+                continue  # Valid format
 
-        # Validate author field
-        if "author" in corrected:
-            author = corrected["author"]
-            if not isinstance(author, str):
-                errors.append(
-                    f"Field 'author' must be a string, got {type(author).__name__}"
+            # Try to fix common version issues
+            if re.match(r"^\d+\.\d+$", version):
+                fixed_version = f"{version}.0"
+                corrected[field] = fixed_version
+                field_corrections[field] = fixed_version
+                corrections.append(
+                    f"Fixed {field} from '{version}' to '{fixed_version}'"
                 )
-            elif len(author) > 100:
-                warnings.append(
-                    f"Author field too long ({len(author)} chars, maximum 100)"
+            elif re.match(r"^v?\d+\.\d+\.\d+$", version):
+                fixed_version = version.lstrip("v")
+                corrected[field] = fixed_version
+                field_corrections[field] = fixed_version
+                corrections.append(
+                    f"Fixed {field} from '{version}' to '{fixed_version}'"
                 )
-
-        # Validate tags field (supports both list and comma-separated string)
-        if "tags" in corrected:
-            tags = corrected["tags"]
-            if isinstance(tags, str):
-                # Convert comma-separated string to list for validation
-                tag_list = [tag.strip() for tag in tags.split(",") if tag.strip()]
-            elif isinstance(tags, list):
-                tag_list = tags
             else:
-                errors.append(
-                    f"Field 'tags' must be a list or comma-separated string, got {type(tags).__name__}"
+                errors.append(f"Invalid {field} format: {version}")
+
+    def _validate_description_field(
+        self, corrected: Dict[str, Any], errors: List[str], warnings: List[str]
+    ) -> None:
+        """Validate the description field."""
+        if "description" not in corrected:
+            return
+
+        desc = corrected["description"]
+        if not isinstance(desc, str):
+            errors.append(
+                f"Field 'description' must be a string, got {type(desc).__name__}"
+            )
+        elif len(desc) < 10:
+            warnings.append(f"Description too short ({len(desc)} chars, minimum 10)")
+        elif len(desc) > 200:
+            warnings.append(f"Description too long ({len(desc)} chars, maximum 200)")
+
+    def _validate_category_field(
+        self, corrected: Dict[str, Any], warnings: List[str]
+    ) -> None:
+        """Validate the category field."""
+        if "category" not in corrected:
+            return
+
+        valid_categories = [
+            "engineering",
+            "research",
+            "quality",
+            "operations",
+            "specialized",
+        ]
+        if corrected["category"] not in valid_categories:
+            warnings.append(f"Invalid category: {corrected['category']}")
+
+    def _validate_resource_tier_field(
+        self, corrected: Dict[str, Any], warnings: List[str]
+    ) -> None:
+        """Validate the resource_tier field."""
+        if "resource_tier" not in corrected:
+            return
+
+        valid_tiers = ["basic", "standard", "intensive", "lightweight"]
+        if corrected["resource_tier"] not in valid_tiers:
+            warnings.append(f"Invalid resource_tier: {corrected['resource_tier']}")
+
+    def _validate_color_field(
+        self, corrected: Dict[str, Any], errors: List[str]
+    ) -> None:
+        """Validate the color field."""
+        if "color" not in corrected:
+            return
+
+        color = corrected["color"]
+        if not isinstance(color, str):
+            errors.append(f"Field 'color' must be a string, got {type(color).__name__}")
+
+    def _validate_author_field(
+        self, corrected: Dict[str, Any], errors: List[str], warnings: List[str]
+    ) -> None:
+        """Validate the author field."""
+        if "author" not in corrected:
+            return
+
+        author = corrected["author"]
+        if not isinstance(author, str):
+            errors.append(
+                f"Field 'author' must be a string, got {type(author).__name__}"
+            )
+        elif len(author) > 100:
+            warnings.append(f"Author field too long ({len(author)} chars, maximum 100)")
+
+    def _validate_tags_field(
+        self, corrected: Dict[str, Any], errors: List[str], warnings: List[str]
+    ) -> None:
+        """Validate the tags field."""
+        if "tags" not in corrected:
+            return
+
+        tags = corrected["tags"]
+        if isinstance(tags, str):
+            # Convert comma-separated string to list for validation
+            tag_list = [tag.strip() for tag in tags.split(",") if tag.strip()]
+        elif isinstance(tags, list):
+            tag_list = tags
+        else:
+            errors.append(
+                f"Field 'tags' must be a list or comma-separated string, got {type(tags).__name__}"
+            )
+            return
+
+        for tag in tag_list:
+            if not isinstance(tag, str):
+                errors.append(f"All tags must be strings, found {type(tag).__name__}")
+            elif not re.match(r"^[a-z][a-z0-9-]*$", tag):
+                warnings.append(
+                    f"Tag '{tag}' doesn't match recommended pattern (lowercase, alphanumeric with hyphens)"
                 )
-                tag_list = []
-
-            for tag in tag_list:
-                if not isinstance(tag, str):
-                    errors.append(
-                        f"All tags must be strings, found {type(tag).__name__}"
-                    )
-                elif not re.match(r"^[a-z][a-z0-9-]*$", tag):
-                    warnings.append(
-                        f"Tag '{tag}' doesn't match recommended pattern (lowercase, alphanumeric with hyphens)"
-                    )
-
-        # Validate numeric fields
+
+    def _validate_numeric_fields(
+        self, corrected: Dict[str, Any], errors: List[str], warnings: List[str]
+    ) -> None:
+        """Validate numeric fields (max_tokens, temperature)."""
         for field_name, (min_val, max_val) in [
             ("max_tokens", (1000, 200000)),
             ("temperature", (0, 1)),
         ]:
-            if field_name in corrected:
-                value = corrected[field_name]
-                if field_name == "temperature" and not isinstance(value, (int, float)):
-                    errors.append(
-                        f"Field '{field_name}' must be a number, got {type(value).__name__}"
-                    )
-                elif field_name == "max_tokens" and not isinstance(value, int):
-                    errors.append(
-                        f"Field '{field_name}' must be an integer, got {type(value).__name__}"
-                    )
-                elif isinstance(value, (int, float)) and not (
-                    min_val <= value <= max_val
-                ):
-                    warnings.append(
-                        f"Field '{field_name}' value {value} outside recommended range [{min_val}, {max_val}]"
-                    )
+            if field_name not in corrected:
+                continue
 
-        # Determine if valid
-        is_valid = len(errors) == 0
-
-        return ValidationResult(
-            is_valid=is_valid,
-            errors=errors,
-            warnings=warnings,
-            corrections=corrections,
-            corrected_frontmatter=corrected if corrections else None,
-            field_corrections=field_corrections if field_corrections else None,
-        )
+            value = corrected[field_name]
+            if field_name == "temperature" and not isinstance(value, (int, float)):
+                errors.append(
+                    f"Field '{field_name}' must be a number, got {type(value).__name__}"
+                )
+            elif field_name == "max_tokens" and not isinstance(value, int):
+                errors.append(
+                    f"Field '{field_name}' must be an integer, got {type(value).__name__}"
+                )
+            elif isinstance(value, (int, float)) and not (min_val <= value <= max_val):
+                warnings.append(
+                    f"Field '{field_name}' value {value} outside recommended range [{min_val}, {max_val}]"
+                )
 
     def _normalize_model(self, model: str) -> str:
         """
-        Normalize model name to standard tier (opus, sonnet, haiku).
+        Normalize model name to standard tier using ModelTier enum.
 
         Args:
             model: Original model name
@@ -423,27 +474,7 @@ class FrontmatterValidator:
         Returns:
             Normalized model tier name
         """
-        # Direct mapping check
-        if model in self.MODEL_MAPPINGS:
-            return self.MODEL_MAPPINGS[model]
-
-        # Already normalized
-        if model in self.VALID_MODELS:
-            return model
-
-        # Try case-insensitive match
-        model_lower = model.lower()
-        if model_lower in self.VALID_MODELS:
-            return model_lower
-
-        # Check if model contains tier name
-        for tier in self.VALID_MODELS:
-            if tier in model_lower:
-                return tier
-
-        # Default to sonnet if unrecognized
-        logger.warning(f"Unrecognized model '{model}', defaulting to 'sonnet'")
-        return "sonnet"
+        return ModelTier.normalize(model).value
 
     def _correct_tools(self, tools: Any) -> Tuple[List[str], List[str]]:
         """