tree-sitter-analyzer 0.1.2__py3-none-any.whl → 0.2.0__py3-none-any.whl

tree_sitter_analyzer/__init__.py

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

tree_sitter_analyzer/cli/commands/advanced_command.py

@@ -37,7 +37,7 @@ class AdvancedCommand(BaseCommand):
             "node_count": analysis_result.node_count,
             "language": analysis_result.language,
         }
-        output_section("統計情報")
+        output_section("Statistics")
         if self.args.output_format == "json":
             output_json(stats)
         else:
@@ -46,7 +46,7 @@ class AdvancedCommand(BaseCommand):
 
     def _output_full_analysis(self, analysis_result: "AnalysisResult") -> None:
         """Output full analysis results."""
-        output_section("高度な解析結果")
+        output_section("Advanced Analysis Results")
         if self.args.output_format == "json":
             result_dict = {
                 "file_path": analysis_result.file_path,
@@ -72,17 +72,17 @@ class AdvancedCommand(BaseCommand):
 
     def _output_text_analysis(self, analysis_result: "AnalysisResult") -> None:
         """Output analysis in text format."""
-        output_data(f"ファイル: {analysis_result.file_path}")
-        output_data(f"パッケージ: (default)")
-        output_data(f"行数: {analysis_result.line_count}")
+        output_data(f"File: {analysis_result.file_path}")
+        output_data(f"Package: (default)")
+        output_data(f"Lines: {analysis_result.line_count}")
 
         element_counts = {}
         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
 
-        output_data(f"\nクラス数: {element_counts.get('Class', 0)}")
-        output_data(f"メソッド数: {element_counts.get('Function', 0)}")
-        output_data(f"フィールド数: {element_counts.get('Variable', 0)}")
-        output_data(f"インポート数: {element_counts.get('Import', 0)}")
-        output_data(f"アノテーション数: 0")
+        output_data(f"Classes: {element_counts.get('Class', 0)}")
+        output_data(f"Methods: {element_counts.get('Function', 0)}")
+        output_data(f"Fields: {element_counts.get('Variable', 0)}")
+        output_data(f"Imports: {element_counts.get('Import', 0)}")
+        output_data(f"Annotations: 0")

tree_sitter_analyzer/cli/commands/base_command.py

@@ -34,13 +34,13 @@ class BaseCommand(ABC):
     def validate_file(self) -> bool:
         """Validate input file exists and is accessible."""
         if not hasattr(self.args, "file_path") or not self.args.file_path:
-            output_error("ERROR: ファイルパスが指定されていません。")
+            output_error("ERROR: File path not specified.")
             return False
 
         import os
 
         if not os.path.exists(self.args.file_path):
-            output_error(f"ERROR: ファイルが見つかりません: {self.args.file_path}")
+            output_error(f"ERROR: File not found: {self.args.file_path}")
             return False
 
         return True
@@ -50,18 +50,18 @@ class BaseCommand(ABC):
         if hasattr(self.args, "language") and self.args.language:
             target_language = self.args.language.lower()
             if (not hasattr(self.args, "table") or not self.args.table) and (not hasattr(self.args, "quiet") or not self.args.quiet):
-                output_info(f"INFO: 言語が明示的に指定されました: {target_language}")
+                output_info(f"INFO: Language explicitly specified: {target_language}")
         else:
             target_language = detect_language_from_file(self.args.file_path)
             if target_language == "unknown":
                 output_error(
-                    f"ERROR: ファイル '{self.args.file_path}' の言語を判定できませんでした。"
+                    f"ERROR: Could not determine language for file '{self.args.file_path}'."
                 )
                 return None
             else:
                 if (not hasattr(self.args, "table") or not self.args.table) and (not hasattr(self.args, "quiet") or not self.args.quiet):
                     output_info(
-                        f"INFO: 拡張子から言語を自動判定しました: {target_language}"
+                        f"INFO: Language auto-detected from extension: {target_language}"
                     )
 
         # Language support validation
@@ -69,7 +69,7 @@ class BaseCommand(ABC):
             if target_language != "java":
                 if (not hasattr(self.args, "table") or not self.args.table) and (not hasattr(self.args, "quiet") or not self.args.quiet):
                     output_info(
-                        "INFO: Java解析エンジンで試行します。正しく動作しない可能性があります。"
+                        "INFO: Trying with Java analysis engine. May not work correctly."
                     )
                 target_language = "java"  # Fallback
 
@@ -89,10 +89,10 @@ class BaseCommand(ABC):
                         end_column=getattr(self.args, 'end_column', None)
                     )
                     if partial_content is None:
