tree-sitter-analyzer 0.1.0__py3-none-any.whl

tree_sitter_analyzer/cli/__main__.py

@@ -0,0 +1,13 @@
+#!/usr/bin/env python3
+# -*- coding: utf-8 -*-
+"""
+CLI Module Entry Point
+
+This module allows the CLI to be executed as a module with:
+python -m tree_sitter_analyzer.cli
+"""
+
+from ..cli_main import main
+
+if __name__ == "__main__":
+    main() 

tree_sitter_analyzer/cli/commands/__init__.py

@@ -0,0 +1,27 @@
+#!/usr/bin/env python3
+# -*- coding: utf-8 -*-
+"""
+CLI Commands Package
+
+This package contains all command implementations for the CLI interface.
+"""
+
+from .advanced_command import AdvancedCommand
+from .base_command import BaseCommand
+from .default_command import DefaultCommand
+from .partial_read_command import PartialReadCommand
+from .query_command import QueryCommand
+from .structure_command import StructureCommand
+from .summary_command import SummaryCommand
+from .table_command import TableCommand
+
+__all__ = [
+    "BaseCommand",
+    "AdvancedCommand",
+    "DefaultCommand",
+    "PartialReadCommand",
+    "QueryCommand",
+    "StructureCommand",
+    "SummaryCommand",
+    "TableCommand",
+]

tree_sitter_analyzer/cli/commands/advanced_command.py

@@ -0,0 +1,88 @@
+#!/usr/bin/env python3
+# -*- coding: utf-8 -*-
+"""
+Advanced Command
+
+Handles advanced analysis functionality.
+"""
+from typing import TYPE_CHECKING
+
+from ...output_manager import output_data, output_json, output_section
+from .base_command import BaseCommand
+
+if TYPE_CHECKING:
+    from ...models import AnalysisResult
+
+
+class AdvancedCommand(BaseCommand):
+    """Command for advanced analysis."""
+
+    async def execute_async(self, language: str) -> int:
+        analysis_result = await self.analyze_file(language)
+        if not analysis_result:
+            return 1
+
+        if hasattr(self.args, "statistics") and self.args.statistics:
+            self._output_statistics(analysis_result)
+        else:
+            self._output_full_analysis(analysis_result)
+
+        return 0
+
+    def _output_statistics(self, analysis_result: "AnalysisResult") -> None:
+        """Output statistics only."""
+        stats = {
+            "line_count": analysis_result.line_count,
+            "element_count": len(analysis_result.elements),
+            "node_count": analysis_result.node_count,
+            "language": analysis_result.language,
+        }
+        output_section("統計情報")
+        if self.args.output_format == "json":
+            output_json(stats)
+        else:
+            for key, value in stats.items():
+                output_data(f"{key}: {value}")
+
+    def _output_full_analysis(self, analysis_result: "AnalysisResult") -> None:
+        """Output full analysis results."""
+        output_section("高度な解析結果")
+        if self.args.output_format == "json":
+            result_dict = {
+                "file_path": analysis_result.file_path,
+                "language": analysis_result.language,
+                "line_count": analysis_result.line_count,
+                "element_count": len(analysis_result.elements),
+                "node_count": analysis_result.node_count,
+                "elements": [
+                    {
+                        "name": getattr(element, "name", str(element)),
+                        "type": getattr(element, "__class__", type(element)).__name__,
+                        "start_line": getattr(element, "start_line", 0),
+                        "end_line": getattr(element, "end_line", 0),
+                    }
+                    for element in analysis_result.elements
+                ],
+                "success": analysis_result.success,
+                "analysis_time": analysis_result.analysis_time,
+            }
+            output_json(result_dict)
+        else:
+            self._output_text_analysis(analysis_result)
+
+    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}")
+
+        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")

tree_sitter_analyzer/cli/commands/base_command.py

