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

tree_sitter_analyzer/__init__.py

@@ -11,13 +11,13 @@ 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"
 
 # 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
 
@@ -61,7 +60,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 +93,7 @@ __all__ = [
     # Plugin system
     "ElementExtractor",
     "LanguagePlugin",
-    "plugin_registry",
+    "PluginManager",
     "QueryLoader",
     # Language detection
     "LanguageDetector",
@@ -118,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/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/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/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/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/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
@@ -41,10 +42,12 @@ 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(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):
@@ -225,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

@@ -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)
@@ -78,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
@@ -125,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
 
@@ -204,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
@@ -261,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)