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

claude_mpm/cli/commands/commander.py

@@ -0,0 +1,216 @@
+"""Commander command handler for CLI."""
+
+import asyncio
+import logging
+import shutil
+import threading
+import time
+from pathlib import Path
+
+logger = logging.getLogger(__name__)
+
+# ANSI colors
+CYAN = "\033[36m"
+DIM = "\033[2m"
+BOLD = "\033[1m"
+YELLOW = "\033[33m"
+GREEN = "\033[32m"
+RED = "\033[31m"
+RESET = "\033[0m"
+
+
+def _get_terminal_width() -> int:
+    """Get terminal width with reasonable bounds."""
+    try:
+        width = shutil.get_terminal_size().columns
+        return max(80, min(width, 120))
+    except Exception:
+        return 100
+
+
+def _get_version() -> str:
+    """Get Commander version."""
+    version_file = Path(__file__).parent.parent.parent / "VERSION"
+    if version_file.exists():
+        return version_file.read_text().strip()
+    return "unknown"
+
+
+def display_commander_banner():
+    """Display Commander-specific startup banner."""
+    width = _get_terminal_width()
+    version = _get_version()
+
+    # Commander ASCII art banner
+    banner = f"""
+{CYAN}╭{'─' * (width - 2)}╮{RESET}
+{CYAN}│{RESET}{BOLD}  ⚡ MPM Commander {RESET}{DIM}v{version}{RESET}{' ' * (width - 24 - len(version))}│
+{CYAN}│{RESET}{DIM}  Multi-Project AI Orchestration{RESET}{' ' * (width - 36)}│
+{CYAN}├{'─' * (width - 2)}┤{RESET}
+{CYAN}│{RESET}  {YELLOW}ALPHA{RESET} - APIs may change                                {' ' * (width - 55)}│
+{CYAN}╰{'─' * (width - 2)}╯{RESET}
+"""
+    print(banner)
+
+
+def _count_cached_agents() -> int:
+    """Count cached agents from ~/.claude-mpm/cache/agents/."""
+    try:
+        cache_agents_dir = Path.home() / ".claude-mpm" / "cache" / "agents"
+        if not cache_agents_dir.exists():
+            return 0
+        # Recursively find all .md files excluding base/README files
+        agent_files = [
+            f
+            for f in cache_agents_dir.rglob("*.md")
+            if f.is_file()
+            and not f.name.startswith(".")
+            and f.name not in ("README.md", "BASE-AGENT.md", "INSTRUCTIONS.md")
+        ]
+        return len(agent_files)
+    except Exception:
+        return 0
+
+
+def _count_cached_skills() -> int:
+    """Count cached skills from ~/.claude-mpm/cache/skills/."""
+    try:
+        cache_skills_dir = Path.home() / ".claude-mpm" / "cache" / "skills"
+        if not cache_skills_dir.exists():
+            return 0
+        # Recursively find all directories containing SKILL.md
+        skill_files = list(cache_skills_dir.rglob("SKILL.md"))
+        return len(skill_files)
+    except Exception:
+        return 0
+
+
+def load_agents_and_skills():
+    """Load agents and skills for Commander sessions."""
+    try:
+        print(f"{DIM}Loading agents...{RESET}", end=" ", flush=True)
+        agent_count = _count_cached_agents()
+        print(f"{GREEN}✓{RESET} {agent_count} agents")
+
+        print(f"{DIM}Loading skills...{RESET}", end=" ", flush=True)
+        skill_count = _count_cached_skills()
+        print(f"{GREEN}✓{RESET} {skill_count} skills")
+
+        return agent_count, skill_count
+    except Exception as e:
+        logger.warning(f"Could not load agents/skills: {e}")
+        print(f"{YELLOW}⚠{RESET} Could not load agents/skills")
+        return 0, 0
+
+
+def handle_commander_command(args) -> int:
+    """Handle the commander command with auto-starting daemon.
+
+    Args:
+        args: Parsed command line arguments with:
+            - port: Port for daemon (default: 8765)
+            - host: Host for daemon (default: 127.0.0.1)
+            - state_dir: Optional state directory path
+            - debug: Enable debug logging
+            - no_chat: Start daemon only without interactive chat
+            - daemon_only: Alias for no_chat
+
+    Returns:
+        Exit code (0 for success, 1 for error)
+    """
+    try:
+        # Import here to avoid circular dependencies
+        import requests
+
+        from claude_mpm.commander.chat.cli import run_commander
+        from claude_mpm.commander.config import DaemonConfig
+        from claude_mpm.commander.daemon import main as daemon_main
+
+        # Setup debug logging if requested
+        if getattr(args, "debug", False):
+            logging.basicConfig(
+                level=logging.DEBUG,
+                format="%(asctime)s - %(name)s - %(levelname)s - %(message)s",
+            )
+
+        # Display Commander banner
+        display_commander_banner()
+
+        # Load agents and skills
+        load_agents_and_skills()
+
+        print()  # Blank line after loading
+
+        # Get arguments
+        port = getattr(args, "port", 8766)  # NetworkPorts.COMMANDER_DEFAULT
+        host = getattr(args, "host", "127.0.0.1")
+        state_dir = getattr(args, "state_dir", None)
+        no_chat = getattr(args, "no_chat", False) or getattr(args, "daemon_only", False)
+
+        # Check if daemon already running
+        daemon_running = False
+        try:
+            resp = requests.get(f"http://{host}:{port}/api/health", timeout=1)
+            if resp.status_code == 200:
+                print(f"{GREEN}✓{RESET} Daemon already running on {host}:{port}")
+                daemon_running = True
+        except (requests.RequestException, requests.ConnectionError):
+            pass
+
+        # Start daemon if not running
+        if not daemon_running:
+            print(
+                f"{DIM}Starting daemon on {host}:{port}...{RESET}", end=" ", flush=True
+            )
+
+            # Create daemon config
+            config_kwargs = {"host": host, "port": port}
+            if state_dir:
+                config_kwargs["state_dir"] = state_dir
+            config = DaemonConfig(**config_kwargs)
+
+            # Start daemon in background thread
+            daemon_thread = threading.Thread(
+                target=lambda: asyncio.run(daemon_main(config)), daemon=True
+            )
+            daemon_thread.start()
+
+            # Wait for daemon to be ready (max 3 seconds)
+            for _ in range(30):
+                time.sleep(0.1)
+                try:
+                    resp = requests.get(f"http://{host}:{port}/api/health", timeout=1)
+                    if resp.status_code == 200:
+                        print(f"{GREEN}✓{RESET}")
+                        daemon_running = True
+                        break
+                except (requests.RequestException, requests.ConnectionError):
+                    pass
+            else:
+                print(f"{RED}✗{RESET} Failed (timeout)")
+                return 1
+
+        # If daemon-only mode, keep running until interrupted
+        if no_chat:
+            print(f"\n{CYAN}Daemon running.{RESET} API at http://{host}:{port}")
+            print(f"{DIM}Press Ctrl+C to stop{RESET}\n")
+            try:
+                while True:
+                    time.sleep(1)
+            except KeyboardInterrupt:
+                print(f"\n{DIM}Shutting down...{RESET}")
+                return 0
+
+        # Launch interactive chat
+        print(f"\n{CYAN}Entering Commander chat...{RESET}\n")
+        asyncio.run(run_commander(port=port, state_dir=state_dir))
+
+        return 0
+
+    except KeyboardInterrupt:
+        logger.info("Commander interrupted by user")
+        return 0
+    except Exception as e:
+        logger.error(f"Commander error: {e}", exc_info=True)
+        print(f"{RED}Error:{RESET} {e}")
+        return 1