-                        output_error("ERROR: ファイルの部分読み込みに失敗しました")
+                        output_error("ERROR: Failed to read file partially")
                         return None
                 except Exception as e:
-                    output_error(f"ERROR: ファイルの部分読み込みに失敗しました: {e}")
+                    output_error(f"ERROR: Failed to read file partially: {e}")
                     return None
             
             request = AnalysisRequest(
@@ -109,13 +109,13 @@ class BaseCommand(ABC):
                     if analysis_result
                     else "Unknown error"
                 )
-                output_error(f"ERROR: 解析に失敗しました: {error_msg}")
+                output_error(f"ERROR: Analysis failed: {error_msg}")
                 return None
 
             return analysis_result
 
         except Exception as e:
-            output_error(f"ERROR: 解析でエラーが発生しました: {e}")
+            output_error(f"ERROR: An error occurred during analysis: {e}")
             return None
 
     def execute(self) -> int:
@@ -138,7 +138,7 @@ class BaseCommand(ABC):
         try:
             return asyncio.run(self.execute_async(language))
         except Exception as e:
-            output_error(f"ERROR: コマンド実行中にエラーが発生しました: {e}")
+            output_error(f"ERROR: An error occurred during command execution: {e}")
             return 1
 
     @abstractmethod

tree_sitter_analyzer/cli/commands/partial_read_command.py

@@ -28,14 +28,14 @@ class PartialReadCommand(BaseCommand):
         """Validate input file exists and is accessible."""
         if not hasattr(self.args, "file_path") or not self.args.file_path:
             from ...output_manager import output_error
-            output_error("ERROR: ファイルパスが指定されていません。")
+            output_error("ERROR: File path not specified.")
             return False
 
         import os
 
         if not os.path.exists(self.args.file_path):
             from ...output_manager import output_error
-            output_error(f"ERROR: ファイルが見つかりません: {self.args.file_path}")
+            output_error(f"ERROR: File not found: {self.args.file_path}")
             return False
 
         return True
@@ -54,17 +54,17 @@ class PartialReadCommand(BaseCommand):
         # Validate partial read arguments
         if not self.args.start_line:
             from ...output_manager import output_error
-            output_error("ERROR: --start-lineが必須です")
+            output_error("ERROR: --start-line is required")
             return 1
 
         if self.args.start_line < 1:
             from ...output_manager import output_error
-            output_error("ERROR: --start-lineは1以上である必要があります")
+            output_error("ERROR: --start-line must be 1 or greater")
             return 1
 
         if self.args.end_line and self.args.end_line < self.args.start_line:
             from ...output_manager import output_error
-            output_error("ERROR: --end-lineは--start-line以上である必要があります")
+            output_error("ERROR: --end-line must be greater than or equal to --start-line")
             return 1
 
         # Read partial content
@@ -79,7 +79,7 @@ class PartialReadCommand(BaseCommand):
 
             if partial_content is None:
                 from ...output_manager import output_error
-                output_error("ERROR: ファイルの部分読み込みに失敗しました")
+                output_error("ERROR: Failed to read file partially")
                 return 1
 
             # Output the result
@@ -88,7 +88,7 @@ class PartialReadCommand(BaseCommand):
 
         except Exception as e:
             from ...output_manager import output_error
