tree-sitter-analyzer 1.1.3__py3-none-any.whl → 1.2.0__py3-none-any.whl

tree_sitter_analyzer/mcp/server.py

@@ -45,13 +45,21 @@ except ImportError:
         pass
 
 
+from ..constants import (
+    ELEMENT_TYPE_CLASS,
+    ELEMENT_TYPE_FUNCTION,
+    ELEMENT_TYPE_IMPORT,
+    ELEMENT_TYPE_PACKAGE,
+    ELEMENT_TYPE_VARIABLE,
+    is_element_of_type,
+)
 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.analyze_scale_tool import AnalyzeScaleTool
 from .tools.query_tool import QueryTool
 from .tools.read_partial_tool import ReadPartialTool
 from .tools.table_format_tool import TableFormatTool
@@ -81,12 +89,10 @@ class TreeSitterAnalyzerMCPServer:
 
         # 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
+        self.read_partial_tool = ReadPartialTool(project_root)  # extract_code_section
+        self.table_format_tool = TableFormatTool(project_root)  # analyze_code_structure
+        self.analyze_scale_tool = AnalyzeScaleTool(project_root)  # check_code_scale
+
         # Optional universal tool to satisfy initialization tests
         try:
             from .tools.universal_analyze_tool import UniversalAnalyzeTool
@@ -186,54 +192,190 @@ class TreeSitterAnalyzerMCPServer:
             )
             raise RuntimeError(f"Failed to analyze file: {file_path} - {error_msg}")
 
-        # Convert to dictionary format
-        result_dict = analysis_result.to_dict()
+        # Get element counts from the unified elements list
+        elements = analysis_result.elements or []
 
-        # Format result to match test expectations
-        elements = result_dict.get("elements", [])
+        # Count elements by type using the new unified system
+        classes_count = len(
+            [e for e in elements if is_element_of_type(e, ELEMENT_TYPE_CLASS)]
+        )
+        methods_count = len(
+            [e for e in elements if is_element_of_type(e, ELEMENT_TYPE_FUNCTION)]
+        )
+        fields_count = len(
+            [e for e in elements if is_element_of_type(e, ELEMENT_TYPE_VARIABLE)]
+        )
+        imports_count = len(
+            [e for e in elements if is_element_of_type(e, ELEMENT_TYPE_IMPORT)]
+        )
+        packages_count = len(
+            [e for e in elements if is_element_of_type(e, ELEMENT_TYPE_PACKAGE)]
+        )
+        total_elements = (
+            classes_count
+            + methods_count
+            + fields_count
+            + imports_count
+            + packages_count
+        )
 
-        # 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"])
+        # Calculate accurate file metrics including comments and blank lines
+        file_metrics = self._calculate_file_metrics(resolved_path, language)
+        lines_code = file_metrics["code_lines"]
+        lines_comment = file_metrics["comment_lines"]
+        lines_blank = file_metrics["blank_lines"]
 
         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
+                "lines_total": analysis_result.line_count,
+                "lines_code": lines_code,
+                "lines_comment": lines_comment,
+                "lines_blank": lines_blank,
                 "elements": {
                     "classes": classes_count,
                     "methods": methods_count,
                     "fields": fields_count,
                     "imports": imports_count,
-                    "total": len(elements),
+                    "packages": packages_count,
+                    "total": total_elements,
                 },
             },
         }
 
         if include_complexity:
             # Add complexity metrics if available
-            methods = [e for e in elements if e.get("__class__") == "Function"]
+            methods = [
+                e for e in elements if is_element_of_type(e, ELEMENT_TYPE_FUNCTION)
+            ]
             if methods:
