tree-sitter-analyzer 0.1.0__py3-none-any.whl

tree_sitter_analyzer/interfaces/mcp_server.py

@@ -0,0 +1,416 @@
+#!/usr/bin/env python3
+# -*- coding: utf-8 -*-
+"""
+MCP Server Interface
+
+New MCP server implementation that uses the API facade for all operations.
+Provides a clean separation between MCP protocol concerns and core analysis logic.
+"""
+
+import asyncio
+import json
+import logging
+import sys
+from pathlib import Path
+from typing import Any, Dict, List, Optional
+
+try:
+    from mcp.server import Server
+    from mcp.server.models import InitializationOptions
+    from mcp.server.stdio import stdio_server
+    from mcp.types import (
+        Resource,
+        TextContent,
+        Tool,
+    )
+    MCP_AVAILABLE = True
+except ImportError:
+    MCP_AVAILABLE = False
+
+from .. import api
+from ..utils import log_error, log_info, log_warning
+
+# Configure logging for MCP
+logging.basicConfig(
+    level=logging.INFO,
+    format='%(asctime)s - %(name)s - %(levelname)s - %(message)s'
+)
+logger = logging.getLogger(__name__)
+
+
+class TreeSitterAnalyzerMCPServer:
+    """
+    MCP Server for Tree-sitter Analyzer using the new API facade.
+    
+    This server provides code analysis capabilities through the Model Context Protocol,
+    using the unified API facade for all operations.
+    """
+
+    def __init__(self) -> None:
+        """Initialize the MCP server."""
+        if not MCP_AVAILABLE:
+            raise ImportError("MCP library not available. Please install mcp package.")
+        
+        self.server: Optional[Server] = None
+        self.name = "tree-sitter-analyzer"
+        self.version = "2.0.0"
+        
+        log_info(f"Initializing {self.name} v{self.version}")
+
+    def create_server(self) -> Server:
+        """Create and configure the MCP server."""
+        server = Server(self.name)
+
+        @server.list_tools()
+        async def handle_list_tools() -> List[Tool]:
+            """List available tools."""
+            return [
+                Tool(
+                    name="analyze_file",
+                    description="Analyze a source code file comprehensively",
+                    inputSchema={
+                        "type": "object",
+                        "properties": {
+                            "file_path": {
+                                "type": "string",
+                                "description": "Path to the source file to analyze"
+                            },
+                            "language": {
+                                "type": "string",
+                                "description": "Programming language (optional, auto-detected if not specified)"
+                            },
+                            "queries": {
+                                "type": "array",
+                                "items": {"type": "string"},
+                                "description": "List of query names to execute (optional)"
+                            },
+                            "include_elements": {
+                                "type": "boolean",
+                                "description": "Whether to extract code elements",
+                                "default": True
+                            },
+                            "include_queries": {
+                                "type": "boolean",
+                                "description": "Whether to execute queries",
+                                "default": True
+                            }
+                        },
+                        "required": ["file_path"],
+                        "additionalProperties": False
+                    }
+                ),
+                Tool(
+                    name="analyze_code",
+                    description="Analyze source code directly (without file)",
+                    inputSchema={
+                        "type": "object",
+                        "properties": {
+                            "source_code": {
+                                "type": "string",
+                                "description": "Source code string to analyze"
+                            },
+                            "language": {
+                                "type": "string",
+                                "description": "Programming language"
+                            },
+                            "queries": {
+                                "type": "array",
+                                "items": {"type": "string"},
+                                "description": "List of query names to execute (optional)"
+                            },
+                            "include_elements": {
+                                "type": "boolean",
+                                "description": "Whether to extract code elements",
+                                "default": True
+                            },
+                            "include_queries": {
+                                "type": "boolean",
+                                "description": "Whether to execute queries",
+                                "default": True
+                            }
+                        },
+                        "required": ["source_code", "language"],
+                        "additionalProperties": False
+                    }
+                ),
+                Tool(
+                    name="extract_elements",
+                    description="Extract code elements from a file",
+                    inputSchema={
+                        "type": "object",
+                        "properties": {
+                            "file_path": {
+                                "type": "string",
+                                "description": "Path to the source file"
+                            },
+                            "language": {
+                                "type": "string",
+                                "description": "Programming language (optional, auto-detected if not specified)"
+                            },
+                            "element_types": {
+                                "type": "array",
+                                "items": {"type": "string"},
+                                "description": "Types of elements to extract (optional)"
+                            }
+                        },
+                        "required": ["file_path"],
+                        "additionalProperties": False
+                    }
+                ),
+                Tool(
+                    name="execute_query",
+                    description="Execute a specific query on a file",
+                    inputSchema={
+                        "type": "object",
+                        "properties": {
+                            "file_path": {
+                                "type": "string",
+                                "description": "Path to the source file"
+                            },
+                            "query_name": {
+                                "type": "string",
+                                "description": "Name of the query to execute"
+                            },
+                            "language": {
+                                "type": "string",
+                                "description": "Programming language (optional, auto-detected if not specified)"
+                            }
+                        },
+                        "required": ["file_path", "query_name"],
+                        "additionalProperties": False
+                    }
+                ),
+                Tool(
+                    name="validate_file",
+                    description="Validate a source code file",
+                    inputSchema={
+                        "type": "object",
+                        "properties": {
+                            "file_path": {
+                                "type": "string",
+                                "description": "Path to the source file to validate"
+                            }
+                        },
+                        "required": ["file_path"],
+                        "additionalProperties": False
+                    }
+                ),
+                Tool(
+                    name="get_supported_languages",
+                    description="Get list of supported programming languages",
+                    inputSchema={
+                        "type": "object",
+                        "properties": {},
+                        "additionalProperties": False
+                    }
+                ),
+                Tool(
+                    name="get_available_queries",
+                    description="Get available queries for a specific language",
+                    inputSchema={
+                        "type": "object",
+                        "properties": {
+                            "language": {
+                                "type": "string",
+                                "description": "Programming language name"
+                            }
+                        },
+                        "required": ["language"],
+                        "additionalProperties": False
+                    }
+                ),
+                Tool(
+                    name="get_framework_info",
+                    description="Get information about the analyzer framework",
+                    inputSchema={
+                        "type": "object",
+                        "properties": {},
+                        "additionalProperties": False
+                    }
+                )
+            ]
+
+        @server.call_tool()
+        async def handle_call_tool(name: str, arguments: Dict[str, Any]) -> List[TextContent]:
+            """Handle tool calls."""
+            try:
+                result = None
+                
+                if name == "analyze_file":
+                    result = api.analyze_file(
+                        file_path=arguments["file_path"],
+                        language=arguments.get("language"),
+                        queries=arguments.get("queries"),
+                        include_elements=arguments.get("include_elements", True),
+                        include_queries=arguments.get("include_queries", True)
+                    )
+                
+                elif name == "analyze_code":
+                    result = api.analyze_code(
+                        source_code=arguments["source_code"],
+                        language=arguments["language"],
+                        queries=arguments.get("queries"),
+                        include_elements=arguments.get("include_elements", True),
+                        include_queries=arguments.get("include_queries", True)
+                    )
+                
+                elif name == "extract_elements":
+                    result = api.extract_elements(
+                        file_path=arguments["file_path"],
+                        language=arguments.get("language"),
+                        element_types=arguments.get("element_types")
+                    )
+                
+                elif name == "execute_query":
+                    result = api.execute_query(
+                        file_path=arguments["file_path"],
+                        query_name=arguments["query_name"],
+                        language=arguments.get("language")
+                    )
+                
+                elif name == "validate_file":
+                    result = api.validate_file(arguments["file_path"])
+                
+                elif name == "get_supported_languages":
+                    result = {
+                        "languages": api.get_supported_languages(),
+                        "total": len(api.get_supported_languages())
+                    }
+                
+                elif name == "get_available_queries":
+                    queries = api.get_available_queries(arguments["language"])
+                    result = {
+                        "language": arguments["language"],
+                        "queries": queries,
+                        "total": len(queries)
+                    }
+                
+                elif name == "get_framework_info":
+                    result = api.get_framework_info()
+                
+                else:
+                    raise ValueError(f"Unknown tool: {name}")
+
+                return [
+                    TextContent(
+                        type="text",
+                        text=json.dumps(result, indent=2, ensure_ascii=False)
+                    )
+                ]
+
+            except Exception as e:
+                log_error(f"Tool call error for {name}: {e}")
+                error_result = {
+                    "error": str(e),
+                    "tool": name,
+                    "arguments": arguments,
+                    "success": False
+                }
+                return [
+                    TextContent(
+                        type="text",
+                        text=json.dumps(error_result, indent=2, ensure_ascii=False)
+                    )
+                ]
+
+        @server.list_resources()
+        async def handle_list_resources() -> List[Resource]:
+            """List available resources."""
+            return [
+                Resource(
+                    uri="code://file/{file_path}",
+                    name="Code File Analysis",
+                    description="Access to code file content and analysis",
+                    mimeType="application/json"
+                ),
+                Resource(
+                    uri="code://stats/{stats_type}",
+                    name="Project Statistics",
+                    description="Access to project statistics and analysis data",
+                    mimeType="application/json"
+                )
+            ]
+
+        @server.read_resource()
+        async def handle_read_resource(uri: str) -> str:
+            """Read resource content."""
+            try:
+                if uri.startswith("code://file/"):
+                    # Extract file path from URI
+                    file_path = uri[len("code://file/"):]
+                    
+                    # Analyze the file
+                    result = api.analyze_file(file_path)
+                    return json.dumps(result, indent=2, ensure_ascii=False)
+                
+                elif uri.startswith("code://stats/"):
+                    # Extract stats type from URI
+                    stats_type = uri[len("code://stats/"):]
+                    
+                    # Get framework info as basic stats
+                    if stats_type == "framework":
+                        result = api.get_framework_info()
+                    elif stats_type == "languages":
+                        result = {
+                            "supported_languages": api.get_supported_languages(),
+                            "total_languages": len(api.get_supported_languages())
+                        }
+                    else:
+                        raise ValueError(f"Unknown stats type: {stats_type}")
+                    
+                    return json.dumps(result, indent=2, ensure_ascii=False)
+                
+                else:
+                    raise ValueError(f"Resource not found: {uri}")
+
+            except Exception as e:
+                log_error(f"Resource read error for {uri}: {e}")
+                error_result = {
+                    "error": str(e),
+                    "uri": uri,
+                    "success": False
+                }
+                return json.dumps(error_result, indent=2, ensure_ascii=False)
+
+        self.server = server
+        log_info("MCP server created successfully")
+        return server
+
+    async def run(self) -> None:
+        """Run the MCP server."""
+        server = self.create_server()
+
+        # Initialize server options
+        options = InitializationOptions(
+            server_name=self.name,
+            server_version=self.version,
+            capabilities={
+                "tools": {},
+                "resources": {}
+            }
+        )
+
+        log_info(f"Starting MCP server: {self.name} v{self.version}")
+
+        try:
+            async with stdio_server() as (read_stream, write_stream):
+                await server.run(read_stream, write_stream, options)
+        except Exception as e:
+            log_error(f"Server error: {e}")
+            raise
+
+
+async def main() -> None:
+    """Main entry point for the MCP server."""
+    try:
+        server = TreeSitterAnalyzerMCPServer()
+        await server.run()
+    except KeyboardInterrupt:
+        log_info("Server stopped by user")
+    except Exception as e:
+        log_error(f"Server failed: {e}")
+        sys.exit(1)
+
+
+if __name__ == "__main__":
+    asyncio.run(main())

