tree-sitter-analyzer 1.9.1__py3-none-any.whl → 1.9.3__py3-none-any.whl

tree_sitter_analyzer/mcp/server.py

@@ -25,23 +25,23 @@ except ImportError:
     MCP_AVAILABLE = False
 
     # Fallback types for development without MCP
-    class Server:
+    class Server:  # type: ignore
         pass
 
-    class InitializationOptions:
+    class InitializationOptions:  # type: ignore
         def __init__(self, **kwargs: Any) -> None:
             pass
 
-    class Tool:
+    class Tool:  # type: ignore
         pass
 
-    class Resource:
+    class Resource:  # type: ignore
         pass
 
-    class TextContent:
+    class TextContent:  # type: ignore
         pass
 
-    def stdio_server() -> None:
+    def stdio_server() -> None:  # type: ignore[misc]
         pass
 
 
@@ -70,8 +70,11 @@ from .tools.table_format_tool import TableFormatTool
 # Import UniversalAnalyzeTool at module level for test compatibility
 try:
     from .tools.universal_analyze_tool import UniversalAnalyzeTool
+
+    UNIVERSAL_TOOL_AVAILABLE = True
 except ImportError:
-    UniversalAnalyzeTool: type[Any] | None = None
+    UniversalAnalyzeTool = None  # type: ignore
+    UNIVERSAL_TOOL_AVAILABLE = False
 
 # Set up logging
 logger = setup_logger(__name__)
@@ -112,13 +115,15 @@ class TreeSitterAnalyzerMCPServer:
 
         # Optional universal tool to satisfy initialization tests
         # Allow tests to control initialization by checking if UniversalAnalyzeTool is available
-        if UniversalAnalyzeTool is not None:
+        if UNIVERSAL_TOOL_AVAILABLE and UniversalAnalyzeTool is not None:
             try:
-                self.universal_analyze_tool = UniversalAnalyzeTool(project_root)
+                self.universal_analyze_tool: UniversalAnalyzeTool | None = (
+                    UniversalAnalyzeTool(project_root)
+                )
             except Exception:
-                self.universal_analyze_tool: Any = None
+                self.universal_analyze_tool = None
         else:
-            self.universal_analyze_tool: Any = None
+            self.universal_analyze_tool = None
 
         # Initialize MCP resources
         self.code_file_resource = CodeFileResource()
@@ -162,9 +167,11 @@ class TreeSitterAnalyzerMCPServer:
 
         # For specific initialization tests we allow delegating to universal tool
         if "file_path" not in arguments:
-            if getattr(self, "universal_analyze_tool", None) is not None:
+            universal_tool = getattr(self, "universal_analyze_tool", None)
+            if universal_tool is not None:
                 try:
-                    return await self.universal_analyze_tool.execute(arguments)
+                    result = await universal_tool.execute(arguments)
+                    return dict(result)  # Ensure proper type casting
                 except ValueError:
                     # Re-raise ValueError as-is for test compatibility
                     raise
