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

tree_sitter_analyzer/__init__.py

@@ -11,7 +11,7 @@ Architecture:
 - Data Models: Generic and language-specific code element representations
 """
 
-__version__ = "0.3.0"
+__version__ = "0.4.0"
 __author__ = "aisheng.yu"
 __email__ = "aimasteracc@gmail.com"
 
@@ -61,7 +61,8 @@ from .output_manager import (
 )
 
 # Plugin System
-from .plugins import ElementExtractor, LanguagePlugin, plugin_registry
+from .plugins import ElementExtractor, LanguagePlugin
+from .plugins.manager import PluginManager
 from .query_loader import QueryLoader, get_query_loader
 
 # Import new utility modules
@@ -93,7 +94,7 @@ __all__ = [
     # Plugin system
     "ElementExtractor",
     "LanguagePlugin",
-    "plugin_registry",
+    "PluginManager",
     "QueryLoader",
     # Language detection
     "LanguageDetector",

tree_sitter_analyzer/api.py

@@ -240,7 +240,8 @@ def get_available_queries(language: str) -> list[str]:
         # Try to get plugin and its supported queries
         plugin = engine._get_language_plugin(language)
         if plugin and hasattr(plugin, "get_supported_queries"):
-            return plugin.get_supported_queries()
+            result = plugin.get_supported_queries()
+            return list(result) if result else []
         else:
             # Return default queries
             return ["class", "method", "field"]
@@ -300,7 +301,8 @@ def get_file_extensions(language: str) -> list[str]:
         engine = get_engine()
         # Use language_detector to get extensions
         if hasattr(engine.language_detector, "get_extensions_for_language"):
-            return engine.language_detector.get_extensions_for_language(language)
+            result = engine.language_detector.get_extensions_for_language(language)
+            return list(result) if result else []
         else:
             # Fallback: return common extensions
             extension_map = {

tree_sitter_analyzer/cli/__init__.py

@@ -22,9 +22,9 @@ try:
     query_loader = QueryLoader()
 except ImportError:
     # Minimal fallback for import safety
-    get_analysis_engine = None
-    main = None
-    query_loader = None
+    get_analysis_engine = None  # type: ignore
+    main = None  # type: ignore
+    query_loader = None  # type: ignore
 
 __all__ = [
     "InfoCommand",

tree_sitter_analyzer/cli/commands/advanced_command.py

@@ -76,7 +76,7 @@ class AdvancedCommand(BaseCommand):
         output_data("Package: (default)")
         output_data(f"Lines: {analysis_result.line_count}")
 
-        element_counts = {}
+        element_counts: dict[str, int] = {}
         for element in analysis_result.elements:
             element_type = getattr(element, "__class__", type(element)).__name__
             element_counts[element_type] = element_counts.get(element_type, 0) + 1

tree_sitter_analyzer/cli/commands/base_command.py

@@ -78,7 +78,7 @@ class BaseCommand(ABC):
                     )
                 target_language = "java"  # Fallback
 
-        return target_language
+        return str(target_language) if target_language else None
 
     async def analyze_file(self, language: str) -> Optional["AnalysisResult"]:
         """Perform file analysis using the unified analysis engine."""

tree_sitter_analyzer/cli/commands/partial_read_command.py

@@ -5,7 +5,7 @@ Partial Read Command
 Handles partial file reading functionality, extracting specified line ranges.
 """
 
-from typing import TYPE_CHECKING
+from typing import TYPE_CHECKING, Any
 
 from ...file_handler import read_file_partial
 from ...output_manager import output_data, output_json, output_section
@@ -18,7 +18,7 @@ if TYPE_CHECKING:
 class PartialReadCommand(BaseCommand):
     """Command for reading partial file content by line range."""
 
-    def __init__(self, args):
+    def __init__(self, args: Any) -> None:
         """Initialize with arguments but skip base class analysis engine setup."""
         self.args = args
         # Don't call super().__init__() to avoid unnecessary analysis engine setup

tree_sitter_analyzer/cli/commands/summary_command.py

