tree-sitter-analyzer 1.7.5__py3-none-any.whl → 1.8.2__py3-none-any.whl

tree_sitter_analyzer/languages/typescript_plugin.py

@@ -1726,4 +1726,133 @@ class TypeScriptPlugin(LanguagePlugin):
         all_elements.extend(extractor.extract_variables(tree, source_code))
         all_elements.extend(extractor.extract_imports(tree, source_code))
         
-        return all_elements
+        return all_elements
+
+    def execute_query_strategy(self, tree: "tree_sitter.Tree", source_code: str, query_key: str) -> list[CodeElement]:
+        """Execute TypeScript-specific query strategy based on query_key"""
+        if not tree or not source_code:
+            return []
+
+        # Initialize extractor with source code
+        self._extractor.source_code = source_code
+        self._extractor.content_lines = source_code.split("\n")
+        self._extractor._reset_caches()
+        self._extractor._detect_file_characteristics()
+
+        # Map query_key to appropriate extraction method
+        query_mapping = {
+            # Function-related queries
+            "function": lambda: self._extractor.extract_functions(tree, source_code),
+            "async_function": lambda: [f for f in self._extractor.extract_functions(tree, source_code) if getattr(f, 'is_async', False)],
+            "arrow_function": lambda: [f for f in self._extractor.extract_functions(tree, source_code) if getattr(f, 'is_arrow', False)],
+            "method": lambda: [f for f in self._extractor.extract_functions(tree, source_code) if getattr(f, 'is_method', False)],
+            "constructor": lambda: [f for f in self._extractor.extract_functions(tree, source_code) if getattr(f, 'is_constructor', False)],
+            "signature": lambda: [f for f in self._extractor.extract_functions(tree, source_code) if getattr(f, 'is_signature', False)],
+            
+            # Class-related queries
+            "class": lambda: self._extractor.extract_classes(tree, source_code),
+            "interface": lambda: [c for c in self._extractor.extract_classes(tree, source_code) if getattr(c, 'class_type', '') == 'interface'],
+            "type_alias": lambda: [c for c in self._extractor.extract_classes(tree, source_code) if getattr(c, 'class_type', '') == 'type'],
+            "enum": lambda: [c for c in self._extractor.extract_classes(tree, source_code) if getattr(c, 'class_type', '') == 'enum'],
+            
+            # Variable-related queries
+            "variable": lambda: self._extractor.extract_variables(tree, source_code),
+            
+            # Import/Export queries
+            "import": lambda: self._extractor.extract_imports(tree, source_code),
+            "export": lambda: [i for i in self._extractor.extract_imports(tree, source_code) if 'export' in getattr(i, 'raw_text', '')],
+            
+            # TypeScript-specific queries
+            "generic": lambda: [c for c in self._extractor.extract_classes(tree, source_code) if 'generics' in getattr(c, 'raw_text', '')],
+            "decorator": lambda: [f for f in self._extractor.extract_functions(tree, source_code) if '@' in getattr(f, 'raw_text', '')],
+            
+            # Framework-specific queries
+            "react_component": lambda: [c for c in self._extractor.extract_classes(tree, source_code) if getattr(c, 'is_react_component', False)],
+            "angular_component": lambda: [c for c in self._extractor.extract_classes(tree, source_code) if getattr(c, 'framework_type', '') == 'angular'],
+            "vue_component": lambda: [c for c in self._extractor.extract_classes(tree, source_code) if getattr(c, 'framework_type', '') == 'vue'],
+        }
+
+        # Execute the appropriate extraction method
+        if query_key in query_mapping:
+            try:
+                return query_mapping[query_key]()
+            except Exception as e:
+                log_error(f"Error executing TypeScript query '{query_key}': {e}")
+                return []
+        else:
+            log_warning(f"Unsupported TypeScript query key: {query_key}")
+            return []
+
+    def get_element_categories(self) -> dict[str, list[str]]:
+        """Get TypeScript element categories mapping query_key to node_types"""
+        return {
+            # Function-related categories
+            "function": [
+                "function_declaration",
+                "function_expression",
+                "arrow_function",
+                "generator_function_declaration"
+            ],
+            "async_function": [
+                "function_declaration",
+                "function_expression",
+                "arrow_function",
+                "method_definition"
+            ],
+            "arrow_function": ["arrow_function"],
+            "method": [
+                "method_definition",
+                "method_signature"
+            ],
+            "constructor": ["method_definition"],
+            "signature": ["method_signature"],
+            
+            # Class-related categories
+            "class": [
+                "class_declaration",
+                "abstract_class_declaration"
+            ],
+            "interface": ["interface_declaration"],
+            "type_alias": ["type_alias_declaration"],
+            "enum": ["enum_declaration"],
+            
+            # Variable-related categories
+            "variable": [
+                "variable_declaration",
+                "lexical_declaration",
+                "property_definition",
+                "property_signature"
+            ],
+            
+            # Import/Export categories
+            "import": ["import_statement"],
+            "export": [
+                "export_statement",
+                "export_declaration"
+            ],
+            
+            # TypeScript-specific categories
+            "generic": [
+                "type_parameters",
+                "type_parameter"
+            ],
+            "decorator": [
+                "decorator",
+                "decorator_call_expression"
+            ],
+            
+            # Framework-specific categories
+            "react_component": [
+                "class_declaration",
+                "function_declaration",
+                "arrow_function"
+            ],
+            "angular_component": [
+                "class_declaration",
+                "decorator"
+            ],
+            "vue_component": [
+                "class_declaration",
+                "function_declaration"
+            ]
+        }

