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

tree_sitter_analyzer/exceptions.py

@@ -42,7 +42,7 @@ class AnalysisError(TreeSitterAnalyzerError):
         message: str,
         file_path: str | Path | None = None,
         language: str | None = None,
-        **kwargs,
+        **kwargs: Any,
     ) -> None:
         context = kwargs.get("context", {})
         if file_path:
@@ -60,7 +60,7 @@ class ParseError(TreeSitterAnalyzerError):
         message: str,
         language: str | None = None,
         source_info: dict[str, Any] | None = None,
-        **kwargs,
+        **kwargs: Any,
     ) -> None:
         context = kwargs.get("context", {})
         if language:
@@ -74,7 +74,7 @@ class LanguageNotSupportedError(TreeSitterAnalyzerError):
     """Raised when a language is not supported."""
 
     def __init__(
-        self, language: str, supported_languages: list | None = None, **kwargs
+        self, language: str, supported_languages: list[str] | None = None, **kwargs: Any
     ) -> None:
         message = f"Language '{language}' is not supported"
         context = kwargs.get("context", {})
@@ -93,7 +93,7 @@ class PluginError(TreeSitterAnalyzerError):
         message: str,
         plugin_name: str | None = None,
         operation: str | None = None,
-        **kwargs,
+        **kwargs: Any,
     ) -> None:
         context = kwargs.get("context", {})
         if plugin_name:
@@ -112,7 +112,7 @@ class QueryError(TreeSitterAnalyzerError):
         query_name: str | None = None,
         query_string: str | None = None,
         language: str | None = None,
-        **kwargs,
+        **kwargs: Any,
     ) -> None:
         context = kwargs.get("context", {})
         if query_name:
@@ -132,7 +132,7 @@ class FileHandlingError(TreeSitterAnalyzerError):
         message: str,
         file_path: str | Path | None = None,
         operation: str | None = None,
-        **kwargs,
+        **kwargs: Any,
     ) -> None:
         context = kwargs.get("context", {})
         if file_path:
@@ -150,7 +150,7 @@ class ConfigurationError(TreeSitterAnalyzerError):
         message: str,
         config_key: str | None = None,
         config_value: Any | None = None,
-        **kwargs,
+        **kwargs: Any,
     ) -> None:
         context = kwargs.get("context", {})
         if config_key:
@@ -168,7 +168,7 @@ class ValidationError(TreeSitterAnalyzerError):
         message: str,
         validation_type: str | None = None,
         invalid_value: Any | None = None,
-        **kwargs,
+        **kwargs: Any,
     ) -> None:
         context = kwargs.get("context", {})
         if validation_type:
@@ -186,7 +186,7 @@ class MCPError(TreeSitterAnalyzerError):
         message: str,
         tool_name: str | None = None,
         resource_uri: str | None = None,
-        **kwargs,
+        **kwargs: Any,
     ) -> None:
         context = kwargs.get("context", {})
         if tool_name:
@@ -200,7 +200,7 @@ class MCPError(TreeSitterAnalyzerError):
 def handle_exception(
     exception: Exception,
     context: dict[str, Any] | None = None,
-    reraise_as: type | None = None,
+    reraise_as: type[Exception] | None = None,
 ) -> None:
     """
     Handle exceptions with optional context and re-raising.
@@ -231,13 +231,13 @@ def handle_exception(
 
 
 def safe_execute(
-    func,
-    *args,
-    default_return=None,
-    exception_types: tuple = (Exception,),
+    func: Any,
+    *args: Any,
+    default_return: Any = None,
+    exception_types: tuple[type[Exception], ...] = (Exception,),
     log_errors: bool = True,
-    **kwargs,
-):
+    **kwargs: Any,
+) -> Any:
     """
     Safely execute a function with exception handling.
 
