claude-mpm 4.21.3__py3-none-any.whl → 5.1.9__py3-none-any.whl

claude_mpm/services/agents/deployment/remote_agent_discovery_service.py

@@ -0,0 +1,557 @@
+"""Service for discovering and converting remote Markdown agents to JSON format.
+
+This service handles the 4th tier of agent discovery: remote agents cached from GitHub.
+Remote agents are stored as Markdown files with YAML frontmatter and need to be converted
+to the JSON template format expected by the deployment system.
+
+WHY: Remote agents from GitHub are cached as Markdown but the deployment system expects
+JSON templates. This service bridges that gap and integrates remote agents into the
+multi-tier discovery system.
+"""
+
+import json
+import re
+from dataclasses import dataclass
+from pathlib import Path
+from typing import Any, Dict, List, Optional
+
+from claude_mpm.core.logging_config import get_logger
+
+logger = get_logger(__name__)
+
+
+@dataclass
+class RemoteAgentMetadata:
+    """Metadata extracted from remote agent Markdown file."""
+
+    name: str
+    description: str
+    model: str
+    routing_keywords: List[str]
+    routing_paths: List[str]
+    routing_priority: int
+    source_file: Path
+    version: str  # SHA-256 hash from cache metadata
+    collection_id: Optional[str] = None  # Format: owner/repo-name
+    source_path: Optional[str] = None  # Relative path in repo
+    canonical_id: Optional[str] = None  # Format: collection_id:agent_id
+
+
+class RemoteAgentDiscoveryService:
+    """Discovers and converts remote Markdown agents to JSON format.
+
+    Remote agents are discovered from the cache directory (~/.claude-mpm/cache/remote-agents/)
+    where they are stored as Markdown files. This service:
+    1. Discovers all *.md files in the remote agents cache
+    2. Parses Markdown frontmatter and content to extract metadata
+    3. Converts to JSON template format for deployment
+    4. Retrieves version (SHA-256 hash) from cache metadata
+
+    Design Decision: Markdown Parsing Strategy
+    - Use regex for simple frontmatter extraction (fast, no dependencies)
+    - Parse key-value pairs from Configuration section
+    - Extract routing info from Routing section
+    - Fallback to sensible defaults when sections are missing
+
+    Trade-offs:
+    - Performance: Regex parsing is fast for our simple format
+    - Maintainability: Clear regex patterns are easy to understand
+    - Flexibility: Supports optional sections with defaults
+    """
+
+    def __init__(self, remote_agents_dir: Path):
+        """Initialize the remote agent discovery service.
+
+        Args:
+            remote_agents_dir: Directory containing cached remote agent Markdown files
+        """
+        self.remote_agents_dir = remote_agents_dir
+        self.logger = get_logger(__name__)
+
+    def _extract_collection_id_from_path(self, file_path: Path) -> Optional[str]:
+        """Extract collection_id from repository path structure.
+
+        Collection ID is derived from the repository path structure:
+        ~/.claude-mpm/cache/remote-agents/{owner}/{repo}/agents/...
+
+        Args:
+            file_path: Absolute path to agent Markdown file
+
+        Returns:
+            Collection ID in format "owner/repo-name" or None if not found
+
+        Example:
+            Input:  ~/.claude-mpm/cache/remote-agents/bobmatnyc/claude-mpm-agents/agents/pm.md
+            Output: "bobmatnyc/claude-mpm-agents"
+        """
+        try:
+            # Find "remote-agents" in the path
+            path_parts = file_path.parts
+            remote_agents_idx = -1
+
+            for i, part in enumerate(path_parts):
+                if part == "remote-agents":
+                    remote_agents_idx = i
+                    break
+
+            if remote_agents_idx == -1 or remote_agents_idx + 2 >= len(path_parts):
+                self.logger.debug(
+                    f"Could not extract collection_id from path: {file_path}"
+                )
+                return None
+
+            # Extract owner and repo (next two parts after "remote-agents")
+            owner = path_parts[remote_agents_idx + 1]
+            repo = path_parts[remote_agents_idx + 2]
+
+            collection_id = f"{owner}/{repo}"
+            self.logger.debug(f"Extracted collection_id: {collection_id}")
+            return collection_id
+
+        except Exception as e:
+            self.logger.warning(
+                f"Failed to extract collection_id from {file_path}: {e}"
+            )
+            return None
+
+    def _extract_source_path_from_file(self, file_path: Path) -> Optional[str]:
+        """Extract relative source path within repository.
+
+        Source path is relative to the repository root (not the agents subdirectory).
+
+        Args:
+            file_path: Absolute path to agent Markdown file
+
+        Returns:
+            Relative path from repo root, or None if not found
+
+        Example:
+            Input:  ~/.claude-mpm/cache/remote-agents/bobmatnyc/claude-mpm-agents/agents/pm.md
+            Output: "agents/pm.md"
+        """
+        try:
+            # Find "remote-agents" in the path
+            path_parts = file_path.parts
+            remote_agents_idx = -1
+
+            for i, part in enumerate(path_parts):
+                if part == "remote-agents":
+                    remote_agents_idx = i
+                    break
+
+            if remote_agents_idx == -1 or remote_agents_idx + 3 >= len(path_parts):
+                return None
+
+            # Path after owner/repo is the source path
+            # remote-agents/{owner}/{repo}/{source_path}
+            repo_root_idx = remote_agents_idx + 3
+            source_parts = path_parts[repo_root_idx:]
+
+            return "/".join(source_parts)
+
+        except Exception as e:
+            self.logger.warning(f"Failed to extract source_path from {file_path}: {e}")
+            return None
+
+    def _generate_hierarchical_id(self, file_path: Path) -> str:
+        """Generate hierarchical agent ID from file path.
+
+        Converts file path relative to agents subdirectory into hierarchical ID.
+
+        Design Decision: Path-based IDs for hierarchy preservation
+
+        Rationale: Agent IDs must reflect directory hierarchy to enable:
+        - Category-based filtering (engineer/backend/python-engineer)
+        - Preset matching against AUTO-DEPLOY-INDEX.md
+        - Multi-level organization without name collisions
+
+        Bug #4 Fix: Calculate relative to /agents/ subdirectory, not repository root
+        This ensures agent IDs are based on their position within the agents directory.
+
+        Example:
+            Input:  /cache/bobmatnyc/claude-mpm-agents/agents/engineer/backend/python-engineer.md
+            Root:   /cache/bobmatnyc/claude-mpm-agents/agents
+            Output: engineer/backend/python-engineer
+
+        Args:
+            file_path: Absolute path to agent Markdown file
+
+        Returns:
+            Hierarchical agent ID with forward slashes
+        """
+        try:
+            # Calculate relative to /agents/ subdirectory (Bug #4 fix)
+            agents_dir = self.remote_agents_dir / "agents"
+            relative_path = file_path.relative_to(agents_dir)
+
+            # Remove .md extension and convert to forward slashes
+            return str(relative_path.with_suffix("")).replace("\\", "/")
+        except ValueError:
+            # File is not under agents subdirectory, fall back to filename
+            self.logger.warning(
+                f"File {file_path} not under agents directory, using filename"
+            )
+            return file_path.stem
+
+    def _detect_category_from_path(self, file_path: Path) -> str:
+        """Detect category from file path hierarchy.
+
+        Extracts category from directory structure. Category is the path
+        from agents subdirectory to the file, excluding the filename.
+
+        Bug #4 Fix: Calculate relative to /agents/ subdirectory, not repository root
+        This ensures categories are based on agent organization within /agents/.
+
+        Example:
+            Input:  /cache/bobmatnyc/claude-mpm-agents/agents/engineer/backend/python-engineer.md
+            Root:   /cache/bobmatnyc/claude-mpm-agents/agents
+            Output: engineer/backend
+
+        Args:
+            file_path: Absolute path to agent Markdown file
+
+        Returns:
+            Category path with forward slashes, or "universal" if in root
+        """
+        try:
+            # Calculate relative to /agents/ subdirectory (Bug #4 fix)
+            agents_dir = self.remote_agents_dir / "agents"
+            relative_path = file_path.relative_to(agents_dir)
+            parts = relative_path.parts[:-1]  # Exclude filename
+            return "/".join(parts) if parts else "universal"
+        except ValueError:
+            return "universal"
+
+    def discover_remote_agents(self) -> List[Dict[str, Any]]:
+        """Discover all remote agents from cache directory.
+
+        Scans the remote agents directory for *.md files recursively and converts each
+        to JSON template format. Skips files that can't be parsed.
+
+        Bug #4 Fix: Only scan /agents/ subdirectory, not entire repository
+        This prevents README.md, CHANGELOG.md, etc. from being treated as agents.
+
+        Returns:
+            List of agent dictionaries in JSON template format
+
+        Example:
+            >>> service = RemoteAgentDiscoveryService(Path("~/.claude-mpm/cache/remote-agents"))
+            >>> agents = service.discover_remote_agents()
+            >>> len(agents)
+            5
+            >>> agents[0]['name']
+            'Security Scanner Agent'
+        """
+        agents = []
+
+        if not self.remote_agents_dir.exists():
+            self.logger.debug(
+                f"Remote agents directory does not exist: {self.remote_agents_dir}"
+            )
+            return agents
+
+        # Bug #4 Fix: Only scan /agents/ subdirectory, not entire repository
+        # This prevents non-agent files (README.md, CHANGELOG.md, etc.) from polluting results
+        agents_dir = self.remote_agents_dir / "agents"
+
+        if not agents_dir.exists():
+            self.logger.warning(
+                f"Agents subdirectory not found: {agents_dir}. "
+                f"Expected agents to be in /agents/ subdirectory."
+            )
+            return agents
+
+        # Find all Markdown files recursively in /agents/ subdirectory only
+        md_files = list(agents_dir.rglob("*.md"))
+        self.logger.debug(f"Found {len(md_files)} Markdown files in {agents_dir}")
+
+        for md_file in md_files:
+            try:
+                agent_dict = self._parse_markdown_agent(md_file)
+                if agent_dict:
+                    agents.append(agent_dict)
+                    self.logger.debug(
+                        f"Successfully parsed remote agent: {md_file.name}"
+                    )
+                else:
+                    self.logger.warning(
+                        f"Failed to parse remote agent (no name found): {md_file.name}"
+                    )
+            except Exception as e:
+                self.logger.warning(f"Failed to parse remote agent {md_file.name}: {e}")
+
+        self.logger.info(
+            f"Discovered {len(agents)} remote agents from {self.remote_agents_dir.name}"
+        )
+        return agents
+
+    def _parse_markdown_agent(self, md_file: Path) -> Optional[Dict[str, Any]]:
+        """Parse Markdown agent file and convert to JSON template format.
+
+        Expected Markdown format:
+        ```markdown
+        # Agent Name
+
+        Description paragraph (first paragraph after heading)
+
+        ## Configuration
+        - Model: sonnet
+        - Priority: 100
+
+        ## Routing
+        - Keywords: keyword1, keyword2
+        - Paths: /path1/, /path2/
+        ```
+
+        Args:
+            md_file: Path to Markdown agent file
+
+        Returns:
+            Agent dictionary in JSON template format, or None if parsing fails
+
+        Error Handling:
+        - Returns None if agent name (first heading) is missing
+        - Uses defaults for missing sections (model=sonnet, priority=50)
+        - Empty routing keywords/paths if Routing section missing
+        """
+        try:
+            content = md_file.read_text(encoding="utf-8")
+        except Exception as e:
+            self.logger.error(f"Failed to read file {md_file}: {e}")
+            return None
+
+        # Extract agent name from first heading
+        name_match = re.search(r"^#\s+(.+?)$", content, re.MULTILINE)
+        if not name_match:
+            self.logger.debug(f"No agent name heading found in {md_file.name}")
+            return None
+        name = name_match.group(1).strip()
+
+        # Extract description (first paragraph after heading, before next heading)
+        desc_match = re.search(
+            r"^#.+?\n\n(.+?)(?:\n\n##|\Z)", content, re.DOTALL | re.MULTILINE
+        )
+        description = desc_match.group(1).strip() if desc_match else ""
+
+        # Extract model from Configuration section
+        model_match = re.search(r"Model:\s*(\w+)", content, re.IGNORECASE)
+        model = model_match.group(1) if model_match else "sonnet"
+
+        # Extract priority from Configuration section
+        priority_match = re.search(r"Priority:\s*(\d+)", content, re.IGNORECASE)
+        priority = int(priority_match.group(1)) if priority_match else 50
+
+        # Extract routing keywords
+        keywords_match = re.search(r"Keywords:\s*(.+?)(?:\n|$)", content, re.IGNORECASE)
+        keywords = []
+        if keywords_match:
+            keywords = [k.strip() for k in keywords_match.group(1).split(",")]
+
+        # Extract routing paths
+        paths_match = re.search(r"Paths:\s*(.+?)(?:\n|$)", content, re.IGNORECASE)
+        paths = []
+        if paths_match:
+            paths = [p.strip() for p in paths_match.group(1).split(",")]
+
+        # Get version (SHA-256 hash) from cache metadata
+        version = self._get_agent_version(md_file)
+
+        # Bug #3 fix: Generate hierarchical agent_id from file path
+        # This preserves directory structure for category filtering and preset matching
+        agent_id = self._generate_hierarchical_id(md_file)
+
+        # Bug #1 fix: Detect category from directory path
+        category = self._detect_category_from_path(md_file)
+
+        # NEW: Extract collection metadata from path
+        collection_id = self._extract_collection_id_from_path(md_file)
+        source_path = self._extract_source_path_from_file(md_file)
+
+        # NEW: Generate canonical_id (collection_id:agent_id)
+        if collection_id:
+            canonical_id = f"{collection_id}:{agent_id}"
+        else:
+            # Fallback for legacy agents without collection
+            canonical_id = f"legacy:{agent_id}"
+
+        # Convert to JSON template format and return
+        # IMPORTANT: Include 'path' field for compatibility with deployment validation (ticket 1M-480)
+        # Git-sourced agents must have 'path' field to match structure from AgentDiscoveryService
+        return {
+            "agent_id": agent_id,
+            "canonical_id": canonical_id,  # NEW: Primary matching key
+            "collection_id": collection_id,  # NEW: Collection identifier
+            "source_path": source_path,  # NEW: Path within repository
+            "metadata": {
+                "name": name,
+                "description": description,
+                "version": version,
+                "author": "remote",  # Mark as remote agent
+                "category": category,  # Use detected category from path
+                "collection_id": collection_id,  # NEW: Also in metadata
+                "source_path": source_path,  # NEW: Also in metadata
+                "canonical_id": canonical_id,  # NEW: Also in metadata
+            },
+            "model": model,
+            "source": "remote",  # Mark as remote agent
+            "source_file": str(md_file),
+            "path": str(
+                md_file
+            ),  # Add 'path' field for deployment compatibility (1M-480)
+            "file_path": str(md_file),  # Keep for backward compatibility
+            "version": version,  # Include at root level for version comparison
+            "category": category,  # Add category at root level for filtering
+            "routing": {"keywords": keywords, "paths": paths, "priority": priority},
+        }
+
+    def _get_agent_version(self, md_file: Path) -> str:
+        """Get version (SHA-256 hash) from cache metadata.
+
+        Looks for corresponding .meta.json file in cache directory that contains
+        the SHA-256 hash of the agent content.
+
+        Args:
+            md_file: Path to Markdown agent file
+
+        Returns:
+            SHA-256 hash from metadata, or 'unknown' if not found
+
+        Example metadata file:
+            {
+                "content_hash": "abc123...",
+                "etag": "W/\"abc123\"",
+                "last_modified": "2025-11-30T10:00:00Z"
+            }
+        """
+        # Look for .meta.json file
+        meta_file = md_file.with_suffix(".md.meta.json")
+
+        if not meta_file.exists():
+            self.logger.debug(f"No metadata file found for {md_file.name}")
+            return "unknown"
+
+        try:
+            meta_data = json.loads(meta_file.read_text(encoding="utf-8"))
+            content_hash = meta_data.get("content_hash", "unknown")
+            self.logger.debug(
+                f"Retrieved version {content_hash[:8]}... for {md_file.name}"
+            )
+            return content_hash
+        except Exception as e:
+            self.logger.warning(f"Failed to read metadata for {md_file.name}: {e}")
+            return "unknown"
+
+    def get_remote_agent_metadata(
+        self, agent_name: str
+    ) -> Optional[RemoteAgentMetadata]:
+        """Get metadata for a specific remote agent.
+
+        Args:
+            agent_name: Name of the agent to retrieve
+
+        Returns:
+            RemoteAgentMetadata if found, None otherwise
+        """
+        # Bug #4 fix: Search in /agents/ subdirectory, not root directory
+        agents_dir = self.remote_agents_dir / "agents"
+        if not agents_dir.exists():
+            return None
+
+        for md_file in agents_dir.rglob("*.md"):
+            agent_dict = self._parse_markdown_agent(md_file)
+            if agent_dict and agent_dict["metadata"]["name"] == agent_name:
+                return RemoteAgentMetadata(
+                    name=agent_dict["metadata"]["name"],
+                    description=agent_dict["metadata"]["description"],
+                    model=agent_dict["model"],
+                    routing_keywords=agent_dict["routing"]["keywords"],
+                    routing_paths=agent_dict["routing"]["paths"],
+                    routing_priority=agent_dict["routing"]["priority"],
+                    source_file=Path(agent_dict["source_file"]),
+                    version=agent_dict["version"],
+                    collection_id=agent_dict.get("collection_id"),
+                    source_path=agent_dict.get("source_path"),
+                    canonical_id=agent_dict.get("canonical_id"),
+                )
+        return None
+
+    def get_agents_by_collection(self, collection_id: str) -> List[Dict[str, Any]]:
+        """Get all agents belonging to a specific collection.
+
+        Args:
+            collection_id: Collection identifier in format "owner/repo-name"
+
+        Returns:
+            List of agent dictionaries from the specified collection
+
+        Example:
+            >>> service = RemoteAgentDiscoveryService(Path("~/.claude-mpm/cache/remote-agents"))
+            >>> agents = service.get_agents_by_collection("bobmatnyc/claude-mpm-agents")
+            >>> len(agents)
+            45
+        """
+        all_agents = self.discover_remote_agents()
+
+        # Filter by collection_id
+        collection_agents = [
+            agent for agent in all_agents if agent.get("collection_id") == collection_id
+        ]
+
+        self.logger.info(
+            f"Found {len(collection_agents)} agents in collection '{collection_id}'"
+        )
+
+        return collection_agents
+
+    def list_collections(self) -> List[Dict[str, Any]]:
+        """List all available collections with agent counts.
+
+        Returns:
+            List of collection info dictionaries with:
+            - collection_id: Collection identifier
+            - agent_count: Number of agents in collection
+            - agents: List of agent IDs in collection
+
+        Example:
+            >>> service = RemoteAgentDiscoveryService(Path("~/.claude-mpm/cache/remote-agents"))
+            >>> collections = service.list_collections()
+            >>> collections
+            [
+                {
+                    "collection_id": "bobmatnyc/claude-mpm-agents",
+                    "agent_count": 45,
+                    "agents": ["pm", "engineer", "qa", ...]
+                }
+            ]
+        """
+        all_agents = self.discover_remote_agents()
+
+        # Group by collection_id
+        collections_map: Dict[str, List[str]] = {}
+
+        for agent in all_agents:
+            collection_id = agent.get("collection_id")
+            if not collection_id:
+                # Skip agents without collection (legacy)
+                continue
+
+            if collection_id not in collections_map:
+                collections_map[collection_id] = []
+
+            agent_id = agent.get("agent_id", agent.get("metadata", {}).get("name"))
+            if agent_id:
+                collections_map[collection_id].append(agent_id)
+
+        # Convert to list format
+        collections = [
+            {
+                "collection_id": coll_id,
+                "agent_count": len(agent_ids),
+                "agents": sorted(agent_ids),
+            }
+            for coll_id, agent_ids in collections_map.items()
+        ]
+
+        self.logger.info(f"Found {len(collections)} collections")
+
+        return collections

claude_mpm/services/agents/deployment/single_agent_deployer.py

@@ -200,8 +200,8 @@ class SingleAgentDeployer:
         - Enables selective agent management in projects
         """
         try:
-            # Find the template file
-            template_file = templates_dir / f"{agent_name}.json"
+            # Find the template file (templates migrated to .md in v4.26.0+)
+            template_file = templates_dir / f"{agent_name}.md"
             if not template_file.exists():
                 self.logger.error(f"Agent template not found: {agent_name}")
                 return False