claude-mpm 4.16.0__py3-none-any.whl → 4.25.10__py3-none-any.whl

claude_mpm/schemas/frontmatter_schema.json

@@ -0,0 +1,165 @@
+{
+  "$schema": "http://json-schema.org/draft-07/schema#",
+  "version": "1.0.0",
+  "title": "Agent Frontmatter Schema",
+  "description": "Schema for validating agent file frontmatter in .md, .claude, and .claude-mpm files",
+  "type": "object",
+  "required": [
+    "name",
+    "description",
+    "version",
+    "model"
+  ],
+  "properties": {
+    "name": {
+      "type": "string",
+      "pattern": "^[a-z][a-z0-9_-]*$",
+      "minLength": 1,
+      "maxLength": 50,
+      "description": "Agent identifier (kebab-case or snake_case)"
+    },
+    "description": {
+      "type": "string",
+      "minLength": 10,
+      "maxLength": 200,
+      "description": "Brief description of agent purpose"
+    },
+    "version": {
+      "type": "string",
+      "pattern": "^\\d+\\.\\d+\\.\\d+$",
+      "description": "Semantic version (e.g., 1.0.0)"
+    },
+    "base_version": {
+      "type": "string",
+      "pattern": "^\\d+\\.\\d+\\.\\d+$",
+      "description": "Base agent version this extends"
+    },
+    "author": {
+      "type": "string",
+      "minLength": 1,
+      "maxLength": 100,
+      "description": "Author name or organization"
+    },
+    "tools": {
+      "type": "array",
+      "items": {
+        "type": "string",
+        "enum": [
+          "Read",
+          "Write",
+          "Edit",
+          "MultiEdit",
+          "Grep",
+          "Glob",
+          "LS",
+          "Bash",
+          "WebSearch",
+          "WebFetch",
+          "NotebookRead",
+          "NotebookEdit",
+          "TodoWrite",
+          "ExitPlanMode",
+          "git",
+          "docker",
+          "kubectl",
+          "terraform",
+          "aws",
+          "gcloud",
+          "azure"
+        ]
+      },
+      "uniqueItems": true,
+      "description": "List of available tools for the agent"
+    },
+    "model": {
+      "type": "string",
+      "enum": ["opus", "sonnet", "haiku"],
+      "description": "Claude model tier to use"
+    },
+    "tags": {
+      "type": "array",
+      "items": {
+        "type": "string",
+        "pattern": "^[a-z][a-z0-9-]*$"
+      },
+      "uniqueItems": true,
+      "description": "Tags for categorization"
+    },
+    "category": {
+      "type": "string",
+      "enum": ["engineering", "research", "quality", "operations", "specialized"],
+      "description": "Agent category"
+    },
+    "max_tokens": {
+      "type": "integer",
+      "minimum": 1000,
+      "maximum": 200000,
+      "default": 8192,
+      "description": "Maximum tokens for response"
+    },
+    "temperature": {
+      "type": "number",
+      "minimum": 0,
+      "maximum": 1,
+      "default": 0.7,
+      "description": "Model temperature setting"
+    },
+    "resource_tier": {
+      "type": "string",
+      "enum": ["basic", "standard", "intensive", "lightweight"],
+      "description": "Resource allocation tier"
+    },
+    "dependencies": {
+      "type": "array",
+      "items": {
+        "type": "string"
+      },
+      "description": "Other agents this agent depends on"
+    },
+    "capabilities": {
+      "type": "array",
+      "items": {
+        "type": "string"
+      },
+      "description": "List of agent capabilities"
+    }
+  },
+  "additionalProperties": true,
+  "definitions": {
+    "model_mappings": {
+      "description": "Mappings for model normalization",
+      "mappings": {
+        "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",
+        "claude-3-opus-20240229": "opus",
+        "claude-opus-4-20250514": "opus",
+        "claude-4-opus-20250514": "opus",
+        "claude-3-haiku-20240307": "haiku",
+        "claude-3-5-haiku-20241022": "haiku"
+      }
+    },
+    "tool_corrections": {
+      "description": "Common tool name corrections",
+      "mappings": {
+        "read": "Read",
+        "write": "Write",
+        "edit": "Edit",
+        "multiedit": "MultiEdit",
+        "grep": "Grep",
+        "glob": "Glob",
+        "ls": "LS",
+        "bash": "Bash",
+        "websearch": "WebSearch",
+        "webfetch": "WebFetch",
+        "notebookread": "NotebookRead",
+        "notebookedit": "NotebookEdit",
+        "todowrite": "TodoWrite",
+        "exitplanmode": "ExitPlanMode"
+      }
+    }
+  }
+}

