claude-mpm 4.1.8__py3-none-any.whl → 4.1.11__py3-none-any.whl

claude_mpm/cli/parsers/mpm_init_parser.py

@@ -0,0 +1,122 @@
+"""
+MPM-Init parser module for claude-mpm CLI.
+
+WHY: This module handles the mpm-init command parser configuration,
+providing a clean interface for initializing projects with optimal
+Claude Code and Claude MPM standards.
+"""
+
+import argparse
+from typing import Any
+
+
+def add_mpm_init_subparser(subparsers: Any) -> None:
+    """
+    Add the mpm-init subparser to the main parser.
+    
+    WHY: The mpm-init command sets up projects for optimal use with
+    Claude Code and Claude MPM by delegating to the Agentic Coder Optimizer.
+    
+    Args:
+        subparsers: The subparsers object to add the mpm-init command to
+    """
+    mpm_init_parser = subparsers.add_parser(
+        "mpm-init",
+        help="Initialize project for optimal Claude Code and Claude MPM usage",
+        description=(
+            "Initialize a project with comprehensive documentation, single-path workflows, "
+            "and optimized structure for AI agent understanding. Uses the Agentic Coder "
+            "Optimizer agent to establish clear standards and remove ambiguity."
+        ),
+        epilog=(
+            "Examples:\n"
+            "  claude-mpm mpm-init                          # Initialize current directory\n"
+            "  claude-mpm mpm-init --project-type web       # Initialize as web project\n"
+            "  claude-mpm mpm-init --framework react        # Initialize with React framework\n"
+            "  claude-mpm mpm-init /path/to/project --force # Force reinitialize project"
+        ),
+        formatter_class=argparse.RawDescriptionHelpFormatter
+    )
+    
+    # Project configuration options
+    config_group = mpm_init_parser.add_argument_group("project configuration")
+    config_group.add_argument(
+        "--project-type",
+        choices=["web", "api", "cli", "library", "mobile", "desktop", "fullstack", "data", "ml"],
+        help="Type of project to initialize (auto-detected if not specified)"
+    )
+    config_group.add_argument(
+        "--framework",
+        type=str,
+        help="Specific framework to configure (e.g., react, vue, django, fastapi, express)"
+    )
+    config_group.add_argument(
+        "--language",
+        choices=["python", "javascript", "typescript", "go", "rust", "java", "cpp"],
+        help="Primary programming language (auto-detected if not specified)"
+    )
+    
+    # Initialization options
+    init_group = mpm_init_parser.add_argument_group("initialization options")
+    init_group.add_argument(
+        "--force",
+        action="store_true",
+        help="Force reinitialization even if project is already configured"
+    )
+    init_group.add_argument(
+        "--minimal",
+        action="store_true",
+        help="Create minimal configuration (CLAUDE.md only, no additional setup)"
+    )
+    init_group.add_argument(
+        "--comprehensive",
+        action="store_true",
+        help="Create comprehensive setup including CI/CD, testing, and deployment configs"
+    )
+    init_group.add_argument(
+        "--use-venv",
+        action="store_true",
+        help="Use traditional Python venv instead of mamba/conda environment"
+    )
+    
+    # Template options
+    template_group = mpm_init_parser.add_argument_group("template options")
+    template_group.add_argument(
+        "--template",
+        type=str,
+        help="Use a specific template from claude-mpm templates library"
+    )
+    template_group.add_argument(
+        "--list-templates",
+        action="store_true",
+        help="List available project templates"
+    )
+    
+    # Output options
+    output_group = mpm_init_parser.add_argument_group("output options")
+    output_group.add_argument(
+        "--dry-run",
+        action="store_true",
+        help="Show what would be done without making changes"
+    )
+    output_group.add_argument(
+        "--json",
+        action="store_true",
+        help="Output results in JSON format"
+    )
+    output_group.add_argument(
+        "--verbose",
+        action="store_true",
+        help="Show detailed output during initialization"
+    )
+    
+    # Path argument
+    mpm_init_parser.add_argument(
+        "project_path",
+        nargs="?",
+        default=".",
+        help="Path to project directory (default: current directory)"
+    )
+    
+    # Set the command handler
+    mpm_init_parser.set_defaults(command="mpm-init")

claude_mpm/constants.py

@@ -38,9 +38,12 @@ class CLICommands(str, Enum):
     CONFIG = "config"
     CONFIGURE = "configure"
     AGGREGATE = "aggregate"
+    ANALYZE = "analyze"
+    ANALYZE_CODE = "analyze-code"
     CLEANUP = "cleanup-memory"
     MCP = "mcp"
     DOCTOR = "doctor"
+    DASHBOARD = "dashboard"
 
     def with_prefix(self, prefix: CLIPrefix = CLIPrefix.MPM) -> str:
         """Get command with prefix."""