@@ -0,0 +1,155 @@
+#!/usr/bin/env python3
+# -*- coding: utf-8 -*-
+"""
+Base Command Class
+
+Abstract base class for all CLI commands implementing the Command Pattern.
+"""
+
+import asyncio
+from abc import ABC, abstractmethod
+from argparse import Namespace
+from typing import Any, Optional
+
+from ...core.analysis_engine import AnalysisRequest, get_analysis_engine
+from ...file_handler import read_file_partial
+from ...language_detector import detect_language_from_file, is_language_supported
+from ...models import AnalysisResult
+from ...output_manager import output_error, output_info
+
+
+class BaseCommand(ABC):
+    """
+    Base class for all CLI commands.
+
+    Implements common functionality like file validation, language detection,
+    and analysis engine interaction.
+    """
+
+    def __init__(self, args: Namespace):
+        """Initialize command with parsed arguments."""
+        self.args = args
+        self.analysis_engine = get_analysis_engine()
+
+    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: ファイルパスが指定されていません。")
+            return False
+
+        import os
+
+        if not os.path.exists(self.args.file_path):
+            output_error(f"ERROR: ファイルが見つかりません: {self.args.file_path}")
+            return False
+
+        return True
+
+    def detect_language(self) -> Optional[str]:
+        """Detect or validate the target language."""
+        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}")
+        else:
+            target_language = detect_language_from_file(self.args.file_path)
+            if target_language == "unknown":
+                output_error(
+                    f"ERROR: ファイル '{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}"
+                    )
+
+        # Language support validation
+        if not is_language_supported(target_language):
+            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解析エンジンで試行します。正しく動作しない可能性があります。"
+                    )
+                target_language = "java"  # Fallback
+
+        return target_language
+
+    async def analyze_file(self, language: str) -> Optional["AnalysisResult"]:
+        """Perform file analysis using the unified analysis engine."""
+        try:
+            # Handle partial read if enabled
+            if hasattr(self.args, 'partial_read') and self.args.partial_read:
+                try:
+                    partial_content = read_file_partial(
+                        self.args.file_path,
+                        start_line=self.args.start_line,
+                        end_line=getattr(self.args, 'end_line', None),
+                        start_column=getattr(self.args, 'start_column', None),
+                        end_column=getattr(self.args, 'end_column', None)
+                    )
+                    if partial_content is None:
+                        output_error("ERROR: ファイルの部分読み込みに失敗しました")
+                        return None
+                except Exception as e:
+                    output_error(f"ERROR: ファイルの部分読み込みに失敗しました: {e}")
+                    return None
+            
+            request = AnalysisRequest(
+                file_path=self.args.file_path,
+                language=language,
+                include_complexity=True,
+                include_details=True,
+            )
+            analysis_result = await self.analysis_engine.analyze(request)
+
+            if not analysis_result or not analysis_result.success:
+                error_msg = (
+                    analysis_result.error_message
+                    if analysis_result
+                    else "Unknown error"
+                )
+                output_error(f"ERROR: 解析に失敗しました: {error_msg}")
+                return None
+
+            return analysis_result
+
+        except Exception as e:
+            output_error(f"ERROR: 解析でエラーが発生しました: {e}")
+            return None
+
+    def execute(self) -> int:
+        """
+        Execute the command.
+
+        Returns:
+            int: Exit code (0 for success, 1 for failure)
+        """
+        # Validate inputs
+        if not self.validate_file():
+            return 1
+
+        # Detect language
+        language = self.detect_language()
+        if not language:
+            return 1
+
+        # Execute the specific command
+        try:
+            return asyncio.run(self.execute_async(language))
+        except Exception as e:
+            output_error(f"ERROR: コマンド実行中にエラーが発生しました: {e}")
+            return 1
+
+    @abstractmethod
+    async def execute_async(self, language: str) -> int:
+        """
+        Execute the command asynchronously.
+
+        Args:
+            language: Detected/specified target language
+
+        Returns:
+            int: Exit code (0 for success, 1 for failure)
+        """
+        pass

tree_sitter_analyzer/cli/commands/default_command.py

@@ -0,0 +1,19 @@
+#!/usr/bin/env python3
+# -*- coding: utf-8 -*-
+"""
+Default Command
+
+Handles default analysis when no specific command is specified.
+"""
+
+from ...output_manager import output_error
+from .base_command import BaseCommand
+
+
+class DefaultCommand(BaseCommand):
+    """Default command that shows error when no specific command is given."""
+
+    async def execute_async(self, language: str) -> int:
+        """Execute default command - show error for missing options."""
+        output_error("ERROR: クエリまたは--advancedオプションを指定してください")
+        return 1

tree_sitter_analyzer/cli/commands/partial_read_command.py

