tree-sitter-analyzer 0.1.1__py3-none-any.whl → 0.1.3__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.0.1"
+__version__ = "0.1.3"
 __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/server.py

@@ -45,7 +45,6 @@ from ..utils import setup_logger
 from . import MCP_INFO
 from .resources import CodeFileResource, ProjectStatsResource
 from .tools.base_tool import MCPTool
-from .tools.get_positions_tool import GetPositionsTool
 from .tools.read_partial_tool import ReadPartialTool
 from .tools.table_format_tool import TableFormatTool
 from .tools.universal_analyze_tool import UniversalAnalyzeTool
@@ -73,7 +72,6 @@ class TreeSitterAnalyzerMCPServer:
         # Initialize MCP tools
         self.read_partial_tool: MCPTool = ReadPartialTool()
         self.universal_analyze_tool: MCPTool = UniversalAnalyzeTool()
-        self.get_positions_tool: MCPTool = GetPositionsTool()
         self.table_format_tool: MCPTool = TableFormatTool()
 
         # Initialize MCP resources
@@ -145,7 +143,6 @@ class TreeSitterAnalyzerMCPServer:
             # Add tools from tool classes - FIXED VERSION
             for tool_instance in [
                 self.read_partial_tool,
-                self.get_positions_tool,
                 self.table_format_tool,
                 self.universal_analyze_tool,
             ]:
@@ -181,14 +178,6 @@ class TreeSitterAnalyzerMCPServer:
                             text=json.dumps(result, indent=2, ensure_ascii=False),
                         )
                     ]
-                elif name == "get_code_positions":
-                    result = await self.get_positions_tool.execute(arguments)
-                    return [
-                        TextContent(
-                            type="text",
-                            text=json.dumps(result, indent=2, ensure_ascii=False),
-                        )
-                    ]
                 elif name == "format_table":
                     result = await self.table_format_tool.execute(arguments)
                     return [

tree_sitter_analyzer/mcp/tools/__init__.py

@@ -24,11 +24,6 @@ AVAILABLE_TOOLS: Dict[str, Dict[str, Any]] = {
     #     "module": "read_partial_tool",
     #     "class": "ReadPartialTool",
     # },
-    # "get_code_positions": {
-    #     "description": "Get position information for code elements",
-    #     "module": "get_positions_tool",
-    #     "class": "GetPositionsTool",
-    # },
 }
 
 __all__ = [

tree_sitter_analyzer/mcp/tools/analyze_scale_tool.py

@@ -235,7 +235,7 @@ class AnalyzeScaleTool:
         elif total_lines < 1500:
             guidance["size_category"] = "large"
             guidance["analysis_strategy"] = (
-                "This is a large file. Use targeted analysis with get_code_positions and read_code_partial."
+                "This is a large file. Use targeted analysis with read_code_partial."
             )
         else:
             guidance["size_category"] = "very_large"
@@ -245,7 +245,6 @@ class AnalyzeScaleTool:
 
         # Recommend tools based on file size and complexity
         if total_lines > 200:
-            guidance["recommended_tools"].append("get_code_positions")
             guidance["recommended_tools"].append("read_code_partial")
 
         if len(structural_overview["complexity_hotspots"]) > 0:

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}"
                 )