@@ -97,6 +100,15 @@ class MonitorCommands(str, Enum):
     PORT = "port"
 
 
+class DashboardCommands(str, Enum):
+    """Dashboard subcommand constants."""
+
+    START = "start"
+    STOP = "stop"
+    STATUS = "status"
+    OPEN = "open"
+
+
 class ConfigCommands(str, Enum):
     """Config subcommand constants."""
 
@@ -217,7 +229,7 @@ class Paths(str, Enum):
 
     CLAUDE_AGENTS_DIR = ".claude/agents"
     CLAUDE_CONFIG_DIR = ".claude"
-    MPM_LOG_DIR = ".claude-mpm/logs"
+    MPM_LOG_DIR = "logs/mpm"
     MPM_SESSION_DIR = ".claude-mpm/session"
     MPM_PROMPTS_DIR = ".claude-mpm/prompts"
 

claude_mpm/core/framework_loader.py

@@ -1,6 +1,10 @@
 """Framework loader for Claude MPM."""
 
+import getpass
+import locale
 import logging
+import os
+import platform
 import time
 from datetime import datetime
 from pathlib import Path
@@ -995,11 +999,8 @@ class FrameworkLoader:
             # Add dynamic agent capabilities section
             instructions += self._generate_agent_capabilities_section()
 
-            # Add current date for temporal awareness
-            instructions += f"\n\n## Temporal Context\n**Today's Date**: {datetime.now().strftime('%Y-%m-%d')}\n"
-            instructions += (
-                "Apply date awareness to all time-sensitive tasks and decisions.\n"
-            )
+            # Add enhanced temporal and user context for better awareness
+            instructions += self._generate_temporal_user_context()
 
             # Add BASE_PM.md framework requirements AFTER INSTRUCTIONS.md
             if self.framework_content.get("base_pm_instructions"):
@@ -1322,6 +1323,147 @@ Extract tickets from these patterns:
             self._agent_capabilities_cache_time = current_time
             return result
 
+    def _generate_temporal_user_context(self) -> str:
+        """Generate enhanced temporal and user context for better PM awareness.
+
+        Returns:
+            str: Formatted context string with datetime, user, and system information
+        """
+        context_lines = ["\n\n## Temporal & User Context\n"]
+
+        try:
+            # Get current datetime with timezone awareness
+            now = datetime.now()
+
+            # Try to get timezone info - fallback to UTC offset if timezone name not available
+            try:
+                import time as time_module
+
+                if hasattr(time_module, "tzname"):
+                    tz_name = time_module.tzname[time_module.daylight]
+                    tz_offset = time_module.strftime("%z")
+                    if tz_offset:
+                        # Format UTC offset properly (e.g., -0800 to -08:00)
+                        tz_offset = (
+                            f"{tz_offset[:3]}:{tz_offset[3:]}"
+                            if len(tz_offset) >= 4
+                            else tz_offset
+                        )
+                        tz_info = f"{tz_name} (UTC{tz_offset})"
+                    else:
+                        tz_info = tz_name
+                else:
+                    tz_info = "Local Time"
+            except Exception:
+                tz_info = "Local Time"
+
+            # Format datetime components
+            date_str = now.strftime("%Y-%m-%d")
+            time_str = now.strftime("%H:%M:%S")
+            day_name = now.strftime("%A")
+
+            context_lines.append(
+                f"**Current DateTime**: {date_str} {time_str} {tz_info}\n"
+            )
+            context_lines.append(f"**Day**: {day_name}\n")
+
+        except Exception as e:
+            # Fallback to basic date if enhanced datetime fails
+            self.logger.debug(f"Error generating enhanced datetime context: {e}")
+            context_lines.append(
+                f"**Today's Date**: {datetime.now().strftime('%Y-%m-%d')}\n"
+            )
+
+        try:
+            # Get user information with safe fallbacks
+            username = None
+
+            # Try multiple methods to get username
+            methods = [
+                lambda: os.environ.get("USER"),
+                lambda: os.environ.get("USERNAME"),  # Windows fallback
+                lambda: getpass.getuser(),
+            ]
+
+            for method in methods:
+                try:
+                    username = method()
+                    if username:
+                        break
+                except Exception:
+                    continue
+
+            if username:
+                context_lines.append(f"**User**: {username}\n")
+
+                # Add home directory if available
+                try:
+                    home_dir = os.path.expanduser("~")
+                    if home_dir and home_dir != "~":
+                        context_lines.append(f"**Home Directory**: {home_dir}\n")
+                except Exception:
+                    pass
+
+        except Exception as e:
+            # User detection is optional, don't fail
+            self.logger.debug(f"Could not detect user information: {e}")
+
+        try:
+            # Get system information
+            system_info = platform.system()
+            if system_info:
+                # Enhance system name for common platforms
+                system_names = {
+                    "Darwin": "Darwin (macOS)",
+                    "Linux": "Linux",
+                    "Windows": "Windows",
+                }
+                system_display = system_names.get(system_info, system_info)
+                context_lines.append(f"**System**: {system_display}\n")
+
+                # Add platform version if available
+                try:
+                    platform_version = platform.release()
+                    if platform_version:
+                        context_lines.append(
+                            f"**System Version**: {platform_version}\n"
+                        )
+                except Exception:
+                    pass
+
+        except Exception as e:
+            # System info is optional
+            self.logger.debug(f"Could not detect system information: {e}")
+
+        try:
+            # Add current working directory
+            cwd = os.getcwd()
+            if cwd:
+                context_lines.append(f"**Working Directory**: {cwd}\n")
+        except Exception:
+            pass
+
+        try:
+            # Add locale information if available
+            current_locale = locale.getlocale()
+            if current_locale and current_locale[0]:
+                context_lines.append(f"**Locale**: {current_locale[0]}\n")
+        except Exception:
+            # Locale is optional
+            pass
+
+        # Add instruction for applying context
+        context_lines.append(
+            "\nApply temporal and user awareness to all tasks, "
+            "decisions, and interactions.\n"
+        )
+        context_lines.append(
+            "Use this context for personalized responses and "
+            "time-sensitive operations.\n"
+        )
+
+        return "".join(context_lines)
+
     def _parse_agent_metadata(self, agent_file: Path) -> Optional[Dict[str, Any]]:
         """Parse agent metadata from deployed agent file.
         Uses caching based on file path and modification time.
@@ -1333,7 +1475,7 @@ Extract tickets from these patterns:
             # Check cache based on file path and modification time
             cache_key = str(agent_file)
             file_mtime = agent_file.stat().st_mtime
-            current_time = time.time()
+            time.time()
 
             # Try to get from cache first
             cached_result = self._cache_manager.get_agent_metadata(cache_key)

claude_mpm/core/log_manager.py

@@ -101,9 +101,7 @@ class LogManager:
         }
 
         # Base directories
-        self.base_log_dir = Path(
-            logging_config.get("base_directory", ".claude-mpm/logs")
-        )
+        self.base_log_dir = Path(logging_config.get("base_directory", "logs"))
         if not self.base_log_dir.is_absolute():
             self.base_log_dir = Path.cwd() / self.base_log_dir
 
@@ -352,27 +350,32 @@ class LogManager:
         """
         One-time migration to move existing MPM logs to new subdirectory.
 
