claude-mpm 3.7.1__py3-none-any.whl → 3.7.8__py3-none-any.whl

claude_mpm/dashboard/static/js/components/file-tool-tracker.js

@@ -328,8 +328,20 @@ class FileToolTracker {
      */
     isFileOperation(event) {
         // File operations are tool events with tools that operate on files
-        const fileTools = ['Read', 'Write', 'Edit', 'Grep', 'MultiEdit'];
-        return event.tool_name && fileTools.includes(event.tool_name);
+        // Check case-insensitively since tool names can come in different cases
+        const fileTools = ['read', 'write', 'edit', 'grep', 'multiedit', 'glob', 'ls', 'bash', 'notebookedit'];
+        const toolName = event.tool_name ? event.tool_name.toLowerCase() : '';
+        
+        // Also check if Bash commands involve file operations
+        if (toolName === 'bash' && event.tool_parameters) {
+            const command = event.tool_parameters.command || '';
+            // Check for common file operations in bash commands
+            if (command.match(/\b(cat|less|more|head|tail|touch|mv|cp|rm|mkdir|ls|find)\b/)) {
+                return true;
+            }
+        }
+        
+        return toolName && fileTools.includes(toolName);
     }
 
     /**
@@ -341,11 +353,28 @@ class FileToolTracker {
         // Try various locations where file path might be stored
         if (event.tool_parameters?.file_path) return event.tool_parameters.file_path;
         if (event.tool_parameters?.path) return event.tool_parameters.path;
+        if (event.tool_parameters?.notebook_path) return event.tool_parameters.notebook_path;
         if (event.data?.tool_parameters?.file_path) return event.data.tool_parameters.file_path;
         if (event.data?.tool_parameters?.path) return event.data.tool_parameters.path;
+        if (event.data?.tool_parameters?.notebook_path) return event.data.tool_parameters.notebook_path;
         if (event.file_path) return event.file_path;
         if (event.path) return event.path;
         
+        // For Glob tool, use the pattern as a pseudo-path
+        if (event.tool_name?.toLowerCase() === 'glob' && event.tool_parameters?.pattern) {
+            return `[glob] ${event.tool_parameters.pattern}`;
+        }
+        
+        // For Bash commands, try to extract file paths from the command
+        if (event.tool_name?.toLowerCase() === 'bash' && event.tool_parameters?.command) {
+            const command = event.tool_parameters.command;
+            // Try to extract file paths from common patterns
+            const fileMatch = command.match(/(?:cat|less|more|head|tail|touch|mv|cp|rm|mkdir|ls|find|echo.*>|sed|awk|grep)\s+([^\s;|&]+)/);
+            if (fileMatch && fileMatch[1]) {
+                return fileMatch[1];
+            }
+        }
+        
         return null;
     }
 
@@ -383,7 +412,22 @@ class FileToolTracker {
             case 'write': return 'write';
             case 'edit': return 'edit';
             case 'multiedit': return 'edit';
+            case 'notebookedit': return 'edit';
             case 'grep': return 'search';
+            case 'glob': return 'search';
+            case 'ls': return 'list';
+            case 'bash': 
+                // Check bash command for file operation type
+                const command = event.tool_parameters?.command || '';
+                if (command.match(/\b(cat|less|more|head|tail)\b/)) return 'read';
+                if (command.match(/\b(touch|echo.*>|tee)\b/)) return 'write';
+                if (command.match(/\b(sed|awk)\b/)) return 'edit';
+                if (command.match(/\b(grep|find)\b/)) return 'search';
+                if (command.match(/\b(ls|dir)\b/)) return 'list';
+                if (command.match(/\b(mv|cp)\b/)) return 'copy/move';
+                if (command.match(/\b(rm|rmdir)\b/)) return 'delete';
+                if (command.match(/\b(mkdir)\b/)) return 'create';
+                return 'bash';
             default: return toolName;
         }
     }

claude_mpm/dashboard/templates/index.html

@@ -334,11 +334,11 @@
     <!-- New modular components -->
     <script src="/static/js/components/socket-manager.js"></script>
     <script src="/static/js/components/agent-inference.js"></script>
-    <script src="/static/js/components/ui-state-manager.js"></script>
-    <script src="/static/js/components/working-directory.js"></script>
-    <script src="/static/js/components/file-tool-tracker.js"></script>
-    <script src="/static/js/components/event-processor.js"></script>
-    <script src="/static/js/components/export-manager.js"></script>
+    <script src="/static/js/components/ui-state-manager.js?v=1.0"></script>
+    <script src="/static/js/components/working-directory.js?v=1.0"></script>
+    <script src="/static/js/components/file-tool-tracker.js?v=1.1"></script>
+    <script src="/static/js/components/event-processor.js?v=1.0"></script>
+    <script src="/static/js/components/export-manager.js?v=1.0"></script>
     
     <!-- Main dashboard coordinator -->
     <script src="/static/js/dashboard.js"></script>

claude_mpm/services/agents/deployment/agent_deployment.py

@@ -740,10 +740,18 @@ class AgentDeploymentService:
         # IMPORTANT: No spaces after commas - Claude Code requires exact format
         tools_str = ','.join(tools) if isinstance(tools, list) else tools
         
+        # Extract proper agent_id and name from template
+        agent_id = template_data.get('agent_id', agent_name)
+        display_name = template_data.get('metadata', {}).get('name', agent_id)
+        
+        # Convert agent_id to Claude Code compatible name (replace underscores with hyphens)
+        # Claude Code requires name to match pattern: ^[a-z0-9]+(-[a-z0-9]+)*$
+        claude_code_name = agent_id.replace('_', '-').lower()
+        
         # Build frontmatter with only the fields Claude Code uses
         frontmatter_lines = [
             "---",
-            f"name: {agent_name}",
+            f"name: {claude_code_name}",
             f"description: {description}",
             f"version: {version_string}",
             f"base_version: {self._format_version_display(base_version)}",

claude_mpm/services/agents/deployment/async_agent_deployment.py

@@ -387,20 +387,181 @@ class AsyncAgentDeploymentService:
         return filtered
     
     def _build_agent_markdown_sync(self, agent_data: Dict[str, Any]) -> str:
-        """Build agent markdown content (sync version for compatibility)."""
-        # Simplified version - extend as needed
+        """Build agent markdown content matching the synchronous deployment format."""
+        from datetime import datetime
+        
+        # Extract agent info from the loaded JSON data
         agent_name = agent_data.get('_agent_name', 'unknown')
-        version = agent_data.get('version', '1.0.0')
-        instructions = agent_data.get('instructions', '')
-        
-        return f"""---
-name: {agent_name}
-version: {version}
-author: claude-mpm
----
-
-{instructions}
-"""
+        
+        # Extract proper agent_id from template data (not filename)
+        agent_id = agent_data.get('agent_id', agent_name)
+        
+        # Handle both 'agent_version' (new format) and 'version' (old format)
+        agent_version = self._parse_version(agent_data.get('agent_version') or agent_data.get('version', '1.0.0'))
+        base_version = (0, 1, 0)  # Default base version for async deployment
+        
+        # Format version string as semantic version
+        version_string = self._format_version_display(agent_version)
+        
+        # Extract metadata using the same logic as synchronous deployment
+        # Check new format first (metadata.description), then old format
+        description = (
+            agent_data.get('metadata', {}).get('description') or
+            agent_data.get('configuration_fields', {}).get('description') or
+            agent_data.get('description') or
+            'Agent for specialized tasks'
+        )
+        
+        # Get tags from new format (metadata.tags) or old format
+        tags = (
+            agent_data.get('metadata', {}).get('tags') or
+            agent_data.get('configuration_fields', {}).get('tags') or
+            agent_data.get('tags') or
+            [agent_id, 'mpm-framework']
+        )
+        
+        # Get tools from capabilities.tools in new format
+        tools = (
+            agent_data.get('capabilities', {}).get('tools') or
+            agent_data.get('configuration_fields', {}).get('tools') or
+            ["Read", "Write", "Edit", "Grep", "Glob", "LS"]  # Default fallback
+        )
+        
+        # Get model from capabilities.model in new format
+        model = (
+            agent_data.get('capabilities', {}).get('model') or
+            agent_data.get('configuration_fields', {}).get('model') or
+            "sonnet"  # Default fallback
+        )
+        
+        # Simplify model name for Claude Code
+        model_map = {
+            'claude-4-sonnet-20250514': 'sonnet',
+            'claude-sonnet-4-20250514': 'sonnet',
+            'claude-opus-4-20250514': 'opus',
+            'claude-3-opus-20240229': 'opus',
+            'claude-3-haiku-20240307': 'haiku',
+            'claude-3.5-sonnet': 'sonnet',
+            'claude-3-sonnet': 'sonnet'
+        }
+        # Better fallback: extract the model type (opus/sonnet/haiku) from the string
+        if model not in model_map:
+            if 'opus' in model.lower():
+                model = 'opus'
+            elif 'sonnet' in model.lower():
+                model = 'sonnet'
+            elif 'haiku' in model.lower():
+                model = 'haiku'
+            else:
+                # Last resort: try to extract from hyphenated format
+                model = model_map.get(model, model.split('-')[-1] if '-' in model else model)
+        else:
+            model = model_map[model]
+        
+        # Convert tools list to comma-separated string for Claude Code compatibility
+        # IMPORTANT: No spaces after commas - Claude Code requires exact format
+        tools_str = ','.join(tools) if isinstance(tools, list) else str(tools)
+        
+        # Convert agent_id to Claude Code compatible name (replace underscores with hyphens)
+        # Claude Code requires name to match pattern: ^[a-z0-9]+(-[a-z0-9]+)*$
+        claude_code_name = agent_id.replace('_', '-').lower()
+        
+        # Build frontmatter with only the fields Claude Code uses
+        frontmatter_lines = [
+            "---",
+            f"name: {claude_code_name}",
+            f"description: {description}",
+            f"version: {version_string}",
+            f"base_version: {self._format_version_display(base_version)}",
+            f"author: claude-mpm",  # Identify as system agent for deployment
+            f"tools: {tools_str}",
+            f"model: {model}"
+        ]
+        
+        # Add optional fields if present
+        # Check for color in metadata section (new format) or root (old format)
+        color = (
+            agent_data.get('metadata', {}).get('color') or
+            agent_data.get('color')
+        )
+        if color:
+            frontmatter_lines.append(f"color: {color}")
+        
+        frontmatter_lines.append("---")
+        frontmatter_lines.append("")
+        frontmatter_lines.append("")
+        
+        frontmatter = '\n'.join(frontmatter_lines)
+        
+        # Get the main content (instructions)
+        # Check multiple possible locations for instructions
+        content = (
+            agent_data.get('instructions') or
+            agent_data.get('narrative_fields', {}).get('instructions') or
+            agent_data.get('content') or
+            f"You are the {agent_id} agent. Perform tasks related to {agent_data.get('description', 'your specialization')}."
+        )
+        
+        return frontmatter + content
+    
+    def _parse_version(self, version_value: Any) -> tuple:
+        """
+        Parse version from various formats to semantic version tuple.
+        
+        Handles:
+        - Integer values: 5 -> (0, 5, 0)
+        - String integers: "5" -> (0, 5, 0)
+        - Semantic versions: "2.1.0" -> (2, 1, 0)
+        - Invalid formats: returns (0, 0, 0)
+        
+        Args:
+            version_value: Version in various formats
+            
+        Returns:
+            Tuple of (major, minor, patch) for comparison
+        """
+        if isinstance(version_value, int):
+            # Legacy integer version - treat as minor version
+            return (0, version_value, 0)
+            
+        if isinstance(version_value, str):
+            # Try to parse as simple integer
+            if version_value.isdigit():
+                return (0, int(version_value), 0)
+            
+            # Try to parse semantic version (e.g., "2.1.0" or "v2.1.0")
+            import re
+            sem_ver_match = re.match(r'^v?(\d+)\.(\d+)\.(\d+)', version_value)
+            if sem_ver_match:
+                major = int(sem_ver_match.group(1))
+                minor = int(sem_ver_match.group(2))
+                patch = int(sem_ver_match.group(3))
+                return (major, minor, patch)
+            
+            # Try to extract first number from string as minor version
+            num_match = re.search(r'(\d+)', version_value)
+            if num_match:
+                return (0, int(num_match.group(1)), 0)
+        
+        # Default to 0.0.0 for invalid formats
+        return (0, 0, 0)
+    
+    def _format_version_display(self, version_tuple: tuple) -> str:
+        """
+        Format version tuple for display.
+        
+        Args:
+            version_tuple: Tuple of (major, minor, patch)
+            
+        Returns:
+            Formatted version string
+        """
+        if isinstance(version_tuple, tuple) and len(version_tuple) == 3:
+            major, minor, patch = version_tuple
+            return f"{major}.{minor}.{patch}"
+        else:
+            # Fallback for legacy format
+            return str(version_tuple)
     
     async def cleanup(self):
         """Clean up resources."""

claude_mpm/services/agents/management/agent_capabilities_generator.py

@@ -116,9 +116,12 @@ class AgentCapabilitiesGenerator:
             if len(capability_text) > 100:
                 capability_text = capability_text[:97] + '...'
             
+            # Clean up the agent name for TodoWrite usage
+            clean_name = agent['name'].replace(' Agent', '').replace('-', ' ')
+            
             capabilities.append({
-                'name': agent['name'],
-                'id': agent['id'],
+                'name': clean_name,  # Clean name for TodoWrite
+                'id': agent['id'],    # Agent ID for Task tool
                 'capability_text': capability_text,
                 'tools': ', '.join(agent.get('tools', [])[:5])  # First 5 tools
             })
@@ -132,26 +135,33 @@ class AgentCapabilitiesGenerator:
             Configured Jinja2 template
         """
         template_content = """
-## Agent Names & Capabilities
-**Core Agents**: {{ core_agents }}
+## Available Agent Capabilities
+
+You have the following specialized agents available for delegation:
 
 {% if agents_by_tier.project %}
 ### Project-Specific Agents
 {% for agent in agents_by_tier.project %}
-- **{{ agent.name }}** ({{ agent.id }}): {{ agent.description }}
+- **{{ agent.name|replace(' Agent', '')|replace('-', ' ') }}** (`{{ agent.id }}`): {{ agent.description }}
 {% endfor %}
 
 {% endif %}
-**Agent Capabilities**:
+### Engineering Agents
 {% for cap in detailed_capabilities %}
-- **{{ cap.name }}**: {{ cap.capability_text }}
+{% if cap.id in ['engineer', 'data_engineer', 'documentation', 'ops', 'security', 'ticketing', 'version_control', 'web_ui'] %}
+- **{{ cap.name }}** (`{{ cap.id }}`): {{ cap.capability_text }}
+{% endif %}
 {% endfor %}
 
-**Agent Name Formats** (both valid):
-- Capitalized: {{ detailed_capabilities | map(attribute='name') | join('", "') }}
-- Lowercase-hyphenated: {{ detailed_capabilities | map(attribute='id') | join('", "') }}
+### Research Agents
+{% for cap in detailed_capabilities %}
+{% if cap.id in ['code_analyzer', 'qa', 'research', 'web_qa'] %}
+- **{{ cap.name }}** (`{{ cap.id }}`): {{ cap.capability_text }}
+{% endif %}
+{% endfor %}
 
-*Generated from {{ total_agents }} deployed agents*
+**Total Available Agents**: {{ total_agents }}
+Use the agent ID in parentheses when delegating tasks via the Task tool.
 """.strip()
         
         return Template(template_content)