claude-mpm 4.15.6__py3-none-any.whl → 4.21.0__py3-none-any.whl

claude_mpm/services/mcp_gateway/auto_configure.py

@@ -163,17 +163,21 @@ class MCPAutoConfigurator:
         Returns:
             True if user agrees, False if declines, None if timeout
         """
-        print("\n" + "=" * 60)
-        print("🔧 MCP Gateway Configuration")
-        print("=" * 60)
-        print("\nClaude MPM can automatically configure MCP Gateway for")
-        print("Claude Code integration. This enables advanced features:")
-        print("  • File analysis and summarization")
-        print("  • System diagnostics")
-        print("  • Ticket management")
-        print("  • And more...")
-        print("\nWould you like to configure it now? (y/n)")
-        print(f"(Auto-declining in {timeout} seconds)")
+        print("\n" + "=" * 60, file=sys.stderr)
+        print("🔧 MCP Gateway Configuration", file=sys.stderr)
+        print("=" * 60, file=sys.stderr)
+        print(
+            "\nClaude MPM can automatically configure MCP Gateway for", file=sys.stderr
+        )
+        print(
+            "Claude Code integration. This enables advanced features:", file=sys.stderr
+        )
+        print("  • File analysis and summarization", file=sys.stderr)
+        print("  • System diagnostics", file=sys.stderr)
+        print("  • Ticket management", file=sys.stderr)
+        print("  • And more...", file=sys.stderr)
+        print("\nWould you like to configure it now? (y/n)", file=sys.stderr)
+        print(f"(Auto-declining in {timeout} seconds)", file=sys.stderr)
 
         # Use threading for cross-platform timeout support
         # Python 3.7+ has queue built-in - no need to check, we require 3.10+
@@ -203,7 +207,7 @@ class MCPAutoConfigurator:
 
         if input_thread.is_alive():
             # Timed out
-            print("\n(Timed out - declining)")
+            print("\n(Timed out - declining)", file=sys.stderr)
             return None
         # Got input
         return user_input in ["y", "yes"]
@@ -220,7 +224,7 @@ class MCPAutoConfigurator:
             if self.claude_config_path.exists():
                 backup_path = self._create_backup()
                 if backup_path:
-                    print(f"✅ Backup created: {backup_path}")
+                    print(f"✅ Backup created: {backup_path}", file=sys.stderr)
 
             # Load or create configuration
             config = self._load_or_create_config()
@@ -232,7 +236,7 @@ class MCPAutoConfigurator:
             # Find claude-mpm executable
             executable = self._find_claude_mpm_executable()
             if not executable:
-                print("❌ Could not find claude-mpm executable")
+                print("❌ Could not find claude-mpm executable", file=sys.stderr)
                 return False
 
             # Configure MCP server
@@ -246,20 +250,22 @@ class MCPAutoConfigurator:
             with self.claude_config_path.open("w") as f:
                 json.dump(config, f, indent=2)
 
-            print(f"✅ Configuration saved to: {self.claude_config_path}")
-            print("\n🎉 MCP Gateway configured successfully!")
-            print("\nNext steps:")
-            print("1. Restart Claude Code (if running)")
-            print("2. Look for the MCP icon in the interface")
-            print("3. Try @claude-mpm-gateway in a conversation")
+            print(
+                f"✅ Configuration saved to: {self.claude_config_path}", file=sys.stderr
+            )
+            print("\n🎉 MCP Gateway configured successfully!", file=sys.stderr)
+            print("\nNext steps:", file=sys.stderr)
+            print("1. Restart Claude Code (if running)", file=sys.stderr)
+            print("2. Look for the MCP icon in the interface", file=sys.stderr)
+            print("3. Try @claude-mpm-gateway in a conversation", file=sys.stderr)
 
             return True
 
         except Exception as e:
             self.logger.error(f"Auto-configuration failed: {e}")
-            print(f"❌ Configuration failed: {e}")
-            print("\nYou can configure manually with:")
-            print("  claude-mpm mcp install")
+            print(f"❌ Configuration failed: {e}", file=sys.stderr)
+            print("\nYou can configure manually with:", file=sys.stderr)
+            print("  claude-mpm mcp install", file=sys.stderr)
             return False
 
     def _create_backup(self) -> Optional[Path]:
@@ -344,8 +350,8 @@ class MCPAutoConfigurator:
         if user_choice:
             return self.auto_configure()
         if user_choice is False:  # User explicitly said no
-            print("\n📝 You can configure MCP later with:")
-            print("  claude-mpm mcp install")
+            print("\n📝 You can configure MCP later with:", file=sys.stderr)
+            print("  claude-mpm mcp install", file=sys.stderr)
         # If timeout (None), don't show additional message
         return False
 

claude_mpm/services/mcp_gateway/core/process_pool.py

@@ -864,7 +864,7 @@ def _prompt_kuzu_update(current: str, latest: str) -> None:
     # Check if running in a non-interactive context
     try:
         if confirm_operation(message):
-            print("🚀 Updating kuzu-memory...")
+            print("🚀 Updating kuzu-memory...", file=sys.stderr)
             try:
                 result = subprocess.run(
                     ["pipx", "upgrade", "kuzu-memory"],
@@ -874,28 +874,37 @@ def _prompt_kuzu_update(current: str, latest: str) -> None:
                     check=False,
                 )
                 if result.returncode == 0:
-                    print("✅ Successfully updated kuzu-memory!")
+                    print("✅ Successfully updated kuzu-memory!", file=sys.stderr)
                     logger.info(f"Updated kuzu-memory from {current} to {latest}")
                 else:
-                    print(f"⚠️ Update failed: {result.stderr}")
+                    print(f"⚠️ Update failed: {result.stderr}", file=sys.stderr)
                     logger.warning(f"kuzu-memory update failed: {result.stderr}")
             except subprocess.TimeoutExpired:
-                print("⚠️ Update timed out. Please try again later.")
+                print("⚠️ Update timed out. Please try again later.", file=sys.stderr)
                 logger.warning("kuzu-memory update timed out")
             except Exception as e:
-                print(f"⚠️ Update failed: {e}")
+                print(f"⚠️ Update failed: {e}", file=sys.stderr)
                 logger.warning(f"kuzu-memory update error: {e}")
         else:
             # User declined update
-            print("\n  To skip this version permanently, run:")
-            print(f"    claude-mpm config set-skip-version kuzu-memory {latest}")
-            print("  To disable update checks for kuzu-memory:")
-            print("    claude-mpm config disable-update-checks kuzu-memory")
+            print("\n  To skip this version permanently, run:", file=sys.stderr)
+            print(
+                f"    claude-mpm config set-skip-version kuzu-memory {latest}",
+                file=sys.stderr,
+            )
+            print("  To disable update checks for kuzu-memory:", file=sys.stderr)
+            print(
+                "    claude-mpm config disable-update-checks kuzu-memory",
+                file=sys.stderr,
+            )
 
             # Ask if user wants to skip this version
             if confirm_operation("\n  Skip this version in future checks?"):
                 UpdatePreferences.set_skip_version("kuzu-memory", latest)
-                print(f"  Version {latest} will be skipped in future checks.")
+                print(
+                    f"  Version {latest} will be skipped in future checks.",
+                    file=sys.stderr,
+                )
     except (KeyboardInterrupt, EOFError):
         # User interrupted or input not available
         pass

claude_mpm/services/mcp_gateway/tools/external_mcp_services.py

@@ -161,12 +161,17 @@ class ExternalMCPService(BaseToolAdapter):
 
             if interactive:
                 # Show user-friendly installation prompt
-                print(f"\n⚠️  {self.package_name} not found")
-                print("This package enables enhanced functionality (optional).")
-                print("\nInstallation options:")
-                print("1. Install via pip (recommended for this project)")
-                print("2. Install via pipx (isolated, system-wide)")
-                print("3. Skip (continue without this package)")
+                print(f"\n⚠️  {self.package_name} not found", file=sys.stderr)
+                print(
+                    "This package enables enhanced functionality (optional).",
+                    file=sys.stderr,
+                )
+                print("\nInstallation options:", file=sys.stderr)
+                print(
+                    "1. Install via pip (recommended for this project)", file=sys.stderr
+                )
+                print("2. Install via pipx (isolated, system-wide)", file=sys.stderr)
+                print("3. Skip (continue without this package)", file=sys.stderr)
 
                 try:
                     choice = input("\nChoose option (1/2/3) [1]: ").strip() or "1"
@@ -180,7 +185,7 @@ class ExternalMCPService(BaseToolAdapter):
                         )
                         return False
                 except (EOFError, KeyboardInterrupt):
-                    print("\nInstallation cancelled")
+                    print("\nInstallation cancelled", file=sys.stderr)
                     return False
             else:
                 # Non-interactive: default to pip
@@ -201,7 +206,7 @@ class ExternalMCPService(BaseToolAdapter):
     async def _install_via_pip(self) -> bool:
         """Install package via pip."""
         try:
-            print(f"\n📦 Installing {self.package_name} via pip...")
+            print(f"\n📦 Installing {self.package_name} via pip...", file=sys.stderr)
             result = subprocess.run(
                 [sys.executable, "-m", "pip", "install", self.package_name],
                 capture_output=True,
@@ -211,21 +216,21 @@ class ExternalMCPService(BaseToolAdapter):
             )
 
             if result.returncode == 0:
-                print(f"✓ Successfully installed {self.package_name}")
+                print(f"✓ Successfully installed {self.package_name}", file=sys.stderr)
                 self.logger.info(f"Successfully installed {self.package_name} via pip")
                 return True
 
             error_msg = result.stderr.strip() if result.stderr else "Unknown error"
-            print(f"✗ Installation failed: {error_msg}")
+            print(f"✗ Installation failed: {error_msg}", file=sys.stderr)
             self.logger.error(f"Failed to install {self.package_name}: {error_msg}")
             return False
 
         except subprocess.TimeoutExpired:
-            print("✗ Installation timed out")
+            print("✗ Installation timed out", file=sys.stderr)
             self.logger.error(f"Installation of {self.package_name} timed out")
             return False
         except Exception as e:
-            print(f"✗ Installation error: {e}")
+            print(f"✗ Installation error: {e}", file=sys.stderr)
             self.logger.error(f"Error installing {self.package_name}: {e}")
             return False
 
@@ -242,12 +247,12 @@ class ExternalMCPService(BaseToolAdapter):
             )
 
             if pipx_check.returncode != 0:
-                print("✗ pipx is not installed")
-                print("Install pipx first: python -m pip install pipx")
+                print("✗ pipx is not installed", file=sys.stderr)
+                print("Install pipx first: python -m pip install pipx", file=sys.stderr)
                 self.logger.error("pipx not available for installation")
                 return False
 
-            print(f"\n📦 Installing {self.package_name} via pipx...")
+            print(f"\n📦 Installing {self.package_name} via pipx...", file=sys.stderr)
             result = subprocess.run(
                 ["pipx", "install", self.package_name],
                 capture_output=True,
@@ -257,26 +262,26 @@ class ExternalMCPService(BaseToolAdapter):
             )
 
             if result.returncode == 0:
-                print(f"✓ Successfully installed {self.package_name}")
+                print(f"✓ Successfully installed {self.package_name}", file=sys.stderr)
                 self.logger.info(f"Successfully installed {self.package_name} via pipx")
                 return True
 
             error_msg = result.stderr.strip() if result.stderr else "Unknown error"
-            print(f"✗ Installation failed: {error_msg}")
+            print(f"✗ Installation failed: {error_msg}", file=sys.stderr)
             self.logger.error(f"Failed to install {self.package_name}: {error_msg}")
             return False
 
         except FileNotFoundError:
-            print("✗ pipx command not found")
-            print("Install pipx first: python -m pip install pipx")
+            print("✗ pipx command not found", file=sys.stderr)
+            print("Install pipx first: python -m pip install pipx", file=sys.stderr)
             self.logger.error("pipx command not found")
             return False
         except subprocess.TimeoutExpired:
-            print("✗ Installation timed out")
+            print("✗ Installation timed out", file=sys.stderr)
             self.logger.error(f"Installation of {self.package_name} timed out")
             return False
         except Exception as e:
-            print(f"✗ Installation error: {e}")
+            print(f"✗ Installation error: {e}", file=sys.stderr)
             self.logger.error(f"Error installing {self.package_name}: {e}")
             return False
 

claude_mpm/services/session_manager.py

@@ -6,12 +6,19 @@ Ensures a single session ID is generated and used across all components.
 
 This service addresses race conditions and duplicate session ID generation
 by providing a single source of truth for session identifiers.
+
+Extended with:
+- Token usage tracking and monitoring
+- Resume log generation on session end
+- Context metrics persistence
+- Automatic resume log injection on session startup
 """
 
 import os
 from datetime import datetime, timezone