-        Moves mpm_*.log files from .claude-mpm/logs/ to .claude-mpm/logs/mpm/
+        Moves mpm_*.log files from .claude-mpm/logs/ to logs/mpm/
         """
         try:
-            old_location = self.base_log_dir
+            # Check both old possible locations
+            old_locations = [
+                Path.cwd() / ".claude-mpm" / "logs",  # Old default location
+                self.base_log_dir,  # Current base location (logs/)
+            ]
             new_location = self.base_log_dir / "mpm"
 
-            # Only proceed if old location exists and has MPM logs
-            if not old_location.exists():
-                return
-
-            # Find all MPM log files in the old location
-            mpm_logs = list(old_location.glob("mpm_*.log"))
+            # Collect all MPM logs from all old locations
+            all_mpm_logs = []
+            for old_location in old_locations:
+                if old_location.exists() and old_location != new_location:
+                    # Find all MPM log files in this location
+                    mpm_logs = list(old_location.glob("mpm_*.log"))
+                    all_mpm_logs.extend(mpm_logs)
 
-            if not mpm_logs:
+            if not all_mpm_logs:
                 return  # No logs to migrate
 
             # Ensure new directory exists
             new_location.mkdir(parents=True, exist_ok=True)
 
             migrated_count = 0
-            for log_file in mpm_logs:
+            for log_file in all_mpm_logs:
                 try:
                     # Move file to new location
                     new_path = new_location / log_file.name

claude_mpm/core/logger.py

@@ -232,7 +232,7 @@ def setup_logging(
             if log_dir is None:
                 # Use deployment root for logs to keep everything centralized
                 deployment_root = get_project_root()
-                log_dir = deployment_root / ".claude-mpm" / "logs"
+                log_dir = deployment_root / "logs" / "mpm"
 
             log_dir.mkdir(parents=True, exist_ok=True)
 

claude_mpm/core/unified_agent_registry.py

@@ -455,7 +455,7 @@ class UnifiedAgentRegistry:
         """Apply tier precedence rules to resolve conflicts."""
         # Group agents by their actual name (without tier suffix)
         agent_groups = {}
-        for registry_key, metadata in self.registry.items():
+        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:

claude_mpm/dashboard/.claude-mpm/socketio-instances.json

@@ -0,0 +1 @@
+{}