tree-sitter-analyzer 1.6.1.2__py3-none-any.whl → 1.6.1.3__py3-none-any.whl

tree_sitter_analyzer/__init__.py

@@ -11,7 +11,7 @@ Architecture:
 - Data Models: Generic and language-specific code element representations
 """
 
-__version__ = "1.6.1.2"
+__version__ = "1.6.1.3"
 __author__ = "aisheng.yu"
 __email__ = "aimasteracc@gmail.com"
 

tree_sitter_analyzer/core/query.py

@@ -10,7 +10,7 @@ import logging
 import time
 from typing import Any
 
-from tree_sitter import Language, Node, Tree
+from tree_sitter import Language, Node, Query, QueryCursor, Tree
 
 from ..query_loader import get_query_loader
 
@@ -77,10 +77,11 @@ class QueryExecutor:
                     f"Query '{query_name}' not found", query_name=query_name
                 )
 
-            # Create and execute the query
+            # Create and execute the query using new API (tree-sitter 0.25.0+)
             try:
-                query = language.query(query_string)
-                captures = query.captures(tree.root_node)
+                query = Query(language, query_string)
+                cursor = QueryCursor(query)
+                captures = list(cursor.captures(tree.root_node))
 
                 # Process captures
                 try:
@@ -146,10 +147,11 @@ class QueryExecutor:
             if language is None:
                 return self._create_error_result("Language is None")  # type: ignore[unreachable]
 
-            # Create and execute the query
+            # Create and execute the query using new API (tree-sitter 0.25.0+)
             try:
-                query = language.query(query_string)
-                captures = query.captures(tree.root_node)
+                query = Query(language, query_string)
+                cursor = QueryCursor(query)
+                captures = list(cursor.captures(tree.root_node))
 
                 # Process captures
                 try:
@@ -373,8 +375,8 @@ class QueryExecutor:
             if lang_obj is None:
                 return False
 
-            # Try to create the query
-            lang_obj.query(query_string)
+            # Try to create the query using new API (tree-sitter 0.25.0+)
+            Query(lang_obj, query_string)
             return True
 
         except Exception as e:

tree_sitter_analyzer/core/query_service.py

@@ -9,6 +9,8 @@ Provides core tree-sitter query functionality including predefined and custom qu
 import logging
 from typing import Any
 
+from tree_sitter import Query, QueryCursor
+
 from ..encoding_utils import read_file_safe
 from ..query_loader import query_loader
 from .parser import Parser
@@ -80,23 +82,18 @@ class QueryService:
                         f"Query '{query_key}' not found for language '{language}'"
                     )
 
-            # Execute tree-sitter query
-            ts_query = language_obj.query(query_string)
-            captures = ts_query.captures(tree.root_node)
+            # Execute tree-sitter query using new API (tree-sitter 0.25.0+)
+            ts_query = Query(language_obj, query_string)
+            cursor = QueryCursor(ts_query)
+            matches = cursor.matches(tree.root_node)
 
-            # Process capture results
+            # Process match results (new API returns list of (pattern_index, captures_dict))
             results = []
-            if isinstance(captures, dict):
-                # New tree-sitter API returns dictionary
-                for capture_name, nodes in captures.items():
+            for pattern_index, captures_dict in matches:
+                # captures_dict is {capture_name: [node1, node2, ...]}
+                for capture_name, nodes in captures_dict.items():
                     for node in nodes:
                         results.append(self._create_result_dict(node, capture_name))
-            else:
-                # Old tree-sitter API returns list of tuples
-                for capture in captures:
-                    if isinstance(capture, tuple) and len(capture) == 2:
-                        node, name = capture
-                        results.append(self._create_result_dict(node, name))
 
             # Apply filters
             if filter_expression and results:

tree_sitter_analyzer/languages/python_plugin.py

@@ -15,6 +15,7 @@ if TYPE_CHECKING:
 
 try:
     import tree_sitter
+    from tree_sitter import Query, QueryCursor
 
     TREE_SITTER_AVAILABLE = True
 except ImportError:
@@ -113,17 +114,23 @@ class PythonElementExtractor(ElementExtractor):
 
             language = tree.language if hasattr(tree, "language") else None
             if language:
-                query = language.query(class_query)
-                captures = query.captures(tree.root_node)
-
-                if isinstance(captures, dict):
-                    class_bodies = captures.get("class.body", [])
-
-                    # For each class body, extract attribute assignments
-                    for class_body in class_bodies:
-                        variables.extend(
-                            self._extract_class_attributes(class_body, source_code)
-                        )
+                # Use new API (tree-sitter 0.25.0+)
+                query = Query(language, class_query)
+                cursor = QueryCursor(query)
+                matches = cursor.matches(tree.root_node)
+
+                # Process matches to get class bodies
+                class_bodies = []
+                for pattern_index, captures_dict in matches:
+                    for capture_name, nodes in captures_dict.items():
+                        if capture_name == "class.body":
+                            class_bodies.extend(nodes)
+
+                # For each class body, extract attribute assignments
+                for class_body in class_bodies:
+                    variables.extend(
+                        self._extract_class_attributes(class_body, source_code)
+                    )
 
         except Exception as e:
             log_warning(f"Could not extract Python class attributes: {e}")
@@ -664,20 +671,29 @@ class PythonElementExtractor(ElementExtractor):
             language = tree.language if hasattr(tree, "language") else None
             if language:
                 for query_string in import_queries:
-                    query = language.query(query_string)
-                    captures = query.captures(tree.root_node)
-
-                    if isinstance(captures, dict):
-                        # Process different types of imports
-                        for key, nodes in captures.items():
-                            if key.endswith("statement"):
-                                import_type = key.split(".")[0]
-                                for node in nodes:
-                                    imp = self._extract_import_info(
-                                        node, source_code, import_type
-                                    )
-                                    if imp:
-                                        imports.append(imp)
+                    # Use new API (tree-sitter 0.25.0+)
+                    query = Query(language, query_string)
+                    cursor = QueryCursor(query)
+                    matches = cursor.matches(tree.root_node)
+
+                    # Process matches to get statement nodes
+                    statement_nodes = {}
+                    for pattern_index, captures_dict in matches:
+                        for capture_name, nodes in captures_dict.items():
+                            if capture_name.endswith("statement"):
+                                import_type = capture_name.split(".")[0]
+                                if import_type not in statement_nodes:
+                                    statement_nodes[import_type] = []
+                                statement_nodes[import_type].extend(nodes)
+
+                    # Process different types of imports
+                    for import_type, nodes in statement_nodes.items():
+                        for node in nodes:
+                            imp = self._extract_import_info(
+                                node, source_code, import_type
+                            )
+                            if imp:
+                                imports.append(imp)
 
         except Exception as e:
             log_warning(f"Could not extract Python imports: {e}")
@@ -1179,8 +1195,16 @@ class PythonPlugin(LanguagePlugin):
             else:
                 return {"error": f"Unknown query: {query_name}"}
 
-            query = language.query(query_string)
-            captures = query.captures(tree.root_node)
+            # Use new API (tree-sitter 0.25.0+)
+            query = Query(language, query_string)
+            cursor = QueryCursor(query)
+            matches = list(cursor.matches(tree.root_node))
+            # Convert matches to legacy format for compatibility
+            captures = []
+            for pattern_index, captures_dict in matches:
+                for capture_name, nodes in captures_dict.items():
+                    for node in nodes:
+                        captures.append((node, capture_name))
             return {"captures": captures, "query": query_string}
 
         except Exception as e:

tree_sitter_analyzer/logging_manager.py

@@ -0,0 +1,361 @@
+#!/usr/bin/env python3
+"""
+統一ログ管理システム
+
+ログ出力の重複問題を解決するためのLoggerManagerクラスを提供します。
+シングルトンパターンによりロガーインスタンスを一意に管理し、
+重複ハンドラーを防止します。
+"""
+
+import logging
+import os
+import sys
+import tempfile
+import threading
+from pathlib import Path
+from typing import Any, Dict, List, Optional
+
+
+class LoggerManager:
+    """
+    統一されたロガー管理クラス
+    
+    シングルトンパターンでロガーインスタンスを管理し、
+    重複ハンドラーを防止する。
+    """
+    
+    _instance: Optional['LoggerManager'] = None
+    _lock: threading.Lock = threading.Lock()
+    _loggers: Dict[str, logging.Logger] = {}
+    _handler_registry: Dict[str, List[str]] = {}
+    _initialized: bool = False
+    _file_log_message_shown: bool = False
+    
+    def __new__(cls) -> 'LoggerManager':
+        """スレッドセーフなシングルトン実装"""
+        if cls._instance is None:
+            with cls._lock:
+                if cls._instance is None:
+                    cls._instance = super().__new__(cls)
+        return cls._instance
+    
+    def __init__(self) -> None:
+        """初期化（シングルトンのため一度のみ実行）"""
+        if not self._initialized:
+            with self._lock:
+                if not self._initialized:
+                    self._loggers = {}
+                    self._handler_registry = {}
+                    self._initialized = True
+    
+    def get_logger(
+        self,
+        name: str = "tree_sitter_analyzer",
+        level: int | str = logging.WARNING
+    ) -> logging.Logger:
+        """
+        重複を防ぐロガー取得
+        
+        Args:
+            name: ロガー名
+            level: ログレベル
+            
+        Returns:
+            設定済みロガーインスタンス
+        """
+        with self._lock:
+            if name not in self._loggers:
+                self._loggers[name] = self._create_logger(name, level)
+            else:
+                # 既存のロガーでもレベルを更新
+                numeric_level = self._convert_level(level)
+                
+                # 環境変数からのレベル設定が優先
+                env_level = os.environ.get("LOG_LEVEL", "").upper()
+                if env_level and env_level in ["DEBUG", "INFO", "WARNING", "ERROR"]:
+                    numeric_level = getattr(logging, env_level)
+                
+                self._loggers[name].setLevel(numeric_level)
+            
+            return self._loggers[name]
+    
+    def _create_logger(self, name: str, level: int | str) -> logging.Logger:
+        """
+        ロガー作成とハンドラー設定
+        
+        Args:
+            name: ロガー名
+            level: ログレベル
+            
+        Returns:
+            設定済みロガーインスタンス
+        """
+        # レベル変換処理
+        numeric_level = self._convert_level(level)
+        
+        # 環境変数からのレベル設定
+        env_level = os.environ.get("LOG_LEVEL", "").upper()
+        if env_level and env_level in ["DEBUG", "INFO", "WARNING", "ERROR"]:
+            numeric_level = getattr(logging, env_level)
+        
+        logger = logging.getLogger(name)
+        
+        # 重複ハンドラーチェック
+        if not self._has_required_handlers(logger, name):
+            self._setup_handlers(logger, name, numeric_level)
+        
+        # ロガーレベル設定
+        logger.setLevel(numeric_level)
+        
+        return logger
+    
+    def _convert_level(self, level: int | str) -> int:
+        """ログレベル文字列を数値に変換"""
+        if isinstance(level, str):
+            level_upper = level.upper()
+            level_map = {
+                "DEBUG": logging.DEBUG,
+                "INFO": logging.INFO,
+                "WARNING": logging.WARNING,
+                "ERROR": logging.ERROR,
+            }
+            return level_map.get(level_upper, logging.WARNING)
+        return level
+    
+    def _has_required_handlers(self, logger: logging.Logger, name: str) -> bool:
+        """
+        必要なハンドラーが既に設定されているかチェック
+        
+        Args:
+            logger: チェック対象ロガー
+            name: ロガー名
+            
+        Returns:
+            必要なハンドラーが設定済みの場合True
+        """
+        if name in self._handler_registry:
+            # 既に管理されているロガーの場合は設定済みとみなす
+            return True
+        
+        # 既存ハンドラーの有無をチェック
+        has_stream_handler = any(
+            isinstance(h, logging.StreamHandler) and not isinstance(h, logging.FileHandler)
+            for h in logger.handlers
+        )
+        
+        if has_stream_handler:
+            # ハンドラー登録を記録
+            handler_types = [type(h).__name__ for h in logger.handlers]
+            self._handler_registry[name] = handler_types
+            return True
+        
+        return False
+    
+    def _setup_handlers(self, logger: logging.Logger, name: str, level: int) -> None:
+        """
+        ロガーにハンドラーを設定
+        
+        Args:
+            logger: 設定対象ロガー
+            name: ロガー名
+            level: ログレベル
+        """
+        # メインハンドラー（stderr）の追加
+        if not self._has_stream_handler(logger):
+            stream_handler = SafeStreamHandler()
+            formatter = logging.Formatter(
+                "%(asctime)s - %(name)s - %(levelname)s - %(message)s"
+            )
+            stream_handler.setFormatter(formatter)
+            logger.addHandler(stream_handler)
+        
+        # ファイルログハンドラーの追加（環境変数で有効化）
+        enable_file_log = (
+            os.environ.get("TREE_SITTER_ANALYZER_ENABLE_FILE_LOG", "").lower() == "true"
+        )
+        
+        if enable_file_log and not self._has_file_handler(logger):
+            file_handler = self._create_file_handler(level)
+            if file_handler:
+                logger.addHandler(file_handler)
+        
+        # ハンドラー登録を記録
+        handler_types = [type(h).__name__ for h in logger.handlers]
+        self._handler_registry[name] = handler_types
+    
+    def _has_stream_handler(self, logger: logging.Logger) -> bool:
+        """StreamHandlerの存在チェック"""
+        return any(
+            isinstance(h, logging.StreamHandler) and not isinstance(h, logging.FileHandler)
+            for h in logger.handlers
+        )
+    
+    def _has_file_handler(self, logger: logging.Logger) -> bool:
+        """FileHandlerの存在チェック"""
+        return any(isinstance(h, logging.FileHandler) for h in logger.handlers)
+    
+    def _create_file_handler(self, level: int) -> Optional[logging.FileHandler]:
+        """
+        ファイルハンドラーの作成
+        
+        Args:
+            level: ログレベル
+            
+        Returns:
+            作成されたFileHandlerまたはNone
+        """
+        try:
+            # ログディレクトリの決定
+            log_dir = os.environ.get("TREE_SITTER_ANALYZER_LOG_DIR")
+            if log_dir:
+                log_path = Path(log_dir) / "tree_sitter_analyzer.log"
+                Path(log_dir).mkdir(parents=True, exist_ok=True)
+            else:
+                temp_dir = tempfile.gettempdir()
+                log_path = Path(temp_dir) / "tree_sitter_analyzer.log"
+            
+            # ファイルログレベルの決定
+            file_log_level_str = os.environ.get(
+                "TREE_SITTER_ANALYZER_FILE_LOG_LEVEL", ""
+            ).upper()
+            file_log_level = level  # デフォルトはメインレベル
+            
+            if file_log_level_str in ["DEBUG", "INFO", "WARNING", "ERROR"]:
+                file_log_level = getattr(logging, file_log_level_str)
+            
+            # ファイルハンドラー作成
+            file_handler = logging.FileHandler(str(log_path), encoding="utf-8")
+            formatter = logging.Formatter(
+                "%(asctime)s - %(name)s - %(levelname)s - %(message)s"
+            )
+            file_handler.setFormatter(formatter)
+            file_handler.setLevel(file_log_level)
+            
+            # ファイルパス情報を出力（1回のみ）
+            if not LoggerManager._file_log_message_shown:
+                LoggerManager._file_log_message_shown = True
+                if hasattr(sys, "stderr") and hasattr(sys.stderr, "write"):
+                    try:
+                        sys.stderr.write(
+                            f"[LoggerManager] File logging enabled: {log_path}\n"
+                        )
+                    except Exception:
+                        pass
+            
+            return file_handler
+            
+        except Exception as e:
+            # ファイルハンドラー作成に失敗してもメインの動作は継続
+            if hasattr(sys, "stderr") and hasattr(sys.stderr, "write"):
+                try:
+                    sys.stderr.write(
+                        f"[LoggerManager] File handler creation failed: {e}\n"
+                    )
+                except Exception:
+                    pass
+            return None
+    
+    def reset_for_testing(self) -> None:
+        """
+        テスト用リセット機能
+        
+        Note:
+            本番環境では使用しないこと
+        """
+        with self._lock:
+            # 全ハンドラーのクリーンアップ
+            for logger in self._loggers.values():
+                for handler in logger.handlers[:]:
+                    try:
+                        handler.close()
+                        logger.removeHandler(handler)
+                    except Exception:
+                        pass
+            
+            self._loggers.clear()
+            self._handler_registry.clear()
+            LoggerManager._file_log_message_shown = False
+
+
+class SafeStreamHandler(logging.StreamHandler):
+    """
+    安全なStreamHandler実装
+    
+    MCPプロトコルのstdio通信やテスト環境での
+    ストリームクローズ問題に対応。
+    """
+    
+    def __init__(self, stream=None):
+        # デフォルトでstderrを使用（stdoutはMCP用に保持）
+        super().__init__(stream if stream is not None else sys.stderr)
+    
+    def emit(self, record: Any) -> None:
+        """
+        レコードの安全な出力
+        
+        Args:
+            record: ログレコード
+        """
+        try:
+            # ストリームの状態チェック
+            if hasattr(self.stream, "closed") and self.stream.closed:
+                return
+            
+            if not hasattr(self.stream, "write"):
+                return
+            
+            # pytest環境での特別処理
+            stream_name = getattr(self.stream, "name", "")
+            if stream_name is None or "pytest" in str(type(self.stream)).lower():
+                try:
+                    super().emit(record)
+                    return
+                except (ValueError, OSError, AttributeError, UnicodeError):
+                    return
+            
+            # 通常のストリーム書き込み可能性チェック
+            try:
+                if hasattr(self.stream, "writable") and not self.stream.writable():
+                    return
+            except (ValueError, OSError, AttributeError, UnicodeError):
+                return
+            
+            super().emit(record)
+            
+        except (ValueError, OSError, AttributeError, UnicodeError):
+            # I/Oエラーは静かに無視（シャットダウン時やpytestキャプチャ時）
+            pass
+        except Exception:
+            # その他の予期しないエラーも静かに無視
+            pass
+
+
+# グローバルインスタンス
+_logger_manager = LoggerManager()
+
+
+def get_logger_manager() -> LoggerManager:
+    """
+    LoggerManagerのグローバルインスタンス取得
+    
+    Returns:
+        LoggerManagerインスタンス
+    """
+    return _logger_manager
+
+
+def get_unified_logger(
+    name: str = "tree_sitter_analyzer", 
+    level: int | str = logging.WARNING
+) -> logging.Logger:
+    """
+    統一されたロガー取得関数
+    
+    Args:
+        name: ロガー名
+        level: ログレベル
+        
+    Returns:
+        設定済みロガーインスタンス
+    """
+    return _logger_manager.get_logger(name, level)

tree_sitter_analyzer/mcp/server.py

@@ -67,7 +67,7 @@ from .tools.read_partial_tool import ReadPartialTool
 from .tools.search_content_tool import SearchContentTool
 from .tools.table_format_tool import TableFormatTool
 
-# Set up logging
+# Set up logging using unified LoggerManager
 logger = setup_logger(__name__)