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

tree_sitter_analyzer/mcp/tools/read_partial_tool.py

@@ -11,15 +11,14 @@ from pathlib import Path
 from typing import Any
 
 from ...file_handler import read_file_partial
-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 ReadPartialTool:
+class ReadPartialTool(BaseMCPTool):
     """
     MCP Tool for reading partial content from code files.
 
@@ -29,9 +28,7 @@ class ReadPartialTool:
 
     def __init__(self, project_root: str = None) -> None:
         """Initialize the read partial tool."""
-        self.security_validator = SecurityValidator(project_root)
-        self.project_root = project_root
-        self.path_resolver = PathResolver(project_root)
+        super().__init__(project_root)
         logger.info("ReadPartialTool initialized with security validation")
 
     def get_tool_schema(self) -> dict[str, Any]:

tree_sitter_analyzer/mcp/tools/table_format_tool.py

@@ -9,19 +9,26 @@ converting analysis results into structured table formats for better readability
 from pathlib import Path
 from typing import Any
 
+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 AnalysisRequest, get_analysis_engine
 from ...language_detector import detect_language_from_file
-from ...security import SecurityValidator
 from ...table_formatter import TableFormatter
 from ...utils import setup_logger
 from ..utils import get_performance_monitor
-from ..utils.path_resolver import PathResolver
+from .base_tool import BaseMCPTool
 
 # Set up logging
 logger = setup_logger(__name__)
 
 
-class TableFormatTool:
+class TableFormatTool(BaseMCPTool):
     """
     MCP Tool for code structure analysis and table formatting.
 
@@ -31,12 +38,21 @@ class TableFormatTool:
 
     def __init__(self, project_root: str = None) -> None:
         """Initialize the table format tool."""
-        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)
         self.logger = logger
 
+    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"TableFormatTool project path updated to: {project_path}")
+
     def get_tool_schema(self) -> dict[str, Any]:
         """
         Get the MCP tool schema for analyze_code_structure.
@@ -178,11 +194,21 @@ class TableFormatTool:
     def _convert_analysis_result_to_dict(self, result: Any) -> dict[str, Any]:
         """Convert AnalysisResult to dictionary format expected by TableFormatter"""
         # Extract elements by type
-        classes = [e for e in result.elements if e.__class__.__name__ == "Class"]
-        methods = [e for e in result.elements if e.__class__.__name__ == "Function"]
-        fields = [e for e in result.elements if e.__class__.__name__ == "Variable"]
-        imports = [e for e in result.elements if e.__class__.__name__ == "Import"]
-        packages = [e for e in result.elements if e.__class__.__name__ == "Package"]
+        classes = [
+            e for e in result.elements if is_element_of_type(e, ELEMENT_TYPE_CLASS)
+        ]
+        methods = [
+            e for e in result.elements if is_element_of_type(e, ELEMENT_TYPE_FUNCTION)
+        ]
+        fields = [
+            e for e in result.elements if is_element_of_type(e, ELEMENT_TYPE_VARIABLE)
+        ]
+        imports = [
+            e for e in result.elements if is_element_of_type(e, ELEMENT_TYPE_IMPORT)
+        ]
+        packages = [
+            e for e in result.elements if is_element_of_type(e, ELEMENT_TYPE_PACKAGE)
+        ]
 
         # Convert package to expected format
         package_info = None

tree_sitter_analyzer/mcp/tools/universal_analyze_tool.py

@@ -3,25 +3,32 @@
 Universal Analyze Tool for MCP
 
 This tool provides universal code analysis capabilities through the MCP protocol,
-supporting multiple languages with both basic and detailed analysis options.
+supporting multiple programming languages with automatic language detection.
 """
 
 from pathlib import Path
 from typing import Any
 
+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 AnalysisRequest, get_analysis_engine
 from ...language_detector import detect_language_from_file, is_language_supported
-from ...security import SecurityValidator
+from ...mcp.utils import get_performance_monitor
 from ...utils import setup_logger
-from ..utils import get_performance_monitor
 from ..utils.error_handler import handle_mcp_errors
-from ..utils.path_resolver import PathResolver
+from .base_tool import BaseMCPTool
 
 # Set up logging
 logger = setup_logger(__name__)
 
 