+from pathlib import Path
 from threading import Lock
-from typing import Optional
+from typing import Any, Dict, Optional
 
 from claude_mpm.core.logging_utils import get_logger
 
@@ -64,6 +71,24 @@ class SessionManager:
             self._session_id = self._generate_session_id()
             self._session_start_time = datetime.now(timezone.utc)
 
+            # Token usage tracking
+            self._cumulative_tokens = 0
+            self._total_budget = 200000  # Default Claude Code budget
+            self._last_stop_reason: Optional[str] = None
+
+            # Context metrics storage
+            self._context_metrics: Dict[str, Any] = {
+                "total_budget": self._total_budget,
+                "used_tokens": 0,
+                "remaining_tokens": self._total_budget,
+                "percentage_used": 0.0,
+                "stop_reason": None,
+                "model": "claude-sonnet-4.5",
+            }
+
+            # Resume log reference (loaded on startup if exists)
+            self._resume_log_content: Optional[str] = None
+
             # Mark as initialized
             self.__class__._initialized = True
 
@@ -71,6 +96,9 @@ class SessionManager:
                 f"SessionManager initialized with session ID: {self._session_id}"
             )
 
+            # Check for resume log from previous session
+            self._load_resume_log()
+
     def _generate_session_id(self) -> str:
         """
         Generate or retrieve a session ID.
@@ -134,6 +162,182 @@ class SessionManager:
                     f"Session ID already set to {session_id}, no change needed"
                 )
 
+    def update_token_usage(
+        self,
+        input_tokens: int = 0,
+        output_tokens: int = 0,
+        stop_reason: Optional[str] = None,
+    ) -> Dict[str, Any]:
+        """
+        Update cumulative token usage for the session.
+
+        Args:
+            input_tokens: Input tokens from latest API call
+            output_tokens: Output tokens from latest API call
+            stop_reason: Stop reason from Claude API
+
+        Returns:
+            Updated context metrics
+        """
+        with self.__class__._lock:
+            # Update cumulative usage
+            tokens_used = input_tokens + output_tokens
+            self._cumulative_tokens += tokens_used
+
+            # Update stop reason if provided
+            if stop_reason:
+                self._last_stop_reason = stop_reason
+
+            # Calculate metrics
+            remaining = max(0, self._total_budget - self._cumulative_tokens)
+            percentage = (self._cumulative_tokens / self._total_budget) * 100
+
+            # Update context metrics
+            self._context_metrics = {
+                "total_budget": self._total_budget,
+                "used_tokens": self._cumulative_tokens,
+                "remaining_tokens": remaining,
+                "percentage_used": percentage,
+                "stop_reason": self._last_stop_reason,
+                "model": "claude-sonnet-4.5",
+            }
+
+            logger.debug(
+                f"Token usage updated: {self._cumulative_tokens}/{self._total_budget} "
+                f"({percentage:.1f}%) - Stop reason: {stop_reason}"
+            )
+
+            return self._context_metrics.copy()
+
+    def get_context_metrics(self) -> Dict[str, Any]:
+        """
+        Get current context metrics.
+
+        Returns:
+            Dictionary containing token usage and context metrics
+        """
+        with self.__class__._lock:
+            return self._context_metrics.copy()
+
+    def get_token_usage_percentage(self) -> float:
+        """
+        Get current token usage as a percentage (0.0 to 1.0).
+
+        Returns:
+            Token usage percentage
+        """
+        with self.__class__._lock:
+            return self._context_metrics["percentage_used"] / 100.0
+
+    def should_warn_context_limit(self, threshold: float = 0.70) -> bool:
+        """
+        Check if context usage has reached warning threshold.
+
+        Args:
+            threshold: Warning threshold (0.0 to 1.0)
+
+        Returns:
+            True if threshold reached
+        """
+        return self.get_token_usage_percentage() >= threshold
+
+    def _load_resume_log(self) -> None:
+        """
+        Load resume log from previous session if it exists.
+
+        This is called during initialization to check for session continuity.
+        """
+        try:
+            # Lazy import to avoid circular dependencies
+            from claude_mpm.services.infrastructure.resume_log_generator import (
+                ResumeLogGenerator,
+            )
+
+            generator = ResumeLogGenerator()
+
+            # Check if there's a resume log for this session
+            # (Could be from a previous interrupted session with same ID)
+            resume_content = generator.load_resume_log(self._session_id)
+
+            if resume_content:
+                self._resume_log_content = resume_content
+                logger.info(f"Loaded resume log for session {self._session_id}")
+            else:
+                logger.debug("No resume log found for current session")
+
+        except Exception as e:
+            logger.warning(f"Failed to load resume log: {e}")
+            # Non-critical error, continue without resume log
+
+    def get_resume_log_content(self) -> Optional[str]:
+        """
+        Get resume log content if loaded.
+
+        Returns:
+            Resume log markdown content or None
+        """
+        with self.__class__._lock:
+            return self._resume_log_content
+
+    def generate_resume_log(
+        self,
+        session_state: Optional[Dict[str, Any]] = None,
+    ) -> Optional[Path]:
+        """
+        Generate and save resume log for current session.
+
+        Args:
+            session_state: Optional session state data to include
+
+        Returns:
+            Path to saved resume log or None if generation failed
+        """
+        try:
+            # Lazy import to avoid circular dependencies
+            from claude_mpm.models.resume_log import ContextMetrics, ResumeLog
+            from claude_mpm.services.infrastructure.resume_log_generator import (
+                ResumeLogGenerator,
+            )
+
+            generator = ResumeLogGenerator()
+
+            # Create context metrics from current state
+            context_metrics = ContextMetrics(
+                total_budget=self._total_budget,
+                used_tokens=self._cumulative_tokens,
+                remaining_tokens=self._context_metrics["remaining_tokens"],
+                percentage_used=self._context_metrics["percentage_used"],
+                stop_reason=self._last_stop_reason,
+                model=self._context_metrics["model"],
+                session_id=self._session_id,
+            )
+
+            if session_state:
+                # Generate from provided session state
+                resume_log = generator.generate_from_session_state(
+                    session_id=self._session_id,
+                    session_state=session_state,
+                    stop_reason=self._last_stop_reason,
+                )
+            else:
+                # Create minimal resume log
+                resume_log = ResumeLog(
+                    session_id=self._session_id,
+                    context_metrics=context_metrics,
+                    mission_summary="Session ended - resume log auto-generated.",
+                )
+
+            if resume_log:
+                file_path = generator.save_resume_log(resume_log)
+                logger.info(f"Resume log generated and saved: {file_path}")
+                return file_path
+            logger.warning("Resume log generation returned None")
+            return None
+
+        except Exception as e:
+            logger.error(f"Failed to generate resume log: {e}", exc_info=True)
+            return None
+
     @classmethod
     def reset(cls) -> None:
         """

