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

claude_mpm/core/system_context.py

@@ -0,0 +1,38 @@
+"""System context utilities for Claude runner.
+
+This module provides shared context creation functions that can be used
+across different modules without circular dependencies.
+"""
+
+
+def create_simple_context() -> str:
+    """Create basic context for Claude.
+
+    This function is extracted to avoid circular imports between
+    claude_runner.py and interactive_session.py.
+
+    Returns:
+        Basic system context string for Claude
+    """
+    return """You are Claude Code running in Claude MPM (Multi-Agent Project Manager).
+
+You have access to native subagents via the Task tool with subagent_type parameter:
+- engineer: For coding, implementation, and technical tasks
+- qa: For testing, validation, and quality assurance
+- documentation: For docs, guides, and explanations
+- research: For investigation and analysis
+- security: For security-related tasks
+- ops: For deployment and infrastructure
+- version-control: For git and version management
+- data-engineer: For data processing and APIs
+
+Use these agents by calling: Task(description="task description", subagent_type="agent_name")
+
+IMPORTANT: The Task tool accepts both naming formats:
+- Capitalized format: "Research", "Engineer", "QA", "Version Control", "Data Engineer"
+- Lowercase format: "research", "engineer", "qa", "version-control", "data-engineer"
+
+Both formats work correctly. When you see capitalized names (matching TodoWrite prefixes),
+automatically normalize them to lowercase-hyphenated format for the Task tool.
+
+Work efficiently and delegate appropriately to subagents when needed."""

claude_mpm/core/unified_agent_registry.py

@@ -84,6 +84,12 @@ class AgentMetadata:
     version: str = "1.0.0"
     author: str = ""
     tags: List[str] = None
+    # NEW: Collection-based identification fields
+    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 or legacy:filename
+    )
 
     def __post_init__(self):
         """Initialize default values for mutable fields."""
@@ -690,6 +696,111 @@ class UnifiedAgentRegistry:
         """Get all memory-aware agents."""
         return self.list_agents(agent_type=AgentType.MEMORY_AWARE)
 
+    def get_agents_by_collection(self, collection_id: str) -> List[AgentMetadata]:
+        """Get all agents from a specific collection.
+
+        NEW: Enables collection-based agent selection.
+
+        Args:
+            collection_id: Collection identifier (e.g., "bobmatnyc/claude-mpm-agents")
+
+        Returns:
+            List of agents from the specified collection
+
+        Example:
+            >>> registry = get_agent_registry()
+            >>> agents = registry.get_agents_by_collection("bobmatnyc/claude-mpm-agents")
+            >>> len(agents)
+            45
+        """
+        if not self.registry:
+            self.discover_agents()
+
+        collection_agents = [
+            agent
+            for agent in self.registry.values()
+            if agent.collection_id == collection_id
+        ]
+
+        return sorted(collection_agents, key=lambda a: a.name)
+
+    def list_collections(self) -> List[Dict[str, Any]]:
+        """List all available collections with agent counts.
+
+        NEW: Provides overview of available collections.
+
+        Returns:
+            List of collection info dictionaries with:
+            - collection_id: Collection identifier
+            - agent_count: Number of agents in collection
+            - agents: List of agent names in collection
+
+        Example:
+            >>> registry = get_agent_registry()
+            >>> collections = registry.list_collections()
+            >>> collections
+            [
+                {
+                    "collection_id": "bobmatnyc/claude-mpm-agents",
+                    "agent_count": 45,
+                    "agents": ["pm", "engineer", "qa", ...]
+                }
+            ]
+        """
+        if not self.registry:
+            self.discover_agents()
+
+        # Group agents by collection_id
+        collections_map: Dict[str, List[str]] = {}
+
+        for agent in self.registry.values():
+            if not agent.collection_id:
+                # Skip agents without collection (legacy or local)
+                continue
+
+            if agent.collection_id not in collections_map:
+                collections_map[agent.collection_id] = []
+
+            collections_map[agent.collection_id].append(agent.name)
+
+        # Convert to list format
+        collections = [
+            {
+                "collection_id": coll_id,
+                "agent_count": len(agent_names),
+                "agents": sorted(agent_names),
+            }
+            for coll_id, agent_names in collections_map.items()
+        ]
+
+        return sorted(collections, key=lambda c: c["collection_id"])
+
+    def get_agent_by_canonical_id(self, canonical_id: str) -> Optional[AgentMetadata]:
+        """Get agent by canonical ID (primary matching key).
+
+        NEW: Primary matching method using canonical_id.
+
+        Args:
+            canonical_id: Canonical identifier (e.g., "bobmatnyc/claude-mpm-agents:pm")
+
+        Returns:
+            AgentMetadata if found, None otherwise
+
+        Example:
+            >>> registry = get_agent_registry()
+            >>> agent = registry.get_agent_by_canonical_id("bobmatnyc/claude-mpm-agents:pm")
+            >>> agent.name
+            'Project Manager Agent'
+        """
+        if not self.registry:
+            self.discover_agents()
+
+        for agent in self.registry.values():
+            if agent.canonical_id == canonical_id:
+                return agent
+
+        return None
+
     def add_discovery_path(self, path: Union[str, Path]) -> None:
         """Add a new path for agent discovery."""
         path = Path(path)