tree_sitter_analyzer/mcp/tools/analyze_scale_tool.py

@@ -379,19 +379,27 @@ class AnalyzeScaleTool(BaseMCPTool):
         include_details = arguments.get("include_details", False)
         include_guidance = arguments.get("include_guidance", True)
 
+        # Security validation BEFORE path resolution to catch symlinks
+        is_valid, error_msg = self.security_validator.validate_file_path(file_path)
+        if not is_valid:
+            logger.warning(
+                f"Security validation failed for file path: {file_path} - {error_msg}"
+            )
+            raise ValueError(f"Invalid file path: {error_msg}")
+
         # Resolve file path to absolute path
         resolved_file_path = self.path_resolver.resolve(file_path)
         logger.info(f"Analyzing file: {file_path} (resolved to: {resolved_file_path})")
 
-        # Security validation using resolved path
+        # Additional security validation on resolved path
         is_valid, error_msg = self.security_validator.validate_file_path(
             resolved_file_path
         )
         if not is_valid:
             logger.warning(
-                f"Security validation failed for file path: {resolved_file_path} - {error_msg}"
+                f"Security validation failed for resolved path: {resolved_file_path} - {error_msg}"
             )
-            raise ValueError(f"Invalid file path: {error_msg}")
+            raise ValueError(f"Invalid resolved path: {error_msg}")
 
         # Sanitize inputs
         if language:
@@ -423,6 +431,12 @@ class AnalyzeScaleTool(BaseMCPTool):
                 # Calculate basic file metrics
                 file_metrics = self._calculate_file_metrics(resolved_file_path)
 
+                # Handle JSON files specially - they don't need structural analysis
+                if language == "json":
+                    return self._create_json_file_analysis(
+                        resolved_file_path, file_metrics, include_guidance
+                    )
+
                 # Use appropriate analyzer based on language
                 if language == "java":
                     # Use AdvancedAnalyzer for comprehensive analysis
