tree-sitter-analyzer 1.9.17.1__py3-none-any.whl

tree_sitter_analyzer/mcp/__init__.py

@@ -0,0 +1,34 @@
+#!/usr/bin/env python3
+"""
+MCP (Model Context Protocol) integration for Tree-sitter Analyzer
+
+This module provides MCP server functionality that exposes the tree-sitter
+analyzer capabilities through the Model Context Protocol.
+"""
+
+from typing import Any
+
+# Import main package version for consistency
+try:
+    from .. import __version__ as main_version
+
+    __version__ = main_version
+except ImportError:
+    # Fallback version if main package not available
+    __version__ = "1.1.1"
+
+__author__ = "Tree-sitter Analyzer Team"
+
+# MCP module metadata
+MCP_INFO: dict[str, Any] = {
+    "name": "tree-sitter-analyzer-mcp",
+    "version": __version__,
+    "description": "Tree-sitter based code analyzer with MCP support - Solve LLM token limit problems for large code files",
+    "protocol_version": "2024-11-05",
+    "capabilities": {"tools": {}, "resources": {}, "prompts": {}, "logging": {}},
+}
+
+__all__ = [
+    "MCP_INFO",
+    "__version__",
+]

tree_sitter_analyzer/mcp/resources/__init__.py

@@ -0,0 +1,43 @@
+#!/usr/bin/env python3
+"""
+MCP Resources Module
+
+This module provides MCP (Model Context Protocol) resource implementations
+for the tree-sitter-analyzer project. Resources provide dynamic content
+access through URI-based identification.
+
+Resources:
+    - CodeFileResource: Access to code file content
+    - ProjectStatsResource: Access to project statistics and analysis data
+
+The resources integrate with existing analyzer components to provide
+seamless access to code analysis functionality through the MCP protocol.
+"""
+
+# Export main resource classes
+from .code_file_resource import CodeFileResource
+from .project_stats_resource import ProjectStatsResource
+
+# Resource metadata
+__author__ = "Tree-Sitter Analyzer Team"
+
+# MCP Resource capabilities
+MCP_RESOURCE_CAPABILITIES = {
+    "version": "2024-11-05",
+    "resources": [
+        {
+            "name": "code_file",
+            "description": "Access to code file content",
+            "uri_template": "code://file/{file_path}",
+            "mime_type": "text/plain",
+        },
+        {
+            "name": "project_stats",
+            "description": "Access to project statistics and analysis data",
+            "uri_template": "code://stats/{stats_type}",
+            "mime_type": "application/json",
+        },
+    ],
+}
+
+__all__ = ["CodeFileResource", "ProjectStatsResource", "MCP_RESOURCE_CAPABILITIES"]

tree_sitter_analyzer/mcp/resources/code_file_resource.py

