tree-sitter-analyzer 0.3.0__py3-none-any.whl → 0.6.0__py3-none-any.whl

tree_sitter_analyzer/mcp/server.py

@@ -93,7 +93,7 @@ class TreeSitterAnalyzerMCPServer:
         server: Server = Server(self.name)
 
         # Register tools
-        @server.list_tools()
+        @server.list_tools()  # type: ignore
         async def handle_list_tools() -> list[Tool]:
             """List available tools."""
             tools = [
@@ -144,7 +144,7 @@ class TreeSitterAnalyzerMCPServer:
 
             return tools
 
-        @server.call_tool()
+        @server.call_tool()  # type: ignore
         async def handle_call_tool(
             name: str, arguments: dict[str, Any]
         ) -> list[TextContent]:
@@ -201,7 +201,7 @@ class TreeSitterAnalyzerMCPServer:
                 ]
 
         # Register resources
-        @server.list_resources()
+        @server.list_resources()  # type: ignore
         async def handle_list_resources() -> list[Resource]:
             """List available resources."""
             return [
@@ -225,7 +225,7 @@ class TreeSitterAnalyzerMCPServer:
                 ),
             ]
 
-        @server.read_resource()
+        @server.read_resource()  # type: ignore
         async def handle_read_resource(uri: str) -> str:
             """Read resource content."""
             try:

tree_sitter_analyzer/mcp/tools/analyze_scale_tool.py

@@ -214,7 +214,7 @@ class AnalyzeScaleTool:
         Returns:
             Dictionary containing LLM guidance
         """
-        guidance = {
+        guidance: dict[str, Any] = {
             "analysis_strategy": "",
             "recommended_tools": [],
             "key_areas": [],
@@ -417,35 +417,47 @@ class AnalyzeScaleTool:
                         "classes": len(
                             [
                                 e
-                                for e in analysis_result.elements
+                                for e in (
+                                    analysis_result.elements if analysis_result else []
+                                )
                                 if e.__class__.__name__ == "Class"
                             ]
                         ),
                         "methods": len(
                             [
                                 e
-                                for e in analysis_result.elements
+                                for e in (
+                                    analysis_result.elements if analysis_result else []
+                                )
                                 if e.__class__.__name__ == "Function"
                             ]
                         ),
                         "fields": len(
                             [
                                 e
-                                for e in analysis_result.elements
+                                for e in (
+                                    analysis_result.elements if analysis_result else []
+                                )
                                 if e.__class__.__name__ == "Variable"
                             ]
                         ),
                         "imports": len(
                             [
                                 e
-                                for e in analysis_result.elements
+                                for e in (
+                                    analysis_result.elements if analysis_result else []
+                                )
                                 if e.__class__.__name__ == "Import"
                             ]
                         ),
-                        "annotations": len(getattr(analysis_result, "annotations", [])),
+                        "annotations": len(
+                            getattr(analysis_result, "annotations", [])
+                            if analysis_result
+                            else []
+                        ),
                         "package": (
                             analysis_result.package.name
-                            if analysis_result.package
+                            if analysis_result and analysis_result.package
                             else None
                         ),
                     },
@@ -458,20 +470,27 @@ class AnalyzeScaleTool:
                 # Add detailed information if requested (backward compatibility)
                 if include_details:
                     result["detailed_analysis"] = {
-                        "statistics": analysis_result.get_statistics(),
+                        "statistics": (
+                            analysis_result.get_statistics() if analysis_result else {}
+                        ),
                         "classes": [
                             {
                                 "name": cls.name,
-                                "type": cls.class_type,
-                                "visibility": cls.visibility,
-                                "extends": cls.extends_class,
-                                "implements": cls.implements_interfaces,
-                                "annotations": [ann.name for ann in cls.annotations],
+                                "type": getattr(cls, "class_type", "unknown"),
+                                "visibility": getattr(cls, "visibility", "unknown"),
+                                "extends": getattr(cls, "extends_class", None),
+                                "implements": getattr(cls, "implements_interfaces", []),
+                                "annotations": [
+                                    getattr(ann, "name", str(ann))
+                                    for ann in getattr(cls, "annotations", [])
+                                ],
                                 "lines": f"{cls.start_line}-{cls.end_line}",
                             }
                             for cls in [
                                 e
-                                for e in analysis_result.elements
+                                for e in (
+                                    analysis_result.elements if analysis_result else []
+                                )
                                 if e.__class__.__name__ == "Class"
                             ]
                         ],
@@ -479,35 +498,49 @@ class AnalyzeScaleTool:
                             {
                                 "name": method.name,
                                 "file_path": getattr(method, "file_path", file_path),
-                                "visibility": method.visibility,
-                                "return_type": method.return_type,
-                                "parameters": len(method.parameters),
-                                "annotations": [ann.name for ann in method.annotations],
-                                "is_constructor": method.is_constructor,
-                                "is_static": method.is_static,
-                                "complexity": method.complexity_score,
+                                "visibility": getattr(method, "visibility", "unknown"),
+                                "return_type": getattr(
+                                    method, "return_type", "unknown"
+                                ),
+                                "parameters": len(getattr(method, "parameters", [])),
+                                "annotations": [
+                                    getattr(ann, "name", str(ann))
+                                    for ann in getattr(method, "annotations", [])
+                                ],
+                                "is_constructor": getattr(
+                                    method, "is_constructor", False
+                                ),
+                                "is_static": getattr(method, "is_static", False),
+                                "complexity": getattr(method, "complexity_score", 0),
                                 "lines": f"{method.start_line}-{method.end_line}",
                             }
                             for method in [
                                 e
-                                for e in analysis_result.elements
+                                for e in (
+                                    analysis_result.elements if analysis_result else []
+                                )
                                 if e.__class__.__name__ == "Function"
                             ]
                         ],
                         "fields": [
                             {
                                 "name": field.name,
-                                "type": field.field_type,
+                                "type": getattr(field, "field_type", "unknown"),
                                 "file_path": getattr(field, "file_path", file_path),
-                                "visibility": field.visibility,
-                                "is_static": field.is_static,
-                                "is_final": field.is_final,
-                                "annotations": [ann.name for ann in field.annotations],
+                                "visibility": getattr(field, "visibility", "unknown"),
+                                "is_static": getattr(field, "is_static", False),
+                                "is_final": getattr(field, "is_final", False),
+                                "annotations": [
+                                    getattr(ann, "name", str(ann))
+                                    for ann in getattr(field, "annotations", [])
+                                ],
                                 "lines": f"{field.start_line}-{field.end_line}",
                             }
                             for field in [
                                 e
-                                for e in analysis_result.elements
+                                for e in (
+                                    analysis_result.elements if analysis_result else []
+                                )
                                 if e.__class__.__name__ == "Variable"
                             ]
                         ],
@@ -517,14 +550,14 @@ class AnalyzeScaleTool:
                 classes_count = len(
                     [
                         e
-                        for e in analysis_result.elements
+                        for e in (analysis_result.elements if analysis_result else [])
                         if e.__class__.__name__ == "Class"
                     ]
                 )
                 methods_count = len(
                     [
                         e
-                        for e in analysis_result.elements
+                        for e in (analysis_result.elements if analysis_result else [])
                         if e.__class__.__name__ == "Function"
                     ]
                 )

tree_sitter_analyzer/mcp/tools/analyze_scale_tool_cli_compatible.py

@@ -8,7 +8,7 @@ that matches the CLI --advanced --statistics output exactly.
 
 import time
 from pathlib import Path
-from typing import Any
+from typing import Any, cast
 
 from ...core.analysis_engine import get_analysis_engine
 from ...language_detector import detect_language_from_file
@@ -104,8 +104,10 @@ class AnalyzeScaleToolCLICompatible:
             # Use AdvancedAnalyzer for comprehensive analysis
             analysis_result = await self.analysis_engine.analyze_file(file_path)
 
-            if analysis_result is None:
-                # Return CLI-compatible error format
+            # Handle potential None result (for testing purposes with mocked engine)
+            # This can only happen in tests where the engine is mocked to return None
+            # Use cast to tell MyPy this is possible in testing scenarios
+            if cast(Any, analysis_result) is None:
                 return {
                     "file_path": file_path,
                     "success": False,
@@ -129,7 +131,10 @@ class AnalyzeScaleToolCLICompatible:
                 "file_path": file_path,
                 "success": True,
                 "package_name": (
-                    analysis_result.package.name if analysis_result.package else None
+                    analysis_result.package.name
+                    if analysis_result.package
+                    and hasattr(analysis_result.package, "name")
+                    else None
                 ),
                 "element_counts": {
                     "imports": len(analysis_result.imports),

tree_sitter_analyzer/mcp/tools/table_format_tool.py

@@ -157,7 +157,7 @@ class TableFormatTool:
         # Fallback to original conversion method
         return self._convert_parameters(parameters)
 
-    def _get_field_modifiers(self, field) -> list:
+    def _get_field_modifiers(self, field: Any) -> list[str]:
         """Extract field modifiers as a list"""
         modifiers = []
 
@@ -172,7 +172,7 @@ class TableFormatTool:
             modifiers.append("final")
         return modifiers
 
-    def _convert_analysis_result_to_dict(self, result) -> dict[str, Any]:
+    def _convert_analysis_result_to_dict(self, result: Any) -> dict[str, Any]:
         """Convert AnalysisResult to dictionary format expected by TableFormatter"""
         # Extract elements by type
         classes = [e for e in result.elements if e.__class__.__name__ == "Class"]

tree_sitter_analyzer/mcp/utils/__init__.py

@@ -9,6 +9,8 @@ Note: Cache and performance monitoring functionality has been moved to
 the unified core services for better architecture.
 """
 
