claude-mpm 5.0.9__py3-none-any.whl → 5.6.23__py3-none-any.whl

claude_mpm/cli/commands/mpm_init/prompts.py

@@ -10,7 +10,9 @@ from pathlib import Path
 from typing import Any, Dict, Optional
 
 __all__ = [
+    "build_enhanced_update_prompt",
     "build_initialization_prompt",
+    "build_prompt_engineer_optimization_prompt",
     "build_research_context_prompt",
     "build_update_prompt",
 ]
@@ -305,6 +307,208 @@ preserving valuable project-specific information while refreshing standard secti
     return prompt
 
 
+def build_enhanced_update_prompt(
+    project_path: Path,
+    doc_analysis: Dict[str, Any],
+    git_insights: Dict[str, Any],
+    log_insights: Dict[str, Any],
+    memory_insights: Dict[str, Any],
+    project_type: Optional[str] = None,
+    framework: Optional[str] = None,
+    ast_analysis: bool = True,
+    preserve_custom: bool = True,
+) -> str:
+    """
+    Build enhanced update prompt with extracted knowledge from multiple sources.
+
+    This is the AUTO-DETECTED update mode that enriches CLAUDE.md with:
+    - Git history insights (architectural decisions, tech changes, workflows)
+    - Session log learnings (completed work, patterns)
+    - Memory file knowledge (accumulated project wisdom)
+
+    Args:
+        project_path: Path to the project directory
+        doc_analysis: Analysis results from DocumentationManager
+        git_insights: Extracted git history insights
+        log_insights: Extracted session log insights
+        memory_insights: Extracted memory file insights
+        project_type: Type of project (web, api, cli, library, etc.)
+        framework: Specific framework if applicable
+        ast_analysis: Enable AST analysis for enhanced documentation
+        preserve_custom: Preserve custom sections when updating
+
+    Returns:
+        Formatted prompt string for enhanced update mode
+    """
+    prompt = f"""Please delegate this task to the Agentic Coder Optimizer agent:
+
+ENHANCED UPDATE of existing CLAUDE.md documentation with extracted project knowledge.
+
+Project Path: {project_path}
+Update Mode: Knowledge-enriched smart merge
+"""
+    if project_type:
+        prompt += f"Project Type: {project_type}\n"
+    if framework:
+        prompt += f"Framework: {framework}\n"
+
+    prompt += f"""
+Existing Documentation Analysis:
+- Current CLAUDE.md: {doc_analysis.get("size", 0):,} characters, {doc_analysis.get("lines", 0)} lines
+- Has Priority Index: {"Yes" if doc_analysis.get("has_priority_index") else "No"}
+- Custom Sections: {len(doc_analysis.get("custom_sections", []))} found
+"""
+    if preserve_custom and doc_analysis.get("custom_sections"):
+        prompt += f"- Preserve Custom Sections: {', '.join(doc_analysis['custom_sections'][:5])}\n"
+
+    # Add extracted knowledge sections
+    prompt += "\n## Extracted Project Knowledge\n\n"
+
+    # Git insights
+    if git_insights.get("available"):
+        prompt += "### From Git History (last 90 days):\n\n"
+
+        if git_insights.get("architectural_decisions"):
+            prompt += "**Architectural Patterns Detected:**\n"
+            for decision in git_insights["architectural_decisions"][:10]:
+                prompt += f"- {decision}\n"
+            prompt += "\n"
+
+        if git_insights.get("tech_stack_changes"):
+            prompt += "**Tech Stack Changes:**\n"
+            for change in git_insights["tech_stack_changes"][:10]:
+                prompt += f"- {change}\n"
+            prompt += "\n"
+
+        if git_insights.get("workflow_patterns"):
+            prompt += "**Common Workflows:**\n"
+            for workflow in git_insights["workflow_patterns"][:8]:
+                prompt += f"- {workflow}\n"
+            prompt += "\n"
+
+        if git_insights.get("hot_files"):
+            prompt += "**Hot Files (frequently modified):**\n"
+            for file_info in git_insights["hot_files"][:10]:
+                prompt += (
+                    f"- {file_info['path']} ({file_info['modifications']} changes)\n"
+                )
+            prompt += "\n"
+
+    # Session log insights
+    if log_insights.get("available") and log_insights.get("learnings"):
+        prompt += "### From Session Logs:\n\n"
+        prompt += "**Recent Learnings from PM Summaries:**\n"
+        for learning in log_insights["learnings"][:10]:
+            source = learning.get("source", "unknown")
+            content = learning.get("content", "")
+            # Truncate long content
+            if len(content) > 200:
+                content = content[:200] + "..."
+            prompt += f"- [{source}] {content}\n"
+        prompt += "\n"
+
+        if log_insights.get("common_patterns"):
+            prompt += "**Common Task Patterns:**\n"
+            prompt += f"- {', '.join(log_insights['common_patterns'][:10])}\n\n"
+
+    # Memory insights
+    if memory_insights.get("available"):
+        has_content = False
+
+        if memory_insights.get("architectural_knowledge"):
+            has_content = True
+            prompt += "### From Agent Memories:\n\n"
+            prompt += "**Architectural Knowledge:**\n"
+            for item in memory_insights["architectural_knowledge"][:8]:
+                prompt += f"- {item}\n"
+            prompt += "\n"
+
+        if memory_insights.get("implementation_guidelines"):
+            if not has_content:
+                prompt += "### From Agent Memories:\n\n"
+                has_content = True
+            prompt += "**Implementation Guidelines:**\n"
+            for item in memory_insights["implementation_guidelines"][:8]:
+                prompt += f"- {item}\n"
+            prompt += "\n"
+
+        if memory_insights.get("common_mistakes"):
+            if not has_content:
+                prompt += "### From Agent Memories:\n\n"
+                has_content = True
+            prompt += "**Common Mistakes to Avoid:**\n"
+            for item in memory_insights["common_mistakes"][:8]:
+                prompt += f"- {item}\n"
+            prompt += "\n"
+
+        if memory_insights.get("technical_context"):
+            if not has_content:
+                prompt += "### From Agent Memories:\n\n"
+            prompt += "**Current Technical Context:**\n"
+            for item in memory_insights["technical_context"][:8]:
+                prompt += f"- {item}\n"
+            prompt += "\n"
+
+    # Add update instructions
+    prompt += """
+## UPDATE Tasks with Knowledge Integration:
+
+1. **Review Existing Content**:
+   - Analyze current CLAUDE.md structure and content
+   - Identify outdated or missing information
+   - Preserve valuable custom sections and project-specific knowledge
+
+2. **Integrate Extracted Knowledge**:
+   - Merge architectural decisions from git history into Architecture section
+   - Add tech stack changes to Technology/Dependencies sections
+   - Update workflow patterns in Development Guidelines
+   - Incorporate session learnings into relevant sections
+   - Merge memory insights into appropriate documentation areas
+   - Highlight hot files as critical components
+
+3. **Smart Content Merge**:
+   - Update project overview with recent developments
+   - Refresh architecture documentation with detected patterns
+   - Update development workflows with discovered common patterns
+   - Ensure single-path principle (ONE way to do each task)
+   - Remove duplicate or contradictory information
+
+4. **Update Priority Organization**:
+   - Reorganize content with priority markers (🔴🟡🟢⚪)
+   - Ensure critical instructions are at the top
+   - Update priority index with all important items
+   - Promote frequently-modified files to IMPORTANT sections
+
+5. **Refresh Technical Content**:
+   - Update build/test/deploy commands based on workflow patterns
+   - Verify tool configurations match tech stack changes
+   - Update dependency information with detected changes
+   - Refresh API documentation if applicable
+"""
+    if ast_analysis:
+        prompt += """
+6. **Update Code Documentation** (using Code Analyzer agent):
+   - Re-analyze code structure for changes
+   - Update API documentation
+   - Refresh architecture diagrams
+   - Document hot files and critical components
+"""
+    prompt += """
+7. **Final Optimization**:
+   - Ensure single-path principle throughout
+   - Validate all links and references
+   - Add/update timestamp in meta section
+   - Add "Last Updated" note mentioning knowledge extraction
+   - Verify AI agent readability
+
+IMPORTANT: This is an ENHANCED UPDATE operation with extracted knowledge.
+Intelligently merge insights from git history, session logs, and agent memories
+into the existing CLAUDE.md while preserving valuable custom content.
+The goal is to create a living document that reflects actual project evolution.
+"""
+    return prompt
+
+
 def build_research_context_prompt(git_analysis: Dict[str, Any], days: int) -> str:
     """
     Build structured Research agent delegation prompt from git analysis.
@@ -440,3 +644,79 @@ Keep it concise (<1000 words) but actionable.
 """
 
     return prompt
