claude-mpm 5.1.9__py3-none-any.whl → 5.4.48__py3-none-any.whl

claude_mpm/cli/commands/configure_agent_display.py

@@ -59,12 +59,15 @@ class AgentDisplay:
         Shows:
         - Agent ID (for selection)
         - Name and description
-        - Enable/disable status
+        - Installed/Available status
         - Model or tools information
 
         Args:
             agents: List of agent configurations to display
         """
+
+        from ...utils.agent_filters import get_deployed_agent_ids
+
         table = Table(
             title=f"Available Agents ({len(agents)} total)",
             box=ROUNDED,
@@ -77,12 +80,25 @@ class AgentDisplay:
         table.add_column("Description", style="bold", width=45)
         table.add_column("Model/Tools", style="dim", width=20)
 
+        # Get deployed agent IDs
+        deployed_ids = get_deployed_agent_ids()
+
+        # Track installed count for summary
+        installed_count = 0
+
         for idx, agent in enumerate(agents, 1):
-            # Check if agent is enabled
-            is_enabled = self.agent_manager.is_agent_enabled(agent.name)
-            status = (
-                "[green]✓ Enabled[/green]" if is_enabled else "[red]✗ Disabled[/red]"
-            )
+            # Check if agent is deployed to .claude/agents/
+            # Use agent_id (technical ID) for comparison, not display name
+            agent_id = getattr(agent, "agent_id", agent.name)
+            agent_leaf_name = agent_id.split("/")[-1]
+            is_deployed = agent_leaf_name in deployed_ids
+
+            # Increment installed count
+            if is_deployed:
+                installed_count += 1
+
+            # Show "Installed" for deployed agents, "Available" otherwise
+            status = "[green]Installed[/green]" if is_deployed else "Available"
 
             # Format tools/dependencies - show first 2 tools
             tools_display = ""
@@ -115,6 +131,9 @@ class AgentDisplay:
 
         self.console.print(table)
 
+        # Display summary count
+        self.console.print(f"\n📊 Agents: {installed_count} Installed / {len(agents)} Total")
+
     def display_agents_with_pending_states(self, agents: List[AgentConfig]) -> None:
         """Display agents table with pending state indicators.
 

claude_mpm/cli/commands/mpm_init/core.py

@@ -24,6 +24,7 @@ from claude_mpm.utils.display_helper import DisplayHelper
 
 # Import from sibling modules in the mpm_init package
 from . import display, git_activity, modes, prompts
+from .knowledge_extractor import ProjectKnowledgeExtractor
 
 logger = get_logger(__name__)
 
@@ -34,6 +35,7 @@ class MPMInitCommand:
     def __init__(self, project_path: Optional[Path] = None):
         """Initialize the MPM-Init command."""
         self.project_path = project_path or Path.cwd()
+        self.claude_mpm_dir = self.project_path / ".claude-mpm"
         self.claude_mpm_script = self._find_claude_mpm_script()
         self.console = Console()
 
@@ -155,9 +157,8 @@ class MPMInitCommand:
                 if pre_check_result.get("status") == OperationResult.ERROR:
                     return pre_check_result
 
-            # Update .gitignore to exclude claude-mpm configuration directories
-            if not review_only and not dry_run:
-                self._update_gitignore()
+            # Note: .gitignore recommendations are now shown in 'mpm config' command
+            # instead of automatic updates during initialization
 
             # Build the delegation prompt
             if update_mode:
@@ -202,6 +203,10 @@ class MPMInitCommand:
             if update_mode and result.get("status") == OperationResult.SUCCESS:
                 self._handle_update_post_processing()
 
+            # Deploy PM skills after successful initialization
+            if result.get("status") == OperationResult.SUCCESS:
+                self._deploy_pm_skills()
+
             return result
 
         except Exception as e:
@@ -399,48 +404,6 @@ class MPMInitCommand:
             "warnings": warnings,
         }
 
-    def _update_gitignore(self) -> None:
-        """Update .gitignore to exclude claude-mpm configuration directories.
-
-        Ensures that claude-mpm configuration directories are added to .gitignore
-        to prevent them from being committed to version control.
-
-        This is a non-destructive operation that:
-        - Creates .gitignore if it doesn't exist
-        - Appends missing entries only (never duplicates)
-        - Preserves all existing content
-
-        Standard entries added:
-        - .claude-mpm/: Main configuration directory
-        - .claude/agents/: Agent runtime files
-        """
-        from claude_mpm.utils.gitignore import ensure_claude_mpm_gitignore
-
-        try:
-            result = ensure_claude_mpm_gitignore(str(self.project_path))
-
-            if result.get("status") == "success":
-                if result.get("added"):
-                    self.console.print(
-                        f"[green]✓[/green] Updated .gitignore: {', '.join(result['added'])}"
-                    )
-                    logger.info(f"Added to .gitignore: {result['added']}")
-                elif result.get("existing"):
-                    logger.debug(f".gitignore already contains: {result['existing']}")
-            else:
-                # Non-critical error - log but don't fail initialization
-                logger.warning(
-                    f"Could not update .gitignore: {result.get('error', 'Unknown error')}"
-                )
-                self.console.print(
-                    f"[yellow]⚠️  Could not update .gitignore: {result.get('error')}[/yellow]"
-                )
-
-        except Exception as e:
-            # Non-critical error - log but don't fail initialization
-            logger.warning(f"Error updating .gitignore: {e}")
-            self.console.print(f"[yellow]⚠️  Could not update .gitignore: {e}[/yellow]")
-
     def _build_initialization_prompt(
         self,
         project_type: Optional[str] = None,
@@ -452,6 +415,10 @@ class MPMInitCommand:
             self.project_path, project_type, framework, ast_analysis
         )
 