claude_mpm/scripts/claude-hook-handler.sh

@@ -89,7 +89,7 @@ fi
 # STRATEGY:
 # This function implements a fallback chain to find Python with claude-mpm dependencies:
 # 1. Project-specific virtual environments (venv, .venv)
-# 2. Currently active virtual environment ($VIRTUAL_ENV)  
+# 2. Currently active virtual environment ($VIRTUAL_ENV)
 # 3. System python3 (may lack dependencies)
 # 4. System python (last resort)
 #
@@ -121,7 +121,7 @@ find_python_command() {
             return
         fi
     fi
-    
+
     # 2. Check for project-local virtual environment (common in development)
     if [ -f "$CLAUDE_MPM_ROOT/venv/bin/activate" ]; then
         source "$CLAUDE_MPM_ROOT/venv/bin/activate"
@@ -152,7 +152,7 @@ if [[ "$SCRIPT_DIR" == *"/.local/pipx/venvs/claude-mpm/"* ]]; then
 elif [ -d "$CLAUDE_MPM_ROOT/src" ]; then
     # Development install - add src to PYTHONPATH
     export PYTHONPATH="$CLAUDE_MPM_ROOT/src:$PYTHONPATH"
-    
+
     if [ "${CLAUDE_MPM_HOOK_DEBUG}" = "true" ]; then
         echo "[$(date -u +%Y-%m-%dT%H:%M:%S.%3NZ)] Development environment detected" >> /tmp/claude-mpm-hook.log
     fi

claude_mpm/scripts/start_activity_logging.py

@@ -51,7 +51,9 @@ if __name__ == "__main__":
 
     # Initialize aggregator
     aggregator = EventAggregator(
-        host="localhost", port=dashboard_port, save_dir=None  # Will use config value
+        host="localhost",
+        port=dashboard_port,
+        save_dir=None,  # Will use config value
     )
 
     # Set up signal handlers

claude_mpm/services/agents/auto_config_manager.py

@@ -678,7 +678,7 @@ class AutoConfigManagerService(BaseService, IAutoConfigManager):
                     agent_id, agent_name, success=True
                 )
                 deployed.append(agent_id)