-            output_error(f"ERROR: ファイルの部分読み込みに失敗しました: {e}")
+            output_error(f"ERROR: Failed to read file partially: {e}")
             return 1
 
     def _output_partial_content(self, content: str) -> None:
@@ -107,7 +107,7 @@ class PartialReadCommand(BaseCommand):
         }
 
         # Build range info for header
-        range_info = f"行 {self.args.start_line}"
+        range_info = f"Line {self.args.start_line}"
         if hasattr(self.args, 'end_line') and self.args.end_line:
             range_info += f"-{self.args.end_line}"
 
@@ -119,10 +119,10 @@ class PartialReadCommand(BaseCommand):
             output_json(result_data)
         else:
             # Human-readable format with header
-            output_section("部分読み込み結果")
-            output_data(f"ファイル: {self.args.file_path}")
-            output_data(f"範囲: {range_info}")
-            output_data(f"読み込み文字数: {len(content)}")
+            output_section("Partial Read Result")
+            output_data(f"File: {self.args.file_path}")
+            output_data(f"Range: {range_info}")
+            output_data(f"Characters read: {len(content)}")
             output_data("")  # Empty line for separation
             
             # Output the actual content

tree_sitter_analyzer/cli/commands/structure_command.py

@@ -27,7 +27,7 @@ class StructureCommand(BaseCommand):
 
     def _output_structure_analysis(self, analysis_result: "AnalysisResult") -> None:
         """Output structure analysis results with appropriate Japanese header."""
-        output_section("構造解析結果")
+        output_section("Structure Analysis Results")
         
         # Convert to legacy structure format expected by tests
         structure_dict = self._convert_to_legacy_format(analysis_result)
@@ -91,31 +91,31 @@ class StructureCommand(BaseCommand):
     
     def _output_text_format(self, structure_dict: dict) -> None:
         """Output structure analysis in human-readable text format."""
-        output_data(f"ファイル: {structure_dict['file_path']}")
-        output_data(f"言語: {structure_dict['language']}")
+        output_data(f"File: {structure_dict['file_path']}")
+        output_data(f"Language: {structure_dict['language']}")
         
         if structure_dict['package']:
-            output_data(f"パッケージ: {structure_dict['package']['name']}")
+            output_data(f"Package: {structure_dict['package']['name']}")
         
         stats = structure_dict['statistics']
-        output_data(f"統計:")
-        output_data(f"  クラス数: {stats['class_count']}")
-        output_data(f"  メソッド数: {stats['method_count']}")
-        output_data(f"  フィールド数: {stats['field_count']}")
-        output_data(f"  インポート数: {stats['import_count']}")
-        output_data(f"  総行数: {stats['total_lines']}")
+        output_data(f"Statistics:")
+        output_data(f"  Classes: {stats['class_count']}")
+        output_data(f"  Methods: {stats['method_count']}")
+        output_data(f"  Fields: {stats['field_count']}")
+        output_data(f"  Imports: {stats['import_count']}")
+        output_data(f"  Total lines: {stats['total_lines']}")
         
         if structure_dict['classes']:
-            output_data("クラス:")
+            output_data("Classes:")
             for cls in structure_dict['classes']:
                 output_data(f"  - {cls['name']}")
         
         if structure_dict['methods']:
-            output_data("メソッド:")
+            output_data("Methods:")
             for method in structure_dict['methods']:
                 output_data(f"  - {method['name']}")
         
         if structure_dict['fields']:
-            output_data("フィールド:")
+            output_data("Fields:")
             for field in structure_dict['fields']:
                 output_data(f"  - {field['name']}") 

tree_sitter_analyzer/cli/commands/summary_command.py

@@ -27,7 +27,7 @@ class SummaryCommand(BaseCommand):
 
     def _output_summary_analysis(self, analysis_result: "AnalysisResult") -> None:
         """Output summary analysis results."""
