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

claude_mpm/cli/startup_logging.py

@@ -14,11 +14,12 @@ DESIGN DECISIONS:
 - Capture all startup logs to timestamped files for analysis
 """
 
+import asyncio
 import logging
 import shutil
 import subprocess
 import sys
-from datetime import datetime
+from datetime import datetime, timezone
 from pathlib import Path
 from typing import Any, Dict, Optional
 
@@ -69,7 +70,7 @@ def log_memory_stats(logger=None, prefix="Memory Usage"):
                     f"{prefix}: RSS={rss_mb:.1f}MB, System={memory_percent:.1f}%"
                 )
                 return {"rss_mb": rss_mb, "vms_mb": None, "percent": memory_percent}
-            except:
+            except Exception:
                 logger.info(f"{prefix}: RSS={rss_mb:.1f}MB")
                 return {"rss_mb": rss_mb, "vms_mb": None, "percent": None}
         else:
@@ -82,7 +83,7 @@ def log_memory_stats(logger=None, prefix="Memory Usage"):
                     f"System={memory_percent:.1f}%"
                 )
                 return {"rss_mb": rss_mb, "vms_mb": vms_mb, "percent": memory_percent}
-            except:
+            except Exception:
                 logger.info(f"{prefix}: RSS={rss_mb:.1f}MB, VMS={vms_mb:.1f}MB")
                 return {"rss_mb": rss_mb, "vms_mb": vms_mb, "percent": None}
 
@@ -114,12 +115,10 @@ class StartupStatusLogger:
             if mcp_executable:
                 self.logger.info(f"MCP Server: Installed at {mcp_executable}")
 
-                # Try to get version
+                # Try to get version (only log if version is found)
                 version = self._get_mcp_version(mcp_executable)
                 if version:
                     self.logger.info(f"MCP Server: Version {version}")
-                else:
-                    self.logger.info("MCP Server: Version unknown")
             else:
                 self.logger.info("MCP Server: Not found in PATH")
 
@@ -304,7 +303,7 @@ class StartupStatusLogger:
 
             import json
 
-            with open(claude_json_path) as f:
+            with claude_json_path.open() as f:
                 config = json.load(f)
 
             result["found"] = True
@@ -339,14 +338,27 @@ class StartupStatusLogger:
 
     def _check_socketio_dependencies(self) -> Dict[str, Any]:
         """Check if Socket.IO dependencies are available."""
+        import importlib.util
+
         result = {"available": False, "error": None}
 
         try:
-            import aiohttp
-            import engineio
-            import socketio
+            # Check for socketio dependencies without importing them
+            aiohttp_spec = importlib.util.find_spec("aiohttp")
+            engineio_spec = importlib.util.find_spec("engineio")
+            socketio_spec = importlib.util.find_spec("socketio")
 
-            result["available"] = True
+            if aiohttp_spec and engineio_spec and socketio_spec:
+                result["available"] = True
+            else:
+                missing = []
+                if not aiohttp_spec:
+                    missing.append("aiohttp")
+                if not engineio_spec:
+                    missing.append("engineio")
+                if not socketio_spec:
+                    missing.append("socketio")
+                result["error"] = f"Missing dependencies: {', '.join(missing)}"
         except ImportError as e:
             result["error"] = f"Missing dependencies: {e}"
         except Exception as e:
@@ -493,7 +505,7 @@ def setup_startup_logging(project_root: Optional[Path] = None) -> Path:
     log_dir.mkdir(parents=True, exist_ok=True)
 
     # Generate timestamp for log file
-    timestamp = datetime.now().strftime("%Y-%m-%d-%H-%M-%S")
+    timestamp = datetime.now(timezone.utc).strftime("%Y-%m-%d-%H-%M-%S")
     log_file = log_dir / f"startup-{timestamp}.log"
 
     # Create file handler with detailed formatting
@@ -516,7 +528,7 @@ def setup_startup_logging(project_root: Optional[Path] = None) -> Path:
     # Log startup header
     logger = get_logger("startup")
     logger.info("=" * 60)
-    logger.info(f"Claude MPM Startup - {datetime.now().isoformat()}")
+    logger.info(f"Claude MPM Startup - {datetime.now(timezone.utc).isoformat()}")
     logger.info(f"Log file: {log_file}")
     logger.info("=" * 60)
 
@@ -619,6 +631,156 @@ def cleanup_old_startup_logs(
         return deleted_count
 
 
+async def trigger_vector_search_indexing(project_root: Optional[Path] = None) -> None:
+    """
+    Trigger mcp-vector-search indexing in the background.
+
+    This function attempts to start the mcp-vector-search indexing process
+    asynchronously so it doesn't block startup. If the service is not available,
+    it fails silently.
+
+    Args:
+        project_root: Root directory for the project (defaults to cwd)
+    """
+    logger = get_logger("cli")
+
+    if project_root is None:
+        project_root = Path.cwd()
+
+    try:
+        # Check if mcp-vector-search is available
+        from ..services.mcp_config_manager import MCPConfigManager
+
+        manager = MCPConfigManager()
+        vector_search_path = manager.detect_service_path("mcp-vector-search")
+
+        if not vector_search_path:
+            logger.debug("mcp-vector-search not found, skipping indexing")
+            return
+
+        # Build the command based on the service configuration
+        if "python" in vector_search_path:
+            # Using Python interpreter directly
+            cmd = [
+                vector_search_path,
+                "-m",
+                "mcp_vector_search.cli",
+                "index",
+                str(project_root),
+            ]
+        else:
+            # Using installed binary
+            cmd = [vector_search_path, "index", str(project_root)]
+
+        logger.info(
+            "MCP Vector Search: Starting background indexing for improved code search"
+        )
+
+        # Start the indexing process in the background
+        # We use subprocess.Popen instead of run to avoid blocking
+        process = await asyncio.create_subprocess_exec(
+            *cmd,
+            stdout=asyncio.subprocess.DEVNULL,
+            stderr=asyncio.subprocess.DEVNULL,
+            cwd=str(project_root),
+        )
+
+        # Store PID for logging
+        pid = process.pid
+        logger.debug(f"MCP Vector Search: Indexing process started (PID: {pid})")
+
+        # Don't wait for completion - let it run independently in the background
+        # We don't need to track its completion, so we can safely detach
+
+    except ImportError:
+        logger.debug(
+            "MCP config manager not available, skipping vector search indexing"
+        )
+    except Exception as e:
+        # Don't let indexing failures prevent startup
+        logger.debug(f"Failed to start vector search indexing: {e}")
+
+
+def start_vector_search_indexing(project_root: Optional[Path] = None) -> None:
+    """
+    Synchronous wrapper to trigger vector search indexing.
+
+    This creates a new event loop if needed to run the async indexing function.
+    Falls back to subprocess.Popen if async fails.
+
+    Args:
+        project_root: Root directory for the project (defaults to cwd)
+    """
+    logger = get_logger("cli")
+
+    try:
+        # Try to get the current event loop
+        loop = asyncio.get_running_loop()
+        # If we're in an event loop, create a task (fire-and-forget)
+        _task = loop.create_task(trigger_vector_search_indexing(project_root))
+        # Fire-and-forget: task will complete in background
+    except RuntimeError:
+        # No event loop running - use subprocess directly to avoid event loop lifecycle issues
+        # The async approach with asyncio.run() creates and closes a loop which causes
+        # warnings when subprocesses are still running
+        logger.debug("No event loop running, using subprocess approach")
+        _start_vector_search_subprocess(project_root)
+
+
+def _start_vector_search_subprocess(project_root: Optional[Path] = None) -> None:
+    """
+    Fallback method to start vector search indexing using subprocess.Popen.
+
+    Args:
+        project_root: Root directory for the project (defaults to cwd)
+    """
+    logger = get_logger("cli")
+
+    if project_root is None:
+        project_root = Path.cwd()
+
+    try:
+        from ..services.mcp_config_manager import MCPConfigManager
+
+        manager = MCPConfigManager()
+        vector_search_path = manager.detect_service_path("mcp-vector-search")
+
+        if not vector_search_path:
+            logger.debug("mcp-vector-search not found, skipping indexing")
+            return
+
+        # Build the command
+        if "python" in vector_search_path:
+            cmd = [
+                vector_search_path,
+                "-m",
+                "mcp_vector_search.cli",
+                "index",
+                str(project_root),
+            ]
+        else:
+            cmd = [vector_search_path, "index", str(project_root)]
+
+        logger.info(
+            "MCP Vector Search: Starting background indexing for improved code search"
+        )
+
+        # Start the indexing process in the background
+        process = subprocess.Popen(
+            cmd,
+            stdout=subprocess.DEVNULL,
+            stderr=subprocess.DEVNULL,
+            cwd=str(project_root),
+        )
+
+        logger.debug(
+            f"MCP Vector Search: Indexing process started (PID: {process.pid})"
+        )
+
+    except Exception as e:
+        logger.debug(f"Failed to start vector search indexing: {e}")
+
+
 def get_latest_startup_log(project_root: Optional[Path] = None) -> Optional[Path]:
     """
     Get the path to the most recent startup log file.