-class UniversalAnalyzeTool:
+class UniversalAnalyzeTool(BaseMCPTool):
     """
     Universal MCP Tool for code analysis across multiple languages.
 
@@ -31,12 +38,21 @@ class UniversalAnalyzeTool:
 
     def __init__(self, project_root: str | None = None) -> None:
         """Initialize the universal analyze tool."""
-        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("UniversalAnalyzeTool 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"UniversalAnalyzeTool project path updated to: {project_path}")
+
     def get_tool_definition(self) -> dict[str, Any]:
         """
         Get MCP tool definition for universal code analysis
@@ -304,31 +320,75 @@ class UniversalAnalyzeTool:
                         [
                             e
                             for e in analysis_result.elements
-                            if e.__class__.__name__ == "Class"
+                            if is_element_of_type(e, ELEMENT_TYPE_CLASS)
                         ]
                     ),
                     "methods": len(
                         [
                             e
                             for e in analysis_result.elements
-                            if e.__class__.__name__ == "Function"
+                            if is_element_of_type(e, ELEMENT_TYPE_FUNCTION)
                         ]
                     ),
                     "fields": len(
                         [
                             e
                             for e in analysis_result.elements
-                            if e.__class__.__name__ == "Variable"
+                            if is_element_of_type(e, ELEMENT_TYPE_VARIABLE)
                         ]
                     ),
                     "imports": len(
                         [
                             e
                             for e in analysis_result.elements
-                            if e.__class__.__name__ == "Import"
+                            if is_element_of_type(e, ELEMENT_TYPE_IMPORT)
                         ]
                     ),
                     "annotations": len(getattr(analysis_result, "annotations", [])),
+                    "packages": len(
+                        [
+                            e
+                            for e in analysis_result.elements
+                            if is_element_of_type(e, ELEMENT_TYPE_PACKAGE)
+                        ]
+                    ),
+                    "total": (
+                        len(
+                            [
+                                e
+                                for e in analysis_result.elements
+                                if is_element_of_type(e, ELEMENT_TYPE_CLASS)
+                            ]
+                        )
+                        + len(
+                            [
+                                e
+                                for e in analysis_result.elements
+                                if is_element_of_type(e, ELEMENT_TYPE_FUNCTION)
+                            ]
+                        )
+                        + len(
+                            [
+                                e
+                                for e in analysis_result.elements
+                                if is_element_of_type(e, ELEMENT_TYPE_VARIABLE)
+                            ]
+                        )
+                        + len(
+                            [
+                                e
+                                for e in analysis_result.elements
+                                if is_element_of_type(e, ELEMENT_TYPE_IMPORT)
+                            ]
+                        )
+                        + len(
+                            [
+                                e
+                                for e in analysis_result.elements
+                                if is_element_of_type(e, ELEMENT_TYPE_PACKAGE)
+                            ]
+                        )
+                    ),
                 },
             }
         }