+    def _is_initialized(self) -> bool:
+        """Check if project is already initialized with .claude-mpm directory."""
+        return self.claude_mpm_dir.exists()
+
     def _build_update_prompt(
         self,
         project_type: Optional[str],
@@ -459,10 +426,65 @@ class MPMInitCommand:
         ast_analysis: bool,
         preserve_custom: bool,
     ) -> str:
-        """Build prompt for update mode."""
+        """Build prompt for update mode with optional knowledge extraction."""
         # Get existing content analysis
         doc_analysis = self.doc_manager.analyze_existing_content()
 
+        # Check if project is initialized (.claude-mpm exists)
+        # If so, use enhanced update mode with knowledge extraction
+        if self._is_initialized():
+            self.console.print(
+                "[cyan]✓ Detected initialized project - activating enhanced update mode[/cyan]"
+            )
+
+            # Extract knowledge from all sources
+            extractor = ProjectKnowledgeExtractor(self.project_path)
+
+            self.console.print("[cyan]✓ Analyzing git history (last 90 days)...[/cyan]")
+            git_insights = extractor.extract_from_git(days=90)
+
+            if git_insights.get("available"):
+                arch_count = len(git_insights.get("architectural_decisions", []))
+                workflow_count = len(git_insights.get("workflow_patterns", []))
+                self.console.print(f"  - Found {arch_count} architectural decisions")
+                self.console.print(f"  - Detected {workflow_count} workflow patterns")
+
+            self.console.print("[cyan]✓ Analyzing session logs...[/cyan]")
+            log_insights = extractor.extract_from_logs()
+
+            if log_insights.get("available"):
+                learning_count = len(log_insights.get("learnings", []))
+                self.console.print(f"  - Found {learning_count} learning entries")
+
+            self.console.print("[cyan]✓ Analyzing memory files...[/cyan]")
+            memory_insights = extractor.extract_from_memory()
+
+            if memory_insights.get("available"):
+                total_insights = (
+                    len(memory_insights.get("architectural_knowledge", []))
+                    + len(memory_insights.get("implementation_guidelines", []))
+                    + len(memory_insights.get("common_mistakes", []))
+                    + len(memory_insights.get("technical_context", []))
+                )
+                self.console.print(f"  - Found {total_insights} accumulated insights")
+
+            self.console.print(
+                "[green]✓ Knowledge extraction complete - building enhanced prompt[/green]\n"
+            )
+
+            # Build enhanced prompt with extracted knowledge
+            return prompts.build_enhanced_update_prompt(
+                self.project_path,
+                doc_analysis,
+                git_insights,
+                log_insights,
+                memory_insights,
+                project_type,
+                framework,
+                ast_analysis,
+                preserve_custom,
+            )
+        # Standard update mode (no .claude-mpm directory)
         return prompts.build_update_prompt(
             self.project_path,
             doc_analysis,
@@ -548,6 +570,11 @@ class MPMInitCommand:
             self.archive_manager,
         )
 
+        # Optimize CLAUDE.md with prompt-engineer if it exists
+        claude_md = self.project_path / "CLAUDE.md"
+        if claude_md.exists():
+            self._optimize_claude_md_with_prompt_engineer()
+
     def _display_results(self, result: Dict, verbose: bool):
         """Display initialization results."""
         display.display_results(self.display, self.console, result, verbose)
@@ -569,5 +596,157 @@ class MPMInitCommand:
         """Build structured Research agent delegation prompt from git analysis."""
         return prompts.build_research_context_prompt(git_analysis, days)
 
