claude-mpm 4.0.17__py3-none-any.whl → 4.0.20__py3-none-any.whl

claude_mpm/cli/commands/memory.py

@@ -280,7 +280,12 @@ def _show_basic_status(memory_manager):
         print(f"   Expected location: {memory_dir}")
         return
 
-    memory_files = list(memory_dir.glob("*_agent.md"))
+    # Support both old and new formats
+    memory_files = list(memory_dir.glob("*_memories.md"))
+    # Also check for old formats for backward compatibility
+    memory_files.extend(memory_dir.glob("*_agent.md"))
+    memory_files.extend([f for f in memory_dir.glob("*.md") 
+                        if f.name != "README.md" and not f.name.endswith("_memories.md") and not f.name.endswith("_agent.md")])
 
     if not memory_files:
         print("📭 No memory files found")
@@ -296,7 +301,13 @@ def _show_basic_status(memory_manager):
         size_kb = stat.st_size / 1024
         total_size += stat.st_size
 
-        agent_id = file_path.stem.replace("_agent", "")
+        # Extract agent name from various formats
+        if file_path.name.endswith("_memories.md"):
+            agent_id = file_path.stem[:-9]  # Remove "_memories"
+        elif file_path.name.endswith("_agent.md"):
+            agent_id = file_path.stem[:-6]  # Remove "_agent"
+        else:
+            agent_id = file_path.stem
         print(f"   {agent_id}: {size_kb:.1f} KB")
 
     print(f"💾 Total size: {total_size / 1024:.1f} KB")
@@ -395,7 +406,12 @@ def _clean_memory(args, memory_manager):
         print("📁 No memory directory found - nothing to clean")
         return
 
-    memory_files = list(memory_dir.glob("*_agent.md"))
+    # Support both old and new formats
+    memory_files = list(memory_dir.glob("*_memories.md"))
+    # Also check for old formats for backward compatibility
+    memory_files.extend(memory_dir.glob("*_agent.md"))
+    memory_files.extend([f for f in memory_dir.glob("*.md") 
+                        if f.name != "README.md" and not f.name.endswith("_memories.md") and not f.name.endswith("_agent.md")])
     if not memory_files:
         print("📭 No memory files found - nothing to clean")
         return
@@ -651,7 +667,12 @@ def _show_all_agent_memories(format_type, memory_manager):
         print("📁 No memory directory found")
         return
 
-    memory_files = list(memory_dir.glob("*_agent.md"))
+    # Support both old and new formats
+    memory_files = list(memory_dir.glob("*_memories.md"))
+    # Also check for old formats for backward compatibility
+    memory_files.extend(memory_dir.glob("*_agent.md"))
+    memory_files.extend([f for f in memory_dir.glob("*.md") 
+                        if f.name != "README.md" and not f.name.endswith("_memories.md") and not f.name.endswith("_agent.md")])
     if not memory_files:
         print("📭 No agent memories found")
         return
@@ -664,7 +685,13 @@ def _show_all_agent_memories(format_type, memory_manager):
 
     # Load all agent memories
     for file_path in sorted(memory_files):
-        agent_id = file_path.stem.replace("_agent", "")
+        # Extract agent name from various formats
+        if file_path.name.endswith("_memories.md"):
+            agent_id = file_path.stem[:-9]  # Remove "_memories"
+        elif file_path.name.endswith("_agent.md"):
+            agent_id = file_path.stem[:-6]  # Remove "_agent"
+        else:
+            agent_id = file_path.stem
         try:
             memory_content = memory_manager.load_agent_memory(agent_id)
             if memory_content:

claude_mpm/cli/commands/run.py

@@ -33,7 +33,8 @@ def filter_claude_mpm_args(claude_args):
     flags and will error if they're passed through.
 
     DESIGN DECISION: We maintain a list of known claude-mpm flags to filter out,
-    ensuring only genuine Claude CLI arguments are passed through.
+    ensuring only genuine Claude CLI arguments are passed through. We also remove
+    the '--' separator that argparse uses, as it's not needed by Claude CLI.
 
     Args:
         claude_args: List of arguments captured by argparse.REMAINDER
@@ -83,6 +84,11 @@ def filter_claude_mpm_args(claude_args):
     while i < len(claude_args):
         arg = claude_args[i]
 
+        # Skip the '--' separator used by argparse - Claude doesn't need it
+        if arg == "--":
+            i += 1
+            continue
+
         # Check if this is a claude-mpm flag
         if arg in mpm_flags:
             # Skip this flag
@@ -379,16 +385,37 @@ def run_session(args):
     # Create simple runner
     enable_tickets = not args.no_tickets
     raw_claude_args = getattr(args, "claude_args", []) or []
