tree-sitter-analyzer 1.8.3__py3-none-any.whl → 1.9.0__py3-none-any.whl

tree_sitter_analyzer/mcp/tools/find_and_grep_tool.py

@@ -257,9 +257,9 @@ class FindAndGrepTool(BaseMCPTool):
                 "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": []
+                "results": [],
             }
-        
+
         self.validate_arguments(arguments)
         roots = self._validate_roots(arguments["roots"])  # absolute validated
 
@@ -459,7 +459,7 @@ class FindAndGrepTool(BaseMCPTool):
         else:
             # Parse full match details
             matches = fd_rg_utils.parse_rg_json_lines_to_matches(rg_out)
-            
+
             # Apply user-specified max_count limit if provided
             # Note: ripgrep's -m option limits matches per file, not total matches
             # So we need to apply the total limit here in post-processing
@@ -503,25 +503,29 @@ class FindAndGrepTool(BaseMCPTool):
                     try:
                         # Save full result to file
                         import json
-                        json_content = json.dumps(grouped_result, indent=2, ensure_ascii=False)
+
+                        json_content = json.dumps(
+                            grouped_result, indent=2, ensure_ascii=False
+                        )
                         file_path = self.file_output_manager.save_to_file(
-                            content=json_content,
-                            base_name=output_file
+                            content=json_content, base_name=output_file
                         )
-                        
+
                         # If suppress_output is True, return minimal response
                         if suppress_output:
                             minimal_result = {
                                 "success": grouped_result.get("success", True),
                                 "count": grouped_result.get("count", 0),
                                 "output_file": output_file,
-                                "file_saved": f"Results saved to {file_path}"
+                                "file_saved": f"Results saved to {file_path}",
                             }
                             return minimal_result
                         else:
                             # Include file info in full response
                             grouped_result["output_file"] = output_file
-                            grouped_result["file_saved"] = f"Results saved to {file_path}"
+                            grouped_result["file_saved"] = (
+                                f"Results saved to {file_path}"
+                            )
                     except Exception as e:
                         logger.error(f"Failed to save output to file: {e}")
                         grouped_result["file_save_error"] = str(e)
@@ -532,7 +536,7 @@ class FindAndGrepTool(BaseMCPTool):
                         "success": grouped_result.get("success", True),
                         "count": grouped_result.get("count", 0),
                         "summary": grouped_result.get("summary", {}),
-                        "meta": grouped_result.get("meta", {})
+                        "meta": grouped_result.get("meta", {}),
                     }
                     return minimal_result
 
@@ -562,19 +566,19 @@ class FindAndGrepTool(BaseMCPTool):
                     try:
                         # Save full result to file
                         import json
+
                         json_content = json.dumps(result, indent=2, ensure_ascii=False)
                         file_path = self.file_output_manager.save_to_file(
-                            content=json_content,
-                            base_name=output_file
+                            content=json_content, base_name=output_file
                         )
-                        
+
                         # If suppress_output is True, return minimal response
                         if suppress_output:
                             minimal_result = {
                                 "success": result.get("success", True),
                                 "count": len(matches),
                                 "output_file": output_file,
-                                "file_saved": f"Results saved to {file_path}"
+                                "file_saved": f"Results saved to {file_path}",
                             }
                             return minimal_result
                         else:
@@ -591,7 +595,7 @@ class FindAndGrepTool(BaseMCPTool):
                         "success": result.get("success", True),
                         "count": len(matches),
                         "summary": result.get("summary", {}),
-                        "meta": result.get("meta", {})
+                        "meta": result.get("meta", {}),
                     }
                     return minimal_result
 
@@ -624,20 +628,24 @@ class FindAndGrepTool(BaseMCPTool):
                             "success": True,
                             "results": matches,
                             "count": len(matches),
-                            "files": fd_rg_utils.group_matches_by_file(matches)["files"] if matches else [],
+                            "files": fd_rg_utils.group_matches_by_file(matches)["files"]
+                            if matches
+                            else [],
                             "summary": fd_rg_utils.summarize_search_results(matches),
-                            "meta": result["meta"]
+                            "meta": result["meta"],
                         }
 
                         # Convert to JSON for file output
                         # Save full result to file using FileOutputManager
                         import json
-                        json_content = json.dumps(file_content, indent=2, ensure_ascii=False)
+
+                        json_content = json.dumps(
+                            file_content, indent=2, ensure_ascii=False
+                        )
                         file_path = self.file_output_manager.save_to_file(
-                            content=json_content,
-                            base_name=output_file
+                            content=json_content, base_name=output_file
                         )