tree_sitter_analyzer/java_analyzer.py

@@ -0,0 +1,219 @@
+#!/usr/bin/env python3
+# -*- coding: utf-8 -*-
+"""
+Java Code Analyzer with tree-sitter
+"""
+import json
+import sys
+from pathlib import Path
+from typing import Any, Dict, List, Optional
+
+try:
+    import tree_sitter
+    import tree_sitter_java as tsjava
+    from tree_sitter import Language, Node, Parser
+
+    TREE_SITTER_AVAILABLE = True
+except ImportError:
+    TREE_SITTER_AVAILABLE = False
+    from .utils import log_error
+
+    log_error(
+        "tree-sitter libraries not found. Please install tree-sitter and tree-sitter-java."
+    )
+
+from .file_handler import read_file_with_fallback
+from .output_manager import output_error, output_info, output_warning
+from .utils import log_error, log_info, log_warning
+
+
+class CodeAnalyzer:
+    """
+    Tree-sitterを使用してソースコードを解析するコアクラス。
+
+    Attributes:
+        language: Tree-sitter言語オブジェクト
+        parser: Tree-sitterパーサー
+        source_code_bytes: 解析対象のソースコードのバイト列
+        tree: 構築されたAST
+    """
+
+    def __init__(self, language: str = "java") -> None:
+        """
+        指定された言語用のパーサーを初期化する。
+
+        Args:
+            language: 解析対象のプログラミング言語。現在はJavaのみサポート。
+
+        Raises:
+            SystemExit: Tree-sitterライブラリの初期化に失敗した場合
+        """
+        if not TREE_SITTER_AVAILABLE:
+            output_error("ERROR: Tree-sitter libraries not available.")
+            raise RuntimeError("Tree-sitter libraries not available")
+
+        try:
+            if language != "java":
+                output_warning(
+                    f"WARNING: Currently only Java is supported. Using Java parser."
+                )
+
+            self.language = Language(tsjava.language())
+            self.parser = Parser(self.language)
+            self.source_code_bytes: bytes = b""
+            self.tree: Optional[tree_sitter.Tree] = None
+
+        except Exception as e:
+            output_error(
+                f"ERROR: '{language}' 言語の初期化に失敗しました。ライブラリが正しくインストールされているか確認してください。"
+            )
+            output_error(f"詳細: {e}")
+            raise RuntimeError(f"Failed to initialize language '{language}': {e}")
+
+    def parse_file(self, file_path: str) -> bool:
+        """
+        指定されたファイルを解析し、AST（抽象構文木）を構築する。
+
+        Args:
+            file_path: 解析するソースファイルのパス
+
+        Returns:
+            解析に成功した場合はTrue、失敗した場合はFalse
+
+        Raises:
+            None: エラーは内部でハンドリングし、戻り値で示す
+        """
+        try:
+            source_bytes = read_file_with_fallback(file_path)
+            if source_bytes is None:
+                output_error(
+                    f"ERROR: ファイル '{file_path}' の読み込みに失敗しました。"
+                )
+                return False
+
+            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
+
+            log_info(f"INFO: '{file_path}' の解析が完了し、ASTを構築しました。")
+            return True
+
+        except Exception as e:
+            output_error(f"ERROR: ファイル解析中にエラーが発生しました: {e}")
+            return False
+
+    def execute_query(self, query_string: str) -> List[Dict[str, Any]]:
+        """
+        ASTに対して指定されたクエリを実行し、マッチしたノードの情報を抽出する。
+
+        Args:
+            query_string: 実行するTree-sitterクエリ
+
+        Returns:
+            マッチした各ノードの情報（内容、位置、キャプチャ名）のリスト
+
+        Raises:
+            None: エラーは内部でハンドリングし、空リストを返す
+        """
+        if not self.tree:
+            output_error(
+                "ERROR: ASTが構築されていません。先にparse_fileを実行してください。"
+            )
+            return []
+
+        try:
+            query = self.language.query(query_string)
+        except Exception as e:
+            output_error(
+                f"ERROR: クエリのコンパイルに失敗しました。\nクエリ: {query_string}\nエラー: {e}"
+            )
+            return []
+
+        try:
+            captures = query.captures(self.tree.root_node)
+        except Exception as e:
+            output_error(f"ERROR: クエリの実行に失敗しました: {e}")
+            return []
+
+        results = []
+
+        # 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:
+                        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,
+                                    }
+                                )
+                        except Exception as e:
+                            output_warning(
+                                f"WARNING: ノード処理中にエラーが発生しました: {e}"
+                            )
+                            continue
+
+        except Exception as e:
+            output_error(f"ERROR: capture処理中に予期しないエラーが発生しました: {e}")
+            return []
+
+        return results
+
+
+def main() -> None:
+    """
+    モジュールが直接実行された場合のエントリーポイント。
+    通常はcli.pyを使用することを推奨。
+    """
+    output_warning("注意: 直接的なモジュール実行は非推奨です。")
+    output_warning("代わりに以下を使用してください:")
+    output_info("  uv run java-analyzer <file> --query-key <key>")
+    output_info("  または")
+    output_info("  python -m tree_sitter_analyzer.cli <file> --query-key <key>")
+
+
+if __name__ == "__main__":
+    main()