@@ -338,8 +345,9 @@ class TreeSitterAnalyzerMCPServer:
             Dictionary containing file metrics
         """
         try:
-            with open(file_path, encoding="utf-8") as f:
-                content = f.read()
+            from ..encoding_utils import read_file_safe
+
+            content, _ = read_file_safe(file_path)
 
             lines = content.split("\n")
             total_lines = len(lines)
@@ -400,10 +408,6 @@ class TreeSitterAnalyzerMCPServer:
                     if "-->" not in stripped:
                         in_multiline_comment = True
                     continue
-                elif in_multiline_comment and "-->" in stripped:
-                    comment_lines += 1
-                    in_multiline_comment = False
-                    continue
 
                 # If not a comment, it's code
                 code_lines += 1
@@ -444,7 +448,7 @@ class TreeSitterAnalyzerMCPServer:
         server: Server = Server(self.name)
 
         # Register tools using @server decorators (standard MCP pattern)
-        @server.list_tools()
+        @server.list_tools()  # type: ignore[misc]
         async def handle_list_tools() -> list[Tool]:
             """List all available tools."""
             logger.info("Client requesting tools list")
@@ -477,7 +481,7 @@ class TreeSitterAnalyzerMCPServer:
             logger.info(f"Returning {len(tools)} tools: {[t.name for t in tools]}")
             return tools
 
-        @server.call_tool()
+        @server.call_tool()  # type: ignore[misc]
         async def handle_call_tool(
             name: str, arguments: dict[str, Any]
         ) -> list[TextContent]:
@@ -634,9 +638,10 @@ class TreeSitterAnalyzerMCPServer:
                     pass  # Silently ignore logging errors during shutdown
                 raise
 
+        # Some clients may request prompts; explicitly return empty list
         # Some clients may request prompts; explicitly return empty list
         try:
-            from mcp.types import Prompt  # type: ignore
+            from mcp.types import Prompt
 
             @server.list_prompts()  # type: ignore
             async def handle_list_prompts() -> list[Prompt]:
@@ -701,10 +706,20 @@ class TreeSitterAnalyzerMCPServer:
         server = self.create_server()
 
         # Initialize server options with required capabilities field
+        from mcp.server.models import ServerCapabilities
+        from mcp.types import ToolsCapability, ResourcesCapability, PromptsCapability, LoggingCapability
+        
+        capabilities = ServerCapabilities(
+            tools=ToolsCapability(listChanged=True),
+            resources=ResourcesCapability(subscribe=True, listChanged=True),
+            prompts=PromptsCapability(listChanged=True),
+            logging=LoggingCapability()
+        )
+        
         options = InitializationOptions(
             server_name=self.name,
             server_version=self.version,
-            capabilities={"tools": {}, "resources": {}, "prompts": {}, "logging": {}},
+            capabilities=capabilities,
         )
 
         try:

tree_sitter_analyzer/mcp/tools/analyze_scale_tool.py

@@ -65,8 +65,9 @@ class AnalyzeScaleTool(BaseMCPTool):
             Dictionary containing file metrics
         """
         try:
-            with open(file_path, encoding="utf-8") as f:
-                content = f.read()
+            from ...encoding_utils import read_file_safe
+
+            content, _ = read_file_safe(file_path)
 
             lines = content.split("\n")
             total_lines = len(lines)
@@ -736,11 +737,13 @@ class AnalyzeScaleTool(BaseMCPTool):
                 "methods": [],
                 "fields": [],
             },
-            "scale_category": "small"
-            if file_metrics["total_lines"] < 100
-            else "medium"
-            if file_metrics["total_lines"] < 1000
-            else "large",
+            "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",

tree_sitter_analyzer/mcp/tools/analyze_scale_tool_cli_compatible.py

@@ -137,19 +137,63 @@ class AnalyzeScaleToolCLICompatible:
                     else None
                 ),
                 "element_counts": {
-                    "imports": len(analysis_result.imports),
-                    "classes": len(analysis_result.classes),
-                    "methods": len(analysis_result.methods),
-                    "fields": len(analysis_result.fields),
-                    "annotations": len(getattr(analysis_result, "annotations", [])),
+                    "imports": len(
+                        [
+                            e
+                            for e in analysis_result.elements
+                            if getattr(e, "element_type", "") == "import"
+                        ]
+                    ),
+                    "classes": len(
+                        [
+                            e
+                            for e in analysis_result.elements
+                            if getattr(e, "element_type", "") == "class"
+                        ]
+                    ),
+                    "methods": len(
+                        [
+                            e
+                            for e in analysis_result.elements
+                            if getattr(e, "element_type", "") == "function"
+                        ]
+                    ),
+                    "fields": len(
+                        [
+                            e
+                            for e in analysis_result.elements
+                            if getattr(e, "element_type", "") == "variable"
+                        ]
+                    ),
+                    "annotations": len(
+                        [
+                            e
+                            for e in analysis_result.elements
+                            if getattr(e, "element_type", "") == "annotation"
+                        ]
+                    ),
                 },
                 "analysis_time_ms": analysis_time_ms,
                 "error_message": None,
             }
 