@@ -472,6 +486,7 @@ class AnalyzeScaleTool(BaseMCPTool):
 
                 # Build enhanced result structure
                 result = {
+                    "success": True,
                     "file_path": file_path,
                     "language": language,
                     "file_metrics": file_metrics,
@@ -688,6 +703,56 @@ class AnalyzeScaleTool(BaseMCPTool):
 
         return True
 
+    def _create_json_file_analysis(
+        self, file_path: str, file_metrics: dict[str, Any], include_guidance: bool
+    ) -> dict[str, Any]:
+        """
+        Create analysis result for JSON files.
+        
+        Args:
+            file_path: Path to the JSON file
+            file_metrics: Basic file metrics
+            include_guidance: Whether to include guidance
+            
+        Returns:
+            Analysis result for JSON file
+        """
+        result = {
+            "success": True,
+            "file_path": file_path,
+            "language": "json",
+            "file_size_bytes": file_metrics["file_size_bytes"],
+            "total_lines": file_metrics["total_lines"],
+            "non_empty_lines": file_metrics["total_lines"] - file_metrics["blank_lines"],
+            "estimated_tokens": file_metrics["estimated_tokens"],
+            "complexity_metrics": {
+                "total_elements": 0,
+                "max_depth": 0,
+                "avg_complexity": 0.0,
+            },
+            "structural_overview": {
+                "classes": [],
+                "methods": [],
+                "fields": [],
+            },
+            "scale_category": "small" if file_metrics["total_lines"] < 100 else "medium" if file_metrics["total_lines"] < 1000 else "large",
+            "analysis_recommendations": {
+                "suitable_for_full_analysis": file_metrics["total_lines"] < 1000,
+                "recommended_approach": "JSON files are configuration/data files - structural analysis not applicable",
+                "token_efficiency_notes": "JSON files can be read directly without tree-sitter parsing",
+            },
+        }
+        
+        if include_guidance:
+            result["llm_analysis_guidance"] = {
+                "file_characteristics": "JSON configuration/data file",
+                "recommended_workflow": "Direct file reading for content analysis",
+                "token_optimization": "Use simple file reading tools for JSON content",
+                "analysis_focus": "Data structure and configuration values",
+            }
+            
+        return result
+
     def get_tool_definition(self) -> dict[str, Any]:
         """
         Get the MCP tool definition for check_code_scale.

tree_sitter_analyzer/mcp/tools/fd_rg_utils.py

@@ -11,6 +11,7 @@ from __future__ import annotations
 import asyncio
 import json
 import os
+import shutil
 import tempfile
 from dataclasses import dataclass
 from pathlib import Path
@@ -27,6 +28,21 @@ DEFAULT_RG_TIMEOUT_MS = 4000
 RG_TIMEOUT_HARD_CAP_MS = 30000
 
 
+def check_external_command(command: str) -> bool:
+    """Check if an external command is available in the system PATH."""
+    return shutil.which(command) is not None
+
+
+def get_missing_commands() -> list[str]:
+    """Get list of missing external commands required by fd/rg tools."""
+    missing = []
+    if not check_external_command("fd"):
+        missing.append("fd")
+    if not check_external_command("rg"):
+        missing.append("rg")
+    return missing
+
+
 def clamp_int(value: int | None, default_value: int, hard_cap: int) -> int:
     if value is None:
         return default_value
@@ -64,13 +80,22 @@ async def run_command_capture(
     Returns (returncode, stdout, stderr). On timeout, kills process and returns 124.
     Separated into a util for easy monkeypatching in tests.
     """
-    # Create process
-    proc = await asyncio.create_subprocess_exec(
-        *cmd,
-        stdin=asyncio.subprocess.PIPE if input_data is not None else None,
-        stdout=asyncio.subprocess.PIPE,
-        stderr=asyncio.subprocess.PIPE,
-    )
+    # Check if command exists before attempting to run
+    if cmd and not check_external_command(cmd[0]):
+        error_msg = f"Command '{cmd[0]}' not found in PATH. Please install {cmd[0]} to use this functionality."
+        return 127, b"", error_msg.encode()
+    
+    try:
+        # Create process
+        proc = await asyncio.create_subprocess_exec(
+            *cmd,
+            stdin=asyncio.subprocess.PIPE if input_data is not None else None,
+            stdout=asyncio.subprocess.PIPE,
+            stderr=asyncio.subprocess.PIPE,
+        )
+    except FileNotFoundError as e:
+        error_msg = f"Command '{cmd[0]}' not found: {e}"
+        return 127, b"", error_msg.encode()
 
     # Compute timeout seconds
     timeout_s: float | None = None

tree_sitter_analyzer/mcp/tools/find_and_grep_tool.py

@@ -239,6 +239,16 @@ class FindAndGrepTool(BaseMCPTool):
 
     @handle_mcp_errors("find_and_grep")
     async def execute(self, arguments: dict[str, Any]) -> dict[str, Any]:
+        # Check if both fd and rg commands are available
+        missing_commands = fd_rg_utils.get_missing_commands()
+        if missing_commands:
+            return {
+                "success": False,
+                "error": f"Required commands not found: {', '.join(missing_commands)}. Please install fd (https://github.com/sharkdp/fd) and ripgrep (https://github.com/BurntSushi/ripgrep) to use this tool.",
+                "count": 0,
+                "results": []
+            }
+        
         self.validate_arguments(arguments)
         roots = self._validate_roots(arguments["roots"])  # absolute validated
 

tree_sitter_analyzer/mcp/tools/list_files_tool.py

@@ -181,6 +181,15 @@ class ListFilesTool(BaseMCPTool):
 
     @handle_mcp_errors("list_files")
     async def execute(self, arguments: dict[str, Any]) -> dict[str, Any]:
+        # Check if fd command is available
+        if not fd_rg_utils.check_external_command("fd"):
+            return {
+                "success": False,
+                "error": "fd command not found. Please install fd (https://github.com/sharkdp/fd) to use this tool.",
+                "count": 0,
+                "results": []
+            }
+        
         self.validate_arguments(arguments)
         roots = self._validate_roots(arguments["roots"])  # normalized absolutes
 

tree_sitter_analyzer/mcp/tools/query_tool.py

@@ -97,7 +97,6 @@ class QueryTool(BaseMCPTool):
             },
         }
 