@@ -5,7 +5,7 @@ Summary Command
 Handles summary functionality with specified element types.
 """
 
-from typing import TYPE_CHECKING
+from typing import TYPE_CHECKING, Any
 
 from ...output_manager import output_data, output_json, output_section
 from .base_command import BaseCommand
@@ -50,7 +50,7 @@ class SummaryCommand(BaseCommand):
             e for e in analysis_result.elements if e.__class__.__name__ == "Import"
         ]
 
-        summary_data = {
+        summary_data: dict[str, Any] = {
             "file_path": analysis_result.file_path,
             "language": analysis_result.language,
             "summary": {},

tree_sitter_analyzer/cli/commands/table_command.py

@@ -6,6 +6,7 @@ Handles table format output generation.
 """
 
 import sys
+from typing import Any
 
 from ...output_manager import output_error
 from ...table_formatter import create_table_formatter
@@ -44,7 +45,9 @@ class TableCommand(BaseCommand):
             output_error(f"ERROR: テーブル形式での解析でエラーが発生しました: {e}")
             return 1
 
-    def _convert_to_structure_format(self, analysis_result, language: str) -> dict:
+    def _convert_to_structure_format(
+        self, analysis_result: Any, language: str
+    ) -> dict[str, Any]:
         """Convert AnalysisResult to the format expected by table formatter."""
         classes = []
         methods = []
@@ -59,7 +62,7 @@ class TableCommand(BaseCommand):
                 element_name = getattr(element, "name", None)
 
                 if element_type == "Package":
-                    package_name = element_name
+                    package_name = str(element_name)
                 elif element_type == "Class":
                     classes.append(self._convert_class_element(element, i))
                 elif element_type == "Function":
@@ -90,7 +93,7 @@ class TableCommand(BaseCommand):
             },
         }
 
-    def _convert_class_element(self, element, index: int) -> dict:
+    def _convert_class_element(self, element: Any, index: int) -> dict[str, Any]:
         """Convert class element to table format."""
         element_name = getattr(element, "name", None)
         final_name = element_name if element_name else f"UnknownClass_{index}"
@@ -105,7 +108,7 @@ class TableCommand(BaseCommand):
             },
         }
 
-    def _convert_function_element(self, element, language: str) -> dict:
+    def _convert_function_element(self, element: Any, language: str) -> dict[str, Any]:
         """Convert function element to table format."""
         # Process parameters based on language
         params = getattr(element, "parameters", [])
@@ -133,7 +136,7 @@ class TableCommand(BaseCommand):
             "javadoc": javadoc,
         }
 
-    def _convert_variable_element(self, element, language: str) -> dict:
+    def _convert_variable_element(self, element: Any, language: str) -> dict[str, Any]:
         """Convert variable element to table format."""
         # Get field type based on language
         if language == "python":
@@ -162,14 +165,14 @@ class TableCommand(BaseCommand):
             "javadoc": javadoc,
         }
 
-    def _convert_import_element(self, element) -> dict:
+    def _convert_import_element(self, element: Any) -> dict[str, Any]:
         """Convert import element to table format."""
         return {
             "statement": getattr(element, "name", str(element)),
             "name": getattr(element, "name", str(element)),
         }
 
-    def _process_parameters(self, params, language: str) -> list:
+    def _process_parameters(self, params: Any, language: str) -> list[dict[str, str]]:
         """Process parameters based on language syntax."""
         if isinstance(params, str):
             param_list = []
@@ -213,7 +216,7 @@ class TableCommand(BaseCommand):
         else:
             return []
 
-    def _get_element_visibility(self, element) -> str:
+    def _get_element_visibility(self, element: Any) -> str:
         """Get element visibility."""
         visibility = getattr(element, "visibility", "public")
         if hasattr(element, "is_private") and getattr(element, "is_private", False):

tree_sitter_analyzer/cli_main.py

@@ -4,6 +4,7 @@
 import argparse
 import logging
 import sys