+            classes_count = len(
+                [
+                    e
+                    for e in analysis_result.elements
+                    if getattr(e, "element_type", "") == "class"
+                ]
+            )
+            methods_count = len(
+                [
+                    e
+                    for e in analysis_result.elements
+                    if getattr(e, "element_type", "") == "function"
+                ]
+            )
             logger.info(
-                f"Successfully analyzed {file_path}: {len(analysis_result.classes)} classes, "
-                f"{len(analysis_result.methods)} methods, {analysis_time_ms}ms"
+                f"Successfully analyzed {file_path}: {classes_count} classes, "
+                f"{methods_count} methods, {analysis_time_ms}ms"
             )
 
             return result

tree_sitter_analyzer/mcp/tools/fd_rg_utils.py

@@ -397,7 +397,13 @@ def group_matches_by_file(matches: list[dict[str, Any]]) -> dict[str, Any]:
     # Convert to grouped structure
     files = []
     for file_path, file_matches in file_groups.items():
-        files.append({"file": file_path, "matches": file_matches})
+        files.append(
+            {
+                "file": file_path,
+                "matches": file_matches,
+                "match_count": len(file_matches),
+            }
+        )
 
     return {"success": True, "count": total_matches, "files": files}
 
@@ -516,6 +522,11 @@ def summarize_search_results(
                 sample_lines.append(f"L{line_num}: {truncated_line}")
                 remaining_lines -= 1
 
+        # Ensure we have at least some sample lines if matches exist
+        if not sample_lines and file_matches:
+            # Fallback: create a simple summary line
+            sample_lines.append(f"Found {len(file_matches)} matches")
+
         # Optimize file path for token efficiency
         optimized_path = _optimize_file_path(file_path, common_prefix)
 
@@ -628,7 +639,9 @@ def write_files_to_temp(files: list[str]) -> TempFileList:
     fd, temp_path = tempfile.mkstemp(prefix="rg-files-", suffix=".lst")
     os.close(fd)
     content = "\n".join(files)
-    Path(temp_path).write_text(content, encoding="utf-8")
+    from ...encoding_utils import write_file_safe
+
+    write_file_safe(temp_path, content)
     return TempFileList(path=temp_path)
 
 

tree_sitter_analyzer/mcp/tools/find_and_grep_tool.py

@@ -249,7 +249,7 @@ class FindAndGrepTool(BaseMCPTool):
         return True
 
     @handle_mcp_errors("find_and_grep")
-    async def execute(self, arguments: dict[str, Any]) -> dict[str, Any]:
+    async def execute(self, arguments: dict[str, Any]) -> dict[str, Any] | int:
         # Check if both fd and rg commands are available
         missing_commands = fd_rg_utils.get_missing_commands()
         if missing_commands:
@@ -341,14 +341,14 @@ class FindAndGrepTool(BaseMCPTool):
                     files.sort()
                 elif sort_mode == "mtime":
 
-                    def get_mtime(p):
+                    def get_mtime(p: str) -> float:
                         path_obj = pathlib.Path(p)
                         return path_obj.stat().st_mtime if path_obj.exists() else 0
 
                     files.sort(key=get_mtime, reverse=True)
                 elif sort_mode == "size":
 
-                    def get_size(p):
+                    def get_size(p: str) -> int:
                         path_obj = pathlib.Path(p)
                         return path_obj.stat().st_size if path_obj.exists() else 0
 
@@ -628,9 +628,11 @@ 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"],
                         }

tree_sitter_analyzer/mcp/tools/list_files_tool.py

@@ -301,7 +301,7 @@ class ListFilesTool(BaseMCPTool):
                     saved_path = file_manager.save_to_file(
                         content=json_content, base_name=output_file
                     )