-                        
+
                         # Check if suppress_output is enabled
                         suppress_output = arguments.get("suppress_output", False)
                         if suppress_output:
@@ -646,7 +654,7 @@ class FindAndGrepTool(BaseMCPTool):
                                 "success": result.get("success", True),
                                 "count": result.get("count", 0),
                                 "output_file": output_file,
-                                "file_saved": f"Results saved to {file_path}"
+                                "file_saved": f"Results saved to {file_path}",
                             }
                             return minimal_result
                         else:
@@ -669,7 +677,7 @@ class FindAndGrepTool(BaseMCPTool):
                             "success": result.get("success", True),
                             "count": result.get("count", 0),
                             "summary": result.get("summary", {}),
-                            "meta": result.get("meta", {})
+                            "meta": result.get("meta", {}),
                         }
                         return minimal_result
 

tree_sitter_analyzer/mcp/tools/list_files_tool.py

@@ -113,12 +113,12 @@ class ListFilesTool(BaseMCPTool):
                     },
                     "output_file": {
                         "type": "string",
-                        "description": "Optional filename to save output to file (extension auto-detected based on content)"
+                        "description": "Optional filename to save output to file (extension auto-detected based on content)",
                     },
                     "suppress_output": {
                         "type": "boolean",
                         "description": "When true and output_file is specified, suppress detailed output in response to save tokens",
-                        "default": False
+                        "default": False,
                     },
                 },
                 "required": ["roots"],
@@ -187,9 +187,9 @@ class ListFilesTool(BaseMCPTool):
                 "success": False,
                 "error": "fd command not found. Please install fd (https://github.com/sharkdp/fd) to use this tool.",
                 "count": 0,
-                "results": []
+                "results": [],
             }
-        
+
         self.validate_arguments(arguments)
         roots = self._validate_roots(arguments["roots"])  # normalized absolutes
 
@@ -273,7 +273,7 @@ class ListFilesTool(BaseMCPTool):
             # Handle file output for count_only mode
             output_file = arguments.get("output_file")
             suppress_output = arguments.get("suppress_output", False)
-            
+
             if output_file:
                 file_manager = FileOutputManager(self.project_root)
                 file_content = {
@@ -289,18 +289,20 @@ class ListFilesTool(BaseMCPTool):
                         "extensions": arguments.get("extensions"),
                         "exclude": arguments.get("exclude"),
                         "limit": limit,
-                    }
+                    },
                 }
-                
+
                 try:
                     import json
-                    json_content = json.dumps(file_content, indent=2, ensure_ascii=False)
+
+                    json_content = json.dumps(
+                        file_content, indent=2, ensure_ascii=False
+                    )
                     saved_path = file_manager.save_to_file(
-                        content=json_content,
-                        base_name=output_file
+                        content=json_content, base_name=output_file
                     )
                     result["output_file"] = saved_path
-                    
+
                     if suppress_output:
                         # Return minimal response to save tokens
                         return {
@@ -308,7 +310,7 @@ class ListFilesTool(BaseMCPTool):
                             "count_only": True,
                             "total_count": total_count,
                             "output_file": saved_path,
-                            "message": f"Count results saved to {saved_path}"
+                            "message": f"Count results saved to {saved_path}",
                         }
                 except Exception as e:
                     logger.warning(f"Failed to save output file: {e}")
@@ -359,7 +361,7 @@ class ListFilesTool(BaseMCPTool):
         # Handle file output for detailed results
         output_file = arguments.get("output_file")
         suppress_output = arguments.get("suppress_output", False)
-        
+
         if output_file:
             file_manager = FileOutputManager(self.project_root)
             file_content = {
@@ -384,25 +386,25 @@ class ListFilesTool(BaseMCPTool):
                     "full_path_match": arguments.get("full_path_match", False),
                     "absolute": arguments.get("absolute", True),
                     "limit": limit,
-                }
+                },
             }
-            
+
             try:
                 import json
+
                 json_content = json.dumps(file_content, indent=2, ensure_ascii=False)
                 saved_path = file_manager.save_to_file(
-                    content=json_content,
-                    base_name=output_file
+                    content=json_content, base_name=output_file
                 )
                 result["output_file"] = saved_path
