tree-sitter-analyzer 1.7.0__py3-none-any.whl → 1.7.2__py3-none-any.whl

tree_sitter_analyzer/__init__.py

@@ -11,7 +11,7 @@ Architecture:
 - Data Models: Generic and language-specific code element representations
 """
 
-__version__ = "1.7.0"
+__version__ = "1.7.2"
 __author__ = "aisheng.yu"
 __email__ = "aimasteracc@gmail.com"
 

tree_sitter_analyzer/mcp/tools/find_and_grep_tool.py

@@ -13,6 +13,7 @@ import time
 from typing import Any
 
 from ..utils.error_handler import handle_mcp_errors
+from ..utils.file_output_manager import FileOutputManager
 from ..utils.gitignore_detector import get_default_detector
 from . import fd_rg_utils
 from .base_tool import BaseMCPTool
@@ -23,6 +24,11 @@ logger = logging.getLogger(__name__)
 class FindAndGrepTool(BaseMCPTool):
     """MCP tool that composes fd and ripgrep with safety limits and metadata."""
 
+    def __init__(self, project_root: str | None = None) -> None:
+        """Initialize the find and grep tool."""
+        super().__init__(project_root)
+        self.file_output_manager = FileOutputManager(project_root)
+
     def get_tool_definition(self) -> dict[str, Any]:
         return {
             "name": "find_and_grep",
@@ -191,6 +197,15 @@ class FindAndGrepTool(BaseMCPTool):
                         "default": False,
                         "description": "Return only the total match count as a number. Most token-efficient option for count queries. Takes priority over all other formats",
                     },
+                    "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": ["roots", "query"],
                 "additionalProperties": False,
@@ -373,11 +388,7 @@ class FindAndGrepTool(BaseMCPTool):
             context_before=arguments.get("context_before"),
             context_after=arguments.get("context_after"),
             encoding=arguments.get("encoding"),
-            max_count=fd_rg_utils.clamp_int(
-                arguments.get("max_count"),
-                fd_rg_utils.DEFAULT_RESULTS_LIMIT,
-                fd_rg_utils.MAX_RESULTS_HARD_CAP,
-            ),
+            max_count=arguments.get("max_count"),
             timeout_ms=arguments.get("timeout_ms"),
             roots=rg_roots,
             files_from=None,
@@ -427,9 +438,18 @@ class FindAndGrepTool(BaseMCPTool):
         else:
             # Parse full match details
             matches = fd_rg_utils.parse_rg_json_lines_to_matches(rg_out)
-            truncated_rg = len(matches) >= fd_rg_utils.MAX_RESULTS_HARD_CAP
-            if truncated_rg:
-                matches = matches[: fd_rg_utils.MAX_RESULTS_HARD_CAP]
+            
+            # 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
+            user_max_count = arguments.get("max_count")
+            if user_max_count is not None and len(matches) > user_max_count:
+                matches = matches[:user_max_count]
+                truncated_rg = True
+            else:
+                truncated_rg = len(matches) >= fd_rg_utils.MAX_RESULTS_HARD_CAP
+                if truncated_rg:
+                    matches = matches[: fd_rg_utils.MAX_RESULTS_HARD_CAP]
 
             # Apply path optimization if requested
             optimize_paths = arguments.get("optimize_paths", False)
@@ -452,12 +472,55 @@ class FindAndGrepTool(BaseMCPTool):
                     "fd_elapsed_ms": fd_elapsed_ms,
                     "rg_elapsed_ms": rg_elapsed_ms,
                 }
+
+                # Handle output suppression and file output for grouped results
+                output_file = arguments.get("output_file")
+                suppress_output = arguments.get("suppress_output", False)
+
+                # Handle file output if requested
+                if output_file:
+                    try:
+                        # Save full result to file
+                        import json
+                        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
+                        )
+                        
+                        # 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}"
+                            }
+                            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}"
+                    except Exception as e:
+                        logger.error(f"Failed to save output to file: {e}")
+                        grouped_result["file_save_error"] = str(e)
+                        grouped_result["file_saved"] = False
+                elif suppress_output:
+                    # If suppress_output is True but no output_file, remove detailed results
+                    minimal_result = {
+                        "success": grouped_result.get("success", True),
+                        "count": grouped_result.get("count", 0),
+                        "summary": grouped_result.get("summary", {}),
+                        "meta": grouped_result.get("meta", {})
+                    }
+                    return minimal_result
+
                 return grouped_result
 
             # Check if summary_only mode is requested
             if arguments.get("summary_only", False):
                 summary = fd_rg_utils.summarize_search_results(matches)
-                return {
+                result = {
                     "success": True,
                     "summary_only": True,
                     "summary": summary,
@@ -468,10 +531,53 @@ class FindAndGrepTool(BaseMCPTool):
                         "rg_elapsed_ms": rg_elapsed_ms,
                     },
                 }
+
+                # Handle output suppression and file output for summary results
+                output_file = arguments.get("output_file")
+                suppress_output = arguments.get("suppress_output", False)
+
+                # Handle file output if requested
+                if output_file:
+                    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
+                        )
+                        
+                        # 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}"
+                            }
+                            return minimal_result
+                        else:
+                            # Include file info in full response
+                            result["output_file"] = output_file
+                            result["file_saved"] = f"Results saved to {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
+                elif suppress_output:
+                    # If suppress_output is True but no output_file, remove detailed results
+                    minimal_result = {
+                        "success": result.get("success", True),
+                        "count": len(matches),
+                        "summary": result.get("summary", {}),
+                        "meta": result.get("meta", {})
+                    }
+                    return minimal_result
+
+                return result
             else:
-                return {
+                result = {
                     "success": True,
-                    "results": matches,
                     "count": len(matches),
                     "meta": {
                         "searched_file_count": searched_file_count,
@@ -480,3 +586,70 @@ class FindAndGrepTool(BaseMCPTool):
                         "rg_elapsed_ms": rg_elapsed_ms,
                     },
                 }
+
+                # Handle output suppression and file output
+                output_file = arguments.get("output_file")
+                suppress_output = arguments.get("suppress_output", False)
+
+                # Add results to response unless suppressed
+                if not suppress_output or not output_file:
+                    result["results"] = matches
+
+                # Handle file output if requested
+                if output_file:
+                    try:
+                        # Create detailed output for file
+                        file_content = {
+                            "success": True,
+                            "results": matches,
+                            "count": len(matches),
+                            "files": fd_rg_utils.group_matches_by_file(matches)["files"] if matches else [],
+                            "summary": fd_rg_utils.summarize_search_results(matches),
+                            "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)
+                        file_path = self.file_output_manager.save_to_file(
+                            content=json_content,
+                            base_name=output_file
+                        )
+                        
+                        # Check if suppress_output is enabled
+                        suppress_output = arguments.get("suppress_output", False)
+                        if suppress_output:
+                            # Return minimal response to save tokens
+                            minimal_result = {
+                                "success": result.get("success", True),
+                                "count": result.get("count", 0),
+                                "output_file": output_file,
+                                "file_saved": f"Results saved to {file_path}"
+                            }
+                            return minimal_result
+                        else:
+                            # Include file info in full response
+                            result["output_file"] = output_file
+                            result["file_saved"] = f"Results saved to {file_path}"
+
+                        logger.info(f"Search results saved to: {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
+                else:
+                    # Handle suppress_output without file output
+                    suppress_output = arguments.get("suppress_output", False)
+                    if suppress_output:
+                        # Return minimal response without detailed match results
+                        minimal_result = {
+                            "success": result.get("success", True),
+                            "count": result.get("count", 0),
+                            "summary": result.get("summary", {}),
+                            "meta": result.get("meta", {})
+                        }
+                        return minimal_result
+
+                return result

tree_sitter_analyzer/mcp/tools/list_files_tool.py

@@ -13,6 +13,7 @@ from pathlib import Path
 from typing import Any
 
 from ..utils.error_handler import handle_mcp_errors
+from ..utils.file_output_manager import FileOutputManager
 from ..utils.gitignore_detector import get_default_detector
 from . import fd_rg_utils
 from .base_tool import BaseMCPTool
@@ -110,6 +111,15 @@ class ListFilesTool(BaseMCPTool):
                         "default": False,
                         "description": "Return only the total count of matching files instead of file details. Useful for quick statistics",
                     },
+                    "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": ["roots"],
                 "additionalProperties": False,
@@ -243,7 +253,7 @@ class ListFilesTool(BaseMCPTool):
             else:
                 truncated = False
 
-            return {
+            result = {
                 "success": True,
                 "count_only": True,
                 "total_count": total_count,
@@ -251,6 +261,52 @@ class ListFilesTool(BaseMCPTool):
                 "elapsed_ms": elapsed_ms,
             }
 
+            # 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 = {
+                    "count_only": True,
+                    "total_count": total_count,
+                    "truncated": truncated,
+                    "elapsed_ms": elapsed_ms,
+                    "query_info": {
+                        "roots": arguments.get("roots", []),
+                        "pattern": arguments.get("pattern"),
+                        "glob": arguments.get("glob", False),
+                        "types": arguments.get("types"),
+                        "extensions": arguments.get("extensions"),
+                        "exclude": arguments.get("exclude"),
+                        "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
+                    )
+                    result["output_file"] = saved_path
+                    
+                    if suppress_output:
+                        # Return minimal response to save tokens
+                        return {
+                            "success": True,
+                            "count_only": True,
+                            "total_count": total_count,
+                            "output_file": saved_path,
+                            "message": f"Count results saved to {saved_path}"
+                        }
+                except Exception as e:
+                    logger.warning(f"Failed to save output file: {e}")
+                    result["output_file_error"] = str(e)
+
+            return result
+
         # Truncate defensively even if fd didn't
         truncated = False
         if len(lines) > fd_rg_utils.MAX_RESULTS_HARD_CAP:
@@ -283,10 +339,64 @@ class ListFilesTool(BaseMCPTool):
             except (OSError, ValueError):  # nosec B112
                 continue
 
-        return {
+        result = {
             "success": True,
             "count": len(results),
             "truncated": truncated,
             "elapsed_ms": elapsed_ms,
             "results": results,
         }
+
+        # 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 = {
+                "count": len(results),
+                "truncated": truncated,
+                "elapsed_ms": elapsed_ms,
+                "results": results,
+                "query_info": {
+                    "roots": arguments.get("roots", []),
+                    "pattern": arguments.get("pattern"),
+                    "glob": arguments.get("glob", False),
+                    "types": arguments.get("types"),
+                    "extensions": arguments.get("extensions"),
+                    "exclude": arguments.get("exclude"),
+                    "depth": arguments.get("depth"),
+                    "follow_symlinks": arguments.get("follow_symlinks", False),
+                    "hidden": arguments.get("hidden", False),
+                    "no_ignore": no_ignore,
+                    "size": arguments.get("size"),
+                    "changed_within": arguments.get("changed_within"),
+                    "changed_before": arguments.get("changed_before"),
+                    "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
+                )
+                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}"
+                    }
+            except Exception as e:
+                logger.warning(f"Failed to save output file: {e}")
+                result["output_file_error"] = str(e)
+
+        return result