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

tree_sitter_analyzer/__init__.py

@@ -17,7 +17,7 @@ __email__ = "aimasteracc@gmail.com"
 
 # Legacy imports for backward compatibility
 
-# Core Engine - 一時的に直接インポート
+# Core Engine - temporary direct import
 from .core.analysis_engine import UnifiedAnalysisEngine as UniversalCodeAnalyzer
 from .encoding_utils import (
     EncodingManager,
@@ -30,7 +30,6 @@ from .encoding_utils import (
 )
 
 # from .java_advanced_analyzer import AdvancedAnalyzer  # Removed - migrated to plugin system
-from .java_analyzer import CodeAnalyzer
 from .language_detector import LanguageDetector
 from .language_loader import get_loader
 
@@ -119,7 +118,6 @@ __all__ = [
     "output_error",
     "output_data",
     # Legacy Components (backward compatibility)
-    "CodeAnalyzer",
     "UniversalCodeAnalyzer",
     # Version
     "__version__",

tree_sitter_analyzer/__main__.py

@@ -1,8 +1,8 @@
 #!/usr/bin/env python3
 """
-Tree-sitter Analyzer パッケージのメインエントリーポイント
+Tree-sitter Analyzer package main entry point
 
-このファイルにより、`python -m tree_sitter_analyzer` でパッケージを実行できます。
+This file allows the package to be executed with `python -m tree_sitter_analyzer`.
 """
 
 from .cli_main import main

tree_sitter_analyzer/cli/commands/default_command.py

@@ -14,5 +14,5 @@ class DefaultCommand(BaseCommand):
 
     async def execute_async(self, language: str) -> int:
         """Execute default command - show error for missing options."""
-        output_error("ERROR: クエリまたは--advancedオプションを指定してください")
+        output_error("ERROR: Please specify a query or --advanced option")
         return 1

tree_sitter_analyzer/cli/commands/query_command.py

@@ -22,7 +22,7 @@ class QueryCommand(BaseCommand):
                 query_to_execute = query_loader.get_query(language, self.args.query_key)
                 if query_to_execute is None:
                     output_error(
-                        f"ERROR: クエリ '{self.args.query_key}' が言語 '{language}' で見つかりません"
+                        f"ERROR: Query '{self.args.query_key}' not found for language '{language}'"
                     )
                     return 1
             except ValueError as e:
@@ -32,7 +32,7 @@ class QueryCommand(BaseCommand):
             query_to_execute = self.args.query_string
 
         if not query_to_execute:
-            output_error("ERROR: クエリが指定されていません。")
+            output_error("ERROR: No query specified.")
             return 1
 
         # Perform analysis
@@ -72,10 +72,10 @@ class QueryCommand(BaseCommand):
                         f"\n{i}. {query_result['capture_name']} ({query_result['node_type']})"
                     )
                     output_data(
-                        f"   位置: 行 {query_result['start_line']}-{query_result['end_line']}"
+                        f"   Position: Line {query_result['start_line']}-{query_result['end_line']}"
                     )
-                    output_data(f"   内容:\n{query_result['content']}")
+                    output_data(f"   Content:\n{query_result['content']}")
         else:
-            output_info("\nINFO: クエリにマッチする結果は見つかりませんでした。")
+            output_info("\nINFO: No results found matching the query.")
 
         return 0

tree_sitter_analyzer/cli/commands/table_command.py

@@ -42,7 +42,7 @@ class TableCommand(BaseCommand):
             return 0
 
         except Exception as e:
-            output_error(f"ERROR: テーブル形式での解析でエラーが発生しました: {e}")
+            output_error(f"ERROR: An error occurred during table format analysis: {e}")
             return 1
 
     def _convert_to_structure_format(
@@ -228,8 +228,8 @@ class TableCommand(BaseCommand):
     def _output_table(self, table_output: str) -> None:
         """Output the table with proper encoding."""
         try:
-            # Windows対応: UTF-8エンコーディングで出力
+            # Windows support: Output with UTF-8 encoding
             sys.stdout.buffer.write(table_output.encode("utf-8"))
         except (AttributeError, UnicodeEncodeError):
-            # フォールバック: 通常のprint
+            # Fallback: Normal print
             print(table_output, end="")

tree_sitter_analyzer/cli/info_commands.py

@@ -34,22 +34,23 @@ class ListQueriesCommand(InfoCommand):
         elif hasattr(self.args, "file_path") and self.args.file_path:
             language = detect_language_from_file(self.args.file_path)
         else:
-            output_list("サポートされている言語:")
+            output_list("Supported languages:")
             for lang in query_loader.list_supported_languages():
                 output_list(f"  {lang}")
                 queries = query_loader.list_queries_for_language(lang)
                 for query_key in queries:
                     description = (
                         query_loader.get_query_description(lang, query_key)
-                        or "説明なし"
+                        or "No description"
                     )
                     output_list(f"    {query_key:<20} - {description}")
             return 0
 
-        output_list(f"利用可能なクエリキー ({language}):")
+        output_list(f"Available query keys ({language}):")
         for query_key in query_loader.list_queries_for_language(language):
             description = (
-                query_loader.get_query_description(language, query_key) or "説明なし"
+                query_loader.get_query_description(language, query_key)
+                or "No description"
             )
             output_list(f"  {query_key:<20} - {description}")
         return 0
@@ -65,7 +66,7 @@ class DescribeQueryCommand(InfoCommand):
             language = detect_language_from_file(self.args.file_path)
         else:
             output_error(
-                "ERROR: クエリ説明表示には--languageまたは対象ファイルの指定が必要です"
+                "ERROR: Query description display requires --language or target file specification"
             )
             return 1
 
@@ -77,14 +78,14 @@ class DescribeQueryCommand(InfoCommand):
 
             if query_description is None or query_content is None:
                 output_error(
-                    f"ERROR: クエリ '{self.args.describe_query}' が言語 '{language}' で見つかりません"
+                    f"ERROR: Query '{self.args.describe_query}' not found for language '{language}'"
                 )
                 return 1
 
             output_info(
-                f"クエリキー '{self.args.describe_query}' ({language}): {query_description}"
+                f"Query key '{self.args.describe_query}' ({language}): {query_description}"
             )
-            output_data(f"クエリ内容:\n{query_content}")
+            output_data(f"Query content:\n{query_content}")
         except ValueError as e:
             output_error(f"ERROR: {e}")
             return 1
@@ -95,13 +96,13 @@ class ShowLanguagesCommand(InfoCommand):
     """Command to show supported languages."""
 
     def execute(self) -> int:
-        output_list("サポートされている言語:")
+        output_list("Supported languages:")
         for language in detector.get_supported_languages():
             info = detector.get_language_info(language)
             extensions = ", ".join(info["extensions"][:5])
             if len(info["extensions"]) > 5:
-                extensions += f", ... (他{len(info['extensions'])-5}個)"
-            output_list(f"  {language:<12} - 拡張子: {extensions}")
+                extensions += f", ... ({len(info['extensions'])-5} more)"
+            output_list(f"  {language:<12} - Extensions: {extensions}")
         return 0
 
 
@@ -109,12 +110,12 @@ class ShowExtensionsCommand(InfoCommand):
     """Command to show supported extensions."""
 
     def execute(self) -> int:
-        output_list("サポートされている拡張子:")
+        output_list("Supported file extensions:")
         supported_extensions = detector.get_supported_extensions()
         for i in range(0, len(supported_extensions), 8):
             line = "  " + "  ".join(
                 f"{ext:<6}" for ext in supported_extensions[i : i + 8]
             )
             output_list(line)
-        output_info(f"\n合計 {len(supported_extensions)} 個の拡張子をサポート")
+        output_info(f"\nTotal {len(supported_extensions)} extensions supported")
         return 0

tree_sitter_analyzer/cli_main.py

@@ -79,46 +79,50 @@ class CLICommandFactory:
 def create_argument_parser() -> argparse.ArgumentParser:
     """Create and configure the argument parser."""
     parser = argparse.ArgumentParser(
-        description="Tree-sitterを使用してコードを解析し、構造化された情報を抽出します。",
-        epilog="例: tree-sitter-analyzer example.java --table=full",
+        description="Analyze code using Tree-sitter and extract structured information.",
+        epilog="Example: tree-sitter-analyzer example.java --table=full",
     )
 
     # File path
-    parser.add_argument("file_path", nargs="?", help="解析対象のファイルのパス")
+    parser.add_argument("file_path", nargs="?", help="Path to the file to analyze")
 
     # Query options
     query_group = parser.add_mutually_exclusive_group(required=False)
     query_group.add_argument(
-        "--query-key", help="利用可能なクエリのキー (例: class, method)"
+        "--query-key", help="Available query key (e.g., class, method)"
     )
     query_group.add_argument(
-        "--query-string", help="実行するTree-sitterクエリを直接指定"
+        "--query-string", help="Directly specify Tree-sitter query to execute"
     )
 
     # Information options
     parser.add_argument(
-        "--list-queries", action="store_true", help="利用可能なクエリキーの一覧を表示"
+        "--list-queries",
+        action="store_true",
+        help="Display list of available query keys",
+    )
+    parser.add_argument(
+        "--describe-query", help="Display description of specified query key"
     )
-    parser.add_argument("--describe-query", help="指定されたクエリキーの説明を表示")
     parser.add_argument(
         "--show-supported-languages",
         action="store_true",
-        help="サポートされている言語一覧を表示",
+        help="Display list of supported languages",
     )
     parser.add_argument(
         "--show-supported-extensions",
         action="store_true",
-        help="サポートされている拡張子一覧を表示",
+        help="Display list of supported file extensions",
     )
     parser.add_argument(
         "--show-common-queries",
         action="store_true",
-        help="複数言語共通のクエリ一覧を表示",
+        help="Display list of common queries across multiple languages",
     )
     parser.add_argument(
         "--show-query-languages",
         action="store_true",
-        help="クエリサポートされている言語一覧を表示",
+        help="Display list of languages with query support",
     )
 
     # Output format options
@@ -126,52 +130,67 @@ def create_argument_parser() -> argparse.ArgumentParser:
         "--output-format",
         choices=["json", "text"],
         default="json",
-        help="出力形式を指定",
+        help="Specify output format",
     )
     parser.add_argument(
-        "--table", choices=["full", "compact", "csv"], help="テーブル形式での出力"
+        "--table", choices=["full", "compact", "csv"], help="Output in table format"
     )
     parser.add_argument(
         "--include-javadoc",
         action="store_true",
-        help="JavaDoc/ドキュメントコメントを出力に含める",
+        help="Include JavaDoc/documentation comments in output",
     )
 
     # Analysis options
-    parser.add_argument("--advanced", action="store_true", help="高度な解析機能を使用")
+    parser.add_argument(
+        "--advanced", action="store_true", help="Use advanced analysis features"
+    )
     parser.add_argument(
         "--summary",
         nargs="?",
         const="classes,methods",
-        help="指定された要素タイプの要約を表示",
+        help="Display summary of specified element types",
+    )
+    parser.add_argument(
+        "--structure",
+        action="store_true",
+        help="Output detailed structure information in JSON format",
     )
     parser.add_argument(
-        "--structure", action="store_true", help="詳細な構造情報をJSON形式で出力"
+        "--statistics", action="store_true", help="Display only statistical information"
     )
-    parser.add_argument("--statistics", action="store_true", help="統計情報のみを表示")
 
     # Language options
     parser.add_argument(
-        "--language", help="言語を明示的に指定（省略時は拡張子から自動判定）"
+        "--language",
+        help="Explicitly specify language (auto-detected from extension if omitted)",
     )
 
     # Logging options
     parser.add_argument(
-        "--quiet", action="store_true", help="INFOレベルのログを抑制（エラーのみ表示）"
+        "--quiet",
+        action="store_true",
+        help="Suppress INFO level logs (show errors only)",
     )
 
     # Partial reading options
     parser.add_argument(
         "--partial-read",
         action="store_true",
-        help="ファイルの部分読み込みモードを有効にする",
+        help="Enable partial file reading mode",
+    )
+    parser.add_argument(
+        "--start-line", type=int, help="Starting line number for reading (1-based)"
+    )
+    parser.add_argument(
+        "--end-line", type=int, help="Ending line number for reading (1-based)"
+    )
+    parser.add_argument(
+        "--start-column", type=int, help="Starting column number for reading (0-based)"
     )
-    parser.add_argument("--start-line", type=int, help="読み込み開始行番号（1ベース）")
-    parser.add_argument("--end-line", type=int, help="読み込み終了行番号（1ベース）")
     parser.add_argument(
-        "--start-column", type=int, help="読み込み開始列番号（0ベース）"
+        "--end-column", type=int, help="Ending column number for reading (0-based)"
     )
-    parser.add_argument("--end-column", type=int, help="読み込み終了列番号（0ベース）")
 
     return parser
 
@@ -205,20 +224,20 @@ def handle_special_commands(args: argparse.Namespace) -> int | None:
 
     # Query language commands
     if args.show_query_languages:
-        output_list(["クエリサポートされている言語:"])
+        output_list(["Languages with query support:"])
         for lang in query_loader.list_supported_languages():
             query_count = len(query_loader.list_queries_for_language(lang))
-            output_list([f"  {lang:<15} ({query_count} クエリ)"])
+            output_list([f"  {lang:<15} ({query_count} queries)"])
         return 0
 
     if args.show_common_queries:
         common_queries = query_loader.get_common_queries()
         if common_queries:
-            output_list("複数言語共通のクエリ:")
+            output_list("Common queries across multiple languages:")
             for query in common_queries:
                 output_list(f"  {query}")
         else:
-            output_info("共通クエリが見つかりませんでした。")
+            output_info("No common queries found.")
         return 0
 
     return None
@@ -262,7 +281,7 @@ def main() -> None:
         if not args.file_path:
             output_error("ERROR: File path not specified.")
         else:
-            output_error("ERROR: 実行可能なコマンドが指定されていません。")
+            output_error("ERROR: No executable command specified.")
         parser.print_help()
         sys.exit(1)
 

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
@@ -25,31 +25,31 @@ 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
@@ -58,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,
@@ -93,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] = {

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,