@@ -0,0 +1,208 @@
+#!/usr/bin/env python3
+"""
+Code File Resource for MCP
+
+This module provides MCP resource implementation for accessing code file content.
+The resource allows dynamic access to file content through URI-based identification.
+"""
+
+import logging
+import re
+from pathlib import Path
+from typing import Any
+
+from tree_sitter_analyzer.encoding_utils import read_file_safe
+
+logger = logging.getLogger(__name__)
+
+
+class CodeFileResource:
+    """
+    MCP resource for accessing code file content
+
+    This resource provides access to code file content through the MCP protocol.
+    It supports reading files with proper encoding detection and error handling.
+
+    URI Format: code://file/{file_path}
+
+    Examples:
+        - code://file/src/main/java/Example.java
+        - code://file/scripts/helper.py
+        - code://file/test.js
+    """
+
+    def __init__(self) -> None:
+        """Initialize the code file resource"""
+        self._uri_pattern = re.compile(r"^code://file/(.+)$")
+
+    def get_resource_info(self) -> dict[str, Any]:
+        """
+        Get resource information for MCP registration
+
+        Returns:
+            Dict containing resource metadata
+        """
+        return {
+            "name": "code_file",
+            "description": "Access to code file content through URI-based identification",
+            "uri_template": "code://file/{file_path}",
+            "mime_type": "text/plain",
+        }
+
+    def matches_uri(self, uri: str) -> bool:
+        """
+        Check if the URI matches this resource pattern
+
+        Args:
+            uri: The URI to check
+
+        Returns:
+            True if the URI matches the code file pattern
+        """
+        return bool(self._uri_pattern.match(uri))
+
+    def _extract_file_path(self, uri: str) -> str:
+        """
+        Extract file path from URI
+
+        Args:
+            uri: The URI to extract path from
+
+        Returns:
+            The extracted file path
+
+        Raises:
+            ValueError: If URI format is invalid
+        """
+        match = self._uri_pattern.match(uri)
+        if not match:
+            raise ValueError(f"Invalid URI format: {uri}")
+
+        return match.group(1)
+
+    async def _read_file_content(self, file_path: str) -> str:
+        """
+        Read file content with proper encoding detection
+
+        Args:
+            file_path: Path to the file to read
+
+        Returns:
+            File content as string
+
+        Raises:
+            FileNotFoundError: If file doesn't exist
+            PermissionError: If file cannot be read due to permissions
+            OSError: If file cannot be read due to other OS errors
+        """
+        try:
+            # Use existing encoding-safe file reader
+            # Check if file exists first
+            if not Path(file_path).exists():
+                raise FileNotFoundError(f"File not found: {file_path}")
+
+            content, encoding = read_file_safe(file_path)
+            return content
+
+        except FileNotFoundError:
+            logger.error(f"File not found: {file_path}")
+            raise
+        except PermissionError:
+            logger.error(f"Permission denied reading file: {file_path}")
+            raise
+        except OSError as e:
+            logger.error(f"OS error reading file {file_path}: {e}")
+            raise
+        except Exception as e:
+            logger.error(f"Unexpected error reading file {file_path}: {e}")
+            raise OSError(f"Failed to read file: {e}") from e
+
+    def _validate_file_path(self, file_path: str) -> None:
+        """
+        Validate file path for security and correctness
+
+        Args:
+            file_path: The file path to validate
+
+        Raises:
+            ValueError: If file path is invalid or potentially dangerous
+        """
+        if not file_path:
+            raise ValueError("File path cannot be empty")
+
+        # Check for null bytes
+        if "\x00" in file_path:
+            raise ValueError("File path contains null bytes")
+
+        # Check for potentially dangerous path traversal
+        if ".." in file_path:
+            raise ValueError(f"Path traversal not allowed: {file_path}")
+
+        # Additional security checks could be added here
+        # For example, restricting to certain directories
+
+    async def read_resource(self, uri: str) -> str:
+        """
+        Read resource content from URI
+
+        Args:
+            uri: The resource URI to read
+
+        Returns:
+            Resource content as string
+
+        Raises:
+            ValueError: If URI format is invalid
+            FileNotFoundError: If file doesn't exist
+            PermissionError: If file cannot be read due to permissions
+            OSError: If file cannot be read due to other errors
+        """
+        logger.debug(f"Reading resource: {uri}")
+
+        # Validate URI format
+        if not self.matches_uri(uri):
+            raise ValueError(f"URI does not match code file pattern: {uri}")
+
+        # Extract file path
+        file_path = self._extract_file_path(uri)
+
+        # Validate file path
+        self._validate_file_path(file_path)
+
+        # Read file content
+        try:
+            content = await self._read_file_content(file_path)
+            logger.debug(
+                f"Successfully read {len(content)} characters from {file_path}"
+            )
+            return content
+
+        except Exception as e:
+            logger.error(f"Failed to read resource {uri}: {e}")
+            raise
+
+    def get_supported_schemes(self) -> list[str]:
+        """
+        Get list of supported URI schemes
+
+        Returns:
+            List of supported schemes
+        """
+        return ["code"]
+
+    def get_supported_resource_types(self) -> list[str]:
+        """
+        Get list of supported resource types
+
+        Returns:
+            List of supported resource types
+        """
+        return ["file"]
+
+    def __str__(self) -> str:
+        """String representation of the resource"""
+        return "CodeFileResource(pattern=code://file/{file_path})"
+
+    def __repr__(self) -> str:
+        """Detailed string representation of the resource"""
+        return f"CodeFileResource(uri_pattern={self._uri_pattern.pattern})"