-    @handle_mcp_errors("query_code")
     async def execute(self, arguments: dict[str, Any]) -> dict[str, Any]:
         """
         Execute query tool
@@ -108,46 +107,78 @@ class QueryTool(BaseMCPTool):
         Returns:
             Query results
         """
-        # Validate input parameters
-        file_path = arguments.get("file_path")
-        if not file_path:
-            raise ValueError("file_path is required")
+        try:
+            # Validate input parameters - check for empty arguments first
+            if not arguments:
+                from ..utils.error_handler import AnalysisError
+                raise AnalysisError(
+                    "file_path is required",
+                    operation="query_code"
+                )
+                
+            file_path = arguments.get("file_path")
+            if not file_path:
+                from ..utils.error_handler import AnalysisError
+                raise AnalysisError(
+                    "file_path is required",
+                    operation="query_code"
+                )
+
+            # Check that either query_key or query_string is provided early
+            query_key = arguments.get("query_key")
+            query_string = arguments.get("query_string")
+            
+            if not query_key and not query_string:
+                from ..utils.error_handler import AnalysisError
+                raise AnalysisError(
+                    "Either query_key or query_string must be provided",
+                    operation="query_code"
+                )
+
+            # Security validation BEFORE path resolution to catch symlinks
+            is_valid, error_msg = self.security_validator.validate_file_path(file_path)
+            if not is_valid:
+                return {
+                    "success": False,
+                    "error": f"Invalid or unsafe file path: {error_msg or file_path}"
+                }
 
-        # Resolve file path to absolute path
-        resolved_file_path = self.path_resolver.resolve(file_path)
-        logger.info(f"Querying file: {file_path} (resolved to: {resolved_file_path})")
-
-        # Security validation using resolved path
-        is_valid, error_msg = self.security_validator.validate_file_path(
-            resolved_file_path
-        )
-        if not is_valid:
-            raise ValueError(
-                f"Invalid or unsafe file path: {error_msg or resolved_file_path}"
-            )
+            # Resolve file path to absolute path
+            resolved_file_path = self.path_resolver.resolve(file_path)
+            logger.info(f"Querying file: {file_path} (resolved to: {resolved_file_path})")
 
-        # Get query parameters
-        query_key = arguments.get("query_key")
-        query_string = arguments.get("query_string")
-        filter_expression = arguments.get("filter")
-        output_format = arguments.get("output_format", "json")
-        output_file = arguments.get("output_file")
-        suppress_output = arguments.get("suppress_output", False)
+            # Additional security validation on resolved path
+            is_valid, error_msg = self.security_validator.validate_file_path(
+                resolved_file_path
+            )
+            if not is_valid:
+                return {
+                    "success": False,
+                    "error": f"Invalid or unsafe resolved path: {error_msg or resolved_file_path}"
+                }
 
-        if not query_key and not query_string:
-            raise ValueError("Either query_key or query_string must be provided")
+            # Get query parameters (already validated above)
+            filter_expression = arguments.get("filter")
+            output_format = arguments.get("output_format", "json")
+            output_file = arguments.get("output_file")
+            suppress_output = arguments.get("suppress_output", False)
 
-        if query_key and query_string:
-            raise ValueError("Cannot provide both query_key and query_string")
+            if query_key and query_string:
+                return {
+                    "success": False,
+                    "error": "Cannot provide both query_key and query_string"
+                }
 
-        # Detect language
-        language = arguments.get("language")
-        if not language:
-            language = detect_language_from_file(resolved_file_path)
+            # Detect language
+            language = arguments.get("language")
             if not language:
-                raise ValueError(f"Could not detect language for file: {file_path}")
+                language = detect_language_from_file(resolved_file_path)
+                if not language:
+                    return {
+                        "success": False,
+                        "error": f"Could not detect language for file: {file_path}"
+                    }
 