+from typing import Any
 
 # Import command classes
 from .cli.commands import (
@@ -29,7 +30,7 @@ class CLICommandFactory:
     """Factory for creating CLI commands based on arguments."""
 
     @staticmethod
-    def create_command(args: argparse.Namespace):
+    def create_command(args: argparse.Namespace) -> Any:
         """Create appropriate command based on arguments."""
 
         # Information commands (no file analysis required)

tree_sitter_analyzer/core/analysis_engine.py

@@ -18,6 +18,8 @@ from dataclasses import dataclass
 from typing import Any, Optional, Protocol
 
 from ..models import AnalysisResult
+from ..plugins.base import LanguagePlugin as BaseLanguagePlugin
+from ..plugins.manager import PluginManager
 from ..utils import log_debug, log_error, log_info, log_performance
 from .cache_service import CacheService
 
@@ -181,24 +183,7 @@ class AnalysisRequest:
         )
 
 
-class SimplePluginRegistry:
-    """簡易プラグイン登録管理"""
-
-    def __init__(self) -> None:
-        self._plugins: dict[str, LanguagePlugin] = {}
-
-    def register_plugin(self, language: str, plugin: LanguagePlugin) -> None:
-        """プラグインを登録"""
-        self._plugins[language] = plugin
-        log_info(f"Plugin registered for language: {language}")
-
-    def get_plugin(self, language: str) -> LanguagePlugin | None:
-        """プラグインを取得"""
-        return self._plugins.get(language)
-
-    def get_supported_languages(self) -> list[str]:
-        """サポートされている言語一覧を取得"""
-        return list(self._plugins.keys())
+# SimplePluginRegistry removed - now using PluginManager
 
 
 class UnifiedAnalysisEngine:
@@ -215,7 +200,7 @@ class UnifiedAnalysisEngine:
 
     Attributes:
         _cache_service: キャッシュサービス
-        _plugin_registry: プラグイン登録管理
+        _plugin_manager: プラグイン管理
         _performance_monitor: パフォーマンス監視
     """
 
@@ -236,7 +221,7 @@ class UnifiedAnalysisEngine:
             return
 
         self._cache_service = CacheService()
-        self._plugin_registry = SimplePluginRegistry()
+        self._plugin_manager = PluginManager()
         self._performance_monitor = PerformanceMonitor()
 
         # プラグインを自動ロード
@@ -248,54 +233,21 @@ class UnifiedAnalysisEngine:
 
     def _load_plugins(self) -> None:
         """利用可能なプラグインを自動ロード"""
-        log_info("Loading plugins...")
-
-        try:
-            # Javaプラグインの登録
-            log_debug("Attempting to load Java plugin...")
-            from ..languages.java_plugin import JavaPlugin
-
-            java_plugin = JavaPlugin()
-            self._plugin_registry.register_plugin("java", java_plugin)
-            log_debug("Loaded Java plugin")
-        except Exception as e:
-            log_error(f"Failed to load Java plugin: {e}")
-            import traceback
-
-            log_error(f"Java plugin traceback: {traceback.format_exc()}")
+        log_info("Loading plugins using PluginManager...")
 
         try:
-            # JavaScriptプラグインの登録
-            log_debug("Attempting to load JavaScript plugin...")
-            from ..plugins.javascript_plugin import JavaScriptPlugin
+            # PluginManagerの自動ロード機能を使用
+            loaded_plugins = self._plugin_manager.load_plugins()
 
-            js_plugin = JavaScriptPlugin()
-            self._plugin_registry.register_plugin("javascript", js_plugin)
-            log_debug("Loaded JavaScript plugin")
-        except Exception as e:
-            log_error(f"Failed to load JavaScript plugin: {e}")
-            import traceback
-
-            log_error(f"JavaScript plugin traceback: {traceback.format_exc()}")
-
-        try:
-            # Pythonプラグインの登録
-            log_debug("Attempting to load Python plugin...")
-            from ..languages.python_plugin import PythonPlugin
-
-            python_plugin = PythonPlugin()
-            self._plugin_registry.register_plugin("python", python_plugin)
-            log_debug("Loaded Python plugin")
+            final_languages = [plugin.get_language_name() for plugin in loaded_plugins]
+            log_info(
+                f"Successfully loaded {len(final_languages)} language plugins: {', '.join(final_languages)}"
+            )
         except Exception as e:
-            log_error(f"Failed to load Python plugin: {e}")
+            log_error(f"Failed to load plugins: {e}")
             import traceback
 
-            log_error(f"Python plugin traceback: {traceback.format_exc()}")
-
-        final_languages = self._plugin_registry.get_supported_languages()
-        log_info(
-            f"Successfully loaded {len(final_languages)} language plugins: {', '.join(final_languages)}"
-        )
+            log_error(f"Plugin loading traceback: {traceback.format_exc()}")
 
     async def analyze(self, request: AnalysisRequest) -> AnalysisResult:
         """
@@ -318,19 +270,19 @@ class UnifiedAnalysisEngine:
         cached_result = await self._cache_service.get(cache_key)
         if cached_result:
             log_info(f"Cache hit for {request.file_path}")
-            return cached_result
+            return cached_result  # type: ignore
 
         # 言語検出
         language = request.language or self._detect_language(request.file_path)
         log_debug(f"Detected language: {language}")
 
         # デバッグ：登録されているプラグインを確認
-        supported_languages = self._plugin_registry.get_supported_languages()
+        supported_languages = self._plugin_manager.get_supported_languages()
         log_debug(f"Supported languages: {supported_languages}")
         log_debug(f"Looking for plugin for language: {language}")
 
         # プラグイン取得
-        plugin = self._plugin_registry.get_plugin(language)
+        plugin = self._plugin_manager.get_plugin(language)
         if not plugin:
             error_msg = f"Language {language} not supported"
             log_error(error_msg)
@@ -440,15 +392,15 @@ class UnifiedAnalysisEngine:
         self._cache_service.clear()
         log_info("Analysis engine cache cleared")
 
-    def register_plugin(self, language: str, plugin: LanguagePlugin) -> None:
+    def register_plugin(self, language: str, plugin: BaseLanguagePlugin) -> None:
         """
         プラグインを登録
 
         Args:
-            language: 言語名
+            language: 言語名（互換性のため保持、実際は使用されない）
             plugin: 言語プラグイン
         """
-        self._plugin_registry.register_plugin(language, plugin)
+        self._plugin_manager.register_plugin(plugin)
 
     def get_supported_languages(self) -> list[str]:
         """
@@ -457,7 +409,7 @@ class UnifiedAnalysisEngine:
         Returns:
             サポート言語のリスト
         """
-        return self._plugin_registry.get_supported_languages()
+        return self._plugin_manager.get_supported_languages()
 
     def get_cache_stats(self) -> dict[str, Any]:
         """
@@ -554,6 +506,18 @@ class MockLanguagePlugin:
     def __init__(self, language: str) -> None:
         self.language = language
 
+    def get_language_name(self) -> str:
+        """言語名を取得"""
+        return self.language
+
+    def get_file_extensions(self) -> list[str]:
+        """ファイル拡張子を取得"""
+        return [f".{self.language}"]
+
+    def create_extractor(self) -> None:
+        """エクストラクタを作成（モック）"""
+        return None
+
     async def analyze_file(
         self, file_path: str, request: AnalysisRequest
     ) -> AnalysisResult:

tree_sitter_analyzer/core/engine.py

@@ -350,7 +350,7 @@ class AnalysisEngine:
         """
         # This is a basic fallback implementation
         # Real implementation would extract meaningful elements
-        elements = []
+        elements: list[Any] = []
 
         try:
             if parse_result.tree and parse_result.tree.root_node:
@@ -473,6 +473,7 @@ class AnalysisEngine:
             return []
         except Exception as e:
             logger.error(f"Error getting supported languages: {e}")
+            return []
 
     def get_available_queries(self, language: str) -> list[str]:
         """
@@ -487,16 +488,18 @@ class AnalysisEngine:
         try:
             plugin = self._get_language_plugin(language)
             if plugin and hasattr(plugin, "get_supported_queries"):
-                return plugin.get_supported_queries()
+                queries = plugin.get_supported_queries()
+                return list(queries) if queries else []
             else:
                 # Return default queries
                 return ["class", "method", "field"]
         except Exception as e:
             logger.error(f"Error getting available queries for {language}: {e}")
+            return []
 
     # Add compatibility methods for API layer
     @property
-    def language_registry(self):
+    def language_registry(self) -> "AnalysisEngine":
         """Provide compatibility with API layer expecting language_registry"""
         return self
 
@@ -554,4 +557,3 @@ class AnalysisEngine:
         except Exception as e:
             logger.error(f"Error getting registry info: {e}")
             return {}
-            return []

tree_sitter_analyzer/core/parser.py

@@ -164,7 +164,7 @@ class Parser:
             tree = parser.parse(source_bytes)
 
             if tree is None:
-                return ParseResult(
+                return ParseResult(  # type: ignore[unreachable]
                     tree=None,
                     source_code=source_code,
                     language=language,

tree_sitter_analyzer/core/query.py

@@ -65,7 +65,7 @@ class QueryExecutor:
                 return self._create_error_result("Tree is None", query_name=query_name)
 
             if language is None:
-                return self._create_error_result(
+                return self._create_error_result(  # type: ignore[unreachable]
                     "Language is None", query_name=query_name
                 )
 
@@ -144,7 +144,7 @@ class QueryExecutor:
                 return self._create_error_result("Tree is None")
 
             if language is None:
-                return self._create_error_result("Language is None")
+                return self._create_error_result("Language is None")  # type: ignore[unreachable]
 
             # Create and execute the query
             try:
@@ -206,7 +206,7 @@ class QueryExecutor:
         return results
 
     def _process_captures(
-        self, captures: list[dict[str, Any] | tuple[Node, str]], source_code: str
+        self, captures: Any, source_code: str
     ) -> list[dict[str, Any]]:
         """
         Process query captures into standardized format.
@@ -290,7 +290,7 @@ class QueryExecutor:
             return {"capture_name": capture_name, "node_type": "error", "error": str(e)}
 
     def _create_error_result(
-        self, error_message: str, query_name: str | None = None, **kwargs
+        self, error_message: str, query_name: str | None = None, **kwargs: Any
     ) -> dict[str, Any]:
         """
         Create an error result dictionary.
@@ -322,7 +322,14 @@ class QueryExecutor:
             List of available query names
         """
         try:
-            return self._query_loader.get_all_queries_for_language(language)
+            queries = self._query_loader.get_all_queries_for_language(language)
+            if isinstance(queries, dict):
+                return list(queries.keys())
+            # Handle other iterable types
+            try:  # type: ignore[unreachable]
+                return list(queries) if queries else []
+            except (TypeError, ValueError):
+                return []
         except Exception as e:
             logger.error(f"Error getting available queries for {language}: {e}")
             return []
@@ -405,7 +412,7 @@ class QueryExecutor:
 
 
 # Module-level convenience functions for backward compatibility
-def get_available_queries(language: str = None) -> list[str]:
+def get_available_queries(language: str | None = None) -> list[str]:
     """
     Get available queries for a language (module-level function).
 
@@ -449,6 +456,7 @@ def get_query_description(language: str, query_name: str) -> str | None:
         return loader.get_query_description(language, query_name)
     except Exception as e:
         logger.error(f"Error getting query description: {e}")
+        return None
 
 
 # Module-level attributes for backward compatibility
@@ -457,7 +465,7 @@ try:
 
     query_loader = get_query_loader()
 except Exception:
-    query_loader = None
+    query_loader = None  # type: ignore
 
 
 def get_all_queries_for_language(language: str) -> list[str]:
@@ -491,4 +499,4 @@ try:
 
     loader = get_loader()
 except Exception:
-    loader = None
+    loader = None  # type: ignore

tree_sitter_analyzer/encoding_utils.py

@@ -162,8 +162,6 @@ class EncodingManager:
         Returns:
             Encoded bytes
         """
-        if text is None:
-            return b""
 
         target_encoding = encoding or cls.DEFAULT_ENCODING