@@ -809,6 +920,21 @@ def get_registry_stats() -> Dict[str, Any]:
     return get_agent_registry().get_registry_stats()
 
 
+def get_agents_by_collection(collection_id: str) -> List[AgentMetadata]:
+    """Get all agents from a specific collection."""
+    return get_agent_registry().get_agents_by_collection(collection_id)
+
+
+def list_collections() -> List[Dict[str, Any]]:
+    """List all available collections."""
+    return get_agent_registry().list_collections()
+
+
+def get_agent_by_canonical_id(canonical_id: str) -> Optional[AgentMetadata]:
+    """Get agent by canonical ID."""
+    return get_agent_registry().get_agent_by_canonical_id(canonical_id)
+
+
 # Legacy function names for backward compatibility
 def listAgents() -> List[str]:
     """Legacy function: Get list of agent names."""
@@ -838,14 +964,16 @@ __all__ = [
     "discover_agents",
     "discover_agents_sync",
     "get_agent",
+    "get_agent_by_canonical_id",
     "get_agent_names",
     "get_agent_registry",
+    "get_agents_by_collection",
     "get_core_agents",
     "get_project_agents",
     "get_registry_stats",
     "get_specialized_agents",
-    # Legacy compatibility
     "listAgents",
     "list_agents",
     "list_agents_all",
+    "list_collections",
 ]

claude_mpm/core/unified_config.py

@@ -218,6 +218,27 @@ class DevelopmentConfig(BaseModel):
     )
 
 
+class DocumentationConfig(BaseModel):
+    """Documentation routing and management configuration."""
+
+    docs_path: str = Field(
+        default="docs/research/",
+        description="Default path for session documentation (relative to project root)",
+    )
+    attach_to_tickets: bool = Field(
+        default=True,
+        description="Attach work products to tickets when ticket context exists",
+    )
+    backup_locally: bool = Field(
+        default=True,
+        description="Always create local backup copies of documentation",
+    )
+    enable_ticket_detection: bool = Field(
+        default=True,
+        description="Enable automatic ticket context detection from user messages",
+    )
+
+
 class UnifiedConfig(BaseSettings):
     """
     Unified configuration model for Claude MPM.
@@ -242,6 +263,7 @@ class UnifiedConfig(BaseSettings):
     performance: PerformanceConfig = Field(default_factory=PerformanceConfig)
     sessions: SessionConfig = Field(default_factory=SessionConfig)
     development: DevelopmentConfig = Field(default_factory=DevelopmentConfig)
+    documentation: DocumentationConfig = Field(default_factory=DocumentationConfig)
 
     # Path configuration
     base_path: Optional[Path] = Field(

claude_mpm/hooks/claude_hooks/memory_integration.py

@@ -5,8 +5,19 @@ This module provides utilities for integrating with the memory system,
 including pre and post delegation hooks.
 """
 
-import os
+import logging
 import sys
+
+# Reconfigure logging to INFO level BEFORE kuzu-memory imports
+# This overrides kuzu-memory's WARNING-level basicConfig (fixes 1M-445)
+logging.basicConfig(
+    level=logging.INFO,
+    format="%(asctime)s - %(name)s - %(levelname)s - %(message)s",
+    force=True,  # Python 3.8+ - reconfigures root logger
+    stream=sys.stderr,
+)
+
+import os
 from datetime import datetime, timezone
 from typing import Optional
 

claude_mpm/models/agent_definition.py

@@ -103,6 +103,10 @@ class AgentMetadata:
     author: Optional[str] = None
     tags: List[str] = field(default_factory=list)
     specializations: List[str] = field(default_factory=list)
+    # NEW: Collection metadata for enhanced agent matching
+    collection_id: Optional[str] = None  # Format: owner/repo-name
+    source_path: Optional[str] = None  # Relative path in repository
+    canonical_id: Optional[str] = None  # Format: collection_id:agent_id
 
     def increment_serial_version(self) -> None:
         """Increment the patch version number.
@@ -181,6 +185,9 @@ class AgentDefinition:
                 "author": self.metadata.author,
                 "tags": self.metadata.tags,
                 "specializations": self.metadata.specializations,
+                "collection_id": self.metadata.collection_id,
+                "source_path": self.metadata.source_path,
+                "canonical_id": self.metadata.canonical_id,
             },
             "primary_role": self.primary_role,
             "when_to_use": self.when_to_use,