-        output_section("要約結果")
+        output_section("Summary Results")
         
         # Get summary types from args (default: classes,methods)
         summary_types = getattr(self.args, 'summary', 'classes,methods')
@@ -75,19 +75,19 @@ class SummaryCommand(BaseCommand):
             
     def _output_text_format(self, summary_data: dict, requested_types: list) -> None:
         """Output summary in human-readable text format."""
-        output_data(f"ファイル: {summary_data['file_path']}")
-        output_data(f"言語: {summary_data['language']}")
+        output_data(f"File: {summary_data['file_path']}")
+        output_data(f"Language: {summary_data['language']}")
         
         for element_type in requested_types:
             if element_type in summary_data['summary']:
                 elements = summary_data['summary'][element_type]
                 type_name_map = {
-                    'classes': 'クラス',
-                    'methods': 'メソッド', 
-                    'fields': 'フィールド',
-                    'imports': 'インポート'
+                    'classes': 'Classes',
+                    'methods': 'Methods',
+                    'fields': 'Fields',
+                    'imports': 'Imports'
                 }
                 type_name = type_name_map.get(element_type, element_type)
-                output_data(f"\n{type_name} ({len(elements)}個):")
+                output_data(f"\n{type_name} ({len(elements)} items):")
                 for element in elements:
                     output_data(f"  - {element['name']}") 

tree_sitter_analyzer/cli_main.py

@@ -183,23 +183,23 @@ def handle_special_commands(args: argparse.Namespace) -> Optional[int]:
     # Validate partial read options
     if hasattr(args, 'partial_read') and args.partial_read:
         if args.start_line is None:
-            output_error("ERROR: --start-lineが必須です")
+            output_error("ERROR: --start-line is required")
             return 1
         
         if args.start_line < 1:
-            output_error("ERROR: --start-lineは1以上である必要があります")
+            output_error("ERROR: --start-line must be 1 or greater")
             return 1
         
         if args.end_line and args.end_line < args.start_line:
-            output_error("ERROR: --end-lineは--start-line以上である必要があります")
+            output_error("ERROR: --end-line must be greater than or equal to --start-line")
             return 1
         
         if args.start_column is not None and args.start_column < 0:
-            output_error("ERROR: --start-columnは0以上である必要があります")
+            output_error("ERROR: --start-column must be 0 or greater")
             return 1
         
         if args.end_column is not None and args.end_column < 0:
-            output_error("ERROR: --end-columnは0以上である必要があります")
+            output_error("ERROR: --end-column must be 0 or greater")
             return 1
 
     # Query language commands
@@ -258,7 +258,7 @@ def main() -> None:
         sys.exit(exit_code)
     else:
         if not args.file_path:
-            output_error("ERROR: ファイルパスが指定されていません。")
+            output_error("ERROR: File path not specified.")
         else:
             output_error("ERROR: 実行可能なコマンドが指定されていません。")
         parser.print_help()

tree_sitter_analyzer/mcp/tools/read_partial_tool.py

@@ -158,16 +158,16 @@ class ReadPartialTool:
                 json_output = json.dumps(result_data, indent=2, ensure_ascii=False)
 
                 # Build range info for header
-                range_info = f"行 {start_line}"
+                range_info = f"Line {start_line}"
                 if end_line:
                     range_info += f"-{end_line}"
 
                 # Build CLI-compatible output with header and JSON (without log message)
                 cli_output = (
-                    f"--- 部分読み込み結果 ---\n"
-                    f"ファイル: {file_path}\n"
-                    f"範囲: {range_info}\n"
-                    f"読み込み文字数: {len(content)}\n"
+                    f"--- Partial Read Result ---\n"
+                    f"File: {file_path}\n"
+                    f"Range: {range_info}\n"
+                    f"Characters read: {len(content)}\n"
                     f"{json_output}"
                 )
 

tree_sitter_analyzer/mcp/tools/table_format_tool.py

