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

tree_sitter_analyzer/mcp/server.py

@@ -446,80 +446,9 @@ class TreeSitterAnalyzerMCPServer:
             logger.info("Client requesting tools list")
 
             tools = [
-                Tool(
-                    name="check_code_scale",
-                    description="Analyze code file size and complexity metrics",
-                    inputSchema={
-                        "type": "object",
-                        "properties": {
-                            "file_path": {
-                                "type": "string",
-                                "description": "Path to the code file (relative to project root)",
-                            }
-                        },
-                        "required": ["file_path"],
-                        "additionalProperties": False,
-                    },
-                ),
-                Tool(
-                    name="analyze_code_structure",
-                    description="Analyze code structure and generate tables with line positions, optionally save to file",
-                    inputSchema={
-                        "type": "object",
-                        "properties": {
-                            "file_path": {
-                                "type": "string",
-                                "description": "Path to the code file (relative to project root)",
-                            },
-                            "format_type": {
-                                "type": "string",
-                                "description": "Table format type",
-                                "enum": ["full", "compact", "csv", "json"],
-                                "default": "full",
-                            },
-                            "language": {
-                                "type": "string",
-                                "description": "Programming language (optional, auto-detected if not specified)",
-                            },
-                            "output_file": {
-                                "type": "string",
-                                "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 table_output in response to save tokens",
-                                "default": False,
-                            },
-                        },
-                        "required": ["file_path"],
-                        "additionalProperties": False,
-                    },
-                ),
-                Tool(
-                    name="extract_code_section",
-                    description="Extract a code section by line range",
-                    inputSchema={
-                        "type": "object",
-                        "properties": {
-                            "file_path": {
-                                "type": "string",
-                                "description": "Path to the code file (relative to project root)",
-                            },
-                            "start_line": {
-                                "type": "integer",
-                                "description": "Start line (1-based)",
-                                "minimum": 1,
-                            },
-                            "end_line": {
-                                "type": "integer",
-                                "description": "End line (optional, 1-based)",
-                                "minimum": 1,
-                            },
-                        },
-                        "required": ["file_path", "start_line"],
-                        "additionalProperties": False,
-                    },
-                ),
+                Tool(**self.analyze_scale_tool.get_tool_definition()),
+                Tool(**self.table_format_tool.get_tool_definition()),
+                Tool(**self.read_partial_tool.get_tool_definition()),
                 Tool(
                     name="set_project_path",
                     description="Set or override the project root path used for security boundaries",
@@ -603,6 +532,8 @@ class TreeSitterAnalyzerMCPServer:
                         "start_column": arguments.get("start_column"),
                         "end_column": arguments.get("end_column"),
                         "format": arguments.get("format", "text"),
+                        "output_file": arguments.get("output_file"),
+                        "suppress_output": arguments.get("suppress_output", False),
                     }
                     result = await self.read_partial_tool.execute(full_args)
 

tree_sitter_analyzer/mcp/tools/analyze_scale_tool.py

@@ -688,28 +688,18 @@ class AnalyzeScaleTool(BaseMCPTool):
 
         return True
 
-    def get_tool_definition(self) -> Any:
+    def get_tool_definition(self) -> dict[str, Any]:
         """
-        Get the MCP tool definition for analyze_code_scale.
+        Get the MCP tool definition for check_code_scale.
 
         Returns:
-            Tool definition object compatible with MCP server
+            Tool definition dictionary compatible with MCP server
         """
-        try:
-            from mcp.types import Tool
-
-            return Tool(
-                name="analyze_code_scale",
-                description="Analyze code scale, complexity, and structure metrics with LLM-optimized guidance for efficient large file analysis",
-                inputSchema=self.get_tool_schema(),
-            )
-        except ImportError:
-            # Fallback for when MCP is not available
-            return {
-                "name": "analyze_code_scale",
-                "description": "Analyze code scale, complexity, and structure metrics with LLM-optimized guidance for efficient large file analysis",
-                "inputSchema": self.get_tool_schema(),
-            }
+        return {
+            "name": "check_code_scale",
+            "description": "Analyze code scale, complexity, and structure metrics with LLM-optimized guidance for efficient large file analysis and token-aware workflow recommendations",
+            "inputSchema": self.get_tool_schema(),
+        }
 
 
 # Tool instance for easy access

tree_sitter_analyzer/mcp/tools/find_and_grep_tool.py

@@ -32,7 +32,7 @@ class FindAndGrepTool(BaseMCPTool):
     def get_tool_definition(self) -> dict[str, Any]:
         return {
             "name": "find_and_grep",
-            "description": "Two-stage search: first use fd to find files matching criteria, then use ripgrep to search content within those files. Combines file filtering with content search for precise results.",
+            "description": "Two-stage search: first use fd to find files matching criteria, then use ripgrep to search content within those files. Combines file filtering with content search for precise results with advanced token optimization (summary_only, group_by_file, total_only, suppress_output).",
             "inputSchema": {
                 "type": "object",
                 "properties": {

tree_sitter_analyzer/mcp/tools/list_files_tool.py

@@ -27,7 +27,7 @@ class ListFilesTool(BaseMCPTool):
     def get_tool_definition(self) -> dict[str, Any]:
         return {
             "name": "list_files",
-            "description": "List files and directories using fd with advanced filtering options. Supports glob patterns, file types, size filters, and more. Returns file paths with metadata or just counts.",
+            "description": "List files and directories using fd with advanced filtering options. Supports glob patterns, file types, size filters, and more. Returns file paths with metadata or just counts, with optional file output and token optimization.",
             "inputSchema": {
                 "type": "object",
                 "properties": {

tree_sitter_analyzer/mcp/tools/query_tool.py

@@ -7,11 +7,13 @@ Supports both predefined query keys and custom query strings.
 """
 
 import logging
+from pathlib import Path
 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
 
 logger = logging.getLogger(__name__)
@@ -24,6 +26,7 @@ class QueryTool(BaseMCPTool):
         """Initialize query tool"""
         super().__init__(project_root)
         self.query_service = QueryService(project_root)
+        self.file_output_manager = FileOutputManager(project_root)
 
     def set_project_path(self, project_path: str) -> None:
         """
@@ -34,6 +37,7 @@ class QueryTool(BaseMCPTool):
         """
         super().set_project_path(project_path)
         self.query_service = QueryService(project_path)
+        self.file_output_manager.set_project_root(project_path)
         logger.info(f"QueryTool project path updated to: {project_path}")
 
     def get_tool_definition(self) -> dict[str, Any]:
@@ -45,7 +49,7 @@ class QueryTool(BaseMCPTool):
         """
         return {
             "name": "query_code",
-            "description": "Execute tree-sitter queries on code files to extract specific code elements",
+            "description": "Execute tree-sitter queries on code files to extract specific code elements with filtering, multiple output formats, and optional file saving with token optimization",
             "inputSchema": {
                 "type": "object",
                 "properties": {
@@ -75,6 +79,15 @@ class QueryTool(BaseMCPTool):
                         "default": "json",
                         "description": "Output format",
                     },
+                    "output_file": {
+                        "type": "string",
+                        "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,
+                    },
                 },
                 "required": ["file_path"],
                 "anyOf": [
@@ -118,6 +131,8 @@ class QueryTool(BaseMCPTool):
         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)
 
         if not query_key and not query_string:
             raise ValueError("Either query_key or query_string must be provided")
@@ -148,9 +163,9 @@ class QueryTool(BaseMCPTool):
 
             # Format output
             if output_format == "summary":
-                return self._format_summary(results, query_key or "custom", language)
+                formatted_result = self._format_summary(results, query_key or "custom", language)
             else:
-                return {
+                formatted_result = {
                     "success": True,
                     "results": results,
                     "count": len(results),
@@ -159,6 +174,60 @@ class QueryTool(BaseMCPTool):
                     "query": query_key or query_string,
                 }
 
+            # Handle file output if requested
+            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'}"
+                    else:
+                        base_name = output_file
+
+                    # Convert result to JSON string for file output
+                    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
+                    )
+                    
+                    # 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)
+                    formatted_result["file_saved"] = False
+
+            # Apply suppress_output logic
+            if suppress_output and output_file:
+                # Create minimal result when output is suppressed
+                minimal_result = {
+                    "success": formatted_result.get("success", True),
+                    "count": formatted_result.get("count", len(results)),
+                    "file_path": file_path,
+                    "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["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_saved"] = formatted_result["file_saved"]
+                
+                return minimal_result
+            else:
+                return formatted_result
+
         except Exception as e:
             logger.error(f"Query execution failed: {e}")
             return {
@@ -314,4 +383,18 @@ class QueryTool(BaseMCPTool):
             if output_format not in ["json", "summary"]:
                 raise ValueError("output_format must be one of: json, summary")
 
+        # Validate output_file if provided
+        if "output_file" in arguments:
+            output_file = arguments["output_file"]
+            if not isinstance(output_file, str):
+                raise ValueError("output_file must be a string")
+            if not output_file.strip():
+                raise ValueError("output_file cannot be empty")
+
+        # Validate suppress_output if provided
+        if "suppress_output" in arguments:
+            suppress_output = arguments["suppress_output"]
+            if not isinstance(suppress_output, bool):
+                raise ValueError("suppress_output must be a boolean")
+
         return True

tree_sitter_analyzer/mcp/tools/read_partial_tool.py

@@ -12,6 +12,7 @@ from typing import Any
 
 from ...file_handler import read_file_partial
 from ...utils import setup_logger
+from ..utils.file_output_manager import FileOutputManager
 from .base_tool import BaseMCPTool
 
 # Set up logging
@@ -29,6 +30,7 @@ class ReadPartialTool(BaseMCPTool):
     def __init__(self, project_root: str = None) -> None:
         """Initialize the read partial tool."""
         super().__init__(project_root)
+        self.file_output_manager = FileOutputManager(project_root)
         logger.info("ReadPartialTool initialized with security validation")
 
     def get_tool_schema(self) -> dict[str, Any]:
@@ -68,12 +70,20 @@ class ReadPartialTool(BaseMCPTool):
                 "format": {
                     "type": "string",
                     "description": "Output format for the content",
-                    "enum": ["text", "json"],
+                    "enum": ["text", "json", "raw"],
                     "default": "text",
                 },
+                "output_file": {
+                    "type": "string",
+                    "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 partial_content_result in response to save tokens",
+                    "default": False,
+                },
             },
             "required": ["file_path", "start_line"],
-            "additionalProperties": False,
         }
 
     async def execute(self, arguments: dict[str, Any]) -> dict[str, Any]:
@@ -102,7 +112,9 @@ class ReadPartialTool(BaseMCPTool):
         end_line = arguments.get("end_line")
         start_column = arguments.get("start_column")
         end_column = arguments.get("end_column")
-        # output_format = arguments.get("format", "text")  # Not used currently
+        output_file = arguments.get("output_file")
+        suppress_output = arguments.get("suppress_output", False)
+        output_format = arguments.get("format", "text")
 
         # Resolve file path using common path resolver
         resolved_path = self.path_resolver.resolve(file_path)
@@ -186,7 +198,59 @@ class ReadPartialTool(BaseMCPTool):
                     f"Successfully read {len(content)} characters from {file_path}"
                 )
 
-                return {"partial_content_result": cli_output}
+                # Build result - conditionally include partial_content_result based on suppress_output
+                result = {
+                    "file_path": file_path,
+                    "range": {
+                        "start_line": start_line,
+                        "end_line": end_line,
+                        "start_column": start_column,
+                        "end_column": end_column,
+                    },
+                    "content_length": len(content),
+                }
+
+                # Only include partial_content_result if not suppressed or no output file specified
+                if not suppress_output or not output_file:
+                    result["partial_content_result"] = cli_output
+
+                # Handle file output if requested
+                if output_file:
+                    try:
+                        # Generate base name from original file path if not provided
+                        if not output_file or output_file.strip() == "":
+                            base_name = Path(file_path).stem + "_extract"
+                        else:
+                            base_name = output_file
+
+                        # Determine what content to save based on format preference
+                        if output_format == "raw":
+                            # Save only the extracted code content (no metadata)
+                            content_to_save = content
+                        elif output_format == "json":
+                            # Save structured JSON data
+                            content_to_save = json_output
+                        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
+                        )
+                        
+                        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)
+                        result["file_saved"] = False
+
+                return result
 
         except Exception as e:
             logger.error(f"Error reading partial content from {file_path}: {e}")
@@ -280,33 +344,37 @@ class ReadPartialTool(BaseMCPTool):
             format_value = arguments["format"]
             if not isinstance(format_value, str):
                 raise ValueError("format must be a string")
-            if format_value not in ["text", "json"]:
-                raise ValueError("format must be 'text' or 'json'")
+            if format_value not in ["text", "json", "raw"]:
+                raise ValueError("format must be 'text', 'json', or 'raw'")
+
+        # Validate output_file if provided
+        if "output_file" in arguments:
+            output_file = arguments["output_file"]
+            if not isinstance(output_file, str):
+                raise ValueError("output_file must be a string")
+            if not output_file.strip():
+                raise ValueError("output_file cannot be empty")
+
+        # Validate suppress_output if provided
+        if "suppress_output" in arguments:
+            suppress_output = arguments["suppress_output"]
+            if not isinstance(suppress_output, bool):
+                raise ValueError("suppress_output must be a boolean")
 
         return True
 
-    def get_tool_definition(self) -> Any:
+    def get_tool_definition(self) -> dict[str, Any]:
         """
         Get the MCP tool definition for read_code_partial.
 
         Returns:
-            Tool definition object compatible with MCP server
+            Tool definition dictionary compatible with MCP server
         """
-        try:
-            from mcp.types import Tool
-
-            return Tool(
-                name="extract_code_section",
-                description="Extract specific code sections by line range (equivalent to CLI --partial-read option)",
-                inputSchema=self.get_tool_schema(),
-            )
-        except ImportError:
-            # Fallback for when MCP is not available
-            return {
-                "name": "extract_code_section",
-                "description": "Extract specific code sections by line range (equivalent to CLI --partial-read option)",
-                "inputSchema": self.get_tool_schema(),
-            }
+        return {
+            "name": "extract_code_section",
+            "description": "Extract specific code sections by line/column range with multiple output formats (text/json/raw), optionally save to file with token optimization",
+            "inputSchema": self.get_tool_schema(),
+        }
 
 
 # Tool instance for easy access

tree_sitter_analyzer/mcp/tools/search_content_tool.py

@@ -42,7 +42,7 @@ class SearchContentTool(BaseMCPTool):
     def get_tool_definition(self) -> dict[str, Any]:
         return {
             "name": "search_content",
-            "description": "Search text content inside files using ripgrep. Supports regex patterns, case sensitivity, context lines, and various output formats. Can search in directories or specific files.",
+            "description": "Search text content inside files using ripgrep. Supports regex patterns, case sensitivity, context lines, and various output formats. Can search in directories or specific files with advanced token optimization (summary_only, group_by_file, total_only, suppress_output).",
             "inputSchema": {
                 "type": "object",
                 "properties": {

tree_sitter_analyzer/mcp/tools/table_format_tool.py

@@ -511,28 +511,18 @@ class TableFormatTool(BaseMCPTool):
             self.logger.error(f"Error in code structure analysis tool: {e}")
             raise
 
-    def get_tool_definition(self) -> Any:
+    def get_tool_definition(self) -> dict[str, Any]:
         """
         Get the MCP tool definition for analyze_code_structure.
 
         Returns:
-            Tool definition object compatible with MCP server
+            Tool definition dictionary compatible with MCP server
         """
-        try:
-            from mcp.types import Tool
-
-            return Tool(
-                name="analyze_code_structure",
-                description="Analyze code structure and generate detailed overview tables (classes, methods, fields) for large files",
-                inputSchema=self.get_tool_schema(),
-            )
-        except ImportError:
-            # Fallback for when MCP is not available
-            return {
-                "name": "analyze_code_structure",
-                "description": "Analyze code structure and generate detailed overview tables (classes, methods, fields) for large files",
-                "inputSchema": self.get_tool_schema(),
-            }
+        return {
+            "name": "analyze_code_structure",
+            "description": "Analyze code structure and generate detailed overview tables (classes, methods, fields) with line positions for large files, optionally save to file",
+            "inputSchema": self.get_tool_schema(),
+        }
 
 
 # Tool instance for easy access

tree_sitter_analyzer/queries/javascript.py

@@ -644,6 +644,26 @@ ALL_QUERIES["objects"] = {
 }
 ALL_QUERIES["comments"] = {"query": COMMENTS, "description": "Search all comments"}
 
+# Add missing method queries
+ALL_QUERIES["method"] = {
+    "query": """
+(method_definition
+    name: (property_identifier) @method_name
+    parameters: (formal_parameters) @parameters
+    body: (statement_block) @body) @method_definition
+""",
+    "description": "Search method definitions",
+}
+ALL_QUERIES["methods"] = {
+    "query": """
+(method_definition
+    name: (property_identifier) @method_name
+    parameters: (formal_parameters) @parameters
+    body: (statement_block) @body) @method_definition
+""",
+    "description": "Search method definitions",
+}
+
 
 def get_javascript_query(name: str) -> str:
     """

tree_sitter_analyzer/queries/typescript.py

@@ -213,6 +213,28 @@ ALL_QUERIES["methods"] = {
     "description": "Search all methods declarations (alias for functions)",
 }
 
+# Add singular form aliases
+ALL_QUERIES["function"] = {
+    "query": FUNCTIONS,
+    "description": "Search all functions (alias for functions)",
+}
+ALL_QUERIES["class"] = {
+    "query": CLASSES,
+    "description": "Search all classes (alias for classes)",
+}
+ALL_QUERIES["interface"] = {
+    "query": INTERFACES,
+    "description": "Search all interfaces (alias for interfaces)",
+}
+ALL_QUERIES["type"] = {
+    "query": TYPE_ALIASES,
+    "description": "Search all type aliases (alias for type_aliases)",
+}
+ALL_QUERIES["types"] = {
+    "query": TYPE_ALIASES,
+    "description": "Search all types (alias for type_aliases)",
+}
+
 # Add more specific function queries
 ALL_QUERIES["function_declaration"] = {
     "query": """