claude_mpm/cli/commands/config.py

@@ -68,10 +68,12 @@ class ConfigCommand(BaseCommand):
 
     def validate_args(self, args) -> str:
         """Validate command arguments."""
+        # If no config_command specified, default to 'auto' (preview mode)
         if not hasattr(args, "config_command") or not args.config_command:
-            return "No config command specified"
+            args.config_command = "auto"
+            args.preview = True  # Default to preview when no args
 
-        valid_commands = ["validate", "view", "status"]
+        valid_commands = ["validate", "view", "status", "auto", "gitignore"]
         if args.config_command not in valid_commands:
             return f"Unknown config command: {args.config_command}. Valid commands: {', '.join(valid_commands)}"
 
@@ -85,6 +87,11 @@ class ConfigCommand(BaseCommand):
             return self._view_config(args)
         if args.config_command == "status":
             return self._show_config_status(args)
+        if args.config_command == "gitignore":
+            self._show_gitignore_recommendations()
+            return CommandResult.success_result("Gitignore recommendations displayed")
+        if args.config_command == "auto":
+            return self._auto_configure(args)
         return CommandResult.error_result(
             f"Unknown config command: {args.config_command}"
         )
@@ -450,6 +457,85 @@ class ConfigCommand(BaseCommand):
 
         return flattened
 