@@ -0,0 +1,133 @@
+#!/usr/bin/env python3
+# -*- coding: utf-8 -*-
+"""
+Partial Read Command
+
+Handles partial file reading functionality, extracting specified line ranges.
+"""
+import json
+from typing import TYPE_CHECKING
+
+from ...file_handler import read_file_partial
+from ...output_manager import output_data, output_json, output_section
+from .base_command import BaseCommand
+
+if TYPE_CHECKING:
+    pass
+
+
+class PartialReadCommand(BaseCommand):
+    """Command for reading partial file content by line range."""
+
+    def __init__(self, args):
+        """Initialize with arguments but skip base class analysis engine setup."""
+        self.args = args
+        # Don't call super().__init__() to avoid unnecessary analysis engine setup
+
+    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:
+            from ...output_manager import output_error
+            output_error("ERROR: ファイルパスが指定されていません。")
+            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}")
+            return False
+
+        return True
+
+    def execute(self) -> int:
+        """
+        Execute partial read command.
+
+        Returns:
+            int: Exit code (0 for success, 1 for failure)
+        """
+        # Validate inputs
+        if not self.validate_file():
+            return 1
+
+        # Validate partial read arguments
+        if not self.args.start_line:
+            from ...output_manager import output_error
+            output_error("ERROR: --start-lineが必須です")
+            return 1
+
+        if self.args.start_line < 1:
+            from ...output_manager import output_error
+            output_error("ERROR: --start-lineは1以上である必要があります")
+            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以上である必要があります")
+            return 1
+
+        # Read partial content
+        try:
+            partial_content = read_file_partial(
+                self.args.file_path,
+                start_line=self.args.start_line,
+                end_line=getattr(self.args, 'end_line', None),
+                start_column=getattr(self.args, 'start_column', None),
+                end_column=getattr(self.args, 'end_column', None)
+            )
+
+            if partial_content is None:
+                from ...output_manager import output_error
+                output_error("ERROR: ファイルの部分読み込みに失敗しました")
+                return 1
+
+            # Output the result
+            self._output_partial_content(partial_content)
+            return 0
+
+        except Exception as e:
+            from ...output_manager import output_error
+            output_error(f"ERROR: ファイルの部分読み込みに失敗しました: {e}")
+            return 1
+
+    def _output_partial_content(self, content: str) -> None:
+        """Output the partial content in the specified format."""
+        # Build result data
+        result_data = {
+            "file_path": self.args.file_path,
+            "range": {
+                "start_line": self.args.start_line,
+                "end_line": getattr(self.args, 'end_line', None),
+                "start_column": getattr(self.args, 'start_column', None),
+                "end_column": getattr(self.args, 'end_column', None),
+            },
+            "content": content,
+            "content_length": len(content),
+        }
+
+        # Build range info for header
+        range_info = f"行 {self.args.start_line}"
+        if hasattr(self.args, 'end_line') and self.args.end_line:
+            range_info += f"-{self.args.end_line}"
+
+        # Output format selection
+        output_format = getattr(self.args, 'output_format', 'text')
+
+        if output_format == 'json':
+            # Pure JSON output
+            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_data("")  # Empty line for separation
+            
+            # Output the actual content
+            print(content, end='')  # Use print to avoid extra formatting
+
+    async def execute_async(self, language: str) -> int:
+        """Not used for partial read command."""
+        return self.execute() 

tree_sitter_analyzer/cli/commands/query_command.py

@@ -0,0 +1,82 @@
+#!/usr/bin/env python3
+# -*- coding: utf-8 -*-
+"""
+Query Command
+
+Handles query execution functionality.
+"""
+
+from ...output_manager import output_data, output_error, output_info, output_json
+from ...query_loader import query_loader
+from .base_command import BaseCommand
+
+
+class QueryCommand(BaseCommand):
+    """Command for executing queries."""
+
+    async def execute_async(self, language: str) -> int:
+        # Get the query to execute
+        query_to_execute = None
+
+        if hasattr(self.args, "query_key") and self.args.query_key:
+            try:
+                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}' で見つかりません"
+                    )
+                    return 1
+            except ValueError as e:
+                output_error(f"ERROR: {e}")
+                return 1
+        elif hasattr(self.args, "query_string") and self.args.query_string:
+            query_to_execute = self.args.query_string
+
+        if not query_to_execute:
+            output_error("ERROR: クエリが指定されていません。")
+            return 1
+
+        # Perform analysis
+        analysis_result = await self.analyze_file(language)
+        if not analysis_result:
+            return 1
+
+        # Process query results
+        results = []
+        if hasattr(analysis_result, "query_results") and analysis_result.query_results:
+            results = analysis_result.query_results.get("captures", [])
+        else:
+            # Create basic results from elements
+            if hasattr(analysis_result, "elements") and analysis_result.elements:
+                for element in analysis_result.elements:
+                    results.append(
+                        {
+                            "capture_name": getattr(
+                                element, "__class__", type(element)
+                            ).__name__.lower(),
+                            "node_type": getattr(
+                                element, "__class__", type(element)
+                            ).__name__,
+                            "start_line": getattr(element, "start_line", 0),
+                            "end_line": getattr(element, "end_line", 0),
+                            "content": getattr(element, "name", str(element)),
+                        }
+                    )
+
+        # Output results
+        if results:
+            if self.args.output_format == "json":
+                output_json(results)
+            else:
+                for i, query_result in enumerate(results, 1):
+                    output_data(
+                        f"\n{i}. {query_result['capture_name']} ({query_result['node_type']})"
+                    )
+                    output_data(
+                        f"   位置: 行 {query_result['start_line']}-{query_result['end_line']}"
+                    )
+                    output_data(f"   内容:\n{query_result['content']}")
+        else:
+            output_info(f"\nINFO: クエリにマッチする結果は見つかりませんでした。")
+
+        return 0