@@ -277,7 +277,7 @@ def create_error_response(
     """
     import traceback
 
-    response = {
+    response: dict[str, Any] = {
         "success": False,
         "error": {"type": exception.__class__.__name__, "message": str(exception)},
     }
@@ -299,11 +299,11 @@ def create_error_response(
 
 # Decorator for exception handling
 def handle_exceptions(
-    default_return=None,
-    exception_types: tuple = (Exception,),
-    reraise_as: type | None = None,
+    default_return: Any = None,
+    exception_types: tuple[type[Exception], ...] = (Exception,),
+    reraise_as: type[Exception] | None = None,
     log_errors: bool = True,
-):
+) -> Any:
     """
     Decorator for automatic exception handling.
 
@@ -314,8 +314,8 @@ def handle_exceptions(
         log_errors: Whether to log errors
     """
 
-    def decorator(func):
-        def wrapper(*args, **kwargs):
+    def decorator(func: Any) -> Any:
+        def wrapper(*args: Any, **kwargs: Any) -> Any:
             try:
                 return func(*args, **kwargs)
             except exception_types as e:

tree_sitter_analyzer/file_handler.py

@@ -62,14 +62,10 @@ def read_file_with_fallback(file_path: str) -> bytes | None:
 
     try:
         content, detected_encoding = read_file_safe(file_path)
-        if content is not None:  # 空文字列も有効なコンテンツ
-            log_info(
-                f"Successfully read file {file_path} with encoding: {detected_encoding}"
-            )
-            return content.encode("utf-8")
-        else:
-            log_warning(f"File {file_path} is empty or could not be read")
-            return b""
+        log_info(
+            f"Successfully read file {file_path} with encoding: {detected_encoding}"
+        )
+        return content.encode("utf-8")
 
     except Exception as e:
         log_error(f"Failed to read file {file_path}: {e}")
@@ -113,9 +109,6 @@ def read_file_partial(
     try:
         # ファイル全体を安全に読み込み
         content, detected_encoding = read_file_safe(file_path)
-        if content is None:
-            log_error(f"Failed to read file: {file_path}")
-            return None
 
         # 行に分割
         lines = content.splitlines(keepends=True)

tree_sitter_analyzer/formatters/java_formatter.py

@@ -266,22 +266,26 @@ class JavaTableFormatter(BaseTableFormatter):
 
         # Map<String,Object> -> M<S,O>
         if "Map<" in type_name:
-            return (
+            result = (
                 type_name.replace("Map<", "M<")
                 .replace("String", "S")
                 .replace("Object", "O")
             )
+            return str(result)
 
         # List<String> -> L<S>
         if "List<" in type_name:
-            return type_name.replace("List<", "L<").replace("String", "S")
+            result = type_name.replace("List<", "L<").replace("String", "S")
+            return str(result)
 
         # String[] -> S[]
         if "[]" in type_name:
             base_type = type_name.replace("[]", "")
             if base_type:
-                return type_mapping.get(base_type, base_type[0].upper()) + "[]"
+                result = type_mapping.get(base_type, base_type[0].upper()) + "[]"
+                return str(result)
             else:
                 return "O[]"
 
-        return type_mapping.get(type_name, type_name)
+        result = type_mapping.get(type_name, type_name)
+        return str(result)

tree_sitter_analyzer/formatters/python_formatter.py

@@ -236,20 +236,24 @@ class PythonTableFormatter(BaseTableFormatter):
 
         # List[str] -> L[s]
         if "List[" in type_name:
-            return (
+            result = (
                 type_name.replace("List[", "L[").replace("str", "s").replace("int", "i")
             )
+            return str(result)
 
         # Dict[str, int] -> D[s,i]
         if "Dict[" in type_name:
-            return (
+            result = (
                 type_name.replace("Dict[", "D[").replace("str", "s").replace("int", "i")
             )
+            return str(result)
 
         # Optional[str] -> O[s]
         if "Optional[" in type_name:
-            return type_name.replace("Optional[", "O[").replace("str", "s")
+            result = type_name.replace("Optional[", "O[").replace("str", "s")
+            return str(result)
 
-        return type_mapping.get(
+        result = type_mapping.get(
             type_name, type_name[:3] if len(type_name) > 3 else type_name
         )
+        return str(result)

tree_sitter_analyzer/interfaces/cli.py

@@ -407,7 +407,7 @@ def format_analysis_output(result: dict[str, Any], output_format: str) -> None:
     elements = result.get("elements", [])
     if elements:
         print(f"\nCode Elements: {len(elements)} found")
-        element_types = {}
+        element_types: dict[str, int] = {}
         for element in elements:
             elem_type = element.get("type", "unknown")
             element_types[elem_type] = element_types.get(elem_type, 0) + 1

tree_sitter_analyzer/interfaces/cli_adapter.py

@@ -153,13 +153,34 @@ class CLIAdapter:
             "file_path": result.file_path,
             "language": result.language,
             "package": result.package,
-            "imports": [imp.to_dict() for imp in result.imports],
-            "classes": [cls.to_dict() for cls in result.classes],
-            "methods": [method.to_dict() for method in result.methods],
-            "fields": [field.to_dict() for field in result.fields],
-            "annotations": [ann.to_dict() for ann in result.annotations],
+            "imports": [
+                {"name": imp.name, "type": str(type(imp).__name__)}
+                for imp in result.imports
+            ],
+            "classes": [
+                {"name": cls.name, "type": str(type(cls).__name__)}
+                for cls in result.classes
+            ],
+            "methods": [
+                {"name": method.name, "type": str(type(method).__name__)}
+                for method in result.methods
+            ],
+            "fields": [
+                {"name": field.name, "type": str(type(field).__name__)}
+                for field in result.fields
+            ],
+            "annotations": [
+                {
+                    "name": getattr(ann, "name", str(ann)),
+                    "type": str(type(ann).__name__),
+                }
+                for ann in getattr(result, "annotations", [])
+            ],
             "analysis_time": result.analysis_time,
-            "elements": [elem.to_dict() for elem in result.elements],
+            "elements": [
+                {"name": elem.name, "type": str(type(elem).__name__)}
+                for elem in result.elements
+            ],
             "success": result.success,
         }
 
@@ -315,8 +336,8 @@ class CLIAdapter:
 # Legacy AdvancedAnalyzerAdapter removed - use UnifiedAnalysisEngine directly
 
 
-def get_analysis_engine():
+def get_analysis_engine() -> "UnifiedAnalysisEngine":
     """Get analysis engine instance for testing compatibility."""
-    from ..core.analysis_engine import AnalysisEngine
+    from ..core.analysis_engine import UnifiedAnalysisEngine
 
-    return AnalysisEngine()
+    return UnifiedAnalysisEngine()

tree_sitter_analyzer/interfaces/mcp_adapter.py

@@ -5,19 +5,22 @@ MCP Adapter for Tree-Sitter Analyzer
 This module provides an adapter interface for integrating with the MCP protocol.
 """
 
-from typing import Any
+from typing import TYPE_CHECKING, Any
 
 from ..models import AnalysisResult
 
+if TYPE_CHECKING:
+    from ..core.analysis_engine import UnifiedAnalysisEngine
 
-def get_analysis_engine():
+
+def get_analysis_engine() -> "UnifiedAnalysisEngine":
     """Get analysis engine instance for testing compatibility."""
-    from ..core.analysis_engine import AnalysisEngine
+    from ..core.analysis_engine import UnifiedAnalysisEngine
 
-    return AnalysisEngine()
+    return UnifiedAnalysisEngine()
 
 
-def handle_mcp_resource_request(uri):
+def handle_mcp_resource_request(uri: str) -> dict[str, Any]:
     """Handle MCP resource request for testing compatibility."""
     return {
         "contents": [
@@ -38,13 +41,15 @@ def read_file_safe(file_path: str) -> str:
 class MCPAdapter:
     """MCP Adapter for testing compatibility."""
 
-    def __init__(self):
+    def __init__(self) -> None:
         """Initialize MCP Adapter."""
         from ..core.analysis_engine import UnifiedAnalysisEngine
 
         self.engine = UnifiedAnalysisEngine()
 
-    async def analyze_file_async(self, file_path: str, **kwargs) -> "AnalysisResult":
+    async def analyze_file_async(
+        self, file_path: str, **kwargs: Any
+    ) -> "AnalysisResult":
         """Analyze file asynchronously."""
         from ..core.analysis_engine import AnalysisRequest
 
@@ -58,7 +63,7 @@ class MCPAdapter:
         return await self.engine.analyze(request)
 
     async def get_file_structure_async(
-        self, file_path: str, **kwargs
+        self, file_path: str, **kwargs: Any
     ) -> dict[str, Any]:
         """Get file structure asynchronously."""
         result = await self.analyze_file_async(file_path, **kwargs)
@@ -66,11 +71,29 @@ class MCPAdapter:
             "file_path": result.file_path,
             "language": result.language,
             "structure": {
-                "classes": [cls.to_dict() for cls in result.classes],
-                "methods": [method.to_dict() for method in result.methods],
-                "fields": [field.to_dict() for field in result.fields],
-                "imports": [imp.to_dict() for imp in result.imports],
-                "annotations": [ann.to_dict() for ann in result.annotations],
+                "classes": [
+                    {"name": cls.name, "type": str(type(cls).__name__)}
+                    for cls in result.classes
+                ],
+                "methods": [
+                    {"name": method.name, "type": str(type(method).__name__)}
+                    for method in result.methods
+                ],
+                "fields": [
+                    {"name": field.name, "type": str(type(field).__name__)}
+                    for field in result.fields
+                ],
+                "imports": [
+                    {"name": imp.name, "type": str(type(imp).__name__)}
+                    for imp in result.imports
+                ],
+                "annotations": [
+                    {
+                        "name": getattr(ann, "name", str(ann)),
+                        "type": str(type(ann).__name__),
+                    }
+                    for ann in getattr(result, "annotations", [])
+                ],
             },
             "metadata": {
                 "analysis_time": result.analysis_time,
@@ -86,7 +109,7 @@ class MCPAdapter:
         }
 
     async def analyze_batch_async(
-        self, file_paths: list[str], **kwargs
+        self, file_paths: list[str], **kwargs: Any
     ) -> list["AnalysisResult"]:
         """Analyze multiple files asynchronously."""
         results = []
@@ -157,17 +180,20 @@ class MCPAdapter:
         """Async cleanup."""
         pass
 
-    def analyze_with_mcp_request(self, arguments):
+    async def analyze_with_mcp_request(
+        self, arguments: dict[str, Any]
+    ) -> dict[str, Any]:
         """Analyze with MCP request."""
         if "file_path" not in arguments:
             raise KeyError("file_path is required in MCP request")
-        return self.analyze_file_async(arguments["file_path"])
+        result = await self.analyze_file_async(arguments["file_path"])
+        return {"result": str(result), "success": True}
 
 
 class MCPServerAdapter:
     """MCP Server Adapter for testing compatibility."""
 
-    def __init__(self):
+    def __init__(self) -> None:
         """Initialize MCP Server Adapter."""
         self.mcp_adapter = MCPAdapter()
 

tree_sitter_analyzer/interfaces/mcp_server.py

@@ -53,9 +53,9 @@ class TreeSitterAnalyzerMCPServer:
 
     def create_server(self) -> Server:
         """Create and configure the MCP server."""
-        server = Server(self.name)
+        server: Any = Server(self.name)
 
-        @server.list_tools()
+        @server.list_tools()  # type: ignore
         async def handle_list_tools() -> list[Tool]:
             """List available tools."""
             return [
@@ -224,7 +224,7 @@ class TreeSitterAnalyzerMCPServer:
                 ),
             ]
 
-        @server.call_tool()
+        @server.call_tool()  # type: ignore
         async def handle_call_tool(
             name: str, arguments: dict[str, Any]
         ) -> list[TextContent]:
@@ -309,25 +309,25 @@ class TreeSitterAnalyzerMCPServer:
                     )
                 ]
 
-        @server.list_resources()
+        @server.list_resources()  # type: ignore
         async def handle_list_resources() -> list[Resource]:
             """List available resources."""
             return [
                 Resource(
-                    uri="code://file/{file_path}",
+                    uri="code://file/{file_path}",  # type: ignore
                     name="Code File Analysis",
                     description="Access to code file content and analysis",
                     mimeType="application/json",
                 ),
                 Resource(
-                    uri="code://stats/{stats_type}",
+                    uri="code://stats/{stats_type}",  # type: ignore
                     name="Project Statistics",
                     description="Access to project statistics and analysis data",
                     mimeType="application/json",
                 ),
             ]
 
-        @server.read_resource()
+        @server.read_resource()  # type: ignore
         async def handle_read_resource(uri: str) -> str:
             """Read resource content."""
             try:
@@ -366,7 +366,7 @@ class TreeSitterAnalyzerMCPServer:
 
         self.server = server
         log_info("MCP server created successfully")
-        return server
+        return server  # type: ignore
 
     async def run(self) -> None:
         """Run the MCP server."""
@@ -376,7 +376,7 @@ class TreeSitterAnalyzerMCPServer:
         options = InitializationOptions(
             server_name=self.name,
             server_version=self.version,
-            capabilities={"tools": {}, "resources": {}},
+            capabilities={"tools": {}, "resources": {}},  # type: ignore
         )
 
         log_info(f"Starting MCP server: {self.name} v{self.version}")

tree_sitter_analyzer/java_analyzer.py

@@ -93,10 +93,7 @@ class CodeAnalyzer:
             self.source_code_bytes = source_bytes
             self.tree = self.parser.parse(self.source_code_bytes)
 
-            if self.tree is None:
-                output_error(f"ERROR: '{file_path}' のAST構築に失敗しました。")
-                return False
-
+            # Tree parsing should always succeed with valid input
             log_info(f"INFO: '{file_path}' の解析が完了し、ASTを構築しました。")
             return True
 
@@ -141,54 +138,26 @@ class CodeAnalyzer:
 
         # Tree-sitter 0.24以降の辞書形式に対応
         try:
-            if isinstance(captures, dict):
-                # 新しい辞書形式: {capture_name: [nodes...]}
-                for capture_name, nodes in captures.items():
-                    if isinstance(nodes, list):
-                        for node in nodes:
-                            try:
-                                start_line = node.start_point[0] + 1
-                                end_line = node.end_point[0] + 1
-                                node_text = self.source_code_bytes[
-                                    node.start_byte : node.end_byte
-                                ].decode("utf-8", errors="ignore")
-
-                                results.append(
-                                    {
-                                        "capture_name": capture_name,
-                                        "content": node_text,
-                                        "start_line": start_line,
-                                        "end_line": end_line,
-                                        "node_type": node.type,
-                                    }
-                                )
-                            except Exception as e:
-                                output_warning(
-                                    f"WARNING: ノード処理中にエラーが発生しました: {e}"
-                                )
-                                continue
-            else:
-                # 古い形式への対応（フォールバック）
-                if hasattr(captures, "__iter__"):
-                    for capture in captures:
+            # 辞書形式: {capture_name: [nodes...]}
+            for capture_name, nodes in captures.items():
+                if isinstance(nodes, list):
+                    for node in nodes:
                         try:
-                            if isinstance(capture, tuple) and len(capture) == 2:
-                                node, capture_name = capture
-                                start_line = node.start_point[0] + 1
-                                end_line = node.end_point[0] + 1
-                                node_text = self.source_code_bytes[
-                                    node.start_byte : node.end_byte
-                                ].decode("utf-8", errors="ignore")
-
-                                results.append(
-                                    {
-                                        "capture_name": capture_name,
-                                        "content": node_text,
-                                        "start_line": start_line,
-                                        "end_line": end_line,
-                                        "node_type": node.type,
-                                    }
-                                )
+                            start_line = node.start_point[0] + 1
+                            end_line = node.end_point[0] + 1
+                            node_text = self.source_code_bytes[
+                                node.start_byte : node.end_byte
+                            ].decode("utf-8", errors="ignore")
+
+                            results.append(
+                                {
+                                    "capture_name": capture_name,
+                                    "content": node_text,
+                                    "start_line": start_line,
+                                    "end_line": end_line,
+                                    "node_type": node.type,
+                                }
+                            )
                         except Exception as e:
                             output_warning(
                                 f"WARNING: ノード処理中にエラーが発生しました: {e}"

tree_sitter_analyzer/language_loader.py

@@ -189,8 +189,8 @@ class LanguageLoader:
         self._availability_cache.clear()
         self._parser_cache.clear()
         self._unavailable_languages.clear()
-        # LRUキャッシュもクリア
-        self.is_language_available.cache_clear()
+        # 可用性キャッシュもクリア
+        self._availability_cache.clear()
 
 
 # グローバルインスタンス（最適化：シングルトンパターン）