claude-mpm 5.0.2__py3-none-any.whl → 5.4.3__py3-none-any.whl

claude_mpm/cli/commands/agent_state_manager.py

@@ -152,7 +152,7 @@ class SimpleAgentManager:
 
                     # Get metadata for display info
                     metadata = template_data.get("metadata", {})
-                    metadata.get("name", agent_id)
+                    display_name = metadata.get("name", agent_id)
                     description = metadata.get(
                         "description", "No description available"
                     )
@@ -169,18 +169,26 @@ class SimpleAgentManager:
                     # Normalize agent ID (remove -agent suffix if present, replace underscores)
                     normalized_id = agent_id.replace("-agent", "").replace("_", "-")
 
-                    agents.append(
-                        AgentConfig(
-                            name=normalized_id,
-                            description=(
-                                description[:80] + "..."
-                                if len(description) > 80
-                                else description
-                            ),
-                            dependencies=display_tools,
-                        )
+                    # Check if this agent is deployed
+                    is_deployed = self._is_agent_deployed(normalized_id)
+
+                    agent_config = AgentConfig(
+                        name=normalized_id,
+                        description=(
+                            description[:80] + "..."
+                            if len(description) > 80
+                            else description
+                        ),
+                        dependencies=display_tools,
                     )
 
+                    # Set deployment status and display name
+                    agent_config.is_deployed = is_deployed
+                    agent_config.source_type = "local"
+                    agent_config.display_name = display_name
+
+                    agents.append(agent_config)
+
                 except (json.JSONDecodeError, KeyError) as e:
                     # Log malformed templates but continue
                     self.logger.debug(
@@ -228,7 +236,7 @@ class SimpleAgentManager:
                 # Create AgentConfig with source information
                 # Store full agent_dict for later use in deployment
                 agent_config = AgentConfig(
-                    name=agent_id,  # Use agent_id as name for uniqueness
+                    name=name,  # Use display name for UI
                     description=(
                         f"[{category}] {description[:60]}..."
                         if len(description) > 60
@@ -241,6 +249,7 @@ class SimpleAgentManager:
                 agent_config.source_type = "remote"
                 agent_config.is_deployed = is_deployed
                 agent_config.display_name = name
+                agent_config.agent_id = agent_id  # Store technical ID for reference
                 agent_config.full_agent_id = agent_id
                 agent_config.source_dict = agent_dict  # Store full dict for deployment
 
@@ -256,7 +265,7 @@ class SimpleAgentManager:
             return []
 
     def _is_agent_deployed(self, agent_id: str) -> bool:
-        """Check if agent is deployed in current project or user directory.
+        """Check if agent is deployed (virtual deployment or physical files).
 
         Args:
             agent_id: Full agent ID (may include hierarchy like engineer/backend/python-engineer)
@@ -264,6 +273,46 @@ class SimpleAgentManager:
         Returns:
             True if agent is deployed, False otherwise
         """
+        # Check virtual deployment state (primary method)
+        # Only checking project-level deployment in simplified architecture
+        deployment_state_paths = [
+            Path.cwd() / ".claude" / "agents" / ".mpm_deployment_state",
+        ]
+
+        for state_path in deployment_state_paths:
+            if state_path.exists():
+                try:
+                    with state_path.open() as f:
+                        state = json.load(f)
+
+                    # Check if agent is in deployment state
+                    agents = state.get("last_check_results", {}).get("agents", {})
+
+                    # Check full agent_id
+                    if agent_id in agents:
+                        self.logger.debug(
+                            f"Agent {agent_id} found in virtual deployment state"
+                        )
+                        return True
+
+                    # Check leaf name for hierarchical IDs
+                    if "/" in agent_id:
+                        leaf_name = agent_id.split("/")[-1]
+                        if leaf_name in agents:
+                            self.logger.debug(
+                                f"Agent {agent_id} (leaf: {leaf_name}) found in virtual deployment state"
+                            )
+                            return True
+                except (json.JSONDecodeError, KeyError) as e:
+                    self.logger.debug(
+                        f"Failed to read deployment state from {state_path}: {e}"
+                    )
+                    continue
+                except Exception as e:
+                    self.logger.debug(f"Unexpected error reading deployment state: {e}")
+                    continue
+
+        # Fallback to physical file checks (legacy support)
         # For hierarchical IDs, check both full ID and leaf name
         agent_file_names = [f"{agent_id}.md"]
 
@@ -272,20 +321,15 @@ class SimpleAgentManager:
             leaf_name = agent_id.split("/")[-1]
             agent_file_names.append(f"{leaf_name}.md")
 
-        # Check .claude-mpm/agents/ directory (project level)
-        project_agents_dir = Path.cwd() / ".claude-mpm" / "agents"
+        # Check .claude/agents/ directory (project deployment)
+        project_agents_dir = Path.cwd() / ".claude" / "agents"
         if project_agents_dir.exists():
             for agent_file_name in agent_file_names:
                 agent_file = project_agents_dir / agent_file_name
                 if agent_file.exists():
-                    return True
-
-        # Check ~/.claude/agents/ directory (user level)
-        user_agents_dir = Path.home() / ".claude" / "agents"
-        if user_agents_dir.exists():
-            for agent_file_name in agent_file_names:
-                agent_file = user_agents_dir / agent_file_name
-                if agent_file.exists():
+                    self.logger.debug(
+                        f"Agent {agent_id} found as physical file: {agent_file}"
+                    )
                     return True
 
         return False

claude_mpm/cli/commands/agents.py

@@ -167,6 +167,16 @@ class AgentsCommand(AgentCommand):
                 "available": self._list_available_from_sources,
                 # Agent discovery with rich filtering (Phase 1: Discovery & Browsing)
                 "discover": self._discover_agents,
+                # NEW: Collection-based agent management
+                "list-collections": self._list_collections,
+                "deploy-collection": self._deploy_collection,
+                "list-by-collection": self._list_by_collection,
+                # Cache git management commands
+                "cache-status": self._cache_status,
+                "cache-pull": self._cache_pull,
+                "cache-push": self._cache_push,
+                "cache-sync": self._cache_sync,
+                "cache-commit": self._cache_commit,
             }
 
             if args.agents_command in command_map:
@@ -551,34 +561,63 @@ class AgentsCommand(AgentCommand):
             return CommandResult.error_result(f"Error discovering agents: {e}")
 
     def _deploy_agents(self, args, force=False) -> CommandResult:
-        """Deploy both system and project agents, or deploy by preset."""
+        """Deploy agents using two-phase sync: cache → deploy.
+
+        Phase 3 Integration (1M-486): Uses Git sync service for deployment.
+        - Phase 1: Sync agents to ~/.claude-mpm/cache/remote-agents/ (if needed)
+        - Phase 2: Deploy from cache to project .claude-mpm/agents/
+
+        This replaces the old single-tier deployment with a multi-project
+        architecture where one cache serves multiple project deployments.
+        """
         try:
-            # Handle preset deployment
+            # Handle preset deployment (uses different path)
             if hasattr(args, "preset") and args.preset:
                 return self._deploy_preset(args)
 
-            # Deploy system agents
-            system_result = self.deployment_service.deploy_system_agents(force=force)
+            from ...services.agents.sources.git_source_sync_service import (
+                GitSourceSyncService,
+            )
+
+            # Initialize git sync service
+            git_sync = GitSourceSyncService()
+            project_dir = Path.cwd()
+
+            self.logger.info("Phase 1: Syncing agents to cache...")
+
+            # Sync to cache (downloads from GitHub if needed)
+            sync_result = git_sync.sync_repository(force=force)
+
+            if not sync_result.get("synced"):
+                error_msg = sync_result.get("error", "Unknown sync error")
+                self.logger.error(f"Sync failed: {error_msg}")
+                return CommandResult.error_result(f"Sync failed: {error_msg}")
+
+            self.logger.info(
+                f"Phase 1 complete: {sync_result.get('agent_count', 0)} agents in cache"
+            )
+            self.logger.info(f"Phase 2: Deploying agents to {project_dir}...")
 
-            # Deploy project agents if they exist
-            project_result = self.deployment_service.deploy_project_agents(force=force)
+            # Deploy from cache to project directory
+            deploy_result = git_sync.deploy_agents_to_project(
+                project_dir=project_dir,
+                agent_list=None,  # Deploy all cached agents
+                force=force,
+            )
 
-            # Combine results
+            # Format combined results for output
             combined_result = {
-                "deployed_count": system_result.get("deployed_count", 0)
-                + project_result.get("deployed_count", 0),
-                "deployed": system_result.get("deployed", [])
-                + project_result.get("deployed", []),
-                "updated_count": system_result.get("updated_count", 0)
-                + project_result.get("updated_count", 0),
-                "updated": system_result.get("updated", [])
-                + project_result.get("updated", []),
-                "skipped": system_result.get("skipped", [])
-                + project_result.get("skipped", []),
-                "errors": system_result.get("errors", [])
-                + project_result.get("errors", []),
-                "target_dir": system_result.get("target_dir")
-                or project_result.get("target_dir"),
+                "deployed_count": len(deploy_result.get("deployed", []))
+                + len(deploy_result.get("updated", [])),
+                "deployed": deploy_result.get("deployed", []),
+                "updated": deploy_result.get("updated", []),
+                "skipped": deploy_result.get("skipped", []),
+                "errors": deploy_result.get("failed", []),
+                "target_dir": deploy_result.get("deployment_dir", ""),
+                "sync_info": {
+                    "cached_agents": sync_result.get("agent_count", 0),
+                    "cache_dir": sync_result.get("cache_dir", ""),
+                },
             }
 
             output_format = self._get_output_format(args)
@@ -589,12 +628,15 @@ class AgentsCommand(AgentCommand):
             )
             print(formatted)
 
+            success_count = len(deploy_result["deployed"]) + len(
+                deploy_result["updated"]
+            )
             return CommandResult.success_result(
-                f"Deployed {combined_result['deployed_count']} agents",
+                f"Deployed {success_count} agents from cache",
                 data={
-                    "system_agents": system_result,
-                    "project_agents": project_result,
-                    "total_deployed": combined_result["deployed_count"],
+                    "sync_result": sync_result,
+                    "deploy_result": deploy_result,
+                    "total_deployed": success_count,
                 },
             )
 
@@ -2119,6 +2161,385 @@ class AgentsCommand(AgentCommand):
             self.logger.error(f"Error in auto-configure: {e}", exc_info=True)
             return CommandResult.error_result(f"Error in auto-configure: {e}")
 
+    def _list_collections(self, args) -> CommandResult:
+        """List all available agent collections.
+
+        NEW: Shows all collections with agent counts and metadata.
+        Enables discovery of available agent collections before deployment.
+        """
+        try:
+            from pathlib import Path
+
+            from ...services.agents.deployment.remote_agent_discovery_service import (
+                RemoteAgentDiscoveryService,
+            )
+
+            # Get remote agents cache directory
+            cache_dir = Path.home() / ".claude-mpm" / "cache" / "remote-agents"
+
+            if not cache_dir.exists():
+                return CommandResult.error_result(
+                    "No remote agent collections found. Run 'claude-mpm agents deploy' first."
+                )
+
+            # Use RemoteAgentDiscoveryService to list collections
+            remote_service = RemoteAgentDiscoveryService(cache_dir)
+            collections = remote_service.list_collections()
+
+            if not collections:
+                return CommandResult.success_result(
+                    "No agent collections found in cache.", data={"collections": []}
+                )
+
+            # Format output
+            output_lines = ["Available Agent Collections:\n"]
+            for collection in collections:
+                output_lines.append(
+                    f"  • {collection['collection_id']} ({collection['agent_count']} agents)"
+                )
+
+            return CommandResult.success_result(
+                "\n".join(output_lines), data={"collections": collections}
+            )
+
+        except Exception as e:
+            self.logger.error(f"Error listing collections: {e}", exc_info=True)
+            return CommandResult.error_result(f"Error listing collections: {e}")
+
+    def _deploy_collection(self, args) -> CommandResult:
+        """Deploy all agents from a specific collection.
+
+        NEW: Enables bulk deployment of all agents from a named collection.
+        Useful for deploying entire agent sets at once.
+        """
+        try:
+            from pathlib import Path
+
+            from ...services.agents.deployment.multi_source_deployment_service import (
+                MultiSourceAgentDeploymentService,
+            )
+
+            collection_id = args.collection_id
+
+            # Get agents from collection
+            service = MultiSourceAgentDeploymentService()
+            cache_dir = Path.home() / ".claude-mpm" / "cache" / "remote-agents"
+            agents = service.get_agents_by_collection(collection_id, cache_dir)
+
+            if not agents:
+                return CommandResult.error_result(
+                    f"No agents found in collection '{collection_id}'"
+                )
+
+            # Dry run mode
+            if getattr(args, "dry_run", False):
+                agent_names = [
+                    agent.get("metadata", {}).get("name", "Unknown") for agent in agents
+                ]
+                output = f"Would deploy {len(agents)} agents from collection '{collection_id}':\n"
+                for name in agent_names:
+                    output += f"  • {name}\n"
+                return CommandResult.success_result(
+                    output,
+                    data={"collection_id": collection_id, "agent_count": len(agents)},
+                )
+
+            # Deploy agents
+            # TODO: Implement actual deployment logic using deployment service
+            # For now, show what would be deployed
+            return CommandResult.success_result(
+                f"Deployment of collection '{collection_id}' would deploy {len(agents)} agents.\n"
+                f"(Full deployment implementation pending)",
+                data={
+                    "collection_id": collection_id,
+                    "agent_count": len(agents),
+                    "status": "pending_implementation",
+                },
+            )
+
+        except Exception as e:
+            self.logger.error(f"Error deploying collection: {e}", exc_info=True)
+            return CommandResult.error_result(f"Error deploying collection: {e}")
+
+    def _list_by_collection(self, args) -> CommandResult:
+        """List agents from a specific collection.
+
+        NEW: Shows detailed information about agents in a collection.
+        Supports multiple output formats (table, json, yaml).
+        """
+        try:
+            import json as json_lib
+            from pathlib import Path
+
+            from ...services.agents.deployment.multi_source_deployment_service import (
+                MultiSourceAgentDeploymentService,
+            )
+
+            collection_id = args.collection_id
+            output_format = getattr(args, "format", "table")
+
+            # Get agents from collection
+            service = MultiSourceAgentDeploymentService()
+            cache_dir = Path.home() / ".claude-mpm" / "cache" / "remote-agents"
+            agents = service.get_agents_by_collection(collection_id, cache_dir)
+
+            if not agents:
+                return CommandResult.error_result(
+                    f"No agents found in collection '{collection_id}'"
+                )
+
+            # Format output based on requested format
+            if output_format == "json":
+                return CommandResult.success_result(
+                    json_lib.dumps(agents, indent=2),
+                    data={"collection_id": collection_id, "agents": agents},
+                )
+            if output_format == "yaml":
+                try:
+                    import yaml
+
+                    return CommandResult.success_result(
+                        yaml.dump(agents, default_flow_style=False),
+                        data={"collection_id": collection_id, "agents": agents},
+                    )
+                except ImportError:
+                    return CommandResult.error_result(
+                        "YAML support not available (install PyYAML)"
+                    )
+
+            # Table format (default)
+            output_lines = [f"Agents in collection '{collection_id}':\n"]
+            for agent in agents:
+                metadata = agent.get("metadata", {})
+                name = metadata.get("name", "Unknown")
+                description = metadata.get("description", "No description")
+                version = agent.get("version", "unknown")
+                output_lines.append(f"  • {name} (v{version})")
+                output_lines.append(f"    {description}\n")
+
+            return CommandResult.success_result(
+                "\n".join(output_lines),
+                data={"collection_id": collection_id, "agent_count": len(agents)},
+            )
+
+        except Exception as e:
+            self.logger.error(f"Error listing collection agents: {e}", exc_info=True)
+            return CommandResult.error_result(f"Error listing collection agents: {e}")
+
+    def _cache_status(self, args) -> CommandResult:
+        """Show git status of agent cache.
+
+        Displays current branch, uncommitted changes, unpushed commits, and
+        remote URL for the agent cache repository.
+        """
+        try:
+            from ...services.agents.cache_git_manager import CacheGitManager
+
+            cache_dir = Path.home() / ".claude-mpm" / "cache" / "remote-agents"
+            manager = CacheGitManager(cache_dir)
+
+            if not manager.is_git_repo():
+                print("❌ Cache is not a git repository")
+                print(f"\nCache location: {cache_dir}")
+                print(
+                    "\n💡 This is expected if you haven't cloned the agents repository."
+                )
+                print("   The cache will be managed via HTTP sync instead.")
+                return CommandResult.error_result("Cache is not a git repository")
+
+            status = manager.get_status()
+            output_format = self._get_output_format(args)
+
+            if self._is_structured_format(output_format):
+                formatted = (
+                    self._formatter.format_as_json(status)
+                    if str(output_format).lower() == OutputFormat.JSON
+                    else self._formatter.format_as_yaml(status)
+                )
+                print(formatted)
+                return CommandResult.success_result(
+                    "Cache status retrieved", data=status
+                )
+
+            # Text output
+            print(f"\n📁 Cache: {manager.repo_path}")
+            print(f"🌿 Branch: {status.get('branch', 'unknown')}")
+
+            if status.get("remote_url"):
+                print(f"🔗 Remote: {status['remote_url']}")
+
+            # Show sync status
+            ahead = status.get("ahead", 0)
+            behind = status.get("behind", 0)
+
+            if ahead > 0:
+                print(f"📤 Ahead of remote: {ahead} commit(s)")
+            if behind > 0:
+                print(f"📥 Behind remote: {behind} commit(s)")
+
+            if ahead == 0 and behind == 0:
+                print("✅ In sync with remote")
+
+            # Show uncommitted changes
+            uncommitted = status.get("uncommitted", [])
+            if uncommitted:
+                print(f"\n⚠️  Uncommitted changes: {len(uncommitted)}")
+                for file in uncommitted[:10]:  # Show max 10 files
+                    print(f"   - {file}")
+                if len(uncommitted) > 10:
+                    print(f"   ... and {len(uncommitted) - 10} more")
+            else:
+                print("\n✅ No uncommitted changes")
+
+            # Overall status
+            if status.get("is_clean"):
+                print("\n✨ Cache is clean and up-to-date")
+            else:
+                print("\n💡 Run 'claude-mpm agents cache-sync' to sync with remote")
+
+            return CommandResult.success_result("Cache status displayed", data=status)
+
+        except Exception as e:
+            self.logger.error(f"Error getting cache status: {e}", exc_info=True)
+            return CommandResult.error_result(f"Error getting cache status: {e}")
+
+    def _cache_pull(self, args) -> CommandResult:
+        """Pull latest agents from remote repository."""
+        try:
+            from ...services.agents.cache_git_manager import CacheGitManager
+
+            cache_dir = Path.home() / ".claude-mpm" / "cache" / "remote-agents"
+            manager = CacheGitManager(cache_dir)
+
+            if not manager.is_git_repo():
+                print("❌ Cache is not a git repository")
+                return CommandResult.error_result("Cache is not a git repository")
+
+            branch = getattr(args, "branch", "main")
+            print(f"🔄 Pulling latest changes from {branch}...")
+
+            success, msg = manager.pull_latest(branch)
+
+            if success:
+                print(f"✅ {msg}")
+                return CommandResult.success_result(msg)
+            print(f"❌ {msg}")
+            return CommandResult.error_result(msg)
+
+        except Exception as e:
+            self.logger.error(f"Error pulling cache: {e}", exc_info=True)
+            return CommandResult.error_result(f"Error pulling cache: {e}")
+
+    def _cache_commit(self, args) -> CommandResult:
+        """Commit changes to cache repository."""
+        try:
+            from ...services.agents.cache_git_manager import CacheGitManager
+
+            cache_dir = Path.home() / ".claude-mpm" / "cache" / "remote-agents"
+            manager = CacheGitManager(cache_dir)
+
+            if not manager.is_git_repo():
+                print("❌ Cache is not a git repository")
+                return CommandResult.error_result("Cache is not a git repository")
+
+            # Get commit message from args
+            message = getattr(args, "message", None)
+            if not message:
+                # Default message
+                message = "feat: update agents from local development"
+
+            print("💾 Committing changes...")
+            success, msg = manager.commit_changes(message)
+
+            if success:
+                print(f"✅ {msg}")
+                print(f"\n💡 Commit message: {message}")
+                return CommandResult.success_result(msg)
+            print(f"❌ {msg}")
+            return CommandResult.error_result(msg)
+
+        except Exception as e:
+            self.logger.error(f"Error committing cache changes: {e}", exc_info=True)
+            return CommandResult.error_result(f"Error committing cache changes: {e}")
+
+    def _cache_push(self, args) -> CommandResult:
+        """Push local agent changes to remote."""
+        try:
+            from ...services.agents.cache_git_manager import CacheGitManager
+
+            cache_dir = Path.home() / ".claude-mpm" / "cache" / "remote-agents"
+            manager = CacheGitManager(cache_dir)
+
+            if not manager.is_git_repo():
+                print("❌ Cache is not a git repository")
+                return CommandResult.error_result("Cache is not a git repository")
+
+            # Check for uncommitted changes
+            if manager.has_uncommitted_changes():
+                print("⚠️  You have uncommitted changes.")
+                print("\n💡 Commit changes first with:")
+                print("   claude-mpm agents cache-commit --message 'your message'")
+
+                # Ask if user wants to commit first
+                auto_commit = getattr(args, "auto_commit", False)
+                if auto_commit:
+                    print("\n📝 Auto-committing changes...")
+                    success, msg = manager.commit_changes("feat: update agents")
+                    if not success:
+                        print(f"❌ Commit failed: {msg}")
+                        return CommandResult.error_result(f"Commit failed: {msg}")
+                    print(f"✅ {msg}")
+                else:
+                    return CommandResult.error_result(
+                        "Uncommitted changes detected. Commit first or use --auto-commit"
+                    )
+
+            # Push changes
+            branch = getattr(args, "branch", "main")
+            print(f"📤 Pushing changes to {branch}...")
+
+            success, msg = manager.push_changes(branch)
+
+            if success:
+                print(f"✅ {msg}")
+                return CommandResult.success_result(msg)
+            print(f"❌ {msg}")
+            return CommandResult.error_result(msg)
+
+        except Exception as e:
+            self.logger.error(f"Error pushing cache: {e}", exc_info=True)
+            return CommandResult.error_result(f"Error pushing cache: {e}")
+
+    def _cache_sync(self, args) -> CommandResult:
+        """Full cache sync: pull, commit (if needed), push."""
+        try:
+            from ...services.agents.cache_git_manager import CacheGitManager
+
+            cache_dir = Path.home() / ".claude-mpm" / "cache" / "remote-agents"
+            manager = CacheGitManager(cache_dir)
+
+            if not manager.is_git_repo():
+                print("❌ Cache is not a git repository")
+                return CommandResult.error_result("Cache is not a git repository")
+
+            print("🔄 Syncing cache with remote...\n")
+
+            success, msg = manager.sync_with_remote()
+
+            # Print detailed sync message
+            print(msg)
+
+            if success:
+                print("\n✨ Cache sync complete!")
+                return CommandResult.success_result("Cache synced successfully")
+
+            print("\n❌ Cache sync failed. See details above.")
+            return CommandResult.error_result("Cache sync failed")
+
+        except Exception as e:
+            self.logger.error(f"Error syncing cache: {e}", exc_info=True)
+            return CommandResult.error_result(f"Error syncing cache: {e}")
+
 
 def manage_agents(args):
     """