+
+
+def build_prompt_engineer_optimization_prompt(
+    content: str, estimated_tokens: int
+) -> str:
+    """
+    Build prompt for prompt-engineer to optimize CLAUDE.md.
+
+    Args:
+        content: Current CLAUDE.md content to optimize
+        estimated_tokens: Estimated token count of current content
+
+    Returns:
+        Formatted prompt string for prompt-engineer optimization
+    """
+    return f"""Please delegate this task to the Prompt Engineer agent:
+
+Optimize this CLAUDE.md file for conciseness, clarity, and token efficiency while preserving all critical information.
+
+## Current CLAUDE.md Statistics
+- Estimated tokens: {estimated_tokens:,}
+- Target reduction: 20-30% if possible
+- Priority: Preserve ALL CRITICAL (🔴) and IMPORTANT (🟡) information
+
+## Optimization Goals
+
+1. **Remove Redundancy**:
+   - Eliminate duplicate information across sections
+   - Consolidate similar instructions
+   - Remove verbose explanations where brevity suffices
+
+2. **Tighten Language**:
+   - Use fewer words to convey the same meaning
+   - Replace wordy phrases with concise alternatives
+   - Remove filler words and unnecessary qualifiers
+
+3. **Improve Structure**:
+   - Ensure clear hierarchical organization
+   - Use priority markers (🔴 🟡 🟢 ⚪) effectively
+   - Group related information logically
+   - Maintain scannable headings
+
+4. **Preserve Critical Content**:
+   - Keep ALL security and data handling rules (🔴)
+   - Maintain core business logic and constraints (🔴)
+   - Preserve architectural decisions (🟡)
+   - Keep essential workflows intact (🟡)
+
+5. **Apply Claude Best Practices**:
+   - Use high-level guidance over prescriptive checklists
+   - Provide context for WHY, not just WHAT
+   - Ensure instructions are actionable and unambiguous
+   - Optimize for AI agent understanding
+
+## Current CLAUDE.md Content
+
+{content}
+
+## Output Requirements
+
+Return ONLY the optimized CLAUDE.md content with NO additional explanations.
+The optimized version should:
+- Reduce token count by 20-30% if feasible
+- Maintain all CRITICAL and IMPORTANT instructions
+- Improve clarity and scannability
+- Follow the same structural template (Priority Index, sections with markers)
+
+## Quality Criteria
+
+✅ All 🔴 CRITICAL items preserved
+✅ All 🟡 IMPORTANT items preserved
+✅ No contradictory instructions
+✅ Clear, concise language throughout
+✅ Logical organization maintained
+✅ Token count reduced meaningfully
+"""