+    
+    # Add --resume to claude_args if the flag is set
+    resume_flag_present = getattr(args, "resume", False)
+    if resume_flag_present:
+        logger.info("📌 --resume flag detected in args")
+        if "--resume" not in raw_claude_args:
+            raw_claude_args = ["--resume"] + raw_claude_args
+            logger.info("✅ Added --resume to claude_args")
+        else:
+            logger.info("ℹ️ --resume already in claude_args")
+    
     # Filter out claude-mpm specific flags before passing to Claude CLI
+    logger.debug(f"Pre-filter claude_args: {raw_claude_args}")
     claude_args = filter_claude_mpm_args(raw_claude_args)
     monitor_mode = getattr(args, "monitor", False)
 
-    # Debug logging for argument filtering
+    # Enhanced debug logging for argument filtering
     if raw_claude_args != claude_args:
-        logger.debug(
-            f"Filtered claude-mpm args: {set(raw_claude_args) - set(claude_args)}"
-        )
-        logger.debug(f"Passing to Claude CLI: {claude_args}")
+        filtered_out = list(set(raw_claude_args) - set(claude_args))
+        logger.debug(f"Filtered out MPM-specific args: {filtered_out}")
+    
+    logger.info(f"Final claude_args being passed: {claude_args}")
+    
+    # Explicit verification of --resume flag
+    if resume_flag_present:
+        if "--resume" in claude_args:
+            logger.info("✅ CONFIRMED: --resume flag will be passed to Claude CLI")
+        else:
+            logger.error("❌ WARNING: --resume flag was filtered out! This is a bug!")
+            logger.error(f"   Original args: {raw_claude_args}")
+            logger.error(f"   Filtered args: {claude_args}")
 
     # Use the specified launch method (default: exec)
     launch_method = getattr(args, "launch_method", "exec")

claude_mpm/cli/parsers/base_parser.py

@@ -187,6 +187,11 @@ def add_top_level_run_arguments(parser: argparse.ArgumentParser) -> None:
         const="last",
         help="Resume an MPM session (last session if no ID specified, or specific session ID)",
     )
+    run_group.add_argument(
+        "--resume",
+        action="store_true",
+        help="Pass --resume flag to Claude Desktop to resume the last conversation",
+    )
     run_group.add_argument(
         "--force",
         action="store_true",

claude_mpm/cli/parsers/run_parser.py

@@ -75,6 +75,11 @@ def add_run_arguments(parser: argparse.ArgumentParser) -> None:
         const="last",
         help="Resume an MPM session (last session if no ID specified, or specific session ID)",
     )
+    run_group.add_argument(
+        "--resume",
+        action="store_true",
+        help="Pass --resume flag to Claude Desktop to resume the last conversation",
+    )
 
     # Dependency checking options
     dep_group = parser.add_argument_group("dependency options")

claude_mpm/cli/utils.py

@@ -132,11 +132,24 @@ def list_agent_versions_at_startup() -> None:
 
     WHY: Users want to see what agents are available when they start a session.
     This provides immediate feedback about the deployed agent environment.
+    
+    DESIGN DECISION: We suppress INFO logging during this call to avoid duplicate
+    initialization messages since the deployment service will be initialized again
+    later in the ClaudeRunner.
     """
-    agent_versions = get_agent_versions_display()
-    if agent_versions:
-        print(agent_versions)
-        print()  # Extra newline after the display
+    # Temporarily suppress INFO level logging to avoid duplicate initialization messages
+    import logging
+    original_level = logging.getLogger("claude_mpm").level
+    logging.getLogger("claude_mpm").setLevel(logging.WARNING)
+    
+    try:
+        agent_versions = get_agent_versions_display()
+        if agent_versions:
+            print(agent_versions)
+            print()  # Extra newline after the display
+    finally:
+        # Restore original logging level
+        logging.getLogger("claude_mpm").setLevel(original_level)
 
 
 def setup_logging(args) -> object:

claude_mpm/core/base_service.py

@@ -159,7 +159,7 @@ class BaseService(LoggerMixin, ABC):
 
         # Only log if not in quiet mode
         if not os.environ.get("CLAUDE_PM_QUIET_MODE", "").lower() == "true":
-            self.logger.info(f"Initialized {self.name} service")
+            self.logger.debug(f"Initialized {self.name} service")
 
     def _init_enhanced_features(self):
         """Initialize enhanced features when enabled."""

claude_mpm/core/config.py

@@ -24,6 +24,9 @@ class Config:
     """
     Configuration manager for Claude PM services.
 
+    Implements singleton pattern to ensure configuration is loaded only once
+    and shared across all services.
+
     Supports loading from:
     - Python dictionaries
     - JSON files