@@ -339,7 +399,9 @@ class UniversalAnalyzeTool:
 
         # Add complexity metrics
         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)
         ]
         total_complexity = sum(
             getattr(method, "complexity_score", 0) or 0 for method in methods
@@ -347,7 +409,7 @@ class UniversalAnalyzeTool:
 
         basic["metrics"]["complexity"] = {
             "total": total_complexity,
-            "average": (total_complexity / len(methods) if methods else 0),
+            "average": round(total_complexity / len(methods) if methods else 0, 2),
             "max": max(
                 (getattr(method, "complexity_score", 0) or 0 for method in methods),
                 default=0,
@@ -372,7 +434,7 @@ class UniversalAnalyzeTool:
                     for cls in [
                         e
                         for e in analysis_result.elements
-                        if e.__class__.__name__ == "Class"
+                        if is_element_of_type(e, ELEMENT_TYPE_CLASS)
                     ]
                 ],
                 "methods": [
@@ -384,7 +446,7 @@ class UniversalAnalyzeTool:
                     for method in [
                         e
                         for e in analysis_result.elements
-                        if e.__class__.__name__ == "Function"
+                        if is_element_of_type(e, ELEMENT_TYPE_FUNCTION)
                     ]
                 ],
                 "fields": [
@@ -396,7 +458,7 @@ class UniversalAnalyzeTool:
                     for field in [
                         e
                         for e in analysis_result.elements
-                        if e.__class__.__name__ == "Variable"
+                        if is_element_of_type(e, ELEMENT_TYPE_VARIABLE)
                     ]
                 ],
                 "imports": [
@@ -408,7 +470,7 @@ class UniversalAnalyzeTool:
                     for imp in [
                         e
                         for e in analysis_result.elements
-                        if e.__class__.__name__ == "Import"
+                        if is_element_of_type(e, ELEMENT_TYPE_IMPORT)
                     ]
                 ],
                 "annotations": [
@@ -446,16 +508,34 @@ class UniversalAnalyzeTool:
                 "lines_blank": 0,  # Not available in universal analyzer
                 "elements": {
                     "classes": len(
-                        [e for e in elements if e.get("__class__", "") == "Class"]
+                        [
+                            e
+                            for e in elements
+                            if hasattr(e, "element_type") and e.element_type == "class"
+                        ]
                     ),
                     "methods": len(
-                        [e for e in elements if e.get("__class__", "") == "Function"]
+                        [
+                            e
+                            for e in elements
+                            if hasattr(e, "element_type")
+                            and e.element_type == "function"
+                        ]
                     ),
                     "fields": len(
-                        [e for e in elements if e.get("__class__", "") == "Variable"]
+                        [
+                            e
+                            for e in elements
+                            if hasattr(e, "element_type")
+                            and e.element_type == "variable"
+                        ]
                     ),
                     "imports": len(
-                        [e for e in elements if e.get("__class__", "") == "Import"]
+                        [
+                            e
+                            for e in elements
+                            if hasattr(e, "element_type") and e.element_type == "import"
+                        ]
                     ),
                     "annotations": 0,  # Not available in universal analyzer
                 },

tree_sitter_analyzer/models.py

@@ -11,6 +11,16 @@ from collections.abc import Callable
 from dataclasses import dataclass, field
 from typing import TYPE_CHECKING, Any
 
+from .constants import (
+    ELEMENT_TYPE_ANNOTATION,
+    ELEMENT_TYPE_CLASS,
+    ELEMENT_TYPE_FUNCTION,
+    ELEMENT_TYPE_IMPORT,
+    ELEMENT_TYPE_PACKAGE,
+    ELEMENT_TYPE_VARIABLE,
+    is_element_of_type,
+)
+
 if TYPE_CHECKING:
     pass
 
@@ -276,45 +286,64 @@ class AnalysisResult:
     )  # Query results for new architecture
     source_code: str = ""  # Source code for new architecture
     package: JavaPackage | None = None
-    imports: list[JavaImport] = field(default_factory=list)
-    classes: list[JavaClass] = field(default_factory=list)
-    methods: list[JavaMethod] = field(default_factory=list)
-    fields: list[JavaField] = field(default_factory=list)
-    annotations: list[JavaAnnotation] = field(default_factory=list)
+    # Legacy fields removed - use elements list instead
+    # imports: list[JavaImport] = field(default_factory=list)
+    # classes: list[JavaClass] = field(default_factory=list)
+    # methods: list[JavaMethod] = field(default_factory=list)
+    # fields: list[JavaField] = field(default_factory=list)
+    # annotations: list[JavaAnnotation] = field(default_factory=list)
     analysis_time: float = 0.0
     success: bool = True
     error_message: str | None = None
 
     def to_dict(self) -> dict[str, Any]:
-        """Convert analysis result to dictionary for serialization"""
+        """Convert analysis result to dictionary for serialization using unified elements"""
+        # Use unified elements list for consistent data structure
+        elements = self.elements or []
+
+        # Extract elements by type from unified list using constants
+        classes = [e for e in elements if is_element_of_type(e, ELEMENT_TYPE_CLASS)]
+        methods = [e for e in elements if is_element_of_type(e, ELEMENT_TYPE_FUNCTION)]
+        fields = [e for e in elements if is_element_of_type(e, ELEMENT_TYPE_VARIABLE)]
+        imports = [e for e in elements if is_element_of_type(e, ELEMENT_TYPE_IMPORT)]
+        packages = [e for e in elements if is_element_of_type(e, ELEMENT_TYPE_PACKAGE)]
+
         return {
             "file_path": self.file_path,
             "line_count": self.line_count,
-            "package": {"name": self.package.name} if self.package else None,
+            "package": {"name": packages[0].name} if packages else None,
             "imports": [
                 {
                     "name": imp.name,
-                    "is_static": imp.is_static,
-                    "is_wildcard": imp.is_wildcard,
+                    "is_static": getattr(imp, "is_static", False),
+                    "is_wildcard": getattr(imp, "is_wildcard", False),
                 }
-                for imp in self.imports
+                for imp in imports
             ],
             "classes": [
-                {"name": cls.name, "type": cls.class_type, "package": cls.package_name}
-                for cls in self.classes
+                {
+                    "name": cls.name,
+                    "type": getattr(cls, "class_type", "class"),
+                    "package": getattr(cls, "package_name", None),
+                }
+                for cls in classes
             ],
             "methods": [
                 {
                     "name": method.name,
-                    "return_type": method.return_type,
-                    "parameters": method.parameters,
+                    "return_type": getattr(method, "return_type", None),
+                    "parameters": getattr(method, "parameters", []),
                 }
-                for method in self.methods
+                for method in methods
             ],
             "fields": [
-                {"name": field.name, "type": field.field_type} for field in self.fields
+                {"name": field.name, "type": getattr(field, "field_type", None)}
+                for field in fields
+            ],
+            "annotations": [
+                {"name": getattr(ann, "name", str(ann))}
+                for ann in getattr(self, "annotations", [])
             ],
-            "annotations": [{"name": ann.name} for ann in self.annotations],
             "analysis_time": self.analysis_time,
             "success": self.success,
             "error_message": self.error_message,
@@ -322,40 +351,56 @@ class AnalysisResult:
 
     def to_summary_dict(self, types: list[str] | None = None) -> dict[str, Any]:
         """
-        Return analysis summary as a dictionary.
+        Return analysis summary as a dictionary using unified elements.
         Only include specified element types (e.g., 'classes', 'methods', 'fields').
         """
         if types is None:
             types = ["classes", "methods"]  # default
 
         summary: dict[str, Any] = {"file_path": self.file_path, "summary_elements": []}
-
-        all_elements: dict[str, list[Any]] = {
-            "imports": self.imports,
-            "classes": self.classes,
-            "methods": self.methods,
-            "fields": self.fields,
-            "annotations": self.annotations,
+        elements = self.elements or []
+
+        # Map type names to element_type constants
+        type_mapping = {
+            "imports": ELEMENT_TYPE_IMPORT,
+            "classes": ELEMENT_TYPE_CLASS,
+            "methods": ELEMENT_TYPE_FUNCTION,
+            "fields": ELEMENT_TYPE_VARIABLE,
+            "annotations": ELEMENT_TYPE_ANNOTATION,
         }
 
-        for type_name, elements in all_elements.items():
+        for type_name, element_type in type_mapping.items():
             if "all" in types or type_name in types:
-                for element in elements:
+                type_elements = [
+                    e for e in elements if is_element_of_type(e, element_type)
+                ]
+                for element in type_elements:
                     # Call each element model's to_summary_item()
                     summary["summary_elements"].append(element.to_summary_item())
 
         return summary
 
     def get_summary(self) -> dict[str, Any]:
-        """Get analysis summary statistics"""
+        """Get analysis summary statistics using unified elements"""
+        elements = self.elements or []
+
+        # Count elements by type from unified list using constants
+        classes = [e for e in elements if is_element_of_type(e, ELEMENT_TYPE_CLASS)]
+        methods = [e for e in elements if is_element_of_type(e, ELEMENT_TYPE_FUNCTION)]
+        fields = [e for e in elements if is_element_of_type(e, ELEMENT_TYPE_VARIABLE)]
+        imports = [e for e in elements if is_element_of_type(e, ELEMENT_TYPE_IMPORT)]
+        annotations = [
+            e for e in elements if is_element_of_type(e, ELEMENT_TYPE_ANNOTATION)
+        ]
+
         return {
             "file_path": self.file_path,
             "line_count": self.line_count,
-            "class_count": len(self.classes),
-            "method_count": len(self.methods),
-            "field_count": len(self.fields),
-            "import_count": len(self.imports),
-            "annotation_count": len(self.annotations),
+            "class_count": len(classes),
+            "method_count": len(methods),
+            "field_count": len(fields),
+            "import_count": len(imports),
+            "annotation_count": len(annotations),
             "success": self.success,
             "analysis_time": self.analysis_time,
         }
@@ -400,7 +445,11 @@ class AnalysisResult:
                             "end": safe_get_attr(imp, "end_line", 0),
                         },
                     }
-                    for imp in self.imports
+                    for imp in [
+                        e
+                        for e in (self.elements or [])
+                        if is_element_of_type(e, ELEMENT_TYPE_IMPORT)
+                    ]
                 ],
                 "classes": [
                     {
@@ -412,7 +461,11 @@ class AnalysisResult:
                             "end": safe_get_attr(cls, "end_line", 0),
                         },
                     }
-                    for cls in self.classes
+                    for cls in [
+                        e
+                        for e in (self.elements or [])
+                        if is_element_of_type(e, ELEMENT_TYPE_CLASS)
+                    ]
                 ],
                 "methods": [
                     {
@@ -424,7 +477,11 @@ class AnalysisResult:
                             "end": safe_get_attr(method, "end_line", 0),
                         },
                     }