claude_mpm/cli/commands/postmortem.py

@@ -317,7 +317,7 @@ def _create_prs(report, verbose: bool) -> int:
     print(f"\n🤖 Creating {len(pr_actions)} PR(s) for agent improvements...")
 
     # Check if we're in the agent cache git repo
-    agent_cache_path = Path.home() / ".claude-mpm" / "cache" / "remote-agents"
+    agent_cache_path = Path.home() / ".claude-mpm" / "cache" / "agents"
 
     if not agent_cache_path.exists():
         print(f"❌ Agent cache not found at: {agent_cache_path}")

claude_mpm/cli/commands/profile.py

@@ -0,0 +1,276 @@
+"""
+Profile management commands for claude-mpm CLI.
+
+WHY: Users need a simple way to manage deployment profiles from the command
+line. Profiles control which agents and skills are deployed, reducing context
+usage by limiting available agents to only what's needed.
+
+DESIGN DECISIONS:
+- Use BaseCommand for consistent CLI patterns
+- Provide clear, actionable output with standardized error handling
+- Support profile listing, activation, and status reporting
+- Integrate with ConfigLoader for profile persistence
+"""
+
+from pathlib import Path
+
+import yaml
+from rich.table import Table
+
+from ...core.shared.config_loader import ConfigLoader
+from ...services.profile_manager import ProfileManager
+from ...utils.console import console
+from ..shared import BaseCommand, CommandResult
+
+
+class ProfileCommand(BaseCommand):
+    """Profile management command for agents and skills filtering."""
+
+    def __init__(self):
+        super().__init__("profile")
+        # ProfileManager will auto-detect project directory
+        self.profile_manager = ProfileManager()
+        self.config_loader = ConfigLoader()
+
+    def validate_args(self, args) -> str:
+        """Validate command arguments."""
+        if not hasattr(args, "profile_command") or not args.profile_command:
+            return "Profile command required. Use: list, set, status, or show"
+
+        valid_commands = ["list", "set", "status", "show"]
+        if args.profile_command not in valid_commands:
+            return (
+                f"Unknown profile command: {args.profile_command}. "
+                f"Valid commands: {', '.join(valid_commands)}"
+            )
+
+        # Validate set command has profile name
+        if args.profile_command == "set":
+            if not hasattr(args, "profile_name") or not args.profile_name:
+                return "Profile name required for 'set' command"
+
+        # Validate show command has profile name
+        if args.profile_command == "show":
+            if not hasattr(args, "profile_name") or not args.profile_name:
+                return "Profile name required for 'show' command"
+
+        return None
+
+    def run(self, args) -> CommandResult:
+        """Execute the profile command."""
+        try:
+            if args.profile_command == "list":
+                return self._list_profiles(args)
+            if args.profile_command == "set":
+                return self._set_profile(args)
+            if args.profile_command == "status":
+                return self._show_status(args)
+            if args.profile_command == "show":
+                return self._show_profile(args)
+            return CommandResult.error_result(
+                f"Unknown profile command: {args.profile_command}"
+            )
+        except Exception as e:
+            return CommandResult.error_result(f"Profile command failed: {e}")
+
+    def _list_profiles(self, args) -> CommandResult:
+        """List all available profiles."""
+        profiles = self.profile_manager.list_available_profiles()
+
+        if not profiles:
+            console.print("[yellow]No profiles found in .claude-mpm/profiles/[/yellow]")
+            return CommandResult.success_result("No profiles available")
+
+        # Load current active profile
+        main_config = self.config_loader.load_main_config()
+        active_profile = main_config.get("active_profile")
+
+        # Create table
+        table = Table(title="Available Deployment Profiles")
+        table.add_column("Profile", style="cyan", no_wrap=True)
+        table.add_column("Description", style="white")
+        table.add_column("Status", style="green")
+
+        for profile_name in profiles:
+            description = self.profile_manager.get_profile_description(profile_name)
+            status = "✓ Active" if profile_name == active_profile else ""
+
+            table.add_row(
+                profile_name, description or "(no description)", status or "-"
+            )
+
+        console.print(table)
+
+        return CommandResult.success_result(
+            f"Found {len(profiles)} profile(s)", {"profiles": profiles}
+        )
+
+    def _set_profile(self, args) -> CommandResult:
+        """Set active profile."""
+        profile_name = args.profile_name
+
+        # Validate profile exists
+        available_profiles = self.profile_manager.list_available_profiles()
+        if profile_name not in available_profiles:
+            return CommandResult.error_result(
+                f"Profile '{profile_name}' not found. "
+                f"Available profiles: {', '.join(available_profiles)}"
+            )
+
+        # Load profile to validate it
+        success = self.profile_manager.load_profile(profile_name)
+        if not success:
+            return CommandResult.error_result(
+                f"Failed to load profile '{profile_name}'"
+            )
+
+        # Update configuration.yaml
+        config_path = Path.cwd() / ".claude-mpm" / "configuration.yaml"
+        if not config_path.exists():
+            # Create configuration.yaml if it doesn't exist
+            config_path.parent.mkdir(parents=True, exist_ok=True)
+            config_data = {"active_profile": profile_name}
+        else:
+            # Load existing configuration
+            with config_path.open("r") as f:
+                config_data = yaml.safe_load(f) or {}
+            config_data["active_profile"] = profile_name
+
+        # Save configuration
+        with config_path.open("w") as f:
+            yaml.safe_dump(config_data, f, default_flow_style=False, sort_keys=False)
+
+        # Show summary
+        summary = self.profile_manager.get_filtering_summary()
+        console.print(
+            f"[green]✓[/green] Active profile set to: [cyan]{profile_name}[/cyan]"
+        )
+        console.print(
+            f"  Agents enabled: [cyan]{summary['enabled_agents_count']}[/cyan]"
+        )
+        console.print(
+            f"  Skills enabled: [cyan]{summary['enabled_skills_count']}[/cyan]"
+        )
+        console.print(
+            f"  Skill patterns disabled: [cyan]{summary['disabled_patterns_count']}[/cyan]"
+        )
+        console.print(
+            "\n[yellow]Note:[/yellow] Restart Claude Code or run [cyan]claude-mpm init[/cyan] "
+            "to apply profile filtering."
+        )
+
+        return CommandResult.success_result(
+            f"Profile '{profile_name}' activated",
+            {"profile": profile_name, "summary": summary},
+        )
+
+    def _show_status(self, args) -> CommandResult:
+        """Show current profile status."""
+        # Load current active profile
+        main_config = self.config_loader.load_main_config()
+        active_profile = main_config.get("active_profile")
+
+        if not active_profile:
+            console.print(
+                "[yellow]No active profile[/yellow] - All agents and skills enabled"
+            )
+            return CommandResult.success_result(
+                "No active profile", {"active_profile": None}
+            )
+
+        # Load profile
+        success = self.profile_manager.load_profile(active_profile)
+        if not success:
+            return CommandResult.error_result(
+                f"Failed to load active profile '{active_profile}'"
+            )
+
+        # Get summary
+        summary = self.profile_manager.get_filtering_summary()
+
+        # Display status
+        console.print(f"[green]Active Profile:[/green] [cyan]{active_profile}[/cyan]")
+        console.print()
+
+        # Agents section
+        console.print("[bold]Agents:[/bold]")
+        console.print(f"  Enabled: [cyan]{summary['enabled_agents_count']}[/cyan]")
+        console.print(f"  Disabled: [cyan]{summary['disabled_agents_count']}[/cyan]")
+
+        # Skills section
+        console.print()
+        console.print("[bold]Skills:[/bold]")
+        console.print(f"  Enabled: [cyan]{summary['enabled_skills_count']}[/cyan]")
+        console.print(
+            f"  Disabled patterns: [cyan]{summary['disabled_patterns_count']}[/cyan]"
+        )
+
+        return CommandResult.success_result(
+            f"Profile '{active_profile}' status",
+            {"active_profile": active_profile, "summary": summary},
+        )
+
+    def _show_profile(self, args) -> CommandResult:
+        """Show detailed profile configuration."""
+        profile_name = args.profile_name
+
+        # Validate profile exists
+        available_profiles = self.profile_manager.list_available_profiles()
+        if profile_name not in available_profiles:
+            return CommandResult.error_result(
+                f"Profile '{profile_name}' not found. "
+                f"Available profiles: {', '.join(available_profiles)}"
+            )
+
+        # Load profile
+        success = self.profile_manager.load_profile(profile_name)
+        if not success:
+            return CommandResult.error_result(
+                f"Failed to load profile '{profile_name}'"
+            )
+
+        # Display profile details
+        console.print(f"[bold]Profile:[/bold] [cyan]{profile_name}[/cyan]")
+        console.print()
+
+        # Show enabled agents
+        enabled_agents = self.profile_manager.get_enabled_agents()
+        if enabled_agents:
+            console.print("[bold]Enabled Agents:[/bold]")
+            for agent in sorted(enabled_agents):
+                console.print(f"  • {agent}")
+            console.print()
+
+        # Show disabled agents
+        disabled_agents = self.profile_manager.get_disabled_agents()
+        if disabled_agents:
+            console.print("[bold]Disabled Agents:[/bold]")
+            for agent in sorted(disabled_agents):
+                console.print(f"  • {agent}")
+            console.print()
+
+        # Show enabled skills
+        enabled_skills = self.profile_manager.get_enabled_skills()
+        if enabled_skills:
+            console.print("[bold]Enabled Skills:[/bold]")
+            for skill in sorted(enabled_skills):
+                console.print(f"  • {skill}")
+            console.print()
+
+        # Show disabled skill patterns
+        disabled_patterns = self.profile_manager.get_disabled_skill_patterns()
+        if disabled_patterns:
+            console.print("[bold]Disabled Skill Patterns:[/bold]")
+            for pattern in disabled_patterns:
+                console.print(f"  • {pattern}")
+
+        return CommandResult.success_result(
+            f"Profile '{profile_name}' details",
+            {
+                "profile": profile_name,
+                "enabled_agents": list(enabled_agents),
+                "disabled_agents": list(disabled_agents),
+                "enabled_skills": list(enabled_skills),
+                "disabled_patterns": disabled_patterns,
+            },
+        )