-        try:
             # Execute query
             results = await self.query_service.execute_query(
                 resolved_file_path, language, query_key, query_string, filter_expression
@@ -163,7 +194,9 @@ class QueryTool(BaseMCPTool):
 
             # Format output
             if output_format == "summary":
-                formatted_result = self._format_summary(results, query_key or "custom", language)
+                formatted_result = self._format_summary(
+                    results, query_key or "custom", language
+                )
             else:
                 formatted_result = {
                     "success": True,
@@ -178,28 +211,31 @@ class QueryTool(BaseMCPTool):
             if output_file:
                 try:
                     import json
-                    
+
                     # Generate base name from original file path if not provided
                     if not output_file or output_file.strip() == "":
-                        base_name = f"{Path(file_path).stem}_query_{query_key or 'custom'}"
+                        base_name = (
+                            f"{Path(file_path).stem}_query_{query_key or 'custom'}"
+                        )
                     else:
                         base_name = output_file
 
                     # Convert result to JSON string for file output
-                    json_content = json.dumps(formatted_result, indent=2, ensure_ascii=False)
+                    json_content = json.dumps(
+                        formatted_result, indent=2, ensure_ascii=False
+                    )
 
                     # Save to file with automatic extension detection
                     saved_file_path = self.file_output_manager.save_to_file(
-                        content=json_content,
-                        base_name=base_name
+                        content=json_content, base_name=base_name
                     )
-                    
+
                     # Add file output info to result
                     formatted_result["output_file_path"] = saved_file_path
                     formatted_result["file_saved"] = True
-                    
+
                     logger.info(f"Query output saved to: {saved_file_path}")
-                    
+
                 except Exception as e:
                     logger.error(f"Failed to save output to file: {e}")
                     formatted_result["file_save_error"] = str(e)
@@ -215,26 +251,35 @@ class QueryTool(BaseMCPTool):
                     "language": language,
                     "query": query_key or query_string,
                 }
-                
+
                 # Include file output info if present
                 if "output_file_path" in formatted_result:
-                    minimal_result["output_file_path"] = formatted_result["output_file_path"]
+                    minimal_result["output_file_path"] = formatted_result[
+                        "output_file_path"
+                    ]
                     minimal_result["file_saved"] = formatted_result["file_saved"]
                 if "file_save_error" in formatted_result:
-                    minimal_result["file_save_error"] = formatted_result["file_save_error"]
+                    minimal_result["file_save_error"] = formatted_result[
+                        "file_save_error"
+                    ]
                     minimal_result["file_saved"] = formatted_result["file_saved"]
-                
+
                 return minimal_result
             else:
                 return formatted_result
 
         except Exception as e:
+            from ..utils.error_handler import AnalysisError
+            # Re-raise AnalysisError to maintain proper error handling
+            if isinstance(e, AnalysisError):
+                raise
+            
             logger.error(f"Query execution failed: {e}")
             return {
                 "success": False,
                 "error": str(e),
-                "file_path": file_path,
-                "language": language,
+                "file_path": arguments.get("file_path", "unknown"),
+                "language": arguments.get("language", "unknown"),
             }
 
     def _format_summary(
@@ -252,7 +297,7 @@ class QueryTool(BaseMCPTool):
             Summary formatted results
         """
         # Group by capture name
-        by_capture = {}
+        by_capture: dict[str, list[dict[str, Any]]] = {}
         for result in results:
             capture_name = result["capture_name"]
             if capture_name not in by_capture:
@@ -260,7 +305,7 @@ class QueryTool(BaseMCPTool):
             by_capture[capture_name].append(result)
 
         # Create summary
-        summary = {
+        summary: dict[str, Any] = {
             "success": True,
             "query_type": query_type,
             "language": language,
@@ -302,6 +347,9 @@ class QueryTool(BaseMCPTool):
 
             # Match common declaration patterns
             patterns = [
+                # Markdown headers
+                r"^#{1,6}\s+(.+)$",  # Markdown headers (# Title, ## Subtitle, etc.)
+                # Programming language patterns
                 r"(?:public|private|protected)?\s*(?:static)?\s*(?:class|interface)\s+(\w+)",  # class/interface
                 r"(?:public|private|protected)?\s*(?:static)?\s*\w+\s+(\w+)\s*\(",  # method
                 r"(\w+)\s*\(",  # simple function call
@@ -310,7 +358,7 @@ class QueryTool(BaseMCPTool):
             for pattern in patterns:
                 match = re.search(pattern, first_line)
                 if match:
-                    return match.group(1)
+                    return match.group(1).strip()
 
         return "unnamed"