hanzo-mcp 0.8.8__py3-none-any.whl → 0.9.0__py3-none-any.whl

hanzo_mcp/tools/editor/neovim_session.py

@@ -168,9 +168,7 @@ Note: Requires Neovim to be installed.
                 project_path,
             )
         elif action == "restore":
-            return await self._restore_session(
-                tool_ctx, session_name, project_session_dir
-            )
+            return await self._restore_session(tool_ctx, session_name, project_session_dir)
         elif action == "list":
             return self._list_sessions(project_session_dir, project_path)
         elif action == "delete":
@@ -214,9 +212,7 @@ Note: Requires Neovim to be installed.
             # Run Neovim to save session
             # First, check if Neovim is already running
             # For now, we'll create a new instance
-            result = subprocess.run(
-                ["nvim", "-c", vim_script.strip()], capture_output=True, text=True
-            )
+            result = subprocess.run(["nvim", "-c", vim_script.strip()], capture_output=True, text=True)
 
             if result.returncode != 0 and result.stderr:
                 return f"Error saving session: {result.stderr}"
@@ -246,15 +242,15 @@ Or manually in Neovim:
         except Exception as e:
             return f"Error saving session: {str(e)}"
 
-    async def _restore_session(
-        self, tool_ctx, session_name: Optional[str], project_dir: Path
-    ) -> str:
+    async def _restore_session(self, tool_ctx, session_name: Optional[str], project_dir: Path) -> str:
         """Restore Neovim session."""
         if not session_name:
             # List available sessions
             sessions = list(project_dir.glob("*.vim"))
             if not sessions:
-                return "Error: No sessions found for this project. Use 'neovim_session --action list' to see all sessions."
+                return (
+                    "Error: No sessions found for this project. Use 'neovim_session --action list' to see all sessions."
+                )
 
             # Use most recent
             sessions.sort(key=lambda x: x.stat().st_mtime, reverse=True)
@@ -330,9 +326,7 @@ Or manually in Neovim:
             if len(other_sessions) > 10:
                 output.append(f"  ... and {len(other_sessions) - 10} more")
 
-        output.append(
-            "\nUse 'neovim_session --action restore --session-name <name>' to restore a session."
-        )
+        output.append("\nUse 'neovim_session --action restore --session-name <name>' to restore a session.")
 
         return "\n".join(output)
 

hanzo_mcp/tools/environment/__init__.py

@@ -0,0 +1,8 @@
+"""Environment detection and configuration tools."""
+
+from .environment_detector import EnvironmentDetector, create_environment_detector
+
+__all__ = [
+    "EnvironmentDetector",
+    "create_environment_detector",
+]

hanzo_mcp/tools/environment/environment_detector.py

