claude-mpm 4.15.2__py3-none-any.whl → 4.20.3__py3-none-any.whl

claude_mpm/services/agents/deployment/agent_validator.py

@@ -329,10 +329,26 @@ class AgentValidator:
             "type": "agent",  # Default type
         }
 
-        # Extract from YAML frontmatter
+        # Extract ONLY from YAML frontmatter (between --- markers)
         lines = content.split("\n")
+        in_frontmatter = False
+        frontmatter_ended = False
+
         for line in lines:
             stripped_line = line.strip()
+
+            # Track frontmatter boundaries
+            if stripped_line == "---":
+                if not in_frontmatter:
+                    in_frontmatter = True
+                    continue
+                frontmatter_ended = True
+                break  # Stop parsing after frontmatter ends
+
+            # Only parse within frontmatter
+            if not in_frontmatter or frontmatter_ended:
+                continue
+
             if stripped_line.startswith("name:"):
                 agent_info["name"] = stripped_line.split(":", 1)[1].strip().strip("\"'")
             elif stripped_line.startswith("description:"):

claude_mpm/services/agents/deployment/async_agent_deployment.py

@@ -224,7 +224,7 @@ class AsyncAgentDeploymentService:
 
         elapsed = (time.time() - start_time) * 1000
         self._metrics["time_saved_ms"] += max(0, (len(directories) * 75) - elapsed)
-        self.logger.info(f"Discovered agents in {elapsed:.1f}ms (parallel scan)")
+        self.logger.debug(f"Discovered agents in {elapsed:.1f}ms (parallel scan)")
 
         return discovered
 

claude_mpm/services/agents/deployment/local_template_deployment.py

@@ -90,7 +90,7 @@ class LocalTemplateDeploymentService:
                 logger.error(f"Failed to deploy local template {agent_id}: {e}")
                 results["errors"].append(f"{agent_id}: {e}")
 
-        logger.info(
+        logger.debug(
             f"Local template deployment: deployed={len(results['deployed'])}, "
             f"updated={len(results['updated'])}, skipped={len(results['skipped'])}, "
             f"errors={len(results['errors'])}"

claude_mpm/services/agents/deployment/validation/__init__.py

@@ -5,10 +5,12 @@ including template validation, agent file validation, and
 deployment environment validation.
 """
 
+from claude_mpm.core.enums import ValidationSeverity
+
 from .agent_validator import AgentValidator
 from .deployment_validator import DeploymentValidator
 from .template_validator import TemplateValidator
-from .validation_result import ValidationResult, ValidationSeverity
+from .validation_result import ValidationResult
 
 __all__ = [
     "AgentValidator",

claude_mpm/services/agents/deployment/validation/validation_result.py

@@ -1,17 +1,9 @@
 """Validation result classes for deployment validation."""
 
 from dataclasses import dataclass, field
-from enum import Enum
 from typing import Any, Dict, List, Optional
 
-
-class ValidationSeverity(Enum):
-    """Severity levels for validation issues."""
-
-    INFO = "info"
-    WARNING = "warning"
-    ERROR = "error"
-    CRITICAL = "critical"
+from claude_mpm.core.enums import ValidationSeverity
 
 
 @dataclass

claude_mpm/services/agents/local_template_manager.py

@@ -182,7 +182,7 @@ class LocalAgentTemplateManager:
             self._discover_templates_in_dir(self.user_agents_dir, "user")
 
         self._cache_valid = True
-        logger.info(f"Discovered {len(self._template_cache)} local agent templates")
+        logger.debug(f"Discovered {len(self._template_cache)} local agent templates")
 
         return self._template_cache
 

claude_mpm/services/agents/recommender.py

@@ -226,6 +226,53 @@ class AgentRecommenderService(BaseService, IAgentRecommender):
         if max_agents is not None:
             recommendations = recommendations[:max_agents]
 
+        # Check if toolchain is unknown and we have no recommendations
+        if not recommendations and toolchain.primary_language.lower() == "unknown":
+            self.logger.info("Toolchain unknown - applying default configuration")
+
+            # Get default configuration
+            default_config = self._capabilities_config.get("default_configuration", {})
+            if default_config.get("enabled", False):
+                default_agents = default_config.get("agents", [])
+                default_confidence = default_config.get("min_confidence", 0.7)
+
+                for default_agent in default_agents:
+                    agent_id = default_agent.get("agent_id")
+
+                    # Skip if agent doesn't exist in capabilities
+                    if agent_id not in agent_configs:
+                        self.logger.warning(f"Default agent not found: {agent_id}")
+                        continue
+
+                    agent_config = agent_configs[agent_id]
+                    capabilities = self.get_agent_capabilities(agent_id)
+
+                    recommendation = AgentRecommendation(
+                        agent_id=agent_id,
+                        agent_name=agent_config.get("name", agent_id),
+                        confidence_score=default_confidence,
+                        match_reasons=[
+                            "Default configuration applied - toolchain detection unsuccessful",
+                            default_agent.get("reasoning", "General-purpose agent"),
+                        ],
+                        concerns=[
+                            "Consider manually selecting specialized agents for better results"
+                        ],
+                        capabilities=capabilities,
+                        deployment_priority=default_agent.get("priority", 10),
+                        configuration_hints={"default_deployment": True},
+                        metadata={
+                            "is_default": True,
+                            "specialization": agent_config.get("specialization"),
+                            "auto_deploy": agent_config.get("auto_deploy", True),
+                        },
+                    )
+                    recommendations.append(recommendation)
+
+                self.logger.info(
+                    f"Applied {len(recommendations)} default agent recommendations"
+                )
+
         self.logger.info(
             f"Generated {len(recommendations)} agent recommendations "
             f"for project: {toolchain.project_path}"