+    def _optimize_claude_md_with_prompt_engineer(self) -> None:
+        """Optimize CLAUDE.md with prompt-engineer for conciseness and clarity."""
+        claude_md_path = self.project_path / "CLAUDE.md"
+        if not claude_md_path.exists():
+            return
+
+        try:
+            # Read current content
+            original_content = claude_md_path.read_text()
+            original_tokens = self._estimate_tokens(original_content)
+
+            # Create backup
+            backup_path = self.archive_manager.auto_archive_before_update(
+                claude_md_path, update_reason="Before prompt-engineer optimization"
+            )
+
+            if not backup_path:
+                logger.warning("Could not create backup before optimization")
+                self.console.print(
+                    "[yellow]⚠️  Skipping optimization - backup failed[/yellow]"
+                )
+                return
+
+            self.console.print(
+                "\n[cyan]✓ Optimizing CLAUDE.md with prompt-engineer...[/cyan]"
+            )
+            self.console.print(f"  - Original: {original_tokens:,} tokens (estimated)")
+            self.console.print(f"  - Backup created: {backup_path}")
+
+            # Build optimization prompt
+            prompt = prompts.build_prompt_engineer_optimization_prompt(
+                original_content, original_tokens
+            )
+
+            # Run optimization through subprocess
+            with Progress(
+                SpinnerColumn(),
+                TextColumn("[progress.description]{task.description}"),
+                console=self.console,
+            ) as progress:
+                task = progress.add_task(
+                    "[cyan]Running prompt-engineer optimization...", total=None
+                )
+
+                result = self._run_initialization(
+                    prompt, verbose=False, update_mode=True
+                )
+
+                progress.update(task, description="[green]✓ Optimization complete")
+
+            # Check if optimization succeeded
+            if result.get("status") == OperationResult.SUCCESS:
+                # Read optimized content
+                optimized_content = claude_md_path.read_text()
+                optimized_tokens = self._estimate_tokens(optimized_content)
+
+                # Calculate reduction
+                token_reduction = original_tokens - optimized_tokens
+                reduction_percent = (
+                    (token_reduction / original_tokens * 100)
+                    if original_tokens > 0
+                    else 0
+                )
+
+                self.console.print(
+                    f"  - Optimized: {optimized_tokens:,} tokens ({reduction_percent:.1f}% reduction)"
+                )
+                self.console.print("[green]✓ CLAUDE.md optimization complete[/green]\n")
+            # Restore from backup on failure
+            elif backup_path and backup_path.exists():
+                import shutil
+
+                shutil.copy2(backup_path, claude_md_path)
+                self.console.print(
+                    "[yellow]⚠️  Optimization failed - restored from backup[/yellow]\n"
+                )
+
+        except Exception as e:
+            logger.error(f"Failed to optimize CLAUDE.md: {e}")
+            self.console.print(
+                f"[yellow]⚠️  Could not optimize CLAUDE.md: {e}[/yellow]\n"
+            )
+
+    def _estimate_tokens(self, text: str) -> int:
+        """Estimate token count for text (rough approximation).
+
+        Uses a simple heuristic: ~4 characters per token for English text.
+        This is a rough estimate but sufficient for displaying progress.
+        """
+        return len(text) // 4
+
+    def _deploy_pm_skills(self) -> None:
+        """Deploy PM skills templates to project .claude-mpm directory.
+
+        Copies PM skills from bundled templates to .claude-mpm/skills/pm/
+        with version tracking and checksum validation.
+        """
+        try:
+            from rich.progress import BarColumn, Progress, TaskProgressColumn, TextColumn
+
+            from claude_mpm.services.pm_skills_deployer import PMSkillsDeployerService
+
+            deployer = PMSkillsDeployerService()
+
+            # Use progress bar for deployment
+            with Progress(
+                TextColumn("[cyan]Deploying PM skills[/cyan]"),
+                BarColumn(bar_width=30),
+                TaskProgressColumn(),
+                TextColumn("[dim]{task.description}[/dim]"),
+                console=self.console,
+            ) as progress:
+                task = progress.add_task("", total=None)  # Unknown total initially
+
+                def update_progress(skill_name: str, current: int, total: int) -> None:
+                    progress.update(task, total=total, completed=current, description=skill_name)
+
+                result = deployer.deploy_pm_skills(
+                    self.project_path, progress_callback=update_progress
+                )
+
+            if result.success:
+                if result.deployed:
+                    self.console.print(
+                        f"[green]✓ Deployed {len(result.deployed)} PM skills[/green]"
+                    )
+
+                if result.skipped:
+                    self.console.print(
+                        f"[dim]  Skipped {len(result.skipped)} (already deployed)[/dim]"
+                    )
+
+                if result.errors:
+                    self.console.print(f"[yellow]⚠️  {len(result.errors)} errors:[/yellow]")
+                    for error in result.errors[:3]:  # Show first 3 errors
+                        self.console.print(f"  • {error['skill']}: {error['error']}")
+            else:
+                self.console.print(
+                    f"[yellow]⚠️  PM skills deployment had errors: {result.message}[/yellow]"
+                )
+
+        except ImportError as e:
+            logger.warning(f"PM skills deployer not available: {e}")
+            self.console.print(
+                "[yellow]⚠️  PM skills deployment skipped (service not available)[/yellow]"
+            )
+        except Exception as e:
+            logger.error(f"Failed to deploy PM skills: {e}")
+            self.console.print(
+                f"[yellow]⚠️  PM skills deployment failed: {e}[/yellow]"
+            )
+
 
 __all__ = ["MPMInitCommand"]