-                complexities = [e.get("complexity_score", 0) for e in methods]
+                complexities = [getattr(m, "complexity_score", 0) for m in methods]
                 result["metrics"]["complexity"] = {
                     "total": sum(complexities),
-                    "average": (
-                        sum(complexities) / len(complexities) if complexities else 0
+                    "average": round(
+                        sum(complexities) / len(complexities) if complexities else 0, 2
                     ),
                     "max": max(complexities) if complexities else 0,
                 }
 
         if include_details:
-            result["detailed_elements"] = elements
+            # Convert elements to serializable format
+            detailed_elements = []
+            for elem in elements:
+                if hasattr(elem, "__dict__"):
+                    detailed_elements.append(elem.__dict__)
+                else:
+                    detailed_elements.append(str(elem))
+            result["detailed_elements"] = detailed_elements
 
         return result
 
+    def _calculate_file_metrics(self, file_path: str, language: str) -> dict[str, Any]:
+        """
+        Calculate accurate file metrics including line counts, comments, and blank lines.
+
+        Args:
+            file_path: Path to the file to analyze
+            language: Programming language
+
+        Returns:
+            Dictionary containing file metrics
+        """
+        try:
+            with open(file_path, encoding="utf-8") as f:
+                content = f.read()
+
+            lines = content.split("\n")
+            total_lines = len(lines)
+
+            # Remove empty line at the end if file ends with newline
+            if lines and not lines[-1]:
+                total_lines -= 1
+
+            # Count different types of lines
+            code_lines = 0
+            comment_lines = 0
+            blank_lines = 0
+            in_multiline_comment = False
+
+            for line in lines:
+                stripped = line.strip()
+
+                # Check for blank lines first
+                if not stripped:
+                    blank_lines += 1
+                    continue
+
+                # Check if we're in a multi-line comment
+                if in_multiline_comment:
+                    comment_lines += 1
+                    # Check if this line ends the multi-line comment
+                    if "*/" in stripped:
+                        in_multiline_comment = False
+                    continue
+
+                # Check for multi-line comment start
+                if stripped.startswith("/**") or stripped.startswith("/*"):
+                    comment_lines += 1
+                    # Check if this line also ends the comment
+                    if "*/" not in stripped:
+                        in_multiline_comment = True
+                    continue
+
+                # Check for single-line comments
+                if stripped.startswith("//"):
+                    comment_lines += 1
+                    continue
+
+                # Check for JavaDoc continuation lines (lines starting with * but not */)
+                if stripped.startswith("*") and not stripped.startswith("*/"):
+                    comment_lines += 1
+                    continue
+
+                # Check for other comment types based on language
+                if language == "python" and stripped.startswith("#"):
+                    comment_lines += 1
+                    continue
+                elif language == "sql" and stripped.startswith("--"):
+                    comment_lines += 1
+                    continue
+                elif language in ["html", "xml"] and stripped.startswith("<!--"):
+                    comment_lines += 1
+                    if "-->" not in stripped:
+                        in_multiline_comment = True
+                    continue
+                elif in_multiline_comment and "-->" in stripped:
+                    comment_lines += 1
+                    in_multiline_comment = False
+                    continue
+
+                # If not a comment, it's code
+                code_lines += 1
+
+            # Ensure the sum equals total_lines (handle any rounding errors)
+            calculated_total = code_lines + comment_lines + blank_lines
+            if calculated_total != total_lines:
+                # Adjust code_lines to match total
+                code_lines = total_lines - comment_lines - blank_lines
+                # Ensure code_lines is not negative
+                code_lines = max(0, code_lines)
+
+            return {
+                "total_lines": total_lines,
+                "code_lines": code_lines,
+                "comment_lines": comment_lines,
+                "blank_lines": blank_lines,
+            }
+        except Exception as e:
+            logger.error(f"Error calculating file metrics for {file_path}: {e}")
+            return {
+                "total_lines": 0,
+                "code_lines": 0,
+                "comment_lines": 0,
+                "blank_lines": 0,
+            }
+
     def create_server(self) -> Server:
         """
         Create and configure the MCP server.
@@ -359,14 +501,8 @@ class TreeSitterAnalyzerMCPServer:
                     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)
+                    # Use the original _analyze_code_scale method for backward compatibility
+                    result = await self._analyze_code_scale(arguments)
 
                 elif name == "analyze_code_structure":
                     if "file_path" not in arguments:
@@ -504,12 +640,28 @@ class TreeSitterAnalyzerMCPServer:
 
     def set_project_path(self, project_path: str) -> None:
         """
-        Set the project path for statistics resource
+        Set the project path for all components
 
         Args:
             project_path: Path to the project directory
         """
+        # Update project stats resource
         self.project_stats_resource.set_project_path(project_path)
+
+        # Update all MCP tools (all inherit from BaseMCPTool)
+        self.query_tool.set_project_path(project_path)
+        self.read_partial_tool.set_project_path(project_path)
+        self.table_format_tool.set_project_path(project_path)
+        self.analyze_scale_tool.set_project_path(project_path)
+
+        # Update universal tool if available
+        if hasattr(self, "universal_analyze_tool") and self.universal_analyze_tool:
+            self.universal_analyze_tool.set_project_path(project_path)
+
+        # Update analysis engine and security validator
+        self.analysis_engine = get_analysis_engine(project_path)
+        self.security_validator = SecurityValidator(project_path)
+
         try:
             logger.info(f"Set project path to: {project_path}")
         except (ValueError, OSError):

tree_sitter_analyzer/mcp/tools/analyze_scale_tool.py

@@ -11,17 +11,23 @@ import re
 from pathlib import Path
 from typing import Any
 
+from ...constants import (
+    ELEMENT_TYPE_CLASS,
+    ELEMENT_TYPE_FUNCTION,
+    ELEMENT_TYPE_IMPORT,
+    ELEMENT_TYPE_VARIABLE,
+    is_element_of_type,
+)
 from ...core.analysis_engine import AnalysisRequest, get_analysis_engine
 from ...language_detector import detect_language_from_file
-from ...security import SecurityValidator
 from ...utils import setup_logger
-from ..utils.path_resolver import PathResolver
+from .base_tool import BaseMCPTool
 
 # Set up logging
 logger = setup_logger(__name__)
 
 
-class AnalyzeScaleTool:
+class AnalyzeScaleTool(BaseMCPTool):
     """
     MCP Tool for analyzing code scale and complexity metrics.
 
@@ -33,12 +39,21 @@ class AnalyzeScaleTool:
     def __init__(self, project_root: str = None) -> None:
         """Initialize the analyze scale tool."""
         # Use unified analysis engine instead of deprecated AdvancedAnalyzer
-        self.project_root = project_root
+        super().__init__(project_root)
         self.analysis_engine = get_analysis_engine(project_root)
-        self.security_validator = SecurityValidator(project_root)
-        self.path_resolver = PathResolver(project_root)
         logger.info("AnalyzeScaleTool initialized with security validation")
 
+    def set_project_path(self, project_path: str) -> None:
+        """
+        Update the project path for all components.
+
+        Args:
+            project_path: New project root directory
+        """
+        super().set_project_path(project_path)
+        self.analysis_engine = get_analysis_engine(project_path)
+        logger.info(f"AnalyzeScaleTool project path updated to: {project_path}")
+
     def _calculate_file_metrics(self, file_path: str) -> dict[str, Any]:
         """
         Calculate basic file metrics including line counts and estimated token count.
@@ -123,7 +138,9 @@ class AnalyzeScaleTool:
 
         # Extract class information with position from unified analysis engine
         classes = [
-            e for e in analysis_result.elements if e.__class__.__name__ == "Class"
+            e
+            for e in analysis_result.elements
+            if is_element_of_type(e, ELEMENT_TYPE_CLASS)
         ]
         for cls in classes:
             class_info = {
@@ -141,7 +158,9 @@ class AnalyzeScaleTool:
 
         # Extract method information with position and complexity from unified analysis engine
         methods = [
-            e for e in analysis_result.elements if e.__class__.__name__ == "Function"
+            e
+            for e in analysis_result.elements
+            if is_element_of_type(e, ELEMENT_TYPE_FUNCTION)
         ]
         for method in methods:
             method_info = {
@@ -174,7 +193,9 @@ class AnalyzeScaleTool:
         # Extract field information with position
         # Extract field information from unified analysis engine
         fields = [
-            e for e in analysis_result.elements if e.__class__.__name__ == "Variable"
+            e
+            for e in analysis_result.elements
+            if is_element_of_type(e, ELEMENT_TYPE_VARIABLE)
         ]
         for field in fields:
             field_info = {
@@ -192,7 +213,9 @@ class AnalyzeScaleTool:
         # Extract import information
         # Extract import information from unified analysis engine
         imports = [
-            e for e in analysis_result.elements if e.__class__.__name__ == "Import"
+            e
+            for e in analysis_result.elements
+            if is_element_of_type(e, ELEMENT_TYPE_IMPORT)
         ]
         for imp in imports:
             import_info = {
@@ -459,7 +482,7 @@ class AnalyzeScaleTool:
                                 for e in (
                                     analysis_result.elements if analysis_result else []
                                 )
-                                if e.__class__.__name__ == "Class"
+                                if is_element_of_type(e, ELEMENT_TYPE_CLASS)
                             ]
                         ),
                         "methods": len(
@@ -468,7 +491,7 @@ class AnalyzeScaleTool:
                                 for e in (
                                     analysis_result.elements if analysis_result else []
                                 )
-                                if e.__class__.__name__ == "Function"
+                                if is_element_of_type(e, ELEMENT_TYPE_FUNCTION)
                             ]
                         ),
                         "fields": len(
@@ -477,7 +500,7 @@ class AnalyzeScaleTool:
                                 for e in (
                                     analysis_result.elements if analysis_result else []
                                 )
-                                if e.__class__.__name__ == "Variable"
+                                if is_element_of_type(e, ELEMENT_TYPE_VARIABLE)
                             ]
                         ),
                         "imports": len(
@@ -486,7 +509,7 @@ class AnalyzeScaleTool:
                                 for e in (
                                     analysis_result.elements if analysis_result else []
                                 )
-                                if e.__class__.__name__ == "Import"
+                                if is_element_of_type(e, ELEMENT_TYPE_IMPORT)
                             ]
                         ),
                         "annotations": len(
@@ -530,7 +553,7 @@ class AnalyzeScaleTool:
                                 for e in (
                                     analysis_result.elements if analysis_result else []
                                 )
-                                if e.__class__.__name__ == "Class"
+                                if is_element_of_type(e, ELEMENT_TYPE_CLASS)
                             ]
                         ],
                         "methods": [
@@ -558,7 +581,7 @@ class AnalyzeScaleTool:
                                 for e in (
                                     analysis_result.elements if analysis_result else []
                                 )
-                                if e.__class__.__name__ == "Function"
+                                if is_element_of_type(e, ELEMENT_TYPE_FUNCTION)
                             ]
                         ],
                         "fields": [
@@ -580,7 +603,7 @@ class AnalyzeScaleTool:
                                 for e in (
                                     analysis_result.elements if analysis_result else []
                                 )
-                                if e.__class__.__name__ == "Variable"
+                                if is_element_of_type(e, ELEMENT_TYPE_VARIABLE)
                             ]
                         ],
                     }
@@ -590,14 +613,14 @@ class AnalyzeScaleTool:
                     [
                         e
                         for e in (analysis_result.elements if analysis_result else [])
-                        if e.__class__.__name__ == "Class"
+                        if is_element_of_type(e, ELEMENT_TYPE_CLASS)
                     ]
                 )
                 methods_count = len(
                     [
                         e
                         for e in (analysis_result.elements if analysis_result else [])
-                        if e.__class__.__name__ == "Function"
+                        if is_element_of_type(e, ELEMENT_TYPE_FUNCTION)
                     ]
                 )
 

tree_sitter_analyzer/mcp/tools/base_tool.py

@@ -2,16 +2,101 @@
 """
 Base Tool Protocol for MCP Tools
 
-This module defines the protocol that all MCP tools must implement
-to ensure type safety and consistency.
+This module defines the base class that all MCP tools should inherit from
+to ensure consistent behavior and project path management.
 """
 
-from typing import Any, Protocol
+from abc import ABC, abstractmethod
+from typing import Any
 
+from ...security import SecurityValidator
+from ...utils import setup_logger
+from ..utils.path_resolver import PathResolver
 
-class MCPTool(Protocol):
+# Set up logging
+logger = setup_logger(__name__)
+
+
+class BaseMCPTool(ABC):
+    """
+    Base class for all MCP tools.
+
+    Provides common functionality including project path management,
+    security validation, and path resolution.
+    """
+
+    def __init__(self, project_root: str | None = None) -> None:
+        """
+        Initialize the base MCP tool.
+
+        Args:
+            project_root: Optional project root directory
+        """
+        self.project_root = project_root
+        self.security_validator = SecurityValidator(project_root)
+        self.path_resolver = PathResolver(project_root)
+        logger.debug(
+            f"{self.__class__.__name__} initialized with project root: {project_root}"
+        )
+
+    def set_project_path(self, project_path: str) -> None:
+        """
+        Update the project path for all components.
+
+        Args:
+            project_path: New project root directory
+        """
+        self.project_root = project_path
+        self.security_validator = SecurityValidator(project_path)
+        self.path_resolver = PathResolver(project_path)
+        logger.info(
+            f"{self.__class__.__name__} project path updated to: {project_path}"
+        )
+
+    @abstractmethod
+    def get_tool_definition(self) -> Any:
+        """
+        Get the MCP tool definition.
+
+        Returns:
+            Tool definition object compatible with MCP server
+        """
+        pass
+
+    @abstractmethod
+    async def execute(self, arguments: dict[str, Any]) -> dict[str, Any]:
+        """
+        Execute the tool with the given arguments.
+
+        Args:
+            arguments: Tool arguments
+
+        Returns:
+            Dictionary containing execution results
+        """
+        pass
+
+    @abstractmethod
+    def validate_arguments(self, arguments: dict[str, Any]) -> bool:
+        """
+        Validate tool arguments.
+
+        Args:
+            arguments: Arguments to validate
+
+        Returns:
+            True if arguments are valid
+
+        Raises:
+            ValueError: If arguments are invalid
+        """
+        pass
+
+
+# Keep the protocol for backward compatibility
+class MCPTool(BaseMCPTool):
     """
-    Protocol for MCP tools.
+    Protocol for MCP tools (deprecated, use BaseMCPTool instead).
 
     All MCP tools must implement this protocol to ensure they have
     the required methods for integration with the MCP server.

tree_sitter_analyzer/mcp/tools/query_tool.py

@@ -11,22 +11,30 @@ from typing import Any
 
 from ...core.query_service import QueryService
 from ...language_detector import detect_language_from_file
-from ...security import SecurityValidator
 from ..utils.error_handler import handle_mcp_errors
-from ..utils.path_resolver import PathResolver
+from .base_tool import BaseMCPTool
 
 logger = logging.getLogger(__name__)
 
 
-class QueryTool:
+class QueryTool(BaseMCPTool):
     """MCP query tool providing tree-sitter query functionality"""
 
     def __init__(self, project_root: str | None = None) -> None:
         """Initialize query tool"""
-        self.project_root = project_root
+        super().__init__(project_root)
         self.query_service = QueryService(project_root)
-        self.security_validator = SecurityValidator(project_root)
-        self.path_resolver = PathResolver(project_root)
+
+    def set_project_path(self, project_path: str) -> None:
+        """
+        Update the project path for all components.
+
+        Args:
+            project_path: New project root directory
+        """
+        super().set_project_path(project_path)
+        self.query_service = QueryService(project_path)
+        logger.info(f"QueryTool project path updated to: {project_path}")
 
     def get_tool_definition(self) -> dict[str, Any]:
         """
@@ -248,3 +256,62 @@ class QueryTool:
             List of available query keys
         """
         return self.query_service.get_available_queries(language)
+
+    def validate_arguments(self, arguments: dict[str, Any]) -> bool:
+        """
+        Validate tool arguments.
+
+        Args:
+            arguments: Arguments to validate
+
+        Returns:
+            True if arguments are valid
+
+        Raises:
+            ValueError: If arguments are invalid
+        """
+        # Check required fields
+        if "file_path" not in arguments:
+            raise ValueError("file_path is required")
+
+        # Validate file_path
+        file_path = arguments["file_path"]
+        if not isinstance(file_path, str):
+            raise ValueError("file_path must be a string")
+        if not file_path.strip():
+            raise ValueError("file_path cannot be empty")
+
+        # Check that either query_key or query_string is provided
+        query_key = arguments.get("query_key")
+        query_string = arguments.get("query_string")
+
+        if not query_key and not query_string:
+            raise ValueError("Either query_key or query_string must be provided")
+
+        # Validate query_key if provided
+        if query_key and not isinstance(query_key, str):
+            raise ValueError("query_key must be a string")
+
+        # Validate query_string if provided
+        if query_string and not isinstance(query_string, str):
+            raise ValueError("query_string must be a string")
+
+        # Validate optional fields
+        if "language" in arguments:
+            language = arguments["language"]
+            if not isinstance(language, str):
+                raise ValueError("language must be a string")
+
+        if "filter" in arguments:
+            filter_expr = arguments["filter"]
+            if not isinstance(filter_expr, str):
+                raise ValueError("filter must be a string")
+
+        if "output_format" in arguments:
+            output_format = arguments["output_format"]
+            if not isinstance(output_format, str):
+                raise ValueError("output_format must be a string")
+            if output_format not in ["json", "summary"]:
+                raise ValueError("output_format must be one of: json, summary")
+
+        return True