claude_mpm/cli/commands/run.py

@@ -13,7 +13,7 @@ DESIGN DECISIONS:
 - Support multiple output formats (json, yaml, table, text)
 """
 
-import subprocess
+import subprocess  # nosec B404 - required for process management
 import sys
 from datetime import datetime, timezone
 from typing import Optional
@@ -489,6 +489,18 @@ class RunCommand(BaseCommand):
         if hasattr(args, "claude_args") and args.claude_args:
             claude_args.extend(args.claude_args)
 
+        # Add --resume if flag is set
+        if getattr(args, "resume", False) and "--resume" not in claude_args:
+            claude_args.insert(0, "--resume")
+
+        # Add --chrome if flag is set
+        if getattr(args, "chrome", False) and "--chrome" not in claude_args:
+            claude_args.insert(0, "--chrome")
+
+        # Add --no-chrome if flag is set
+        if getattr(args, "no_chrome", False) and "--no-chrome" not in claude_args:
+            claude_args.insert(0, "--no-chrome")
+
         # Create runner
         runner = ClaudeRunner(
             enable_tickets=enable_tickets,
@@ -553,7 +565,7 @@ class RunCommand(BaseCommand):
                 wrapper_path = get_scripts_dir() / "interactive_wrapper.py"
                 if wrapper_path.exists():
                     print("Starting interactive session with command interception...")
-                    subprocess.run([sys.executable, str(wrapper_path)], check=False)
+                    subprocess.run([sys.executable, str(wrapper_path)], check=False)  # nosec B603 - trusted internal paths
                 else:
                     self.logger.warning(
                         "Interactive wrapper not found, falling back to normal mode"
@@ -907,6 +919,26 @@ def run_session_legacy(args):
         else:
             logger.info("[INFO]️ --resume already in claude_args")
 
+    # Add --chrome to claude_args if the flag is set
+    chrome_flag_present = getattr(args, "chrome", False)
+    if chrome_flag_present:
+        logger.info("📌 --chrome flag detected in args")
+        if "--chrome" not in raw_claude_args:
+            raw_claude_args = ["--chrome", *raw_claude_args]
+            logger.info("✅ Added --chrome to claude_args")
+        else:
+            logger.info("ℹ️ --chrome already in claude_args")
+
+    # Add --no-chrome to claude_args if the flag is set
+    no_chrome_flag_present = getattr(args, "no_chrome", False)
+    if no_chrome_flag_present:
+        logger.info("📌 --no-chrome flag detected in args")
+        if "--no-chrome" not in raw_claude_args:
+            raw_claude_args = ["--no-chrome", *raw_claude_args]
+            logger.info("✅ Added --no-chrome to claude_args")
+        else:
+            logger.info("ℹ️ --no-chrome 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)
@@ -1044,7 +1076,7 @@ def run_session_legacy(args):
         wrapper_path = get_scripts_dir() / "interactive_wrapper.py"
         if wrapper_path.exists():
             print("Starting interactive session with command interception...")
-            subprocess.run([sys.executable, str(wrapper_path)], check=False)
+            subprocess.run([sys.executable, str(wrapper_path)], check=False)  # nosec B603 - trusted internal paths
         else:
             logger.warning("Interactive wrapper not found, falling back to normal mode")
             runner.run_interactive(context)