claude_mpm/services/unified/deployment_strategies/local.py

@@ -395,7 +395,7 @@ class LocalDeploymentStrategy(DeploymentStrategy):
                 shutil.copy2(artifact, dest)
                 deployed.append(dest)
 
-                self._logger.info(f"Deployed agent: {dest}")
+                self._logger.debug(f"Deployed agent: {dest}")
 
         return deployed
 

claude_mpm/services/version_service.py

@@ -9,7 +9,7 @@ Extracted from ClaudeRunner to follow Single Responsibility Principle.
 """
 
 from pathlib import Path
-from typing import Any, Dict, Optional
+from typing import Any, Dict, List, Optional
 
 from claude_mpm.config.paths import paths
 from claude_mpm.core.base_service import BaseService
@@ -274,3 +274,106 @@ class VersionService(BaseService, VersionServiceInterface):
             "message": "Update checking not implemented",
             "checked_at": None,
         }
+
+    def get_agents_versions(self) -> Dict[str, List[Dict[str, str]]]:
+        """Get all agents grouped by tier with versions.
+
+        Returns:
+            Dict with keys: system, user, project
+            Each value is list of agent dicts with: name, version, id
+        """
+        from claude_mpm.core.unified_agent_registry import get_agent_registry
+
+        agents_by_tier = {"system": [], "user": [], "project": []}
+
+        try:
+            registry = get_agent_registry()
+            all_agents = registry.list_agents()
+
+            for agent in all_agents:
+                agent_info = {
+                    "name": agent.name,
+                    "version": agent.version,
+                    "id": agent.name,  # Use name as ID since agent_id doesn't exist
+                }
+                tier = (
+                    agent.tier.value
+                    if hasattr(agent.tier, "value")
+                    else str(agent.tier)
+                )
+                if tier in agents_by_tier:
+                    agents_by_tier[tier].append(agent_info)
+                else:
+                    agents_by_tier["system"].append(agent_info)
+
+            # Sort each tier alphabetically by name
+            for tier, agents in agents_by_tier.items():
+                agents.sort(key=lambda x: x["name"])
+
+        except Exception as e:
+            self.logger.error(f"Failed to get agent versions: {e}")
+
+        return agents_by_tier
+
+    def get_skills_versions(self) -> Dict[str, List[Dict[str, str]]]:
+        """Get all skills grouped by source with versions.
+
+        Returns:
+            Dict with keys: bundled, user, project
+            Each value is list of skill dicts with: name, version, description
+        """
+        from claude_mpm.skills.registry import get_registry
+
+        skills_by_source = {"bundled": [], "user": [], "project": []}
+
+        try:
+            registry = get_registry()
+
+            for skill in registry.list_skills():
+                skill_info = {
+                    "name": skill.name,
+                    "version": skill.version,
+                    "description": (
+                        skill.description[:60] + "..."
+                        if len(skill.description) > 60
+                        else skill.description
+                    ),
+                }
+                source = skill.source if skill.source in skills_by_source else "bundled"
+                skills_by_source[source].append(skill_info)
+
+            # Sort each source alphabetically by name
+            for source, skills in skills_by_source.items():
+                skills.sort(key=lambda x: x["name"])
+
+        except Exception as e:
+            self.logger.error(f"Failed to get skill versions: {e}")
+
+        return skills_by_source
+
+    def get_version_summary(self) -> Dict:
+        """Get complete version summary.
+
+        Returns:
+            Dict with project_version, build, agents, skills, and counts
+        """
+        agents = self.get_agents_versions()
+        skills = self.get_skills_versions()
+        build = self.get_build_number()
+
+        return {
+            "project_version": self.get_base_version(),
+            "build": build,
+            "agents": agents,
+            "skills": skills,
+            "counts": {
+                "agents_total": sum(len(v) for v in agents.values()),
+                "agents_system": len(agents.get("system", [])),
+                "agents_user": len(agents.get("user", [])),
+                "agents_project": len(agents.get("project", [])),
+                "skills_total": sum(len(v) for v in skills.values()),
+                "skills_bundled": len(skills.get("bundled", [])),
+                "skills_user": len(skills.get("user", [])),
+                "skills_project": len(skills.get("project", [])),
+            },
+        }

claude_mpm/skills/__init__.py

@@ -8,14 +8,35 @@ Skills can be:
 - Bundled with MPM (in skills/bundled/)
 - User-installed (in ~/.claude/skills/)
 - Project-specific (in .claude/skills/)
+
+New Skills Integration System:
+- SkillsService: Core service for skill management
+- AgentSkillsInjector: Dynamic skill injection into agent templates
+- SkillsRegistry: Helper class for registry operations
+
+Legacy System (maintained for compatibility):
+- Skill: Dataclass for skill representation
+- SkillManager: Legacy skill manager
+- get_registry: Legacy registry access
 """
 
+# New Skills Integration System
+from .agent_skills_injector import AgentSkillsInjector
+
+# Legacy System (maintained for compatibility)
 from .registry import Skill, SkillsRegistry, get_registry
 from .skill_manager import SkillManager
+from .skills_registry import SkillsRegistry as SkillsRegistryHelper
+from .skills_service import SkillsService
 
 __all__ = [
+    "AgentSkillsInjector",
+    # Legacy System
     "Skill",
     "SkillManager",
     "SkillsRegistry",
+    "SkillsRegistryHelper",
+    # New Skills Integration System
+    "SkillsService",
     "get_registry",
 ]