-                    result["output_file"] = saved_path
+                    result["output_file"] = saved_path  # type: ignore[assignment]
 
                     if suppress_output:
                         # Return minimal response to save tokens
@@ -314,7 +314,7 @@ class ListFilesTool(BaseMCPTool):
                         }
                 except Exception as e:
                     logger.warning(f"Failed to save output file: {e}")
-                    result["output_file_error"] = str(e)
+                    result["output_file_error"] = str(e)  # type: ignore[assignment]
 
             return result
 
@@ -350,7 +350,7 @@ class ListFilesTool(BaseMCPTool):
             except (OSError, ValueError):  # nosec B112
                 continue
 
-        result = {
+        final_result: dict[str, Any] = {
             "success": True,
             "count": len(results),
             "truncated": truncated,
@@ -396,7 +396,7 @@ class ListFilesTool(BaseMCPTool):
                 saved_path = file_manager.save_to_file(
                     content=json_content, base_name=output_file
                 )
-                result["output_file"] = saved_path
+                final_result["output_file"] = saved_path
 
                 if suppress_output:
                     # Return minimal response to save tokens
@@ -408,6 +408,6 @@ class ListFilesTool(BaseMCPTool):
                     }
             except Exception as e:
                 logger.warning(f"Failed to save output file: {e}")
-                result["output_file_error"] = str(e)
+                final_result["output_file_error"] = str(e)
 
-        return result
+        return final_result

tree_sitter_analyzer/mcp/tools/search_content_tool.py

@@ -341,21 +341,50 @@ class SearchContentTool(BaseMCPTool):
             # Simple cache lookup without complex cross-format logic for performance
             cached_result = self.cache.get(cache_key)
             if cached_result is not None:
-                # Add cache hit indicator to result
-                if isinstance(cached_result, dict):
-                    cached_result = cached_result.copy()
-                    cached_result["cache_hit"] = True
-                    return cached_result
-                elif isinstance(cached_result, int):
-                    # For integer results (like total_only mode), return as-is
-                    return cached_result
+                # Check if this is a total_only request
+                total_only_requested = arguments.get("total_only", False)
+
+                if total_only_requested:
+                    # For total_only mode, always return integer if possible
+                    if isinstance(cached_result, int):
+                        return cached_result
+                    elif (
+                        isinstance(cached_result, dict)
+                        and "total_matches" in cached_result
+                    ):
+                        total_matches = cached_result["total_matches"]
+                        return (
+                            int(total_matches)
+                            if isinstance(total_matches, (int, float))
+                            else 0
+                        )
+                    elif isinstance(cached_result, dict) and "count" in cached_result:
+                        count = cached_result["count"]
+                        return int(count) if isinstance(count, (int, float)) else 0
+                    else:
+                        # Fallback: extract count from dict or return 0
+                        return 0
                 else:
-                    # For other types, convert to dict format
-                    return {
-                        "success": True,
-                        "cached_result": cached_result,
-                        "cache_hit": True,
-                    }
+                    # For non-total_only modes, return dict format
+                    if isinstance(cached_result, dict):
+                        cached_result = cached_result.copy()
+                        cached_result["cache_hit"] = True
+                        return cached_result
+                    elif isinstance(cached_result, int):
+                        # Convert integer to dict format for non-total_only modes
+                        return {
+                            "success": True,
+                            "count": cached_result,
+                            "total_matches": cached_result,
+                            "cache_hit": True,
+                        }
+                    else:
+                        # For other types, convert to dict format
+                        return {
+                            "success": True,
+                            "cached_result": cached_result,
+                            "cache_hit": True,
+                        }
 
         # Handle max_count parameter properly
         # If user specifies max_count, use it directly (with reasonable upper limit)
@@ -731,11 +760,11 @@ class SearchContentTool(BaseMCPTool):
                     "elapsed_ms": elapsed_ms,
                     "results": matches,
                     "summary": fd_rg_utils.summarize_search_results(matches),
-                    "grouped_by_file": fd_rg_utils.group_matches_by_file(matches)[
-                        "files"
-                    ]
-                    if matches
-                    else [],
+                    "grouped_by_file": (
+                        fd_rg_utils.group_matches_by_file(matches)["files"]
+                        if matches
+                        else []
+                    ),
                 }
 
                 # Convert to JSON for file output