tree_sitter_analyzer/cli/commands/structure_command.py

@@ -0,0 +1,121 @@
+#!/usr/bin/env python3
+# -*- coding: utf-8 -*-
+"""
+Structure Command
+
+Handles structure analysis functionality with appropriate Japanese output.
+"""
+from typing import TYPE_CHECKING
+
+from ...output_manager import output_data, output_json, output_section
+from .base_command import BaseCommand
+
+if TYPE_CHECKING:
+    from ...models import AnalysisResult
+
+
+class StructureCommand(BaseCommand):
+    """Command for structure analysis with Japanese output."""
+
+    async def execute_async(self, language: str) -> int:
+        analysis_result = await self.analyze_file(language)
+        if not analysis_result:
+            return 1
+
+        self._output_structure_analysis(analysis_result)
+        return 0
+
+    def _output_structure_analysis(self, analysis_result: "AnalysisResult") -> None:
+        """Output structure analysis results with appropriate Japanese header."""
+        output_section("構造解析結果")
+        
+        # Convert to legacy structure format expected by tests
+        structure_dict = self._convert_to_legacy_format(analysis_result)
+        
+        if self.args.output_format == "json":
+            output_json(structure_dict)
+        else:
+            self._output_text_format(structure_dict)
+    
+    def _convert_to_legacy_format(self, analysis_result: "AnalysisResult") -> dict:
+        """Convert AnalysisResult to legacy structure format expected by tests."""
+        import time
+        
+        # Extract elements by type
+        classes = [e for e in analysis_result.elements if e.__class__.__name__ == 'Class']
+        methods = [e for e in analysis_result.elements if e.__class__.__name__ == 'Function']
+        fields = [e for e in analysis_result.elements if e.__class__.__name__ == 'Variable']
+        imports = [e for e in analysis_result.elements if e.__class__.__name__ == 'Import']
+        packages = [e for e in analysis_result.elements if e.__class__.__name__ == 'Package']
+        
+        return {
+            'file_path': analysis_result.file_path,
+            'language': analysis_result.language,
+            'package': {
+                'name': packages[0].name,
+                'line_range': {
+                    'start': packages[0].start_line,
+                    'end': packages[0].end_line
+                }
+            } if packages else None,
+            'classes': [{'name': getattr(c, 'name', 'unknown')} for c in classes],
+            'methods': [{'name': getattr(m, 'name', 'unknown')} for m in methods],
+            'fields': [{'name': getattr(f, 'name', 'unknown')} for f in fields],
+            'imports': [{
+                'name': getattr(i, 'name', 'unknown'),
+                'is_static': getattr(i, 'is_static', False),
+                'is_wildcard': getattr(i, 'is_wildcard', False),
+                'statement': getattr(i, 'import_statement', ''),
+                'line_range': {
+                    'start': getattr(i, 'start_line', 0),
+                    'end': getattr(i, 'end_line', 0)
+                }
+            } for i in imports],
+            'annotations': [],
+            'statistics': {
+                'class_count': len(classes),
+                'method_count': len(methods),
+                'field_count': len(fields),
+                'import_count': len(imports),
+                'total_lines': analysis_result.line_count,
+                'annotation_count': 0
+            },
+            'analysis_metadata': {
+                'analysis_time': getattr(analysis_result, 'analysis_time', 0.0),
+                'language': analysis_result.language,
+                'file_path': analysis_result.file_path,
+                'analyzer_version': '2.0.0',
+                'timestamp': time.time()
+                         }
+         }
+    
+    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']}")
+        
+        if structure_dict['package']:
+            output_data(f"パッケージ: {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']}")
+        
+        if structure_dict['classes']:
+            output_data("クラス:")
+            for cls in structure_dict['classes']:
+                output_data(f"  - {cls['name']}")
+        
+        if structure_dict['methods']:
+            output_data("メソッド:")
+            for method in structure_dict['methods']:
+                output_data(f"  - {method['name']}")
+        
+        if structure_dict['fields']:
+            output_data("フィールド:")
+            for field in structure_dict['fields']:
+                output_data(f"  - {field['name']}")