-                    for method in self.methods
+                    for method in [
+                        e
+                        for e in (self.elements or [])
+                        if is_element_of_type(e, ELEMENT_TYPE_FUNCTION)
+                    ]
                 ],
                 "fields": [
                     {
@@ -435,7 +492,11 @@ class AnalysisResult:
                             "end": safe_get_attr(field, "end_line", 0),
                         },
                     }
-                    for field in self.fields
+                    for field in [
+                        e
+                        for e in (self.elements or [])
+                        if is_element_of_type(e, ELEMENT_TYPE_VARIABLE)
+                    ]
                 ],
                 "annotations": [
                     {
@@ -445,16 +506,50 @@ class AnalysisResult:
                             "end": safe_get_attr(ann, "end_line", 0),
                         },
                     }
-                    for ann in self.annotations
+                    for ann in [
+                        e
+                        for e in (self.elements or [])
+                        if is_element_of_type(e, ELEMENT_TYPE_ANNOTATION)
+                    ]
                 ],
             },
             "metadata": {
                 "line_count": self.line_count,
-                "class_count": len(self.classes),
-                "method_count": len(self.methods),
-                "field_count": len(self.fields),
-                "import_count": len(self.imports),
-                "annotation_count": len(self.annotations),
+                "class_count": len(
+                    [
+                        e
+                        for e in (self.elements or [])
+                        if is_element_of_type(e, ELEMENT_TYPE_CLASS)
+                    ]
+                ),
+                "method_count": len(
+                    [
+                        e
+                        for e in (self.elements or [])
+                        if is_element_of_type(e, ELEMENT_TYPE_FUNCTION)
+                    ]
+                ),
+                "field_count": len(
+                    [
+                        e
+                        for e in (self.elements or [])
+                        if is_element_of_type(e, ELEMENT_TYPE_VARIABLE)
+                    ]
+                ),
+                "import_count": len(
+                    [
+                        e
+                        for e in (self.elements or [])
+                        if is_element_of_type(e, ELEMENT_TYPE_IMPORT)
+                    ]
+                ),
+                "annotation_count": len(
+                    [
+                        e
+                        for e in (self.elements or [])
+                        if is_element_of_type(e, ELEMENT_TYPE_ANNOTATION)
+                    ]
+                ),
                 "analysis_time": self.analysis_time,
                 "success": self.success,
                 "error_message": self.error_message,

tree_sitter_analyzer/security/boundary_manager.py

@@ -39,18 +39,38 @@ class ProjectBoundaryManager:
         if not project_root:
             raise SecurityError("Project root cannot be empty")
 
-        project_path = Path(project_root)
-        if not project_path.exists():
-            raise SecurityError(f"Project root does not exist: {project_root}")
+        try:
+            project_path = Path(project_root)
+
+            # Handle both string and Path objects
+            if isinstance(project_root, str):
+                project_path = Path(project_root)
+            elif isinstance(project_root, Path):
+                project_path = project_root
+            else:
+                raise SecurityError(f"Invalid project root type: {type(project_root)}")
 
-        if not project_path.is_dir():
-            raise SecurityError(f"Project root is not a directory: {project_root}")
+            # Ensure the path exists and is a directory
+            if not project_path.exists():
+                raise SecurityError(f"Project root does not exist: {project_root}")
 
-        # Store real path to prevent symlink attacks
-        self.project_root = str(project_path.resolve())
-        self.allowed_directories: set[str] = {self.project_root}
+            if not project_path.is_dir():
+                raise SecurityError(f"Project root is not a directory: {project_root}")
 
-        log_debug(f"ProjectBoundaryManager initialized with root: {self.project_root}")
+            # Store real path to prevent symlink attacks
+            self.project_root = str(project_path.resolve())
+            self.allowed_directories: set[str] = {self.project_root}
+
+            log_debug(
+                f"ProjectBoundaryManager initialized with root: {self.project_root}"
+            )
+
+        except Exception as e:
+            if isinstance(e, SecurityError):
+                raise
+            raise SecurityError(
+                f"Failed to initialize ProjectBoundaryManager: {e}"
+            ) from e
 
     def add_allowed_directory(self, directory: str) -> None:
         """