claude-mpm 4.1.4__py3-none-any.whl → 4.1.6__py3-none-any.whl

claude_mpm/cli/parsers/base_parser.py

@@ -331,6 +331,13 @@ def create_parser(
     except ImportError:
         pass
 
+    try:
+        from .configure_parser import add_configure_subparser
+
+        add_configure_subparser(subparsers)
+    except ImportError:
+        pass
+
     # Import and add additional command parsers from commands module
     try:
         from ..commands.aggregate import add_aggregate_parser

claude_mpm/cli/parsers/configure_parser.py

@@ -0,0 +1,119 @@
+"""
+Configure command parser for claude-mpm CLI.
+
+WHY: This module contains all arguments specific to the interactive configuration
+management interface, allowing users to enable/disable agents, edit templates,
+and manage behavior files.
+"""
+
+import argparse
+
+from ...constants import CLICommands
+from .base_parser import add_common_arguments
+
+
+def add_configure_subparser(subparsers) -> argparse.ArgumentParser:
+    """
+    Add the configure subparser for interactive configuration management.
+
+    WHY: Users need an interactive way to manage agent configurations,
+    templates, and behavior files through a terminal-based interface.
+
+    Args:
+        subparsers: The subparsers object from the main parser
+
+    Returns:
+        The configured configure subparser
+    """
+    # Configure command - interactive TUI configuration
+    configure_parser = subparsers.add_parser(
+        CLICommands.CONFIGURE.value,
+        help="Interactive terminal-based configuration interface for managing agents and behaviors",
+        description="Launch an interactive Rich-based TUI for configuring claude-mpm agents, templates, and behavior files",
+    )
+
+    # Add common arguments
+    add_common_arguments(configure_parser)
+
+    # Configuration scope options
+    scope_group = configure_parser.add_argument_group("configuration scope")
+    scope_group.add_argument(
+        "--scope",
+        choices=["project", "user"],
+        default="project",
+        help="Configuration scope to manage (default: project)",
+    )
+    # Note: --project-dir is already defined in base_parser.py
+
+    # Direct navigation options (skip main menu)
+    nav_group = configure_parser.add_argument_group("direct navigation")
+    nav_group.add_argument(
+        "--agents", action="store_true", help="Jump directly to agent management"
+    )
+    nav_group.add_argument(
+        "--templates", action="store_true", help="Jump directly to template editing"
+    )
+    nav_group.add_argument(
+        "--behaviors",
+        action="store_true",
+        help="Jump directly to behavior file management",
+    )
+    nav_group.add_argument(
+        "--version-info",
+        action="store_true",
+        help="Display version information and exit",
+    )
+
+    # Non-interactive options
+    noninteractive_group = configure_parser.add_argument_group(
+        "non-interactive options"
+    )
+    noninteractive_group.add_argument(
+        "--list-agents", action="store_true", help="List all available agents and exit"
+    )
+    noninteractive_group.add_argument(
+        "--enable-agent",
+        type=str,
+        metavar="AGENT_NAME",
+        help="Enable a specific agent and exit",
+    )
+    noninteractive_group.add_argument(
+        "--disable-agent",
+        type=str,
+        metavar="AGENT_NAME",
+        help="Disable a specific agent and exit",
+    )
+    noninteractive_group.add_argument(
+        "--export-config",
+        type=str,
+        metavar="FILE",
+        help="Export current configuration to a file",
+    )
+    noninteractive_group.add_argument(
+        "--import-config",
+        type=str,
+        metavar="FILE",
+        help="Import configuration from a file",
+    )
+
+    # Display options
+    display_group = configure_parser.add_argument_group("display options")
+    display_group.add_argument(
+        "--no-colors", action="store_true", help="Disable colored output in the TUI"
+    )
+    display_group.add_argument(
+        "--compact", action="store_true", help="Use compact display mode"
+    )
+    display_group.add_argument(
+        "--force-rich",
+        action="store_true",
+        help="Force use of Rich menu interface instead of full-screen Textual TUI",
+    )
+    display_group.add_argument(
+        "--no-textual",
+        dest="use_textual",
+        action="store_false",
+        help="Disable Textual TUI and use Rich menu interface",
+    )
+
+    return configure_parser

claude_mpm/cli/startup_logging.py

@@ -57,17 +57,34 @@ def log_memory_stats(logger=None, prefix="Memory Usage"):
         rss_mb = memory_info.rss / (1024 * 1024)
         vms_mb = memory_info.vms / (1024 * 1024)
 
-        # Get percentage of system memory if available
-        try:
-            memory_percent = process.memory_percent()
-            logger.info(
-                f"{prefix}: RSS={rss_mb:.1f}MB, VMS={vms_mb:.1f}MB, "
-                f"System={memory_percent:.1f}%"
-            )
-            return {"rss_mb": rss_mb, "vms_mb": vms_mb, "percent": memory_percent}
-        except:
-            logger.info(f"{prefix}: RSS={rss_mb:.1f}MB, VMS={vms_mb:.1f}MB")
-            return {"rss_mb": rss_mb, "vms_mb": vms_mb, "percent": None}
+        # On macOS, VMS can report misleading values (400+ TB)
+        # Skip VMS reporting if it's unreasonably large
+        import platform
+
+        if platform.system() == "Darwin" and vms_mb > 100000:  # > 100GB is suspicious
+            # Get percentage of system memory if available
+            try:
+                memory_percent = process.memory_percent()
+                logger.info(
+                    f"{prefix}: RSS={rss_mb:.1f}MB, System={memory_percent:.1f}%"
+                )
+                return {"rss_mb": rss_mb, "vms_mb": None, "percent": memory_percent}
+            except:
+                logger.info(f"{prefix}: RSS={rss_mb:.1f}MB")
+                return {"rss_mb": rss_mb, "vms_mb": None, "percent": None}
+        else:
+            # Normal VMS reporting for non-macOS or reasonable values
+            # Get percentage of system memory if available
+            try:
+                memory_percent = process.memory_percent()
+                logger.info(
+                    f"{prefix}: RSS={rss_mb:.1f}MB, VMS={vms_mb:.1f}MB, "
+                    f"System={memory_percent:.1f}%"
+                )
+                return {"rss_mb": rss_mb, "vms_mb": vms_mb, "percent": memory_percent}
+            except:
+                logger.info(f"{prefix}: RSS={rss_mb:.1f}MB, VMS={vms_mb:.1f}MB")
+                return {"rss_mb": rss_mb, "vms_mb": vms_mb, "percent": None}
 
     except Exception as e:
         logger.debug(f"Failed to get memory info: {e}")
@@ -512,11 +529,21 @@ def setup_startup_logging(project_root: Optional[Path] = None) -> Path:
     # Log initial memory usage
     if PSUTIL_AVAILABLE:
         try:
+            import platform
+
             process = psutil.Process()
             memory_info = process.memory_info()
             rss_mb = memory_info.rss / (1024 * 1024)
             vms_mb = memory_info.vms / (1024 * 1024)
-            logger.info(f"Initial Memory: RSS={rss_mb:.1f}MB, VMS={vms_mb:.1f}MB")
+
+            # On macOS, VMS can report misleading values (400+ TB)
+            # Skip VMS reporting if it's unreasonably large
+            if (
+                platform.system() == "Darwin" and vms_mb > 100000
+            ):  # > 100GB is suspicious
+                logger.info(f"Initial Memory: RSS={rss_mb:.1f}MB")
+            else:
+                logger.info(f"Initial Memory: RSS={rss_mb:.1f}MB, VMS={vms_mb:.1f}MB")
         except Exception as e:
             logger.debug(f"Failed to get initial memory info: {e}")
 

claude_mpm/constants.py

@@ -36,6 +36,7 @@ class CLICommands(str, Enum):
     MEMORY = "memory"
     MONITOR = "monitor"
     CONFIG = "config"
+    CONFIGURE = "configure"
     AGGREGATE = "aggregate"
     CLEANUP = "cleanup-memory"
     MCP = "mcp"

claude_mpm/core/output_style_manager.py

@@ -21,6 +21,10 @@ from ..utils.imports import safe_import
 # Import with fallback support
 get_logger = safe_import("claude_mpm.core.logger", "core.logger", ["get_logger"])
 
+# Global cache for Claude version to avoid duplicate detection/logging
+_CACHED_CLAUDE_VERSION: Optional[str] = None
+_VERSION_DETECTED: bool = False
+
 
 class OutputStyleManager:
     """Manages output style deployment and version-based handling."""
@@ -41,10 +45,17 @@ class OutputStyleManager:
     def _detect_claude_version(self) -> Optional[str]:
         """
         Detect Claude Code version by running 'claude --version'.
+        Uses global cache to avoid duplicate detection and logging.
 
         Returns:
             Version string (e.g., "1.0.82") or None if Claude not found
         """
+        global _CACHED_CLAUDE_VERSION, _VERSION_DETECTED
+
+        # Return cached version if already detected
+        if _VERSION_DETECTED:
+            return _CACHED_CLAUDE_VERSION
+
         try:
             # Run claude --version command
             result = subprocess.run(
@@ -57,6 +68,8 @@ class OutputStyleManager:
 
             if result.returncode != 0:
                 self.logger.warning(f"Claude command failed: {result.stderr}")
+                _VERSION_DETECTED = True
+                _CACHED_CLAUDE_VERSION = None
                 return None
 
             # Parse version from output
@@ -66,19 +79,30 @@ class OutputStyleManager:
 
             if version_match:
                 version = version_match.group(1)
+                # Only log on first detection
                 self.logger.info(f"Detected Claude version: {version}")
+                _CACHED_CLAUDE_VERSION = version
+                _VERSION_DETECTED = True
                 return version
             self.logger.warning(f"Could not parse version from: {version_output}")
+            _VERSION_DETECTED = True
+            _CACHED_CLAUDE_VERSION = None
             return None
 
         except FileNotFoundError:
             self.logger.info("Claude Code not found in PATH")
+            _VERSION_DETECTED = True
+            _CACHED_CLAUDE_VERSION = None
             return None
         except subprocess.TimeoutExpired:
             self.logger.warning("Claude version check timed out")
+            _VERSION_DETECTED = True
+            _CACHED_CLAUDE_VERSION = None
             return None
         except Exception as e:
             self.logger.warning(f"Error detecting Claude version: {e}")
+            _VERSION_DETECTED = True
+            _CACHED_CLAUDE_VERSION = None
             return None
 
     def _compare_versions(self, version1: str, version2: str) -> int:

claude_mpm/core/socketio_pool.py

@@ -592,7 +592,7 @@ class SocketIOConnectionPool:
 
             # 2-second timeout for connection
             await asyncio.wait_for(
-                client.connect(self.server_url, auth={"token": "dev-token"}, wait=True),
+                client.connect(self.server_url, wait=True),
                 timeout=2.0,
             )
 
@@ -734,8 +734,8 @@ class SocketIOConnectionPool:
     def emit(self, event: str, data: Dict[str, Any]) -> bool:
         """Emit an event through the connection pool.
 
-        This method provides compatibility for the legacy emit() interface
-        by mapping to the modern emit_event() method with appropriate defaults.
+        This method provides compatibility for the legacy emit() interface.
+        For critical hook events, we use direct emission to avoid batching delays.
 
         Args:
             event: Event name (e.g., "claude_event")
@@ -747,10 +747,42 @@ class SocketIOConnectionPool:
         if not SOCKETIO_AVAILABLE or not self._running:
             return False
 
+        # For critical claude_event, use direct emission to avoid batching delays
+        if event == "claude_event":
+            return self._emit_direct(event, data)
+
         # Map to the modern emit_event method using default namespace
         self.emit_event("/", event, data)
         return True
 
+    def _emit_direct(self, event: str, data: Dict[str, Any]) -> bool:
+        """Emit an event directly without batching.
+
+        This is used for critical events that need immediate delivery.
+        """
+        try:
+            # Create a synchronous client for direct emission
+            import socketio
+
+            client = socketio.Client(logger=False, engineio_logger=False)
+
+            # Quick connect, emit, and disconnect
+            client.connect(self.server_url, wait=True, wait_timeout=1.0)
+            client.emit(event, data)
+            client.disconnect()
+
+            # Update stats
+            for stats in self.connection_stats.values():
+                stats.events_sent += 1
+                break
+
+            return True
+        except Exception as e:
+            self.logger.debug(f"Direct emit failed: {e}")
+            # Fall back to batched emission
+            self.emit_event("/", event, data)
+            return True
+
     def get_stats(self) -> Dict[str, Any]:
         """Get connection pool statistics."""
         with self.pool_lock:

claude_mpm/core/unified_agent_registry.py

@@ -136,7 +136,13 @@ class UnifiedAgentRegistry:
 
         # Discovery configuration
         self.file_extensions = {".md", ".json", ".yaml", ".yml"}
-        self.ignore_patterns = {"__pycache__", ".git", "node_modules", ".pytest_cache"}
+        self.ignore_patterns = {
+            "__pycache__",
+            ".git",
+            "node_modules",
+            ".pytest_cache",
+            "backup",
+        }
 
         # Statistics
         self.discovery_stats = {
@@ -166,15 +172,15 @@ class UnifiedAgentRegistry:
         if user_path.exists():
             self.discovery_paths.append(user_path)
 
-        # System-level agents
+        # System-level agents (includes templates as a subdirectory)
         system_path = self.path_manager.get_system_agents_dir()
         if system_path.exists():
             self.discovery_paths.append(system_path)
 
-        # Templates directory
-        templates_path = self.path_manager.get_templates_dir()
-        if templates_path.exists():
-            self.discovery_paths.append(templates_path)
+        # NOTE: Templates directory is NOT added separately because:
+        # - templates_path = system_path / "templates"
+        # - The rglob("*") in _discover_path will already find templates
+        # - Adding it separately causes duplicate discovery
 
         logger.debug(
             f"Discovery paths configured: {[str(p) for p in self.discovery_paths]}"
@@ -256,7 +262,10 @@ class UnifiedAgentRegistry:
             try:
                 metadata = self._create_agent_metadata(file_path, agent_name, tier)
                 if metadata:
-                    self.registry[agent_name] = metadata
+                    # Store all discovered agents temporarily for tier precedence
+                    # Use a unique key that includes tier to prevent overwrites
+                    registry_key = f"{agent_name}_{tier.value}"
+                    self.registry[registry_key] = metadata
                     self.discovered_files.add(file_path)
                     logger.debug(
                         f"Discovered agent: {agent_name} ({tier.value}) at {file_path}"
@@ -269,9 +278,29 @@ class UnifiedAgentRegistry:
         # Remove extension and use filename as agent name
         name = file_path.stem
 
-        # Skip certain files
-        skip_files = {"README", "INSTRUCTIONS", "template", "example"}
-        if name.upper() in skip_files:
+        # Skip certain files and non-agent templates
+        skip_files = {
+            "README",
+            "INSTRUCTIONS",
+            "template",
+            "example",
+            "base_agent",
+            "base_agent_template",
+            "agent_template",
+            "agent_schema",
+            "base_pm",
+            "workflow",
+            "output_style",
+            "memory",
+            "optimization_report",
+            "vercel_ops_instructions",
+            "agent-template",
+            "agent-schema",  # Also handle hyphenated versions
+        }
+        # Case-insensitive comparison
+        if name.replace("-", "_").upper() in {
+            s.replace("-", "_").upper() for s in skip_files
+        }:
             return None
 
         # Normalize name
@@ -424,12 +453,14 @@ class UnifiedAgentRegistry:
 
     def _apply_tier_precedence(self) -> None:
         """Apply tier precedence rules to resolve conflicts."""
-        # Group agents by name
+        # Group agents by their actual name (without tier suffix)
         agent_groups = {}
-        for name, metadata in self.registry.items():
-            if name not in agent_groups:
-                agent_groups[name] = []
-            agent_groups[name].append(metadata)
+        for registry_key, metadata in self.registry.items():
+            # Extract the actual agent name (registry_key is "name_tier")
+            agent_name = metadata.name  # Use the actual name from metadata
+            if agent_name not in agent_groups:
+                agent_groups[agent_name] = []
+            agent_groups[agent_name].append(metadata)
 
         # Resolve conflicts using tier precedence
         resolved_registry = {}