@@ -0,0 +1,594 @@
+"""Environment detection tool for automatic development environment configuration.
+
+This tool automatically detects installed development tools, frameworks, and
+languages in the user's environment and dynamically loads appropriate MCP tools.
+"""
+
+import os
+import sys
+import json
+import shutil
+import subprocess
+import logging
+from typing import Dict, List, Any, Optional, Set
+from pathlib import Path
+from dataclasses import dataclass, field
+
+from hanzo_mcp.types import MCPResourceDocument
+from hanzo_mcp.tools.common.base import BaseTool
+
+
+@dataclass
+class ToolDetection:
+    """Represents a detected development tool."""
+    name: str
+    version: Optional[str]
+    path: str
+    category: str  # language, framework, database, etc.
+    mcp_tools: List[str] = field(default_factory=list)  # Related MCP tools to enable
+    environment: Dict[str, str] = field(default_factory=dict)  # Environment variables
+
+
+# Tool detection configurations
+TOOL_DETECTIONS = {
+    # Programming Languages
+    "python": {
+        "check_cmd": ["python", "--version"],
+        "category": "language",
+        "mcp_tools": ["run_command", "uvx", "uvx_background"],
+        "parse_version": lambda out: out.split()[1] if out else None,
+        "frameworks": {
+            "django": {
+                "check": ["python", "-c", "import django; print(django.get_version())"],
+                "mcp_tools": ["django_manage", "django_shell"],
+            },
+            "fastapi": {
+                "check": ["python", "-c", "import fastapi; print(fastapi.__version__)"],
+                "mcp_tools": ["uvicorn", "fastapi_routes"],
+            },
+            "flask": {
+                "check": ["python", "-c", "import flask; print(flask.__version__)"],
+                "mcp_tools": ["flask_run"],
+            },
+        },
+    },
+    "node": {
+        "check_cmd": ["node", "--version"],
+        "category": "language",
+        "mcp_tools": ["npx", "npx_background"],
+        "parse_version": lambda out: out.strip().lstrip("v") if out else None,
+        "frameworks": {
+            "next": {
+                "check": ["npm", "list", "next", "--json"],
+                "mcp_tools": ["next_dev", "next_build"],
+            },
+            "react": {
+                "check": ["npm", "list", "react", "--json"],
+                "mcp_tools": ["react_dev"],
+            },
+            "vue": {
+                "check": ["npm", "list", "vue", "--json"],
+                "mcp_tools": ["vue_serve"],
+            },
+            "angular": {
+                "check": ["ng", "version"],
+                "mcp_tools": ["ng_serve", "ng_build"],
+            },
+        },
+    },
+    "go": {
+        "check_cmd": ["go", "version"],
+        "category": "language",
+        "mcp_tools": ["go_build", "go_run", "go_test"],
+        "parse_version": lambda out: out.split()[2].lstrip("go") if out else None,
+        "frameworks": {
+            "gin": {
+                "check_file": "go.mod",
+                "check_content": "github.com/gin-gonic/gin",
+                "mcp_tools": ["gin_server"],
+            },
+            "echo": {
+                "check_file": "go.mod",
+                "check_content": "github.com/labstack/echo",
+                "mcp_tools": ["echo_server"],
+            },
+        },
+    },
+    "rust": {
+        "check_cmd": ["rustc", "--version"],
+        "category": "language",
+        "mcp_tools": ["cargo_build", "cargo_run", "cargo_test"],
+        "parse_version": lambda out: out.split()[1] if out else None,
+        "frameworks": {
+            "actix": {
+                "check_file": "Cargo.toml",
+                "check_content": 'actix-web',
+                "mcp_tools": ["actix_server"],
+            },
+            "rocket": {
+                "check_file": "Cargo.toml",
+                "check_content": 'rocket',
+                "mcp_tools": ["rocket_server"],
+            },
+        },
+    },
+    "java": {
+        "check_cmd": ["java", "--version"],
+        "category": "language",
+        "mcp_tools": ["javac", "java_run"],
+        "parse_version": lambda out: out.split()[1] if out else None,
+        "frameworks": {
+            "spring": {
+                "check_file": "pom.xml",
+                "check_content": "spring-boot",
+                "mcp_tools": ["spring_boot", "mvn"],
+            },
+        },
+    },
+    "cpp": {
+        "check_cmd": ["clang++", "--version"],
+        "category": "language",
+        "mcp_tools": ["cmake", "make", "clang_compile"],
+        "parse_version": lambda out: out.split()[2] if "version" in out else None,
+    },
+    "c": {
+        "check_cmd": ["clang", "--version"],
+        "category": "language",
+        "mcp_tools": ["cmake", "make", "clang_compile"],
+        "parse_version": lambda out: out.split()[2] if "version" in out else None,
+    },
+    "zig": {
+        "check_cmd": ["zig", "version"],
+        "category": "language",
+        "mcp_tools": ["zig_build", "zig_run", "zig_test"],
+        "parse_version": lambda out: out.strip() if out else None,
+    },
+    # Databases
+    "postgresql": {
+        "check_cmd": ["psql", "--version"],
+        "category": "database",
+        "mcp_tools": ["sql_query", "sql_search", "sql_stats"],
+        "parse_version": lambda out: out.split()[-1] if out else None,
+    },
+    "mysql": {
+        "check_cmd": ["mysql", "--version"],
+        "category": "database",
+        "mcp_tools": ["sql_query", "sql_search", "sql_stats"],
+        "parse_version": lambda out: out.split()[4].rstrip(",") if out else None,
+    },
+    "redis": {
+        "check_cmd": ["redis-cli", "--version"],
+        "category": "database",
+        "mcp_tools": ["redis_get", "redis_set", "redis_keys"],
+        "parse_version": lambda out: out.split()[2] if out else None,
+    },
+    "mongodb": {
+        "check_cmd": ["mongod", "--version"],
+        "category": "database",
+        "mcp_tools": ["mongo_query", "mongo_insert"],
+        "parse_version": lambda out: out.split()[2] if "version" in out else None,
+    },
+    # Container & Orchestration
+    "docker": {
+        "check_cmd": ["docker", "--version"],
+        "category": "container",
+        "mcp_tools": ["docker_build", "docker_run", "docker_ps"],
+        "parse_version": lambda out: out.split()[2].rstrip(",") if out else None,
+    },
+    "kubernetes": {
+        "check_cmd": ["kubectl", "version", "--client", "--short"],
+        "category": "orchestration",
+        "mcp_tools": ["kubectl_apply", "kubectl_get", "kubectl_logs"],
+        "parse_version": lambda out: out.split()[-1] if out else None,
+    },
+    # Version Control
+    "git": {
+        "check_cmd": ["git", "--version"],
+        "category": "vcs",
+        "mcp_tools": ["git_search", "git_log", "git_diff"],
+        "parse_version": lambda out: out.split()[-1] if out else None,
+    },
+    # Package Managers
+    "npm": {
+        "check_cmd": ["npm", "--version"],
+        "category": "package_manager",
+        "mcp_tools": ["npx", "npm_install"],
+        "parse_version": lambda out: out.strip() if out else None,
+    },
+    "yarn": {
+        "check_cmd": ["yarn", "--version"],
+        "category": "package_manager",
+        "mcp_tools": ["yarn_install", "yarn_run"],
+        "parse_version": lambda out: out.strip() if out else None,
+    },
+    "pnpm": {
+        "check_cmd": ["pnpm", "--version"],
+        "category": "package_manager",
+        "mcp_tools": ["pnpm_install", "pnpm_run"],
+        "parse_version": lambda out: out.strip() if out else None,
+    },
+    "pip": {
+        "check_cmd": ["pip", "--version"],
+        "category": "package_manager",
+        "mcp_tools": ["pip_install", "pip_freeze"],
+        "parse_version": lambda out: out.split()[1] if out else None,
+    },
+    "cargo": {
+        "check_cmd": ["cargo", "--version"],
+        "category": "package_manager",
+        "mcp_tools": ["cargo_build", "cargo_run"],
+        "parse_version": lambda out: out.split()[1] if out else None,
+    },
+    # Build Tools
+    "make": {
+        "check_cmd": ["make", "--version"],
+        "category": "build",
+        "mcp_tools": ["make_build", "make_clean"],
+        "parse_version": lambda out: out.split()[-1] if out else None,
+    },
+    "cmake": {
+        "check_cmd": ["cmake", "--version"],
+        "category": "build",
+        "mcp_tools": ["cmake_configure", "cmake_build"],
+        "parse_version": lambda out: out.split()[2] if out else None,
+    },
+}
+
+
+class EnvironmentDetector(BaseTool):
+    """Tool for detecting and configuring development environment."""
+    
+    name = "env_detect"
+    description = """Detect development environment and auto-configure tools.
+    
+    Actions:
+    - detect: Detect all installed development tools
+    - check: Check specific tool availability
+    - suggest: Suggest tools to install for project
+    - configure: Auto-configure MCP tools based on detection
+    - export: Export environment configuration
+    
+    This tool helps automatically configure your development environment
+    by detecting installed languages, frameworks, databases, and tools.
+    """
+    
+    def __init__(self):
+        super().__init__()
+        self.logger = logging.getLogger(__name__)
+        self.detected_tools: List[ToolDetection] = []
+        self.project_root = self._find_project_root()
+        
+    def _find_project_root(self) -> Path:
+        """Find project root directory."""
+        markers = [
+            ".git", "package.json", "pyproject.toml", "Cargo.toml",
+            "go.mod", "pom.xml", "build.gradle", "CMakeLists.txt"
+        ]
+        
+        cwd = Path.cwd()
+        for parent in [cwd] + list(cwd.parents):
+            for marker in markers:
+                if (parent / marker).exists():
+                    return parent
+                    
+        return cwd
+    
+    def _run_command(self, cmd: List[str]) -> Optional[str]:
+        """Run command and return output."""
+        try:
+            result = subprocess.run(
+                cmd,
+                capture_output=True,
+                text=True,
+                timeout=5,
+                check=False,
+            )
+            
+            if result.returncode == 0:
+                return result.stdout.strip()
+                
+        except (subprocess.TimeoutExpired, FileNotFoundError):
+            pass
+            
+        return None
+    
+    def _check_file_content(self, file_path: str, content: str) -> bool:
+        """Check if file contains specific content."""
+        try:
+            file = self.project_root / file_path
+            if file.exists():
+                with open(file, "r") as f:
+                    return content in f.read()
+        except Exception:
+            pass
+            
+        return False
+    
+    def _detect_tool(self, tool_name: str, config: Dict[str, Any]) -> Optional[ToolDetection]:
+        """Detect a specific tool."""
+        # Check main tool
+        output = self._run_command(config["check_cmd"])
+        if not output:
+            return None
+            
+        # Parse version
+        version = None
+        if "parse_version" in config:
+            try:
+                version = config["parse_version"](output)
+            except Exception:
+                pass
+        
+        # Find executable path
+        executable = config["check_cmd"][0]
+        path = shutil.which(executable) or executable
+        
+        # Create detection
+        detection = ToolDetection(
+            name=tool_name,
+            version=version,
+            path=path,
+            category=config["category"],
+            mcp_tools=config.get("mcp_tools", []),
+        )
+        
+        # Check frameworks if applicable
+        if "frameworks" in config:
+            for fw_name, fw_config in config["frameworks"].items():
+                if self._check_framework(fw_config):
+                    detection.mcp_tools.extend(fw_config.get("mcp_tools", []))
+                    self.logger.info(f"Detected {fw_name} framework")
+        
+        return detection
+    
+    def _check_framework(self, config: Dict[str, Any]) -> bool:
+        """Check if framework is present."""
+        if "check" in config:
+            output = self._run_command(config["check"])
+            return output is not None
+            
+        if "check_file" in config and "check_content" in config:
+            return self._check_file_content(config["check_file"], config["check_content"])
+            
+        return False
+    
+    def detect_all(self) -> List[ToolDetection]:
+        """Detect all available tools."""
+        self.detected_tools = []
+        
+        for tool_name, config in TOOL_DETECTIONS.items():
+            detection = self._detect_tool(tool_name, config)
+            if detection:
+                self.detected_tools.append(detection)
+                self.logger.info(f"Detected {tool_name} v{detection.version}")
+        
+        return self.detected_tools
+    
+    def suggest_tools(self) -> Dict[str, List[str]]:
+        """Suggest tools to install based on project."""
+        suggestions = {
+            "languages": [],
+            "frameworks": [],
+            "tools": [],
+        }
+        
+        # Check project files
+        files = list(self.project_root.glob("*"))
+        file_names = [f.name for f in files]
+        
+        # Language suggestions
+        if "package.json" in file_names and "node" not in [d.name for d in self.detected_tools]:
+            suggestions["languages"].append("node")
+            
+        if "requirements.txt" in file_names and "python" not in [d.name for d in self.detected_tools]:
+            suggestions["languages"].append("python")
+            
+        if "Cargo.toml" in file_names and "rust" not in [d.name for d in self.detected_tools]:
+            suggestions["languages"].append("rust")
+            
+        if "go.mod" in file_names and "go" not in [d.name for d in self.detected_tools]:
+            suggestions["languages"].append("go")
+        
+        # Tool suggestions
+        if any(d.category == "language" for d in self.detected_tools):
+            if "git" not in [d.name for d in self.detected_tools]:
+                suggestions["tools"].append("git")
+                
+            if "docker" not in [d.name for d in self.detected_tools]:
+                suggestions["tools"].append("docker")
+        
+        return suggestions
+    
+    def get_enabled_mcp_tools(self) -> Set[str]:
+        """Get list of MCP tools to enable based on detection."""
+        tools = set()
+        
+        for detection in self.detected_tools:
+            tools.update(detection.mcp_tools)
+        
+        # Always include essential tools
+        essential = [
+            "read", "write", "edit", "multi_edit",
+            "directory_tree", "grep", "find", "search",
+            "run_command", "bash", "ast", "lsp"
+        ]
+        tools.update(essential)
+        
+        return tools
+    
+    def generate_configuration(self) -> Dict[str, Any]:
+        """Generate MCP configuration based on detection."""
+        config = {
+            "detected_environment": {
+                "project_root": str(self.project_root),
+                "tools": [
+                    {
+                        "name": d.name,
+                        "version": d.version,
+                        "category": d.category,
+                        "path": d.path,
+                    }
+                    for d in self.detected_tools
+                ],
+            },
+            "enabled_mcp_tools": sorted(self.get_enabled_mcp_tools()),
+            "environment_variables": {},
+            "modes": [],
+        }
+        
+        # Add environment variables
+        for detection in self.detected_tools:
+            config["environment_variables"].update(detection.environment)
+        
+        # Determine modes to enable
+        categories = {d.category for d in self.detected_tools}
+        languages = {d.name for d in self.detected_tools if d.category == "language"}
+        
+        if "python" in languages:
+            config["modes"].append("python")
+            if any("django" in t for d in self.detected_tools for t in d.mcp_tools):
+                config["modes"].append("django")
+            if any("fastapi" in t for d in self.detected_tools for t in d.mcp_tools):
+                config["modes"].append("fastapi")
+                
+        if "node" in languages or "typescript" in languages:
+            config["modes"].append("javascript")
+            if any("next" in t for d in self.detected_tools for t in d.mcp_tools):
+                config["modes"].append("nextjs")
+            if any("react" in t for d in self.detected_tools for t in d.mcp_tools):
+                config["modes"].append("react")
+                
+        if "rust" in languages:
+            config["modes"].append("rust")
+            
+        if "go" in languages:
+            config["modes"].append("go")
+        
+        return config
+    
+    async def run(
+        self,
+        action: str = "detect",
+        tool: Optional[str] = None,
+        export_path: Optional[str] = None,
+        **kwargs,
+    ) -> MCPResourceDocument:
+        """Execute environment detection action."""
+        
+        if action == "detect":
+            # Detect all tools
+            detections = self.detect_all()
+            
+            return MCPResourceDocument(
+                data={
+                    "detected_tools": [
+                        {
+                            "name": d.name,
+                            "version": d.version,
+                            "category": d.category,
+                            "path": d.path,
+                            "mcp_tools": d.mcp_tools,
+                        }
+                        for d in detections
+                    ],
+                    "total": len(detections),
+                    "categories": list(set(d.category for d in detections)),
+                }
+            )
+            
+        elif action == "check":
+            # Check specific tool
+            if not tool:
+                return MCPResourceDocument(data={"error": "Tool name required for check action"})
+                
+            if tool in TOOL_DETECTIONS:
+                detection = self._detect_tool(tool, TOOL_DETECTIONS[tool])
+                if detection:
+                    return MCPResourceDocument(
+                        data={
+                            "available": True,
+                            "name": detection.name,
+                            "version": detection.version,
+                            "path": detection.path,
+                            "mcp_tools": detection.mcp_tools,
+                        }
+                    )
+                else:
+                    return MCPResourceDocument(
+                        data={
+                            "available": False,
+                            "name": tool,
+                            "install_hint": f"Install {tool} to enable related MCP tools",
+                        }
+                    )
+            else:
+                return MCPResourceDocument(data={"error": f"Unknown tool: {tool}"})
+                
+        elif action == "suggest":
+            # Suggest tools to install
+            if not self.detected_tools:
+                self.detect_all()
+                
+            suggestions = self.suggest_tools()
+            
+            return MCPResourceDocument(
+                data={
+                    "suggestions": suggestions,
+                    "detected": [d.name for d in self.detected_tools],
+                }
+            )
+            
+        elif action == "configure":
+            # Generate and apply configuration
+            if not self.detected_tools:
+                self.detect_all()
+                
+            config = self.generate_configuration()
+            
+            # Save configuration if export path provided
+            if export_path:
+                export_file = Path(export_path)
+                export_file.write_text(json.dumps(config, indent=2))
+                config["exported_to"] = str(export_file)
+            
+            return MCPResourceDocument(data=config)
+            
+        elif action == "export":
+            # Export configuration
+            if not self.detected_tools:
+                self.detect_all()
+                
+            config = self.generate_configuration()
+            
+            if export_path:
+                export_file = Path(export_path)
+                export_file.write_text(json.dumps(config, indent=2))
+                
+                return MCPResourceDocument(
+                    data={
+                        "exported": True,
+                        "path": str(export_file),
+                        "configuration": config,
+                    }
+                )
+            else:
+                return MCPResourceDocument(data=config)
+                
+        else:
+            return MCPResourceDocument(
+                data={
+                    "error": f"Unknown action: {action}",
+                    "valid_actions": ["detect", "check", "suggest", "configure", "export"],
+                }
+            )
+    
+    async def call(self, **kwargs) -> str:
+        """Tool interface for MCP."""
+        result = await self.run(**kwargs)
+        return result.to_json_string()
+
+
+# Factory function
+def create_environment_detector():
+    """Create environment detection tool."""
+    return EnvironmentDetector()