-                self.logger.info(f"Successfully deployed agent: {agent_id}")
+                self.logger.debug(f"Successfully deployed agent: {agent_id}")
 
             except Exception as e:
                 self.logger.error(

claude_mpm/services/agents/deployment/agent_configuration_manager.py

@@ -71,7 +71,7 @@ class AgentConfigurationManager:
             # Cache the result
             self._base_agent_cache = (base_agent_data, base_agent_version)
 
-            self.logger.info(f"Loaded base agent from {self.base_agent_path}")
+            self.logger.debug(f"Loaded base agent from {self.base_agent_path}")
             return self._base_agent_cache
 
         except Exception as e:

claude_mpm/services/agents/deployment/agent_format_converter.py

@@ -166,7 +166,7 @@ class AgentFormatConverter:
 
 <example>
 Context: When you need specialized assistance from the {name} agent.
-user: "I need help with {agent_name.replace('_', ' ').replace('-', ' ')} tasks"
+user: "I need help with {agent_name.replace("_", " ").replace("-", " ")} tasks"
 assistant: "I'll use the {name} agent to provide specialized assistance."
 </example>"""
 

claude_mpm/services/agents/deployment/agent_metrics_collector.py

@@ -176,9 +176,9 @@ class AgentMetricsCollector:
             agent_name: Name of the agent being validated
             validation_time_ms: Validation time in milliseconds
         """
-        self._deployment_metrics["template_validation_times"][
-            agent_name
-        ] = validation_time_ms
+        self._deployment_metrics["template_validation_times"][agent_name] = (
+            validation_time_ms
+        )
 
     def get_performance_summary(self) -> Dict[str, Any]:
         """

claude_mpm/services/agents/deployment/agent_record_service.py

@@ -107,7 +107,7 @@ class AgentRecordService(BaseService):
                     record = self._deserialize_record(record_data)
                     records[agent_name] = record
 
-                self.logger.info(f"Loaded {len(records)} agent records")
+                self.logger.debug(f"Loaded {len(records)} agent records")
             else:
                 self.logger.debug("No existing records file found")
 

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/facade/deployment_facade.py

@@ -89,9 +89,9 @@ class DeploymentFacade:
 
             results["metadata"]["facade_version"] = "1.0.0"
             results["metadata"]["selected_executor"] = executor.get_executor_name()
-            results["metadata"][
-                "executor_characteristics"
-            ] = executor.get_performance_characteristics()
+            results["metadata"]["executor_characteristics"] = (
+                executor.get_performance_characteristics()
+            )
 
             return results
 

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/pipeline/pipeline_executor.py

@@ -51,11 +51,11 @@ class DeploymentPipelineExecutor:
             try:
                 # Check if step should be executed
                 if not step.should_execute(context):
-                    self.logger.info(f"Skipping step {i+1}/{len(steps)}: {step.name}")
+                    self.logger.info(f"Skipping step {i + 1}/{len(steps)}: {step.name}")
                     skipped_steps.append(step.name)
                     continue
 
-                self.logger.info(f"Executing step {i+1}/{len(steps)}: {step.name}")
+                self.logger.info(f"Executing step {i + 1}/{len(steps)}: {step.name}")
 
                 # Execute the step
                 result = step.execute(context)

claude_mpm/services/agents/loading/framework_agent_loader.py

@@ -404,8 +404,8 @@ class FrameworkAgentLoader:
 **{agent_type} Agent Profile Loaded**
 
 **Agent Identity**: {agent_type} Agent
-**Profile Source**: {profile.get('source_path', 'Unknown')}
-**Primary Role**: {profile.get('role', 'Not specified')}
+**Profile Source**: {profile.get("source_path", "Unknown")}
+**Primary Role**: {profile.get("role", "Not specified")}
 
 **Core Capabilities**:
 """
@@ -415,9 +415,9 @@ class FrameworkAgentLoader:
 
         instruction += f"""
 **Context Preferences**:
-- **Include**: {profile.get('context_preferences', {}).get('include', 'Not specified')}
-- **Exclude**: {profile.get('context_preferences', {}).get('exclude', 'Not specified')}
-- **Focus**: {profile.get('context_preferences', {}).get('focus', 'Not specified')}
+- **Include**: {profile.get("context_preferences", {}).get("include", "Not specified")}
+- **Exclude**: {profile.get("context_preferences", {}).get("exclude", "Not specified")}
+- **Focus**: {profile.get("context_preferences", {}).get("focus", "Not specified")}
 
 **Authority Scope**:
 """
@@ -426,9 +426,9 @@ class FrameworkAgentLoader:
             instruction += f"- **{authority}**: Authorized operation area\n"
 
         instruction += f"""
-**Quality Standards**: {len(profile.get('quality_standards', []))} standards defined
-**Escalation Triggers**: {len(profile.get('escalation_criteria', []))} criteria defined
-**Integration Partners**: {len(profile.get('integration_patterns', {}))} agent coordination patterns
+**Quality Standards**: {len(profile.get("quality_standards", []))} standards defined
+**Escalation Triggers**: {len(profile.get("escalation_criteria", []))} criteria defined
+**Integration Partners**: {len(profile.get("integration_patterns", {}))} agent coordination patterns
 
 Please operate according to your profile specifications and maintain quality standards.
 """

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
 
@@ -270,7 +270,9 @@ class LocalAgentTemplateManager:
                 "tools": (
                     tools
                     if isinstance(tools, str)
-                    else ",".join(tools) if tools else "*"
+                    else ",".join(tools)
+                    if tools
+                    else "*"
                 ),
             },
             instructions=instructions,

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}"