+from typing import Any
+
 # Export main utility classes and functions
 from .error_handler import (
     AnalysisError,
@@ -50,36 +52,36 @@ try:
     class BackwardCompatibleCacheManager:
         """Backward compatible cache manager wrapper"""
 
-        def __init__(self):
+        def __init__(self) -> None:
             self._cache_service = UnifiedCacheService()
 
-        def clear_all_caches(self):
+        def clear_all_caches(self) -> None:
             """Backward compatibility: clear all caches"""
             return self._cache_service.clear()
 
-        def get_cache_stats(self):
+        def get_cache_stats(self) -> dict[str, Any]:
             """Backward compatibility: get cache statistics"""
             return self._cache_service.get_stats()
 
-        def __getattr__(self, name):
+        def __getattr__(self, name: str) -> Any:
             """Delegate other methods to the cache service"""
             return getattr(self._cache_service, name)
 
-    def get_cache_manager():
+    def get_cache_manager() -> Any:
         """Backward compatibility: Get unified cache service"""
         return BackwardCompatibleCacheManager()
 
-    def get_performance_monitor():
+    def get_performance_monitor() -> Any:
         """Backward compatibility: Get unified analysis engine for performance monitoring"""
         return UnifiedAnalysisEngine()
 
 except ImportError:
     # Fallback if core services are not available
-    def get_cache_manager():
+    def get_cache_manager() -> Any:
         """Fallback cache manager"""
         return None
 
-    def get_performance_monitor():
+    def get_performance_monitor() -> Any:
         """Fallback performance monitor"""
         return None