@@ -667,6 +829,10 @@ def log_startup_status(monitor_mode: bool = False, websocket_port: int = 8765) -
         # Log monitor setup status
         status_logger.log_monitor_setup_status(monitor_mode, websocket_port)
 
+        # Trigger vector search indexing in the background after MCP is configured
+        # This will run asynchronously and not block startup
+        start_vector_search_indexing()
+
     except Exception as e:
         # Don't let logging failures prevent startup
         logger = get_logger("cli")

claude_mpm/cli/utils.py

@@ -6,9 +6,10 @@ Centralizing these functions reduces code duplication and provides a single plac
 for common CLI operations.
 """
 
+import difflib
 import sys
 from pathlib import Path
-from typing import Optional
+from typing import List, Optional
 
 from ..core.logger import get_logger
 
@@ -106,7 +107,7 @@ def get_agent_versions_display() -> Optional[str]:
                     base_version_tuple
                 )
                 output_lines.append(f"\n  Base Agent Version:  {base_version_str}")
-        except:
+        except Exception:
             pass
 
         # Check for agents needing migration
@@ -170,7 +171,7 @@ def setup_logging(args) -> object:
 
     # Set default logging level if not specified
     if not hasattr(args, "logging") or args.logging is None:
-        args.logging = LogLevel.INFO.value
+        args.logging = LogLevel.OFF.value
 
     # Handle deprecated --debug flag
     if hasattr(args, "debug") and args.debug and args.logging == LogLevel.INFO.value:
@@ -207,3 +208,53 @@ def ensure_directories() -> None:
         # Continue even if initialization fails
         # The individual commands will handle missing directories as needed
         pass
+
+
+def suggest_similar_commands(
+    invalid_command: str,
+    valid_commands: List[str],
+    cutoff: float = 0.6,
+    max_suggestions: int = 3,
+) -> Optional[str]:
+    """
+    Suggest similar commands for an invalid command using fuzzy matching.
+
+    WHY: Helps users quickly identify typos and discover correct command names
+    by suggesting the most similar valid commands. Uses stdlib difflib for
+    zero-dependency fuzzy matching.
+
+    DESIGN DECISION: Using difflib.get_close_matches provides good results for
+    typos and partial matches while being simple and lightweight (no external deps).
+
+    Args:
+        invalid_command: The invalid command the user typed
+        valid_commands: List of valid commands to match against
+        cutoff: Similarity threshold (0.0-1.0), default 0.6
+        max_suggestions: Maximum number of suggestions to return, default 3
+
+    Returns:
+        Formatted suggestion string or None if no good matches found
+
+    Examples:
+        >>> suggest_similar_commands("tickts", ["tickets", "run", "agents"])
+        "Did you mean 'tickets'?"
+
+        >>> suggest_similar_commands("mem", ["memory", "monitor", "mcp"])
+        "Did you mean one of these?\n  memory\n  monitor\n  mcp"
+
+        >>> suggest_similar_commands("xyz", ["tickets", "run"])
+        None  # No good matches
+    """
+    # Use difflib to find close matches
+    matches = difflib.get_close_matches(
+        invalid_command, valid_commands, n=max_suggestions, cutoff=cutoff
+    )
+
+    if not matches:
+        return None
+
+    # Format suggestion message
+    if len(matches) == 1:
+        return f"Did you mean '{matches[0]}'?"
+    suggestions = "\n  ".join(matches)
+    return f"Did you mean one of these?\n  {suggestions}"

claude_mpm/cli_module/commands.py

@@ -107,7 +107,7 @@ class CommandRegistry:
 
             # Apply extra arguments
             for arg_name, arg_config in command.extra_args.items():
-                flags = arg_config.pop("flags", [f'--{arg_name.replace("_", "-")}'])
+                flags = arg_config.pop("flags", [f"--{arg_name.replace('_', '-')}"])
                 subparser.add_argument(*flags, **arg_config)
 
             # Store handler reference

claude_mpm/commands/mpm-agents-auto-configure.md

@@ -0,0 +1,278 @@
+---
+namespace: mpm/agents
+command: auto-configure
+aliases: [mpm-agents-auto-configure]
+migration_target: /mpm/agents:auto-configure
+category: agents
+deprecated_aliases: [mpm-auto-configure]
+description: Automatically detect project toolchain and configure appropriate agents
+---
+# Automatically configure agents based on project detection
+
+Automatically detect your project's toolchain and configure the most appropriate agents.
+
+## Usage
+
+```
+/mpm-auto-configure [options]
+```
+
+## Description
+
+This command provides intelligent auto-configuration that:
+1. Scans your project to detect programming languages, frameworks, and tools
+2. Recommends the most appropriate agents for your stack
+3. Optionally deploys the recommended agents with confirmation
+
+This is the fastest way to get started with Claude MPM in any project!
+
+## Options
+
+- `--preview` - Show what would be configured without making any changes
+- `--yes` - Automatically apply recommendations without prompting
+- `--force` - Force reconfiguration even if agents are already deployed
+
+## Implementation
+
+When you run `/mpm-auto-configure`, the PM will:
+
+1. **Detect Your Stack**:
+   - Scan for package.json, requirements.txt, Cargo.toml, go.mod, etc.
+   - Identify frameworks (FastAPI, Next.js, React, Express, etc.)
+   - Detect testing tools (pytest, Jest, Playwright, etc.)
+   - Find build tools and deployment configurations
+
+2. **Recommend Agents**:
+   - **Essential agents**: Required for your primary stack
+   - **Recommended agents**: Complementary agents for full functionality
+   - **Optional agents**: Specialized agents for detected tools
+
+3. **Deploy Agents** (with confirmation):
+   - Show what will be deployed
+   - Request confirmation (unless --yes is used)
+   - Deploy agents to your project
+   - Verify deployment success
+
+## Examples
+
+### Preview Mode (Recommended First Step)
+```
+/mpm-auto-configure --preview
+```
+Shows what would be configured without making changes. Great for understanding recommendations before applying.
+
+### Interactive Configuration
+```
+/mpm-auto-configure
+```
+Detect, recommend, and prompt for confirmation before deploying.
+
+### Automatic Configuration
+```
+/mpm-auto-configure --yes
+```
+Automatically apply all recommendations without prompting. Best for quick setup.
+
+### Force Reconfiguration
+```
+/mpm-auto-configure --force
+```
+Reconfigure agents even if some are already deployed. Useful for stack changes.
+
+## Expected Output
+
+```
+🤖 Auto-Configuration for Claude MPM
+=====================================
+
+Step 1: Detecting Project Stack
+--------------------------------
+✓ Detected Python 3.11
+✓ Detected FastAPI 0.104.0
+✓ Detected pytest 7.4.0
+✓ Detected Docker configuration
+✓ Detected Vercel deployment
+
+Step 2: Agent Recommendations
+------------------------------
+Essential Agents (3):
+  ✓ fastapi-engineer - FastAPI framework detected
+  ✓ python-engineer - Python project support
+  ✓ api-qa - API testing and validation
+
+Recommended Agents (2):
+  ○ docker-ops - Docker configuration found
+  ○ vercel-ops - Vercel deployment detected
+
+Optional Agents (1):
+  ○ playwright-qa - Browser testing capability
+
+Step 3: Deploy Agents
+---------------------
+Deploy 5 agents? (y/n): y
+
+Deploying agents...
+✓ fastapi-engineer deployed
+✓ python-engineer deployed
+✓ api-qa deployed
+✓ docker-ops deployed
+✓ vercel-ops deployed
+
+🎉 Auto-configuration complete!
+5 agents deployed successfully.
+
+Next steps:
+- Run /mpm-agents to see your deployed agents
+- Start working with specialized agents for your stack
+- Use /mpm-help for more information
+```
+
+## What Gets Detected
+
+### Languages
+- Python (CPython, PyPy)
+- JavaScript/TypeScript (Node.js, Deno, Bun)
+- Rust
+- Go
+- Java
+
+### Python Frameworks
+- FastAPI
+- Flask
+- Django
+- Starlette
+- Pyramid
+
+### JavaScript/TypeScript Frameworks
+- Next.js
+- React
+- Vue
+- Svelte
+- Angular
+- Express
+- Nest.js
+- Fastify
+
+### Testing Tools
+- pytest (Python)
+- unittest (Python)
+- Jest (JavaScript)
+- Vitest (JavaScript)
+- Playwright (Browser)
+- Cypress (Browser)
+
+### Build Tools
+- Vite
+- Webpack
+- Rollup
+- esbuild
+- Turbopack
+
+### Deployment Platforms
+- Vercel
+- Railway
+- Docker
+- PM2
+- Kubernetes
+
+## Agent Mapping Examples
+
+### Python + FastAPI
+**Essential:**
+- fastapi-engineer
+- python-engineer
+- api-qa
+
+**Recommended:**
+- docker-ops (if Docker detected)
+- vercel-ops (if Vercel detected)
+
+### Next.js + React
+**Essential:**
+- nextjs-engineer
+- react-engineer
+- web-qa
+
+**Recommended:**
+- playwright-qa (if Playwright detected)
+- vercel-ops (if Vercel detected)
+
+### Full-Stack (FastAPI + React)
+**Essential:**
+- fastapi-engineer
+- python-engineer
+- react-engineer
+- api-qa
+- web-qa
+
+**Recommended:**
+- playwright-qa
+- docker-ops
+- local-ops-agent
+
+## Default Configuration Fallback
+
+When auto-configuration cannot detect your project's toolchain (e.g., a new or uncommon language/framework), it automatically falls back to a sensible set of default general-purpose agents instead of leaving your project unconfigured.
+
+### When Defaults are Applied
+
+Default agents are deployed when:
+- Primary language is detected as "Unknown"
+- No specific framework or toolchain can be identified
+- No agent recommendations can be generated from detected technologies
+
+### Default Agents
+
+The following general-purpose agents are recommended with moderate confidence (0.7):
+
+- **engineer**: General-purpose engineer for code implementation
+- **research**: Code exploration and analysis
+- **qa**: Testing and quality assurance
+- **ops**: Infrastructure and deployment operations
+- **documentation**: Documentation and technical writing
+
+All default recommendations will be marked with `is_default: True` in the metadata.
+
+### Disabling Default Fallback
+
+To disable the default configuration fallback, edit `.claude-mpm/config/agent_capabilities.yaml`:
+
+```yaml
+default_configuration:
+  enabled: false  # Disable default fallback
+```
+
+When disabled, auto-configuration will recommend zero agents if the toolchain cannot be detected.
+
+### Customizing Defaults
+
+You can customize which agents are deployed by default by editing the `default_configuration.agents` section in `.claude-mpm/config/agent_capabilities.yaml`:
+
+```yaml
+default_configuration:
+  enabled: true
+  min_confidence: 0.7  # Confidence score for default recommendations
+  agents:
+    - agent_id: engineer
+      reasoning: "General-purpose engineer for code implementation"
+      priority: 1
+    - agent_id: research
+      reasoning: "Code exploration and analysis"
+      priority: 2
+    # Add or remove agents as needed
+```
+
+## Tips
+
+1. **Start with preview**: Always run with `--preview` first to see recommendations
+2. **Review carefully**: Check that detected stack matches your project
+3. **Customize later**: You can always deploy/remove agents manually after auto-config
+4. **Re-run after changes**: Run again with `--force` if you add new frameworks
+5. **Complementary commands**: Use `/mpm-agents-detect` and `/mpm-agents-recommend` for more details
+
+## Related Commands
+
+- `/mpm-agents-detect` - Just show detected toolchain
+- `/mpm-agents-recommend` - Show recommendations without deploying
+- `/mpm-agents` - Manage agents manually
+- `/mpm-help agents` - Learn about manual agent management