-                
+
                 if suppress_output:
                     # Return minimal response to save tokens
                     return {
                         "success": True,
                         "count": len(results),
                         "output_file": saved_path,
-                        "message": f"File list results saved to {saved_path}"
+                        "message": f"File list results saved to {saved_path}",
                     }
             except Exception as e:
                 logger.warning(f"Failed to save output file: {e}")

tree_sitter_analyzer/mcp/tools/query_tool.py

@@ -12,7 +12,6 @@ from typing import Any
 
 from ...core.query_service import QueryService
 from ...language_detector import detect_language_from_file
-from ..utils.error_handler import handle_mcp_errors
 from ..utils.file_output_manager import FileOutputManager
 from .base_tool import BaseMCPTool
 
@@ -111,28 +110,25 @@ class QueryTool(BaseMCPTool):
             # 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"
-                )
-                
+
+                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"
-                )
+
+                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"
+                    operation="query_code",
                 )
 
             # Security validation BEFORE path resolution to catch symlinks
@@ -140,12 +136,14 @@ class QueryTool(BaseMCPTool):
             if not is_valid:
                 return {
                     "success": False,
-                    "error": f"Invalid or unsafe file path: {error_msg or file_path}"
+                    "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})")
+            logger.info(
+                f"Querying file: {file_path} (resolved to: {resolved_file_path})"
+            )
 
             # Additional security validation on resolved path
             is_valid, error_msg = self.security_validator.validate_file_path(
@@ -154,7 +152,7 @@ class QueryTool(BaseMCPTool):
             if not is_valid:
                 return {
                     "success": False,
-                    "error": f"Invalid or unsafe resolved path: {error_msg or resolved_file_path}"
+                    "error": f"Invalid or unsafe resolved path: {error_msg or resolved_file_path}",
                 }
 
             # Get query parameters (already validated above)
@@ -166,7 +164,7 @@ class QueryTool(BaseMCPTool):
             if query_key and query_string:
                 return {
                     "success": False,
-                    "error": "Cannot provide both query_key and query_string"
+                    "error": "Cannot provide both query_key and query_string",
                 }
 
             # Detect language
@@ -176,7 +174,7 @@ class QueryTool(BaseMCPTool):
                 if not language:
                     return {
                         "success": False,
-                        "error": f"Could not detect language for file: {file_path}"
+                        "error": f"Could not detect language for file: {file_path}",
                     }
 
             # Execute query
@@ -270,10 +268,11 @@ class QueryTool(BaseMCPTool):
 
         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,

tree_sitter_analyzer/mcp/tools/read_partial_tool.py

@@ -27,7 +27,7 @@ class ReadPartialTool(BaseMCPTool):
     selective file content reading through the MCP protocol.
     """
 
-    def __init__(self, project_root: str = None) -> None:
+    def __init__(self, project_root: str | None = None) -> None:
         """Initialize the read partial tool."""
         super().__init__(project_root)
         self.file_output_manager = FileOutputManager(project_root)
@@ -117,7 +117,9 @@ class ReadPartialTool(BaseMCPTool):
         output_format = arguments.get("format", "text")
 
         # Security validation BEFORE path resolution to catch symlinks
-        is_valid, error_msg = self.security_validator.validate_file_path(file_path, self.project_root)
+        is_valid, error_msg = self.security_validator.validate_file_path(
+            file_path, self.project_root
+        )
         if not is_valid:
             logger.warning(
                 f"Security validation failed for file path: {file_path} - {error_msg}"
@@ -125,14 +127,16 @@ class ReadPartialTool(BaseMCPTool):
             return {
                 "success": False,
                 "error": f"Security validation failed: {error_msg}",
-                "file_path": file_path
+                "file_path": file_path,
             }
 
         # Resolve file path using common path resolver
         resolved_path = self.path_resolver.resolve(file_path)
 
         # Additional security validation on resolved path
-        is_valid, error_msg = self.security_validator.validate_file_path(resolved_path, self.project_root)
+        is_valid, error_msg = self.security_validator.validate_file_path(
+            resolved_path, self.project_root
+        )
         if not is_valid:
             logger.warning(
                 f"Security validation failed for resolved path: {resolved_path} - {error_msg}"
@@ -140,7 +144,7 @@ class ReadPartialTool(BaseMCPTool):
             return {
                 "success": False,
                 "error": f"Security validation failed for resolved path: {error_msg}",
-                "file_path": file_path
+                "file_path": file_path,
             }
 
         # Validate file exists
@@ -148,7 +152,7 @@ class ReadPartialTool(BaseMCPTool):
             return {
                 "success": False,
                 "error": "Invalid file path: file does not exist",
-                "file_path": file_path
+                "file_path": file_path,
             }
 
         # Validate line numbers
@@ -156,14 +160,14 @@ class ReadPartialTool(BaseMCPTool):
             return {
                 "success": False,
                 "error": "start_line must be >= 1",
-                "file_path": file_path
+                "file_path": file_path,
             }
 
         if end_line is not None and end_line < start_line:
             return {
                 "success": False,
                 "error": "end_line must be >= start_line",
-                "file_path": file_path
+                "file_path": file_path,
             }
 
         # Validate column numbers
@@ -171,14 +175,14 @@ class ReadPartialTool(BaseMCPTool):
             return {
                 "success": False,
                 "error": "start_column must be >= 0",
-                "file_path": file_path
+                "file_path": file_path,
             }
 
         if end_column is not None and end_column < 0:
             return {
                 "success": False,
                 "error": "end_column must be >= 0",
-                "file_path": file_path
+                "file_path": file_path,
             }
 
         logger.info(
@@ -199,15 +203,15 @@ class ReadPartialTool(BaseMCPTool):
                     return {
                         "success": False,
                         "error": f"Failed to read partial content from file: {file_path}",
-                        "file_path": file_path
+                        "file_path": file_path,
                     }
-                
+
                 # Check if content is empty or invalid range
                 if not content or content.strip() == "":
                     return {
                         "success": False,
                         "error": f"Invalid line range or empty content: start_line={start_line}, end_line={end_line}",
-                        "file_path": file_path
+                        "file_path": file_path,
                     }
 
                 # Build result structure compatible with CLI --partial-read format
@@ -245,7 +249,7 @@ class ReadPartialTool(BaseMCPTool):
                 )
 
                 # Calculate lines extracted
-                lines_extracted = len(content.split('\n')) if content else 0
+                lines_extracted = len(content.split("\n")) if content else 0
                 if end_line:
                     lines_extracted = end_line - start_line + 1
 
@@ -267,15 +271,15 @@ class ReadPartialTool(BaseMCPTool):
                 if not suppress_output or not output_file:
                     if output_format == "json":
                         # For JSON format, return structured data with exact line count
-                        lines = content.split('\n') if content else []
-                        
+                        lines = content.split("\n") if content else []
+
                         # If end_line is specified, ensure we return exactly the requested number of lines
                         if end_line and len(lines) > lines_extracted:
                             lines = lines[:lines_extracted]
                         elif end_line and len(lines) < lines_extracted:
                             # Pad with empty lines if needed (shouldn't normally happen)
-                            lines.extend([''] * (lines_extracted - len(lines)))
-                        
+                            lines.extend([""] * (lines_extracted - len(lines)))
+
                         result["partial_content_result"] = {
                             "lines": lines,
                             "metadata": {
@@ -287,8 +291,8 @@ class ReadPartialTool(BaseMCPTool):
                                     "end_column": end_column,
                                 },
                                 "content_length": len(content),
-                                "lines_count": len(lines)
-                            }
+                                "lines_count": len(lines),
+                            },
                         }
                     else:
                         # For text/raw format, return CLI-compatible string
@@ -313,18 +317,17 @@ class ReadPartialTool(BaseMCPTool):
                         else:  # format == "text" (default)
                             # Save CLI-compatible format with headers
                             content_to_save = cli_output
-                        
+
                         # Save to file with automatic extension detection
                         saved_file_path = self.file_output_manager.save_to_file(
-                            content=content_to_save,
-                            base_name=base_name
+                            content=content_to_save, base_name=base_name
                         )
-                        
+
                         result["output_file_path"] = saved_file_path
                         result["file_saved"] = True
-                        
+
                         logger.info(f"Extract output saved to: {saved_file_path}")
-                        
+
                     except Exception as e:
                         logger.error(f"Failed to save output to file: {e}")
                         result["file_save_error"] = str(e)
@@ -334,11 +337,7 @@ class ReadPartialTool(BaseMCPTool):
 
         except Exception as e:
             logger.error(f"Error reading partial content from {file_path}: {e}")
-            return {
-                "success": False,
-                "error": str(e),
-                "file_path": file_path
-            }
+            return {"success": False, "error": str(e), "file_path": file_path}
 
     def _read_file_partial(
         self,