+    def _show_gitignore_recommendations(self) -> None:
+        """Show recommended .gitignore patterns for Claude MPM projects.
+
+        This displays recommended gitignore patterns without making any changes
+        to the user's .gitignore file. Users can choose to apply these manually.
+        """
+        console.print(
+            "\n[bold cyan]Recommended .gitignore Patterns for Claude MPM[/bold cyan]\n"
+        )
+
+        console.print("[bold]Track agent memories, ignore runtime data:[/bold]")
+        console.print("[dim]# Add this to your .gitignore:[/dim]\n")
+
+        # The recommended gitignore block
+        recommended_patterns = """# Claude MPM - Track memories, ignore runtime data
+.claude-mpm/*
+!.claude-mpm/memories/
+.claude-mpm/memories/*
+!.claude-mpm/memories/*.md"""
+
+        # Display in a panel for clarity
+        from rich.panel import Panel
+
+        panel = Panel(
+            recommended_patterns,
+            title="Recommended .gitignore Patterns",
+            border_style="green",
+            padding=(1, 2),
+        )
+        console.print(panel)
+
+        # Explanation
+        console.print("\n[bold]What this does:[/bold]")
+        console.print(
+            "  • Track [cyan].claude-mpm/memories/*.md[/cyan] (agent memories are valuable)"
+        )
+        console.print(
+            "  • Ignore everything else in [dim].claude-mpm/[/dim] (cache, logs, sessions, tmp)"
+        )
+        console.print(
+            "  • Services (mcp-vector-search, kuzu-memory, etc.) handle their own .gitignore"
+        )
+
+        console.print(
+            "\n[yellow]Note:[/yellow] These patterns are recommendations only."
+        )
+        console.print("       Add them manually to your .gitignore if desired.\n")
+
+    def _auto_configure(self, args) -> CommandResult:
+        """
+        Run auto-configuration to detect toolchain and recommend agents/skills.
+
+        This delegates to the AutoConfigureCommand for the actual implementation.
+        """
+        # Check if user wants gitignore recommendations
+        if hasattr(args, "gitignore") and args.gitignore:
+            self._show_gitignore_recommendations()
+            return CommandResult.success_result("Gitignore recommendations displayed")
+
+        try:
+            # Import AutoConfigureCommand
+            from .auto_configure import AutoConfigureCommand
+
+            # Create auto-configure command instance
+            auto_cmd = AutoConfigureCommand()
+
+            # Run auto-configuration
+            return auto_cmd.run(args)
+
+        except ImportError as e:
+            self.logger.error(f"AutoConfigureCommand not available: {e}")
+            return CommandResult.error_result(
+                "Auto-configuration feature not available. "
+                "Please ensure all dependencies are installed."
+            )
+        except Exception as e:
+            self.logger.error(f"Auto-configuration failed: {e}", exc_info=True)
+            return CommandResult.error_result(f"Auto-configuration failed: {e}")
+
 
 def manage_config(args) -> int:
     """Main entry point for configuration management commands.