tree_sitter_analyzer/mcp/tools/table_format_tool.py

@@ -374,8 +374,9 @@ class TableFormatTool(BaseMCPTool):
 
         # Write content to file
         try:
-            with open(output_path, "w", encoding="utf-8") as f:
-                f.write(content)
+            from ...encoding_utils import write_file_safe
+
+            write_file_safe(output_path, content)
             self.logger.info(f"Output written to file: {output_path}")
             return output_path
         except Exception as e:
@@ -471,19 +472,23 @@ class TableFormatTool(BaseMCPTool):
                 try:
                     if FormatterRegistry.is_format_supported(format_type):
                         # Use new FormatterRegistry
-                        formatter = FormatterRegistry.get_formatter(format_type)
-                        table_output = formatter.format(structure_result.elements)
+                        registry_formatter = FormatterRegistry.get_formatter(
+                            format_type
+                        )
+                        table_output = registry_formatter.format(
+                            structure_result.elements
+                        )
                     else:
                         # Fallback to legacy TableFormatter for backward compatibility
-                        formatter: Any = TableFormatter(format_type)
-                        table_output = formatter.format_structure(structure_dict)  # type: ignore[attr-defined]
+                        legacy_formatter: Any = TableFormatter(format_type)
+                        table_output = legacy_formatter.format_structure(structure_dict)
                 except Exception as e:
                     # If FormatterRegistry fails, fallback to legacy TableFormatter
                     logger.warning(
                         f"FormatterRegistry failed, using legacy formatter: {e}"
                     )
-                    formatter: Any = TableFormatter(format_type)
-                    table_output = formatter.format_structure(structure_dict)  # type: ignore[attr-defined]
+                    fallback_formatter: Any = TableFormatter(format_type)
+                    table_output = fallback_formatter.format_structure(structure_dict)
 
                 # Ensure output format matches CLI exactly
                 # Fix line ending differences: normalize to Unix-style LF (\n)

tree_sitter_analyzer/mcp/utils/file_output_manager.py

@@ -36,7 +36,7 @@ class FileOutputManager:
             project_root: Optional project root directory for fallback output path
         """
         self.project_root = project_root
-        self._output_path = None
+        self._output_path: str | None = None
         self._initialize_output_path()
 
     @classmethod
@@ -252,6 +252,10 @@ class FileOutputManager:
             output_file = output_path / filename
         else:
             # Generate filename with appropriate extension
+            if base_name is None:
+                raise ValueError(
+                    "base_name cannot be None when filename is not provided"
+                )
             generated_filename = self.generate_output_filename(base_name, content)
             output_file = output_path / generated_filename
 
@@ -260,8 +264,9 @@ class FileOutputManager:
 
         # Write content to file
         try:
-            with open(output_file, "w", encoding="utf-8") as f:
-                f.write(content)
+            from ...encoding_utils import write_file_safe
+
+            write_file_safe(output_file, content)
 
             logger.info(f"Content saved to file: {output_file}")
             return str(output_file)

tree_sitter_analyzer/mcp/utils/gitignore_detector.py

@@ -16,7 +16,7 @@ logger = logging.getLogger(__name__)
 class GitignoreDetector:
     """Detects .gitignore interference with file searches"""
 
-    def __init__(self):
+    def __init__(self) -> None:
         self.common_ignore_patterns = {
             # Directory patterns that commonly cause search issues
             "build/*",
@@ -116,8 +116,10 @@ class GitignoreDetector:
             current_search_dir: Directory where the search is being performed
         """
         try:
-            with open(gitignore_file, encoding="utf-8", errors="ignore") as f:
-                lines = f.readlines()
+            from ...encoding_utils import read_file_safe
+
+            content, _ = read_file_safe(gitignore_file)
+            lines = content.splitlines()
 
             for line in lines:
                 line = line.strip()
