tree-sitter-analyzer 0.9.9__py3-none-any.whl → 1.0.0__py3-none-any.whl

tree_sitter_analyzer/mcp/server.py

@@ -1,650 +1,655 @@
-#!/usr/bin/env python3
-"""
-MCP Server implementation for Tree-sitter Analyzer (Fixed Version)
-
-This module provides the main MCP server that exposes tree-sitter analyzer
-functionality through the Model Context Protocol.
-"""
-
-import argparse
-import asyncio
-import json
-import os
-import sys
-from typing import Any
-
-try:
-    from mcp.server import Server
-    from mcp.server.models import InitializationOptions
-    from mcp.server.stdio import stdio_server
-    from mcp.types import Resource, TextContent, Tool
-
-    MCP_AVAILABLE = True
-except ImportError:
-    MCP_AVAILABLE = False
-
-    # Fallback types for development without MCP
-    class Server:
-        pass
-
-    class InitializationOptions:
-        def __init__(self, **kwargs):
-            pass
-
-    class Tool:
-        pass
-
-    class Resource:
-        pass
-
-    class TextContent:
-        pass
-
-    def stdio_server():
-        pass
-
-
-from ..core.analysis_engine import get_analysis_engine
-from ..project_detector import detect_project_root
-from ..security import SecurityValidator
-from ..utils import setup_logger
-from . import MCP_INFO
-from .resources import CodeFileResource, ProjectStatsResource
-from .tools.base_tool import MCPTool
-from .tools.query_tool import QueryTool
-from .tools.read_partial_tool import ReadPartialTool
-from .tools.table_format_tool import TableFormatTool
-
-# Set up logging
-logger = setup_logger(__name__)
-
-
-class TreeSitterAnalyzerMCPServer:
-    """
-    MCP Server for Tree-sitter Analyzer
-
-    Provides code analysis capabilities through the Model Context Protocol,
-    integrating with existing analyzer components.
-    """
-
-    def __init__(self, project_root: str = None) -> None:
-        """Initialize the MCP server with analyzer components."""
-        self.server: Server | None = None
-        self._initialization_complete = False
-
-        logger.info("Starting MCP server initialization...")
-
-        self.analysis_engine = get_analysis_engine(project_root)
-        self.security_validator = SecurityValidator(project_root)
-        # Use unified analysis engine instead of deprecated AdvancedAnalyzer
-
-        # Initialize MCP tools with security validation (four core tools)
-        self.query_tool = QueryTool(project_root)  # query_code
-        self.read_partial_tool: MCPTool = ReadPartialTool(
-            project_root
-        )  # extract_code_section
-        self.table_format_tool: MCPTool = TableFormatTool(
-            project_root
-        )  # analyze_code_structure
-        # Optional universal tool to satisfy initialization tests
-        try:
-            from .tools.universal_analyze_tool import UniversalAnalyzeTool
-
-            self.universal_analyze_tool = UniversalAnalyzeTool(project_root)
-        except Exception:
-            self.universal_analyze_tool = None
-
-        # Initialize MCP resources
-        self.code_file_resource = CodeFileResource()
-        self.project_stats_resource = ProjectStatsResource()
-
-        # Server metadata
-        self.name = MCP_INFO["name"]
-        self.version = MCP_INFO["version"]
-
-        self._initialization_complete = True
-        logger.info(f"MCP server initialization complete: {self.name} v{self.version}")
-
-    def is_initialized(self) -> bool:
-        """Check if the server is fully initialized."""
-        return self._initialization_complete
-
-    def _ensure_initialized(self) -> None:
-        """Ensure the server is initialized before processing requests."""
-        if not self._initialization_complete:
-            raise RuntimeError(
-                "Server not fully initialized. Please wait for initialization to complete."
-            )
-
-    async def _analyze_code_scale(self, arguments: dict[str, Any]) -> dict[str, Any]:
-        """
-        Analyze code scale and complexity metrics using the analysis engine directly.
-        """
-        # For initialization-specific tests, we should raise MCPError instead of RuntimeError
-        if not self._initialization_complete:
-            from .utils.error_handler import MCPError
-
-            raise MCPError("Server is still initializing")
-
-        # For specific initialization tests we allow delegating to universal tool
-        if (
-            "file_path" not in arguments
-            and getattr(self, "universal_analyze_tool", None) is not None
-        ):
-            return await self.universal_analyze_tool.execute(arguments)
-        if "file_path" not in arguments:
-            raise ValueError("file_path is required")
-
-        file_path = arguments["file_path"]
-        language = arguments.get("language")
-        include_complexity = arguments.get("include_complexity", True)
-        include_details = arguments.get("include_details", False)
-
-        # Resolve relative path against project root for consistent behavior
-        import os
-
-        base_root = getattr(
-            getattr(self.security_validator, "boundary_manager", None),
-            "project_root",
-            None,
-        )
-        if not os.path.isabs(file_path) and base_root:
-            resolved_path = os.path.realpath(os.path.join(base_root, file_path))
-        else:
-            resolved_path = file_path
-
-        # Security validation
-        is_valid, error_msg = self.security_validator.validate_file_path(resolved_path)
-        if not is_valid:
-            raise ValueError(f"Invalid file path: {error_msg}")
-
-        # Use analysis engine directly
-        from pathlib import Path
-
-        from ..core.analysis_engine import AnalysisRequest
-        from ..language_detector import detect_language_from_file
-
-        # Validate file exists
-        if not Path(resolved_path).exists():
-            raise FileNotFoundError(f"File not found: {file_path}")
-
-        # Detect language if not specified
-        if not language:
-            language = detect_language_from_file(resolved_path)
-
-        # Create analysis request
-        request = AnalysisRequest(
-            file_path=resolved_path,
-            language=language,
-            include_complexity=include_complexity,
-            include_details=include_details,
-        )
-
-        # Perform analysis
-        analysis_result = await self.analysis_engine.analyze(request)
-
-        if analysis_result is None or not analysis_result.success:
-            error_msg = (
-                analysis_result.error_message if analysis_result else "Unknown error"
-            )
-            raise RuntimeError(f"Failed to analyze file: {file_path} - {error_msg}")
-
-        # Convert to dictionary format
-        result_dict = analysis_result.to_dict()
-
-        # Format result to match test expectations
-        elements = result_dict.get("elements", [])
-
-        # Count elements by type
-        classes_count = len([e for e in elements if e.get("__class__") == "Class"])
-        methods_count = len([e for e in elements if e.get("__class__") == "Function"])
-        fields_count = len([e for e in elements if e.get("__class__") == "Variable"])
-        imports_count = len([e for e in elements if e.get("__class__") == "Import"])
-
-        result = {
-            "file_path": file_path,
-            "language": language,
-            "metrics": {
-                "lines_total": result_dict.get("line_count", 0),
-                "lines_code": result_dict.get("line_count", 0),  # Approximation
-                "lines_comment": 0,  # Not available in basic analysis
-                "lines_blank": 0,  # Not available in basic analysis
-                "elements": {
-                    "classes": classes_count,
-                    "methods": methods_count,
-                    "fields": fields_count,
-                    "imports": imports_count,
-                    "total": len(elements),
-                },
-            },
-        }
-
-        if include_complexity:
-            # Add complexity metrics if available
-            methods = [e for e in elements if e.get("__class__") == "Function"]
-            if methods:
-                complexities = [e.get("complexity_score", 0) for e in methods]
-                result["metrics"]["complexity"] = {
-                    "total": sum(complexities),
-                    "average": (
-                        sum(complexities) / len(complexities) if complexities else 0
-                    ),
-                    "max": max(complexities) if complexities else 0,
-                }
-
-        if include_details:
-            result["detailed_elements"] = elements
-
-        return result
-
-    def create_server(self) -> Server:
-        """
-        Create and configure the MCP server.
-
-        Returns:
-            Configured MCP Server instance
-        """
-        if not MCP_AVAILABLE:
-            raise RuntimeError("MCP library not available. Please install mcp package.")
-
-        server: Server = Server(self.name)
-
-        # Register tools using @server decorators (standard MCP pattern)
-        @server.list_tools()
-        async def handle_list_tools() -> list[Tool]:
-            """List all available tools."""
-            logger.info("Client requesting tools list")
-
-            tools = [
-                Tool(
-                    name="check_code_scale",
-                    description="Analyze code file size and complexity metrics",
-                    inputSchema={
-                        "type": "object",
-                        "properties": {
-                            "file_path": {
-                                "type": "string",
-                                "description": "Path to the code file (relative to project root)",
-                            }
-                        },
-                        "required": ["file_path"],
-                        "additionalProperties": False,
-                    },
-                ),
-                Tool(
-                    name="analyze_code_structure",
-                    description="Analyze code structure and generate tables with line positions",
-                    inputSchema={
-                        "type": "object",
-                        "properties": {
-                            "file_path": {
-                                "type": "string",
-                                "description": "Path to the code file (relative to project root)",
-                            }
-                        },
-                        "required": ["file_path"],
-                        "additionalProperties": False,
-                    },
-                ),
-                Tool(
-                    name="extract_code_section",
-                    description="Extract a code section by line range",
-                    inputSchema={
-                        "type": "object",
-                        "properties": {
-                            "file_path": {
-                                "type": "string",
-                                "description": "Path to the code file (relative to project root)",
-                            },
-                            "start_line": {
-                                "type": "integer",
-                                "description": "Start line (1-based)",
-                                "minimum": 1,
-                            },
-                            "end_line": {
-                                "type": "integer",
-                                "description": "End line (optional, 1-based)",
-                                "minimum": 1,
-                            },
-                        },
-                        "required": ["file_path", "start_line"],
-                        "additionalProperties": False,
-                    },
-                ),
-                Tool(
-                    name="set_project_path",
-                    description="Set or override the project root path used for security boundaries",
-                    inputSchema={
-                        "type": "object",
-                        "properties": {
-                            "project_path": {
-                                "type": "string",
-                                "description": "Absolute path to the project root",
-                            }
-                        },
-                        "required": ["project_path"],
-                        "additionalProperties": False,
-                    },
-                ),
-                Tool(**self.query_tool.get_tool_definition()),
-            ]
-
-            logger.info(f"Returning {len(tools)} tools: {[t.name for t in tools]}")
-            return tools
-
-        @server.call_tool()
-        async def handle_call_tool(
-            name: str, arguments: dict[str, Any]
-        ) -> list[TextContent]:
-            try:
-                # Ensure server is fully initialized
-                self._ensure_initialized()
-
-                # Log tool call
-                logger.info(
-                    f"MCP tool call: {name} with args: {list(arguments.keys())}"
-                )
-
-                # Validate file path security
-                if "file_path" in arguments:
-                    file_path = arguments["file_path"]
-                    is_valid, error_msg = self.security_validator.validate_file_path(
-                        file_path
-                    )
-                    if not is_valid:
-                        raise ValueError(
-                            f"Invalid or unsafe file path: {error_msg or file_path}"
-                        )
-
-                # Handle tool calls with simplified parameter handling
-                if name == "check_code_scale":
-                    # Ensure file_path is provided
-                    if "file_path" not in arguments:
-                        raise ValueError("file_path parameter is required")
-
-                    # Add default values for optional parameters
-                    full_args = {
-                        "file_path": arguments["file_path"],
-                        "language": arguments.get("language"),
-                        "include_complexity": arguments.get("include_complexity", True),
-                        "include_details": arguments.get("include_details", False),
-                    }
-                    result = await self._analyze_code_scale(full_args)
-
-                elif name == "analyze_code_structure":
-                    if "file_path" not in arguments:
-                        raise ValueError("file_path parameter is required")
-
-                    full_args = {
-                        "file_path": arguments["file_path"],
-                        "format_type": arguments.get("format_type", "full"),
-                        "language": arguments.get("language"),
-                    }
-                    result = await self.table_format_tool.execute(full_args)
-
-                elif name == "extract_code_section":
-                    if "file_path" not in arguments or "start_line" not in arguments:
-                        raise ValueError(
-                            "file_path and start_line parameters are required"
-                        )
-
-                    full_args = {
-                        "file_path": arguments["file_path"],
-                        "start_line": arguments["start_line"],
-                        "end_line": arguments.get("end_line"),
-                        "start_column": arguments.get("start_column"),
-                        "end_column": arguments.get("end_column"),
-                        "format": arguments.get("format", "text"),
-                    }
-                    result = await self.read_partial_tool.execute(full_args)
-
-                elif name == "set_project_path":
-                    project_path = arguments.get("project_path")
-                    if not project_path or not isinstance(project_path, str):
-                        raise ValueError(
-                            "project_path parameter is required and must be a string"
-                        )
-                    if not os.path.isdir(project_path):
-                        raise ValueError(f"Project path does not exist: {project_path}")
-                    self.set_project_path(project_path)
-                    result = {"status": "success", "project_root": project_path}
-
-                elif name == "query_code":
-                    result = await self.query_tool.execute(arguments)
-
-                else:
-                    raise ValueError(f"Unknown tool: {name}")
-
-                # Return result
-                return [
-                    TextContent(
-                        type="text",
-                        text=json.dumps(result, indent=2, ensure_ascii=False),
-                    )
-                ]
-
-            except Exception as e:
-                try:
-                    logger.error(f"Tool call error for {name}: {e}")
-                except (ValueError, OSError):
-                    pass  # Silently ignore logging errors during shutdown
-                return [
-                    TextContent(
-                        type="text",
-                        text=json.dumps(
-                            {"error": str(e), "tool": name, "arguments": arguments},
-                            indent=2,
-                        ),
-                    )
-                ]
-
-        # Register resources
-        @server.list_resources()  # type: ignore
-        async def handle_list_resources() -> list[Resource]:
-            """List available resources."""
-            return [
-                Resource(
-                    uri=self.code_file_resource.get_resource_info()["uri_template"],
-                    name=self.code_file_resource.get_resource_info()["name"],
-                    description=self.code_file_resource.get_resource_info()[
-                        "description"
-                    ],
-                    mimeType=self.code_file_resource.get_resource_info()["mime_type"],
-                ),
-                Resource(
-                    uri=self.project_stats_resource.get_resource_info()["uri_template"],
-                    name=self.project_stats_resource.get_resource_info()["name"],
-                    description=self.project_stats_resource.get_resource_info()[
-                        "description"
-                    ],
-                    mimeType=self.project_stats_resource.get_resource_info()[
-                        "mime_type"
-                    ],
-                ),
-            ]
-
-        @server.read_resource()  # type: ignore
-        async def handle_read_resource(uri: str) -> str:
-            """Read resource content."""
-            try:
-                # Check which resource matches the URI
-                if self.code_file_resource.matches_uri(uri):
-                    return await self.code_file_resource.read_resource(uri)
-                elif self.project_stats_resource.matches_uri(uri):
-                    return await self.project_stats_resource.read_resource(uri)
-                else:
-                    raise ValueError(f"Resource not found: {uri}")
-
-            except Exception as e:
-                try:
-                    logger.error(f"Resource read error for {uri}: {e}")
-                except (ValueError, OSError):
-                    pass  # Silently ignore logging errors during shutdown
-                raise
-
-        # Some clients may request prompts; explicitly return empty list
-        try:
-            from mcp.types import Prompt  # type: ignore
-
-            @server.list_prompts()  # type: ignore
-            async def handle_list_prompts() -> list[Prompt]:
-                logger.info("Client requested prompts list (returning empty)")
-                return []
-
-        except Exception as e:
-            # If Prompt type is unavailable, log at debug level and continue safely
-            try:
-                logger.debug(f"Prompts API unavailable or incompatible: {e}")
-            except (ValueError, OSError):
-                pass
-
-        self.server = server
-        try:
-            logger.info("MCP server created successfully")
-        except (ValueError, OSError):
-            pass  # Silently ignore logging errors during shutdown
-        return server
-
-    def set_project_path(self, project_path: str) -> None:
-        """
-        Set the project path for statistics resource
-
-        Args:
-            project_path: Path to the project directory
-        """
-        self.project_stats_resource.set_project_path(project_path)
-        try:
-            logger.info(f"Set project path to: {project_path}")
-        except (ValueError, OSError):
-            pass  # Silently ignore logging errors during shutdown
-
-    async def run(self) -> None:
-        """
-        Run the MCP server.
-
-        This method starts the server and handles stdio communication.
-        """
-        if not MCP_AVAILABLE:
-            raise RuntimeError("MCP library not available. Please install mcp package.")
-
-        server = self.create_server()
-
-        # Initialize server options with required capabilities field
-        options = InitializationOptions(
-            server_name=self.name,
-            server_version=self.version,
-            capabilities={"tools": {}, "resources": {}, "prompts": {}, "logging": {}},
-        )
-
-        try:
-            logger.info(f"Starting MCP server: {self.name} v{self.version}")
-        except (ValueError, OSError):
-            pass  # Silently ignore logging errors during shutdown
-
-        try:
-            async with stdio_server() as (read_stream, write_stream):
-                logger.info("Server running, waiting for requests...")
-                await server.run(read_stream, write_stream, options)
-        except Exception as e:
-            # Use safe logging to avoid I/O errors during shutdown
-            try:
-                logger.error(f"Server error: {e}")
-            except (ValueError, OSError):
-                pass  # Silently ignore logging errors during shutdown
-            raise
-        finally:
-            # Safe cleanup
-            try:
-                logger.info("MCP server shutting down")
-            except (ValueError, OSError):
-                pass  # Silently ignore logging errors during shutdown
-
-
-def parse_mcp_args(args=None) -> argparse.Namespace:
-    """Parse command line arguments for MCP server."""
-    parser = argparse.ArgumentParser(
-        description="Tree-sitter Analyzer MCP Server",
-        formatter_class=argparse.RawDescriptionHelpFormatter,
-        epilog="""
-Environment Variables:
-  TREE_SITTER_PROJECT_ROOT    Project root directory (alternative to --project-root)
-
-Examples:
-  python -m tree_sitter_analyzer.mcp.server
-  python -m tree_sitter_analyzer.mcp.server --project-root /path/to/project
-        """,
-    )
-
-    parser.add_argument(
-        "--project-root",
-        help="Project root directory for security validation (auto-detected if not specified)",
-    )
-
-    return parser.parse_args(args)
-
-
-async def main() -> None:
-    """Main entry point for the MCP server."""
-    try:
-        # Parse command line arguments (ignore unknown so pytest flags won't crash)
-        args = parse_mcp_args([] if "pytest" in sys.argv[0] else None)
-
-        # Determine project root with robust priority handling and fallbacks
-        project_root = None
-
-        # Priority 1: Command line argument
-        if args.project_root:
-            project_root = args.project_root
-        # Priority 2: Environment variable
-        elif os.getenv("TREE_SITTER_PROJECT_ROOT"):
-            project_root = os.getenv("TREE_SITTER_PROJECT_ROOT")
-        # Priority 3: Auto-detection from current directory
-        else:
-            project_root = detect_project_root()
-
-        # Handle unresolved placeholders from clients (e.g., "${workspaceFolder}")
-        invalid_placeholder = isinstance(project_root, str) and (
-            "${" in project_root or "}" in project_root or "$" in project_root
-        )
-
-        # Validate existence; if invalid, fall back to auto-detected root
-        if not project_root or invalid_placeholder or not os.path.isdir(project_root):
-            detected = detect_project_root()
-            try:
-                logger.warning(
-                    f"Invalid project root '{project_root}', falling back to auto-detected root: {detected}"
-                )
-            except (ValueError, OSError):
-                pass
-            project_root = detected
-
-        logger.info(f"MCP server starting with project root: {project_root}")
-
-        server = TreeSitterAnalyzerMCPServer(project_root)
-        await server.run()
-    except KeyboardInterrupt:
-        try:
-            logger.info("Server stopped by user")
-        except (ValueError, OSError):
-            pass  # Silently ignore logging errors during shutdown
-    except Exception as e:
-        try:
-            logger.error(f"Server failed: {e}")
-        except (ValueError, OSError):
-            pass  # Silently ignore logging errors during shutdown
-        sys.exit(1)
-    finally:
-        # Ensure clean shutdown
-        try:
-            logger.info("MCP server shutdown complete")
-        except (ValueError, OSError):
-            pass  # Silently ignore logging errors during shutdown
-
-
-def main_sync() -> None:
-    """Synchronous entry point for setuptools scripts."""
-    asyncio.run(main())
-
-
-if __name__ == "__main__":
-    main_sync()
+#!/usr/bin/env python3
+"""
+MCP Server implementation for Tree-sitter Analyzer (Fixed Version)
+
+This module provides the main MCP server that exposes tree-sitter analyzer
+functionality through the Model Context Protocol.
+"""
+
+import argparse
+import asyncio
+import json
+import os
+import sys
+from pathlib import Path as PathClass
+from typing import Any
+
+try:
+    from mcp.server import Server
+    from mcp.server.models import InitializationOptions
+    from mcp.server.stdio import stdio_server
+    from mcp.types import Resource, TextContent, Tool
+
+    MCP_AVAILABLE = True
+except ImportError:
+    MCP_AVAILABLE = False
+
+    # Fallback types for development without MCP
+    class Server:
+        pass
+
+    class InitializationOptions:
+        def __init__(self, **kwargs):
+            pass
+
+    class Tool:
+        pass
+
+    class Resource:
+        pass
+
+    class TextContent:
+        pass
+
+    def stdio_server():
+        pass
+
+
+from ..core.analysis_engine import get_analysis_engine
+from ..project_detector import detect_project_root
+from ..security import SecurityValidator
+from ..utils import setup_logger
+from . import MCP_INFO
+from .resources import CodeFileResource, ProjectStatsResource
+from .tools.base_tool import MCPTool
+from .tools.query_tool import QueryTool
+from .tools.read_partial_tool import ReadPartialTool
+from .tools.table_format_tool import TableFormatTool
+
+# Set up logging
+logger = setup_logger(__name__)
+
+
+class TreeSitterAnalyzerMCPServer:
+    """
+    MCP Server for Tree-sitter Analyzer
+
+    Provides code analysis capabilities through the Model Context Protocol,
+    integrating with existing analyzer components.
+    """
+
+    def __init__(self, project_root: str = None) -> None:
+        """Initialize the MCP server with analyzer components."""
+        self.server: Server | None = None
+        self._initialization_complete = False
+
+        logger.info("Starting MCP server initialization...")
+
+        self.analysis_engine = get_analysis_engine(project_root)
+        self.security_validator = SecurityValidator(project_root)
+        # Use unified analysis engine instead of deprecated AdvancedAnalyzer
+
+        # Initialize MCP tools with security validation (four core tools)
+        self.query_tool = QueryTool(project_root)  # query_code
+        self.read_partial_tool: MCPTool = ReadPartialTool(
+            project_root
+        )  # extract_code_section
+        self.table_format_tool: MCPTool = TableFormatTool(
+            project_root
+        )  # analyze_code_structure
+        # Optional universal tool to satisfy initialization tests
+        try:
+            from .tools.universal_analyze_tool import UniversalAnalyzeTool
+
+            self.universal_analyze_tool = UniversalAnalyzeTool(project_root)
+        except Exception:
+            self.universal_analyze_tool = None
+
+        # Initialize MCP resources
+        self.code_file_resource = CodeFileResource()
+        self.project_stats_resource = ProjectStatsResource()
+
+        # Server metadata
+        self.name = MCP_INFO["name"]
+        self.version = MCP_INFO["version"]
+
+        self._initialization_complete = True
+        logger.info(f"MCP server initialization complete: {self.name} v{self.version}")
+
+    def is_initialized(self) -> bool:
+        """Check if the server is fully initialized."""
+        return self._initialization_complete
+
+    def _ensure_initialized(self) -> None:
+        """Ensure the server is initialized before processing requests."""
+        if not self._initialization_complete:
+            raise RuntimeError(
+                "Server not fully initialized. Please wait for initialization to complete."
+            )
+
+    async def _analyze_code_scale(self, arguments: dict[str, Any]) -> dict[str, Any]:
+        """
+        Analyze code scale and complexity metrics using the analysis engine directly.
+        """
+        # For initialization-specific tests, we should raise MCPError instead of RuntimeError
+        if not self._initialization_complete:
+            from .utils.error_handler import MCPError
+
+            raise MCPError("Server is still initializing")
+
+        # For specific initialization tests we allow delegating to universal tool
+        if (
+            "file_path" not in arguments
+            and getattr(self, "universal_analyze_tool", None) is not None
+        ):
+            return await self.universal_analyze_tool.execute(arguments)
+        if "file_path" not in arguments:
+            raise ValueError("file_path is required")
+
+        file_path = arguments["file_path"]
+        language = arguments.get("language")
+        include_complexity = arguments.get("include_complexity", True)
+        include_details = arguments.get("include_details", False)
+
+        # Resolve relative path against project root for consistent behavior
+        base_root = getattr(
+            getattr(self.security_validator, "boundary_manager", None),
+            "project_root",
+            None,
+        )
+        if not PathClass(file_path).is_absolute() and base_root:
+            resolved_path = str((PathClass(base_root) / file_path).resolve())
+        else:
+            resolved_path = file_path
+
+        # Security validation
+        is_valid, error_msg = self.security_validator.validate_file_path(resolved_path)
+        if not is_valid:
+            raise ValueError(f"Invalid file path: {error_msg}")
+
+        # Use analysis engine directly
+        from ..core.analysis_engine import AnalysisRequest
+        from ..language_detector import detect_language_from_file
+
+        # Validate file exists
+        if not PathClass(resolved_path).exists():
+            raise FileNotFoundError(f"File not found: {file_path}")
+
+        # Detect language if not specified
+        if not language:
+            language = detect_language_from_file(resolved_path)
+
+        # Create analysis request
+        request = AnalysisRequest(
+            file_path=resolved_path,
+            language=language,
+            include_complexity=include_complexity,
+            include_details=include_details,
+        )
+
+        # Perform analysis
+        analysis_result = await self.analysis_engine.analyze(request)
+
+        if analysis_result is None or not analysis_result.success:
+            error_msg = (
+                analysis_result.error_message if analysis_result else "Unknown error"
+            )
+            raise RuntimeError(f"Failed to analyze file: {file_path} - {error_msg}")
+
+        # Convert to dictionary format
+        result_dict = analysis_result.to_dict()
+
+        # Format result to match test expectations
+        elements = result_dict.get("elements", [])
+
+        # Count elements by type
+        classes_count = len([e for e in elements if e.get("__class__") == "Class"])
+        methods_count = len([e for e in elements if e.get("__class__") == "Function"])
+        fields_count = len([e for e in elements if e.get("__class__") == "Variable"])
+        imports_count = len([e for e in elements if e.get("__class__") == "Import"])
+
+        result = {
+            "file_path": file_path,
+            "language": language,
+            "metrics": {
+                "lines_total": result_dict.get("line_count", 0),
+                "lines_code": result_dict.get("line_count", 0),  # Approximation
+                "lines_comment": 0,  # Not available in basic analysis
+                "lines_blank": 0,  # Not available in basic analysis
+                "elements": {
+                    "classes": classes_count,
+                    "methods": methods_count,
+                    "fields": fields_count,
+                    "imports": imports_count,
+                    "total": len(elements),
+                },
+            },
+        }
+
+        if include_complexity:
+            # Add complexity metrics if available
+            methods = [e for e in elements if e.get("__class__") == "Function"]
+            if methods:
+                complexities = [e.get("complexity_score", 0) for e in methods]
+                result["metrics"]["complexity"] = {
+                    "total": sum(complexities),
+                    "average": (
+                        sum(complexities) / len(complexities) if complexities else 0
+                    ),
+                    "max": max(complexities) if complexities else 0,
+                }
+
+        if include_details:
+            result["detailed_elements"] = elements
+
+        return result
+
+    def create_server(self) -> Server:
+        """
+        Create and configure the MCP server.
+
+        Returns:
+            Configured MCP Server instance
+        """
+        if not MCP_AVAILABLE:
+            raise RuntimeError("MCP library not available. Please install mcp package.")
+
+        server: Server = Server(self.name)
+
+        # Register tools using @server decorators (standard MCP pattern)
+        @server.list_tools()
+        async def handle_list_tools() -> list[Tool]:
+            """List all available tools."""
+            logger.info("Client requesting tools list")
+
+            tools = [
+                Tool(
+                    name="check_code_scale",
+                    description="Analyze code file size and complexity metrics",
+                    inputSchema={
+                        "type": "object",
+                        "properties": {
+                            "file_path": {
+                                "type": "string",
+                                "description": "Path to the code file (relative to project root)",
+                            }
+                        },
+                        "required": ["file_path"],
+                        "additionalProperties": False,
+                    },
+                ),
+                Tool(
+                    name="analyze_code_structure",
+                    description="Analyze code structure and generate tables with line positions",
+                    inputSchema={
+                        "type": "object",
+                        "properties": {
+                            "file_path": {
+                                "type": "string",
+                                "description": "Path to the code file (relative to project root)",
+                            }
+                        },
+                        "required": ["file_path"],
+                        "additionalProperties": False,
+                    },
+                ),
+                Tool(
+                    name="extract_code_section",
+                    description="Extract a code section by line range",
+                    inputSchema={
+                        "type": "object",
+                        "properties": {
+                            "file_path": {
+                                "type": "string",
+                                "description": "Path to the code file (relative to project root)",
+                            },
+                            "start_line": {
+                                "type": "integer",
+                                "description": "Start line (1-based)",
+                                "minimum": 1,
+                            },
+                            "end_line": {
+                                "type": "integer",
+                                "description": "End line (optional, 1-based)",
+                                "minimum": 1,
+                            },
+                        },
+                        "required": ["file_path", "start_line"],
+                        "additionalProperties": False,
+                    },
+                ),
+                Tool(
+                    name="set_project_path",
+                    description="Set or override the project root path used for security boundaries",
+                    inputSchema={
+                        "type": "object",
+                        "properties": {
+                            "project_path": {
+                                "type": "string",
+                                "description": "Absolute path to the project root",
+                            }
+                        },
+                        "required": ["project_path"],
+                        "additionalProperties": False,
+                    },
+                ),
+                Tool(**self.query_tool.get_tool_definition()),
+            ]
+
+            logger.info(f"Returning {len(tools)} tools: {[t.name for t in tools]}")
+            return tools
+
+        @server.call_tool()
+        async def handle_call_tool(
+            name: str, arguments: dict[str, Any]
+        ) -> list[TextContent]:
+            try:
+                # Ensure server is fully initialized
+                self._ensure_initialized()
+
+                # Log tool call
+                logger.info(
+                    f"MCP tool call: {name} with args: {list(arguments.keys())}"
+                )
+
+                # Validate file path security
+                if "file_path" in arguments:
+                    file_path = arguments["file_path"]
+                    is_valid, error_msg = self.security_validator.validate_file_path(
+                        file_path
+                    )
+                    if not is_valid:
+                        raise ValueError(
+                            f"Invalid or unsafe file path: {error_msg or file_path}"
+                        )
+
+                # Handle tool calls with simplified parameter handling
+                if name == "check_code_scale":
+                    # Ensure file_path is provided
+                    if "file_path" not in arguments:
+                        raise ValueError("file_path parameter is required")
+
+                    # Add default values for optional parameters
+                    full_args = {
+                        "file_path": arguments["file_path"],
+                        "language": arguments.get("language"),
+                        "include_complexity": arguments.get("include_complexity", True),
+                        "include_details": arguments.get("include_details", False),
+                    }
+                    result = await self._analyze_code_scale(full_args)
+
+                elif name == "analyze_code_structure":
+                    if "file_path" not in arguments:
+                        raise ValueError("file_path parameter is required")
+
+                    full_args = {
+                        "file_path": arguments["file_path"],
+                        "format_type": arguments.get("format_type", "full"),
+                        "language": arguments.get("language"),
+                    }
+                    result = await self.table_format_tool.execute(full_args)
+
+                elif name == "extract_code_section":
+                    if "file_path" not in arguments or "start_line" not in arguments:
+                        raise ValueError(
+                            "file_path and start_line parameters are required"
+                        )
+
+                    full_args = {
+                        "file_path": arguments["file_path"],
+                        "start_line": arguments["start_line"],
+                        "end_line": arguments.get("end_line"),
+                        "start_column": arguments.get("start_column"),
+                        "end_column": arguments.get("end_column"),
+                        "format": arguments.get("format", "text"),
+                    }
+                    result = await self.read_partial_tool.execute(full_args)
+
+                elif name == "set_project_path":
+                    project_path = arguments.get("project_path")
+                    if not project_path or not isinstance(project_path, str):
+                        raise ValueError(
+                            "project_path parameter is required and must be a string"
+                        )
+                    if not PathClass(project_path).is_dir():
+                        raise ValueError(f"Project path does not exist: {project_path}")
+                    self.set_project_path(project_path)
+                    result = {"status": "success", "project_root": project_path}
+
+                elif name == "query_code":
+                    result = await self.query_tool.execute(arguments)
+
+                else:
+                    raise ValueError(f"Unknown tool: {name}")
+
+                # Return result
+                return [
+                    TextContent(
+                        type="text",
+                        text=json.dumps(result, indent=2, ensure_ascii=False),
+                    )
+                ]
+
+            except Exception as e:
+                try:
+                    logger.error(f"Tool call error for {name}: {e}")
+                except (ValueError, OSError):
+                    pass  # Silently ignore logging errors during shutdown
+                return [
+                    TextContent(
+                        type="text",
+                        text=json.dumps(
+                            {"error": str(e), "tool": name, "arguments": arguments},
+                            indent=2,
+                        ),
+                    )
+                ]
+
+        # Register resources
+        @server.list_resources()  # type: ignore
+        async def handle_list_resources() -> list[Resource]:
+            """List available resources."""
+            return [
+                Resource(
+                    uri=self.code_file_resource.get_resource_info()["uri_template"],
+                    name=self.code_file_resource.get_resource_info()["name"],
+                    description=self.code_file_resource.get_resource_info()[
+                        "description"
+                    ],
+                    mimeType=self.code_file_resource.get_resource_info()["mime_type"],
+                ),
+                Resource(
+                    uri=self.project_stats_resource.get_resource_info()["uri_template"],
+                    name=self.project_stats_resource.get_resource_info()["name"],
+                    description=self.project_stats_resource.get_resource_info()[
+                        "description"
+                    ],
+                    mimeType=self.project_stats_resource.get_resource_info()[
+                        "mime_type"
+                    ],
+                ),
+            ]
+
+        @server.read_resource()  # type: ignore
+        async def handle_read_resource(uri: str) -> str:
+            """Read resource content."""
+            try:
+                # Check which resource matches the URI
+                if self.code_file_resource.matches_uri(uri):
+                    return await self.code_file_resource.read_resource(uri)
+                elif self.project_stats_resource.matches_uri(uri):
+                    return await self.project_stats_resource.read_resource(uri)
+                else:
+                    raise ValueError(f"Resource not found: {uri}")
+
+            except Exception as e:
+                try:
+                    logger.error(f"Resource read error for {uri}: {e}")
+                except (ValueError, OSError):
+                    pass  # Silently ignore logging errors during shutdown
+                raise
+
+        # Some clients may request prompts; explicitly return empty list
+        try:
+            from mcp.types import Prompt  # type: ignore
+
+            @server.list_prompts()  # type: ignore
+            async def handle_list_prompts() -> list[Prompt]:
+                logger.info("Client requested prompts list (returning empty)")
+                return []
+
+        except Exception as e:
+            # If Prompt type is unavailable, log at debug level and continue safely
+            try:
+                logger.debug(f"Prompts API unavailable or incompatible: {e}")
+            except (ValueError, OSError):
+                pass
+
+        self.server = server
+        try:
+            logger.info("MCP server created successfully")
+        except (ValueError, OSError):
+            pass  # Silently ignore logging errors during shutdown
+        return server
+
+    def set_project_path(self, project_path: str) -> None:
+        """
+        Set the project path for statistics resource
+
+        Args:
+            project_path: Path to the project directory
+        """
+        self.project_stats_resource.set_project_path(project_path)
+        try:
+            logger.info(f"Set project path to: {project_path}")
+        except (ValueError, OSError):
+            pass  # Silently ignore logging errors during shutdown
+
+    async def run(self) -> None:
+        """
+        Run the MCP server.
+
+        This method starts the server and handles stdio communication.
+        """
+        if not MCP_AVAILABLE:
+            raise RuntimeError("MCP library not available. Please install mcp package.")
+
+        server = self.create_server()
+
+        # Initialize server options with required capabilities field
+        options = InitializationOptions(
+            server_name=self.name,
+            server_version=self.version,
+            capabilities={"tools": {}, "resources": {}, "prompts": {}, "logging": {}},
+        )
+
+        try:
+            logger.info(f"Starting MCP server: {self.name} v{self.version}")
+        except (ValueError, OSError):
+            pass  # Silently ignore logging errors during shutdown
+
+        try:
+            async with stdio_server() as (read_stream, write_stream):
+                logger.info("Server running, waiting for requests...")
+                await server.run(read_stream, write_stream, options)
+        except Exception as e:
+            # Use safe logging to avoid I/O errors during shutdown
+            try:
+                logger.error(f"Server error: {e}")
+            except (ValueError, OSError):
+                pass  # Silently ignore logging errors during shutdown
+            raise
+        finally:
+            # Safe cleanup
+            try:
+                logger.info("MCP server shutting down")
+            except (ValueError, OSError):
+                pass  # Silently ignore logging errors during shutdown
+
+
+def parse_mcp_args(args=None) -> argparse.Namespace:
+    """Parse command line arguments for MCP server."""
+    parser = argparse.ArgumentParser(
+        description="Tree-sitter Analyzer MCP Server",
+        formatter_class=argparse.RawDescriptionHelpFormatter,
+        epilog="""
+Environment Variables:
+  TREE_SITTER_PROJECT_ROOT    Project root directory (alternative to --project-root)
+
+Examples:
+  python -m tree_sitter_analyzer.mcp.server
+  python -m tree_sitter_analyzer.mcp.server --project-root /path/to/project
+        """,
+    )
+
+    parser.add_argument(
+        "--project-root",
+        help="Project root directory for security validation (auto-detected if not specified)",
+    )
+
+    return parser.parse_args(args)
+
+
+async def main() -> None:
+    """Main entry point for the MCP server."""
+    try:
+        # Parse command line arguments (ignore unknown so pytest flags won't crash)
+        args = parse_mcp_args([] if "pytest" in sys.argv[0] else None)
+
+        # Determine project root with robust priority handling and fallbacks
+        project_root = None
+
+        # Priority 1: Command line argument
+        if args.project_root:
+            project_root = args.project_root
+        # Priority 2: Environment variable
+        elif (
+            PathClass.cwd()
+            .joinpath(os.environ.get("TREE_SITTER_PROJECT_ROOT", ""))
+            .exists()
+        ):
+            project_root = os.environ.get("TREE_SITTER_PROJECT_ROOT")
+        # Priority 3: Auto-detection from current directory
+        else:
+            project_root = detect_project_root()
+
+        # Handle unresolved placeholders from clients (e.g., "${workspaceFolder}")
+        invalid_placeholder = isinstance(project_root, str) and (
+            "${" in project_root or "}" in project_root or "$" in project_root
+        )
+
+        # Validate existence; if invalid, fall back to auto-detected root
+        if (
+            not project_root
+            or invalid_placeholder
+            or not PathClass(project_root).is_dir()
+        ):
+            detected = detect_project_root()
+            try:
+                logger.warning(
+                    f"Invalid project root '{project_root}', falling back to auto-detected root: {detected}"
+                )
+            except (ValueError, OSError):
+                pass
+            project_root = detected
+
+        logger.info(f"MCP server starting with project root: {project_root}")
+
+        server = TreeSitterAnalyzerMCPServer(project_root)
+        await server.run()
+    except KeyboardInterrupt:
+        try:
+            logger.info("Server stopped by user")
+        except (ValueError, OSError):
+            pass  # Silently ignore logging errors during shutdown
+    except Exception as e:
+        try:
+            logger.error(f"Server failed: {e}")
+        except (ValueError, OSError):
+            pass  # Silently ignore logging errors during shutdown
+        sys.exit(1)
+    finally:
+        # Ensure clean shutdown
+        try:
+            logger.info("MCP server shutdown complete")
+        except (ValueError, OSError):
+            pass  # Silently ignore logging errors during shutdown
+
+
+def main_sync() -> None:
+    """Synchronous entry point for setuptools scripts."""
+    asyncio.run(main())
+
+
+if __name__ == "__main__":
+    main_sync()