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

tree_sitter_analyzer/interfaces/cli_adapter.py

@@ -2,14 +2,14 @@
 """
 CLI Adapter for tree-sitter-analyzer
 
-既存のCLI APIとの互換性を保ちながら、新しい統一解析エンジンを使用するアダプター。
+Adapter that uses the new unified analysis engine while maintaining compatibility with existing CLI API.
 
-Roo Code規約準拠:
-- 型ヒント: 全関数に型ヒント必須
-- MCPログ: 各ステップでログ出力
+Roo Code compliance:
+- Type hints: Required for all functions
+- MCP logging: Log output at each step
 - docstring: Google Style docstring
-- エラーハンドリング: 適切な例外処理
-- パフォーマンス: 統一エンジンによる最適化
+- Error handling: Proper exception handling
+- Performance: Optimization through unified engine
 """
 
 import asyncio
@@ -26,17 +26,17 @@ logger = logging.getLogger(__name__)
 
 class CLIAdapter:
     """
-    CLI用アダプター
+    CLI Adapter
 
-    既存のCLI APIとの互換性を保ちながら、新しい統一解析エンジンを使用します。
-    同期APIを提供し、内部的に非同期エンジンを呼び出します。
+    Uses the new unified analysis engine while maintaining compatibility with existing CLI API.
+    Provides synchronous API and internally calls asynchronous engine.
 
     Features:
-        - 既存API互換性の維持
-        - 統一解析エンジンの活用
-        - 同期/非同期変換
-        - パフォーマンス監視
-        - エラーハンドリング
+        - Maintaining existing API compatibility
+        - Utilizing unified analysis engine
+        - Sync/async conversion
+        - Performance monitoring
+        - Error handling
 
     Example:
         >>> adapter = CLIAdapter()
@@ -46,10 +46,10 @@ class CLIAdapter:
 
     def __init__(self) -> None:
         """
-        CLIアダプターを初期化
+        Initialize CLI adapter
 
         Raises:
-            Exception: 統一解析エンジンの初期化に失敗した場合
+            Exception: If unified analysis engine initialization fails
         """
         try:
             self._engine = UnifiedAnalysisEngine()
@@ -60,26 +60,26 @@ class CLIAdapter:
 
     def analyze_file(self, file_path: str, **kwargs: Any) -> AnalysisResult:
         """
-        ファイルを解析（同期版）
+        Analyze file (synchronous version)
 
-        既存のCLI APIとの互換性を保つため、同期インターフェースを提供します。
-        内部的には統一解析エンジンの非同期メソッドを呼び出します。
+        Provides synchronous interface to maintain compatibility with existing CLI API.
+        Internally calls asynchronous methods of unified analysis engine.
 
         Args:
-            file_path: 解析対象ファイルのパス
-            **kwargs: 解析オプション
-                - language: 言語指定（自動検出も可能）
-                - include_complexity: 複雑度計算を含める
-                - include_details: 詳細情報を含める
-                - format_type: 出力形式（"standard", "structure", "summary"）
+            file_path: Path to file to analyze
+            **kwargs: Analysis options
+                - language: Language specification (auto-detection possible)
+                - include_complexity: Include complexity calculation
+                - include_details: Include detailed information
+                - format_type: Output format ("standard", "structure", "summary")
 
         Returns:
-            AnalysisResult: 解析結果
+            AnalysisResult: Analysis result
 
         Raises:
-            ValueError: 無効なファイルパスの場合
-            FileNotFoundError: ファイルが存在しない場合
-            UnsupportedLanguageError: サポートされていない言語の場合
+            ValueError: For invalid file path
+            FileNotFoundError: If file does not exist
+            UnsupportedLanguageError: For unsupported language
 
         Example:
             >>> adapter = CLIAdapter()
@@ -88,16 +88,16 @@ class CLIAdapter:
         """
         start_time = time.time()
 
-        # 入力検証
+        # Input validation
         if not file_path or not file_path.strip():
             raise ValueError("File path cannot be empty")
 
-        # ファイル存在チェック
+        # File existence check
         if not Path(file_path).exists():
             raise FileNotFoundError(f"File not found: {file_path}")
 
         try:
-            # AnalysisRequestを作成
+            # Create AnalysisRequest
             request = AnalysisRequest(
                 file_path=file_path,
                 language=kwargs.get("language"),
@@ -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]
+    ) -> AnalysisResult:
         """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
 
 
 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}")