@@ -257,14 +259,14 @@ class GitignoreDetector:
 
     def get_detection_info(
         self, roots: list[str], project_root: str | None = None
-    ) -> dict:
+    ) -> dict[str, object]:
         """
         Get detailed information about gitignore detection
 
         Returns:
             Dictionary with detection details for debugging/logging
         """
-        info = {
+        info: dict[str, object] = {
             "should_use_no_ignore": False,
             "detected_gitignore_files": [],
             "interfering_patterns": [],
@@ -294,13 +296,21 @@ class GitignoreDetector:
                     gitignore_file, gitignore_dir, project_path
                 )
                 if patterns:
-                    info["interfering_patterns"].extend(patterns)
-
-            if info["interfering_patterns"]:
+                    existing_patterns = info.get("interfering_patterns", [])
+                    if isinstance(existing_patterns, list):
+                        info["interfering_patterns"] = existing_patterns + patterns
+                    else:
+                        info["interfering_patterns"] = patterns
+
+            interfering_patterns = info.get("interfering_patterns", [])
+            if interfering_patterns:
                 info["should_use_no_ignore"] = True
-                info["reason"] = (
-                    f"Found {len(info['interfering_patterns'])} interfering patterns"
+                pattern_count = (
+                    len(interfering_patterns)
+                    if isinstance(interfering_patterns, list)
+                    else 0
                 )
+                info["reason"] = f"Found {pattern_count} interfering patterns"
 
         except Exception as e:
             info["reason"] = f"Error during detection: {e}"
@@ -314,8 +324,10 @@ class GitignoreDetector:
         interfering = []
 
         try:
-            with open(gitignore_file, encoding="utf-8", errors="ignore") as f:
-                lines = f.readlines()
+            from ...encoding_utils import read_file_safe
+
+            content, _ = read_file_safe(gitignore_file)
+            lines = content.splitlines()
 
             for line in lines:
                 line = line.strip()

tree_sitter_analyzer/mcp/utils/path_resolver.py

@@ -52,7 +52,7 @@ def _normalize_path_cross_platform(path_str: str) -> str:
             from ctypes import wintypes
 
             # GetLongPathNameW function
-            _GetLongPathNameW = ctypes.windll.kernel32.GetLongPathNameW  # type: ignore[attr-defined]
+            _GetLongPathNameW = ctypes.windll.kernel32.GetLongPathNameW
             _GetLongPathNameW.argtypes = [
                 wintypes.LPCWSTR,
                 wintypes.LPWSTR,
@@ -110,7 +110,7 @@ class PathResolver:
             project_root: Optional project root directory for resolving relative paths
         """
         self.project_root = None
-        self._cache = {}  # Simple cache for resolved paths
+        self._cache: dict[str, str] = {}  # Simple cache for resolved paths
         self._cache_size_limit = 100  # Limit cache size to prevent memory issues
 
         if project_root:

tree_sitter_analyzer/models.py

@@ -45,6 +45,14 @@ class CodeElement(ABC):
     raw_text: str = ""
     language: str = "unknown"
     docstring: str | None = None  # JavaDoc/docstring for this element
+    element_type: str = "unknown"
+
+    def to_summary_item(self) -> dict[str, Any]:
+        return {
+            "name": self.name,
+            "type": self.element_type,
+            "lines": {"start": self.start_line, "end": self.end_line},
+        }
 
 
 @dataclass(frozen=False)
@@ -341,6 +349,14 @@ class JavaPackage:
     start_line: int = 0
     end_line: int = 0
 
+    def to_summary_item(self) -> dict[str, Any]:
+        """Return dictionary for summary item"""
+        return {
+            "name": self.name,
+            "type": "package",
+            "lines": {"start": self.start_line, "end": self.end_line},
+        }
+
 
 @dataclass(frozen=False)
 class AnalysisResult: