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

tree_sitter_analyzer/core/analysis_engine.py

@@ -1,15 +1,15 @@
 #!/usr/bin/env python3
 """
-統一解析エンジン - CLI・MCP共通解析システム（修正版）
+Unified Analysis Engine - Common Analysis System for CLI and MCP (Fixed Version)
 
-このモジュールは、すべての解析処理の中心となる統一エンジンを提供します。
-CLI、MCP、その他のインターフェースから共通して使用されます。
+This module provides a unified engine that serves as the center of all analysis processing.
+It is commonly used by CLI, MCP, and other interfaces.
 
-Roo Code規約準拠:
-- 型ヒント: 全関数に型ヒント必須
-- MCPログ: 各ステップでログ出力
+Roo Code compliance:
+- Type hints: Required for all functions
+- MCP logging: Log output at each step
 - docstring: Google Style docstring
-- パフォーマンス重視: シングルトンパターンとキャッシュ共有
+- Performance-focused: Singleton pattern and cache sharing
 """
 
 import hashlib
@@ -18,36 +18,38 @@ 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
 
 
 class UnsupportedLanguageError(Exception):
-    """サポートされていない言語エラー"""
+    """Unsupported language error"""
 
     pass
 
 
 class PluginRegistry(Protocol):
-    """プラグイン登録管理のプロトコル"""
+    """Protocol for plugin registration management"""
 
     def get_plugin(self, language: str) -> Optional["LanguagePlugin"]:
-        """言語プラグインを取得"""
+        """Get language plugin"""
         ...
 
 
 class LanguagePlugin(Protocol):
-    """言語プラグインのプロトコル"""
+    """Language plugin protocol"""
 
     async def analyze_file(
         self, file_path: str, request: "AnalysisRequest"
     ) -> AnalysisResult:
-        """ファイル解析"""
+        """File analysis"""
         ...
 
 
 class PerformanceMonitor:
-    """パフォーマンス監視（簡易版）"""
+    """Performance monitoring (simplified version)"""
 
     def __init__(self) -> None:
         self._last_duration: float = 0.0
@@ -56,33 +58,33 @@ class PerformanceMonitor:
         self._total_operations: int = 0
 
     def measure_operation(self, operation_name: str) -> "PerformanceContext":
-        """操作の測定コンテキストを返す"""
+        """Return measurement context for operation"""
         return PerformanceContext(operation_name, self)
 
     def get_last_duration(self) -> float:
-        """最後の操作時間を取得"""
+        """Get last operation time"""
         return self._last_duration
 
     def _set_duration(self, duration: float) -> None:
-        """操作時間を設定（内部用）"""
+        """Set operation time (internal use)"""
         self._last_duration = duration
 
     def start_monitoring(self) -> None:
-        """パフォーマンス監視を開始"""
+        """Start performance monitoring"""
         self._monitoring_active = True
         log_info("Performance monitoring started")
 
     def stop_monitoring(self) -> None:
-        """パフォーマンス監視を停止"""
+        """Stop performance monitoring"""
         self._monitoring_active = False
         log_info("Performance monitoring stopped")
 
     def get_operation_stats(self) -> dict[str, Any]:
-        """操作統計を取得"""
+        """Get operation statistics"""
         return self._operation_stats.copy()
 
     def get_performance_summary(self) -> dict[str, Any]:
-        """パフォーマンス要約を取得"""
+        """Get performance summary"""
         return {
             "total_operations": self._total_operations,
             "monitoring_active": self._monitoring_active,
@@ -91,7 +93,7 @@ class PerformanceMonitor:
         }
 
     def record_operation(self, operation_name: str, duration: float) -> None:
-        """操作を記録"""
+        """Record operation"""
         if self._monitoring_active:
             if operation_name not in self._operation_stats:
                 self._operation_stats[operation_name] = {
@@ -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()}")
-
-        try:
-            # JavaScriptプラグインの登録
-            log_debug("Attempting to load JavaScript plugin...")
-            from ..plugins.javascript_plugin import JavaScriptPlugin
-
-            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()}")
+        log_info("Loading plugins using PluginManager...")
 
         try:
-            # Pythonプラグインの登録
-            log_debug("Attempting to load Python plugin...")
-            from ..languages.python_plugin import PythonPlugin
+            # PluginManagerの自動ロード機能を使用
+            loaded_plugins = self._plugin_manager.load_plugins()
 
-            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/cache_service.py

@@ -1,15 +1,15 @@
 #!/usr/bin/env python3
 """
-統一キャッシュサービス - CLI・MCP共通キャッシュシステム
+Unified Cache Service - Common Cache System for CLI and MCP
 
-このモジュールは、メモリ効率的な階層キャッシュシステムを提供します。
-L1（高速）、L2（中期）、L3（長期）の3層構造で最適なパフォーマンスを実現。
+This module provides a memory-efficient hierarchical cache system.
+Achieves optimal performance with a 3-tier structure: L1 (fast), L2 (medium-term), L3 (long-term).
 
-Roo Code規約準拠:
-- 型ヒント: 全関数に型ヒント必須
-- MCPログ: 各ステップでログ出力
+Roo Code compliance:
+- Type hints: Required for all functions
+- MCP logging: Log output at each step
 - docstring: Google Style docstring
-- パフォーマンス重視: メモリ効率とアクセス速度の最適化
+- Performance-focused: Optimization of memory efficiency and access speed
 """
 
 import hashlib
@@ -26,15 +26,15 @@ from ..utils import log_debug, log_error, log_info
 @dataclass(frozen=True)
 class CacheEntry:
     """
-    キャッシュエントリ
+    Cache Entry
 
-    キャッシュされた値とメタデータを保持するデータクラス。
+    Data class that holds cached values and metadata.
 
     Attributes:
-        value: キャッシュされた値
-        created_at: 作成日時
-        expires_at: 有効期限
-        access_count: アクセス回数
+        value: Cached value
+        created_at: Creation timestamp
+        expires_at: Expiration time
+        access_count: Access count
     """
 
     value: Any
@@ -44,10 +44,10 @@ class CacheEntry:
 
     def is_expired(self) -> bool:
         """
-        有効期限チェック
+        Expiration check
 
         Returns:
-            bool: 期限切れの場合True
+            bool: True if expired
         """
         if self.expires_at is None:
             return False
@@ -56,17 +56,17 @@ class CacheEntry:
 
 class CacheService:
     """
-    統一キャッシュサービス
+    Unified Cache Service
 
-    階層化キャッシュシステムを提供し、CLI・MCP間でキャッシュを共有。
-    メモリ効率とアクセス速度を最適化した3層構造。
+    Provides hierarchical cache system and shares cache between CLI and MCP.
+    3-tier structure optimized for memory efficiency and access speed.
 
     Attributes:
-        _l1_cache: L1キャッシュ（高速アクセス用）
-        _l2_cache: L2キャッシュ（中期保存用）
-        _l3_cache: L3キャッシュ（長期保存用）
-        _lock: スレッドセーフ用ロック
-        _stats: キャッシュ統計情報
+        _l1_cache: L1 cache (for fast access)
+        _l2_cache: L2 cache (for medium-term storage)
+        _l3_cache: L3 cache (for long-term storage)
+        _lock: Lock for thread safety
+        _stats: Cache statistics
     """
 
     def __init__(
@@ -77,25 +77,25 @@ class CacheService:
         ttl_seconds: int = 3600,
     ) -> None:
         """
-        初期化
+        Initialization
 
         Args:
-            l1_maxsize: L1キャッシュの最大サイズ
-            l2_maxsize: L2キャッシュの最大サイズ
-            l3_maxsize: L3キャッシュの最大サイズ
-            ttl_seconds: デフォルトTTL（秒）
+            l1_maxsize: Maximum size of L1 cache
+            l2_maxsize: Maximum size of L2 cache
+            l3_maxsize: Maximum size of L3 cache
+            ttl_seconds: Default TTL (seconds)
         """
-        # 階層化キャッシュの初期化
+        # Initialize hierarchical cache
         self._l1_cache: LRUCache[str, CacheEntry] = LRUCache(maxsize=l1_maxsize)
         self._l2_cache: TTLCache[str, CacheEntry] = TTLCache(
             maxsize=l2_maxsize, ttl=ttl_seconds
         )
         self._l3_cache: LRUCache[str, CacheEntry] = LRUCache(maxsize=l3_maxsize)
 
-        # スレッドセーフ用ロック
+        # Lock for thread safety
         self._lock = threading.RLock()
 
-        # キャッシュ統計
+        # Cache statistics
         self._stats = {
             "hits": 0,
             "misses": 0,

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,