@@ -39,7 +39,7 @@ class TableFormatTool:
 
     def get_tool_schema(self) -> Dict[str, Any]:
         """
-        Get the MCP tool schema for format_table.
+        Get the MCP tool schema for analyze_code_structure.
 
         Returns:
             Dictionary containing the tool schema
@@ -255,7 +255,7 @@ class TableFormatTool:
         }
 
     async def execute(self, args: Dict[str, Any]) -> Dict[str, Any]:
-        """Execute table formatting tool."""
+        """Execute code structure analysis tool."""
         try:
             # Validate arguments first
             if "file_path" not in args:
@@ -275,7 +275,7 @@ class TableFormatTool:
 
             # Use performance monitoring
             monitor = get_performance_monitor()
-            with monitor.measure_operation("table_format_analysis"):
+            with monitor.measure_operation("code_structure_analysis"):
                 # Analyze structure using the unified analysis engine
                 request = AnalysisRequest(
                     file_path=file_path,
@@ -328,12 +328,12 @@ class TableFormatTool:
                 }
 
         except Exception as e:
-            self.logger.error(f"Error in table format tool: {e}")
+            self.logger.error(f"Error in code structure analysis tool: {e}")
             raise
 
     def get_tool_definition(self) -> Any:
         """
-        Get the MCP tool definition for format_table.
+        Get the MCP tool definition for analyze_code_structure.
 
         Returns:
             Tool definition object compatible with MCP server
@@ -342,15 +342,15 @@ class TableFormatTool:
             from mcp.types import Tool
 
             return Tool(
-                name="format_table",
-                description="Format code analysis results as tables (equivalent to CLI --table=full option)",
+                name="analyze_code_structure",
+                description="Analyze code structure and generate detailed overview tables (classes, methods, fields) for large files",
                 inputSchema=self.get_tool_schema(),
             )
         except ImportError:
             # Fallback for when MCP is not available
             return {
-                "name": "format_table",
-                "description": "Format code analysis results as tables (equivalent to CLI --table=full option)",
+                "name": "analyze_code_structure",
+                "description": "Analyze code structure and generate detailed overview tables (classes, methods, fields) for large files",
                 "inputSchema": self.get_tool_schema(),
             }
 

tree_sitter_analyzer/table_formatter.py

@@ -15,7 +15,7 @@ from .models import AnalysisResult
 
 
 class TableFormatter:
-    """テーブル形式でのフォーマッター"""
+    """Table formatter for code analysis results"""
 
     def __init__(self, format_type: str = "full", language: str = "java", include_javadoc: bool = False):
         self.format_type = format_type
@@ -23,17 +23,17 @@ class TableFormatter:
         self.include_javadoc = include_javadoc
 
     def _get_platform_newline(self) -> str:
-        """プラットフォーム固有の改行コードを取得"""
+        """Get platform-specific newline character"""
         return os.linesep
 
     def _convert_to_platform_newlines(self, text: str) -> str:
-        """通常の\nをプラットフォーム固有の改行コードに変換"""
+        """Convert standard \\n to platform-specific newline characters"""
         if os.linesep != "\n":
             return text.replace("\n", os.linesep)
         return text
 
     def format_structure(self, structure_data: Dict[str, Any]) -> str:
-        """構造データをテーブル形式でフォーマット"""
+        """Format structure data as table"""
         if self.format_type == "full":
             result = self._format_full_table(structure_data)
         elif self.format_type == "compact":
@@ -43,18 +43,18 @@ class TableFormatter:
         else:
             raise ValueError(f"Unsupported format type: {self.format_type}")
 
-        # 最終的にプラットフォーム固有の改行コードに変換
-        # CSV形式の場合は改行変換をスキップ（改行制御は_format_csv内で完結）
+        # Finally convert to platform-specific newline characters
+        # Skip newline conversion for CSV format (newline control is handled within _format_csv)
         if self.format_type == "csv":
             return result
 
         return self._convert_to_platform_newlines(result)
 
     def _format_full_table(self, data: Dict[str, Any]) -> str:
-        """完全版テーブル形式"""
+        """Full table format"""
         lines = []
 
-        # ヘッダー - 複数クラスがある場合はファイル名を使用
+        # Header - use filename when multiple classes exist
         classes = data.get("classes", [])
         if classes is None:
             classes = []
@@ -201,10 +201,10 @@ class TableFormatter:
         return "\n".join(lines)
 
     def _format_compact_table(self, data: Dict[str, Any]) -> str:
-        """コンパクト版テーブル形式"""
+        """Compact table format"""
         lines = []
 
-        # ヘッダー
+        # Header
         package_name = (data.get("package") or {}).get("name", "unknown")
         classes = data.get("classes", [])
         if classes is None:
@@ -255,11 +255,11 @@ class TableFormatter:
         return "\n".join(lines)
 
     def _format_csv(self, data: Dict[str, Any]) -> str:
-        """CSV形式"""
+        """CSV format"""
         output = io.StringIO()
-        writer = csv.writer(output, lineterminator="\n")  # 改行文字を明示的に指定
+        writer = csv.writer(output, lineterminator="\n")  # Explicitly specify newline character
 
-        # ヘッダー
+        # Header
         writer.writerow(
             ["Type", "Name", "Signature", "Visibility", "Lines", "Complexity", "Doc"]
         )
@@ -296,9 +296,9 @@ class TableFormatter:
                 ]
             )
 
-        # CSV出力の改行を完全に制御
+        # Completely control CSV output newlines
         csv_content = output.getvalue()
-        # 全ての改行パターンを統一し、末尾の改行を除去
+        # Unify all newline patterns and remove trailing newlines
         csv_content = csv_content.replace("\r\n", "\n").replace("\r", "\n")
         csv_content = csv_content.rstrip("\n")
         output.close()
@@ -411,38 +411,38 @@ class TableFormatter:
         if not javadoc:
             return "-"
 
-        # コメント記号を除去
+        # Remove comment symbols
         clean_doc = (
             javadoc.replace("/**", "").replace("*/", "").replace("*", "").strip()
         )
 
-        # 最初の行を取得（通常の\nのみを使用）
+        # Get first line (use standard \\n only)
         lines = clean_doc.split("\n")
         first_line = lines[0].strip()
 
-        # 長すぎる場合は切り詰め
+        # Truncate if too long
         if len(first_line) > 50:
             first_line = first_line[:47] + "..."
 
-        # Markdownテーブルで問題となる文字をエスケープ（通常の\nのみを使用）
+        # Escape characters that cause problems in Markdown tables (use standard \\n only)
         return first_line.replace("|", "\\|").replace("\n", " ")
 
     def _clean_csv_text(self, text: str) -> str:
-        """CSV形式用のテキストクリーニング"""
+        """Text cleaning for CSV format"""
         if not text:
             return ""
 
-        # 改行文字を全て空白に置換
+        # Replace all newline characters with spaces
         cleaned = text.replace("\r\n", " ").replace("\r", " ").replace("\n", " ")
-        # 連続する空白を単一の空白に変換
+        # Convert consecutive spaces to single space
         cleaned = " ".join(cleaned.split())
-        # CSVで問題となる文字をエスケープ
-        cleaned = cleaned.replace('"', '""')  # ダブルクォートをエスケープ
+        # Escape characters that cause problems in CSV
+        cleaned = cleaned.replace('"', '""')  # Escape double quotes
 
         return cleaned
 
 
 def create_table_formatter(format_type: str, language: str = "java", include_javadoc: bool = False):
-    """テーブルフォーマッターを作成（新しいファクトリーを使用）"""
-    # 直接TableFormatterを作成（JavaDoc対応のため）
+    """Create table formatter (using new factory)"""
+    # Create TableFormatter directly (for JavaDoc support)
     return TableFormatter(format_type, language, include_javadoc)