@@ -31,6 +34,23 @@ class Config:
     - Environment variables
     """
 
+    _instance = None
+    _initialized = False
+    _success_logged = False  # Class-level flag to track if success message was already logged
+
+    def __new__(cls, *args, **kwargs):
+        """Implement singleton pattern to ensure single configuration instance.
+        
+        WHY: Configuration was being loaded 11 times during startup, once for each service.
+        This singleton pattern ensures configuration is loaded only once and reused.
+        """
+        if cls._instance is None:
+            cls._instance = super().__new__(cls)
+            logger.info("Creating new Config singleton instance")
+        else:
+            logger.debug("Reusing existing Config singleton instance")
+        return cls._instance
+
     def __init__(
         self,
         config: Optional[Dict[str, Any]] = None,
@@ -45,6 +65,21 @@ class Config:
             config_file: Path to configuration file (JSON or YAML)
             env_prefix: Prefix for environment variables
         """
+        # Skip initialization if already done (singleton pattern)
+        if Config._initialized:
+            logger.debug("Config already initialized, skipping re-initialization")
+            # If someone tries to load a different config file after initialization,
+            # log a debug message but don't reload
+            if config_file and str(config_file) != getattr(self, '_loaded_from', None):
+                logger.debug(
+                    f"Ignoring config_file parameter '{config_file}' - "
+                    f"configuration already loaded from '{getattr(self, '_loaded_from', 'defaults')}'"
+                )
+            return
+        
+        Config._initialized = True
+        logger.info("Initializing Config singleton for the first time")
+        
         self._config: Dict[str, Any] = {}
         self._env_prefix = env_prefix
         self._config_mgr = ConfigurationManager(cache_enabled=True)
@@ -55,22 +90,24 @@ class Config:
 
         # Track where configuration was loaded from
         self._loaded_from = None
+        # Track the actual file we loaded from to prevent re-loading
+        self._actual_loaded_file = None
 
         # Load from file if provided
         if config_file:
-            self.load_file(config_file)
+            self.load_file(config_file, is_initial_load=True)
             self._loaded_from = str(config_file)
         else:
             # Try to load from standard location: .claude-mpm/configuration.yaml
             default_config = Path.cwd() / ".claude-mpm" / "configuration.yaml"
             if default_config.exists():
-                self.load_file(default_config)
+                self.load_file(default_config, is_initial_load=True)
                 self._loaded_from = str(default_config)
             else:
                 # Also try .yml extension
                 alt_config = Path.cwd() / ".claude-mpm" / "configuration.yml"
                 if alt_config.exists():
-                    self.load_file(alt_config)
+                    self.load_file(alt_config, is_initial_load=True)
                     self._loaded_from = str(alt_config)
 
         # Load from environment variables (new and legacy prefixes)
@@ -80,13 +117,22 @@ class Config:
         # Apply defaults
         self._apply_defaults()
 
-    def load_file(self, file_path: Union[str, Path]) -> None:
+    def load_file(self, file_path: Union[str, Path], is_initial_load: bool = True) -> None:
         """Load configuration from file with enhanced error handling.
 
         WHY: Configuration loading failures can cause silent issues. We need
         to provide clear, actionable error messages to help users fix problems.
+        
+        Args:
+            file_path: Path to the configuration file
+            is_initial_load: Whether this is the initial configuration load (for logging control)
         """
         file_path = Path(file_path)
+        
+        # Check if we've already loaded from this exact file to prevent duplicate messages
+        if hasattr(self, '_actual_loaded_file') and self._actual_loaded_file == str(file_path):
+            logger.debug(f"Configuration already loaded from {file_path}, skipping reload")
+            return
 
         if not file_path.exists():
             logger.warning(f"Configuration file not found: {file_path}")
@@ -113,7 +159,14 @@ class Config:
             file_config = self._config_mgr.load_auto(file_path)
             if file_config:
                 self._config = self._config_mgr.merge_configs(self._config, file_config)
-                logger.info(f"✓ Successfully loaded configuration from {file_path}")
+                # Track that we've successfully loaded from this file
+                self._actual_loaded_file = str(file_path)
+                # Only log success message once using class-level flag to avoid duplicate messages
+                if is_initial_load and not Config._success_logged:
+                    logger.info(f"✓ Successfully loaded configuration from {file_path}")
+                    Config._success_logged = True
+                else:
+                    logger.debug(f"Configuration reloaded from {file_path}")
 
                 # Log important configuration values for debugging
                 if logger.isEnabledFor(logging.DEBUG):
@@ -789,3 +842,15 @@ class Config:
     def __repr__(self) -> str:
         """String representation of configuration."""
         return f"<Config({len(self._config)} keys)>"
+    
+    @classmethod
+    def reset_singleton(cls):
+        """Reset the singleton instance (mainly for testing purposes).
+        
+        WHY: During testing, we may need to reset the singleton to test different
+        configurations. This method allows controlled reset of the singleton state.
+        """
+        cls._instance = None
+        cls._initialized = False
+        cls._success_logged = False
+        logger.debug("Config singleton reset")