tree-sitter-analyzer 1.7.2__py3-none-any.whl → 1.7.4__py3-none-any.whl

tree_sitter_analyzer/__init__.py

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

tree_sitter_analyzer/cli/commands/advanced_command.py

@@ -15,6 +15,7 @@ from ...constants import (
     get_element_type,
 )
 from ...output_manager import output_data, output_json, output_section
+from ...formatters.language_formatter_factory import create_language_formatter
 from .base_command import BaseCommand
 
 if TYPE_CHECKING:
@@ -158,6 +159,16 @@ class AdvancedCommand(BaseCommand):
 
     def _output_full_analysis(self, analysis_result: "AnalysisResult") -> None:
         """Output full analysis results."""
+        # Check if we have a language-specific formatter
+        formatter = create_language_formatter(analysis_result.language)
+        if formatter:
+            # Use language-specific formatter
+            output_format = getattr(self.args, 'output_format', 'json')
+            formatted_output = formatter.format_advanced(self._convert_to_formatter_format(analysis_result), output_format)
+            print(formatted_output)
+            return
+
+        # Fallback to original implementation for unsupported languages
         output_section("Advanced Analysis Results")
         if self.args.output_format == "json":
             result_dict = {
@@ -182,6 +193,47 @@ class AdvancedCommand(BaseCommand):
         else:
             self._output_text_analysis(analysis_result)
 
+    def _convert_to_formatter_format(self, analysis_result: "AnalysisResult") -> dict:
+        """Convert AnalysisResult to format expected by formatters."""
+        return {
+            "file_path": analysis_result.file_path,
+            "language": analysis_result.language,
+            "line_count": analysis_result.line_count,
+            "element_count": len(analysis_result.elements),
+            "node_count": getattr(analysis_result, "node_count", 0),
+            "elements": [
+                {
+                    "name": getattr(element, "name", str(element)),
+                    "type": get_element_type(element),
+                    "start_line": getattr(element, "start_line", 0),
+                    "end_line": getattr(element, "end_line", 0),
+                    "text": getattr(element, "text", ""),
+                    "level": getattr(element, "level", 1),
+                    "url": getattr(element, "url", ""),
+                    "alt": getattr(element, "alt", ""),
+                    "language": getattr(element, "language", ""),
+                    "line_count": getattr(element, "line_count", 0),
+                    "list_type": getattr(element, "list_type", ""),
+                    "item_count": getattr(element, "item_count", 0),
+                    "column_count": getattr(element, "column_count", 0),
+                    "row_count": getattr(element, "row_count", 0),
+                    "line_range": {
+                        "start": getattr(element, "start_line", 0),
+                        "end": getattr(element, "end_line", 0),
+                    }
+                }
+                for element in analysis_result.elements
+            ],
+            "success": getattr(analysis_result, "success", True),
+            "analysis_time": getattr(analysis_result, "analysis_time", 0.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",
+            }
+        }
+
     def _output_text_analysis(self, analysis_result: "AnalysisResult") -> None:
         """Output analysis in text format."""
         output_data(f"File: {analysis_result.file_path}")

tree_sitter_analyzer/cli/commands/structure_command.py

@@ -16,6 +16,7 @@ from ...constants import (
     is_element_of_type,
 )
 from ...output_manager import output_data, output_json, output_section
+from ...formatters.language_formatter_factory import create_language_formatter
 from .base_command import BaseCommand
 
 if TYPE_CHECKING:
@@ -34,7 +35,16 @@ class StructureCommand(BaseCommand):
         return 0
 
     def _output_structure_analysis(self, analysis_result: "AnalysisResult") -> None:
-        """Output structure analysis results with appropriate Japanese header."""
+        """Output structure analysis results with appropriate header."""
+        # Check if we have a language-specific formatter
+        formatter = create_language_formatter(analysis_result.language)
+        if formatter:
+            # Use language-specific formatter
+            formatted_output = formatter.format_structure(self._convert_to_formatter_format(analysis_result))
+            print(formatted_output)
+            return
+
+        # Fallback to original implementation for unsupported languages
         output_section("Structure Analysis Results")
 
         # Convert to legacy structure format expected by tests
@@ -45,6 +55,45 @@ class StructureCommand(BaseCommand):
         else:
             self._output_text_format(structure_dict)
 
+    def _convert_to_formatter_format(self, analysis_result: "AnalysisResult") -> dict:
+        """Convert AnalysisResult to format expected by formatters."""
+        from ...constants import get_element_type
+        
+        return {
+            "file_path": analysis_result.file_path,
+            "language": analysis_result.language,
+            "line_count": analysis_result.line_count,
+            "elements": [
+                {
+                    "name": getattr(element, "name", str(element)),
+                    "type": get_element_type(element),
+                    "start_line": getattr(element, "start_line", 0),
+                    "end_line": getattr(element, "end_line", 0),
+                    "text": getattr(element, "text", ""),
+                    "level": getattr(element, "level", 1),
+                    "url": getattr(element, "url", ""),
+                    "alt": getattr(element, "alt", ""),
+                    "language": getattr(element, "language", ""),
+                    "line_count": getattr(element, "line_count", 0),
+                    "list_type": getattr(element, "list_type", ""),
+                    "item_count": getattr(element, "item_count", 0),
+                    "column_count": getattr(element, "column_count", 0),
+                    "row_count": getattr(element, "row_count", 0),
+                    "line_range": {
+                        "start": getattr(element, "start_line", 0),
+                        "end": getattr(element, "end_line", 0),
+                    }
+                }
+                for element in analysis_result.elements
+            ],
+            "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",
+            }
+        }
+
     def _convert_to_legacy_format(self, analysis_result: "AnalysisResult") -> dict:
         """Convert AnalysisResult to legacy structure format expected by tests."""
         import time

tree_sitter_analyzer/cli/commands/summary_command.py

@@ -15,6 +15,7 @@ from ...constants import (
     is_element_of_type,
 )
 from ...output_manager import output_data, output_json, output_section
+from ...formatters.language_formatter_factory import create_language_formatter
 from .base_command import BaseCommand
 
 if TYPE_CHECKING:
@@ -34,6 +35,15 @@ class SummaryCommand(BaseCommand):
 
     def _output_summary_analysis(self, analysis_result: "AnalysisResult") -> None:
         """Output summary analysis results."""
+        # Check if we have a language-specific formatter
+        formatter = create_language_formatter(analysis_result.language)
+        if formatter:
+            # Use language-specific formatter
+            formatted_output = formatter.format_summary(self._convert_to_formatter_format(analysis_result))
+            print(formatted_output)
+            return
+
+        # Fallback to original implementation for unsupported languages
         output_section("Summary Results")
 
         # Get summary types from args (default: classes,methods)
@@ -96,6 +106,45 @@ class SummaryCommand(BaseCommand):
         else:
             self._output_text_format(summary_data, requested_types)
 
+    def _convert_to_formatter_format(self, analysis_result: "AnalysisResult") -> dict[str, Any]:
+        """Convert AnalysisResult to format expected by formatters."""
+        from ...constants import get_element_type
+        
+        return {
+            "file_path": analysis_result.file_path,
+            "language": analysis_result.language,
+            "line_count": analysis_result.line_count,
+            "elements": [
+                {
+                    "name": getattr(element, "name", str(element)),
+                    "type": get_element_type(element),
+                    "start_line": getattr(element, "start_line", 0),
+                    "end_line": getattr(element, "end_line", 0),
+                    "text": getattr(element, "text", ""),
+                    "level": getattr(element, "level", 1),
+                    "url": getattr(element, "url", ""),
+                    "alt": getattr(element, "alt", ""),
+                    "language": getattr(element, "language", ""),
+                    "line_count": getattr(element, "line_count", 0),
+                    "list_type": getattr(element, "list_type", ""),
+                    "item_count": getattr(element, "item_count", 0),
+                    "column_count": getattr(element, "column_count", 0),
+                    "row_count": getattr(element, "row_count", 0),
+                    "line_range": {
+                        "start": getattr(element, "start_line", 0),
+                        "end": getattr(element, "end_line", 0),
+                    }
+                }
+                for element in analysis_result.elements
+            ],
+            "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",
+            }
+        }
+
     def _output_text_format(self, summary_data: dict, requested_types: list) -> None:
         """Output summary in human-readable text format."""
         output_data(f"File: {summary_data['file_path']}")

tree_sitter_analyzer/cli/commands/table_command.py

@@ -18,6 +18,7 @@ from ...constants import (
 )
 from ...output_manager import output_error
 from ...table_formatter import create_table_formatter
+from ...formatters.language_formatter_factory import create_language_formatter
 from .base_command import BaseCommand
 
 
@@ -32,6 +33,16 @@ class TableCommand(BaseCommand):
             if not analysis_result:
                 return 1
 
+            # Check if we have a language-specific formatter
+            formatter = create_language_formatter(analysis_result.language)
+            if formatter:
+                # Use language-specific formatter
+                table_type = getattr(self.args, 'table', 'full')
+                formatted_output = formatter.format_table(self._convert_to_formatter_format(analysis_result), table_type)
+                self._output_table(formatted_output)
+                return 0
+
+            # Fallback to original implementation for unsupported languages
             # Convert analysis result to structure format
             structure_result = self._convert_to_structure_format(
                 analysis_result, language
@@ -53,6 +64,43 @@ class TableCommand(BaseCommand):
             output_error(f"An error occurred during table format analysis: {e}")
             return 1
 
+    def _convert_to_formatter_format(self, analysis_result: Any) -> dict[str, Any]:
+        """Convert AnalysisResult to format expected by formatters."""
+        return {
+            "file_path": analysis_result.file_path,
+            "language": analysis_result.language,
+            "line_count": analysis_result.line_count,
+            "elements": [
+                {
+                    "name": getattr(element, "name", str(element)),
+                    "type": get_element_type(element),
+                    "start_line": getattr(element, "start_line", 0),
+                    "end_line": getattr(element, "end_line", 0),
+                    "text": getattr(element, "text", ""),
+                    "level": getattr(element, "level", 1),
+                    "url": getattr(element, "url", ""),
+                    "alt": getattr(element, "alt", ""),
+                    "language": getattr(element, "language", ""),
+                    "line_count": getattr(element, "line_count", 0),
+                    "list_type": getattr(element, "list_type", ""),
+                    "item_count": getattr(element, "item_count", 0),
+                    "column_count": getattr(element, "column_count", 0),
+                    "row_count": getattr(element, "row_count", 0),
+                    "line_range": {
+                        "start": getattr(element, "start_line", 0),
+                        "end": getattr(element, "end_line", 0),
+                    }
+                }
+                for element in analysis_result.elements
+            ],
+            "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",
+            }
+        }
+
     def _convert_to_structure_format(
         self, analysis_result: Any, language: str
     ) -> dict[str, Any]:

tree_sitter_analyzer/core/query_service.py

@@ -80,9 +80,24 @@ class QueryService:
                         f"Query '{query_key}' not found for language '{language}'"
                     )
 
-            # Execute tree-sitter query
-            ts_query = language_obj.query(query_string)
-            captures = ts_query.captures(tree.root_node)
+            # Execute tree-sitter query using new API with fallback
+            import tree_sitter
+            captures = []
+            
+            # Try to create and execute the query
+            try:
+                ts_query = tree_sitter.Query(language_obj, query_string)
+                
+                # Try to execute the query
+                captures = ts_query.captures(tree.root_node)
+                
+                # If captures is empty or not in expected format, try manual fallback
+                if not captures or (isinstance(captures, list) and len(captures) == 0):
+                    captures = self._manual_query_execution(tree.root_node, query_key, language)
+                    
+            except (AttributeError, Exception) as e:
+                # If query creation or execution fails, use manual fallback
+                captures = self._manual_query_execution(tree.root_node, query_key, language)
 
             # Process capture results
             results = []
@@ -91,12 +106,19 @@ class QueryService:
                 for capture_name, nodes in captures.items():
                     for node in nodes:
                         results.append(self._create_result_dict(node, capture_name))
-            else:
-                # Old tree-sitter API returns list of tuples
+            elif isinstance(captures, list):
+                # Handle both old API (list of tuples) and manual execution (list of tuples)
                 for capture in captures:
                     if isinstance(capture, tuple) and len(capture) == 2:
                         node, name = capture
                         results.append(self._create_result_dict(node, name))
+            else:
+                # If captures is not in expected format, try manual fallback
+                manual_captures = self._manual_query_execution(tree.root_node, query_key, language)
+                for capture in manual_captures:
+                    if isinstance(capture, tuple) and len(capture) == 2:
+                        node, name = capture
+                        results.append(self._create_result_dict(node, name))
 
             # Apply filters
             if filter_expression and results:
@@ -160,3 +182,131 @@ class QueryService:
             return query_loader.get_query_description(language, query_key)
         except Exception:
             return None
+
+    def _manual_query_execution(self, root_node: Any, query_key: str | None, language: str) -> list[tuple[Any, str]]:
+        """
+        Manual query execution fallback for tree-sitter 0.25.x compatibility
+        
+        Args:
+            root_node: Root node of the parsed tree
+            query_key: Query key to execute (can be None for custom queries)
+            language: Programming language
+            
+        Returns:
+            List of (node, capture_name) tuples
+        """
+        captures = []
+        
+        def walk_tree(node):
+            """Walk the tree and find matching nodes"""
+            # If query_key is None, this is a custom query - try to match common patterns
+            if query_key is None:
+                # For custom queries, try to match common node types
+                if language == "java":
+                    if node.type == "method_declaration":
+                        captures.append((node, "method"))
+                    elif node.type == "class_declaration":
+                        captures.append((node, "class"))
+                    elif node.type == "field_declaration":
+                        captures.append((node, "field"))
+                elif language == "python":
+                    if node.type == "function_definition":
+                        captures.append((node, "function"))
+                    elif node.type == "class_definition":
+                        captures.append((node, "class"))
+                    elif node.type in ["import_statement", "import_from_statement"]:
+                        captures.append((node, "import"))
+                elif language in ["javascript", "typescript"]:
+                    if node.type in ["function_declaration", "method_definition"]:
+                        captures.append((node, "function"))
+                    elif node.type == "class_declaration":
+                        captures.append((node, "class"))
+            
+            # Markdown-specific queries
+            elif language == "markdown":
+                if query_key == "headers" and node.type in ["atx_heading", "setext_heading"]:
+                    captures.append((node, "headers"))
+                elif query_key == "code_blocks" and node.type in ["fenced_code_block", "indented_code_block"]:
+                    captures.append((node, "code_blocks"))
+                elif query_key == "links" and node.type == "inline":
+                    # リンクは inline ノード内のパターンとして検出
+                    node_text = node.text.decode('utf-8', errors='replace') if hasattr(node, 'text') and node.text else ""
+                    if '[' in node_text and '](' in node_text:
+                        captures.append((node, "links"))
+                elif query_key == "images" and node.type == "inline":
+                    # 画像は inline ノード内のパターンとして検出
+                    node_text = node.text.decode('utf-8', errors='replace') if hasattr(node, 'text') and node.text else ""
+                    if '![' in node_text and '](' in node_text:
+                        captures.append((node, "images"))
+                elif query_key == "lists" and node.type in ["list", "list_item"]:
+                    captures.append((node, "lists"))
+                elif query_key == "emphasis" and node.type == "inline":
+                    # 強調は inline ノード内の * や ** パターンとして検出
+                    node_text = node.text.decode('utf-8', errors='replace') if hasattr(node, 'text') and node.text else ""
+                    if '*' in node_text or '_' in node_text:
+                        captures.append((node, "emphasis"))
+                elif query_key == "blockquotes" and node.type == "block_quote":
+                    captures.append((node, "blockquotes"))
+                elif query_key == "tables" and node.type == "pipe_table":
+                    captures.append((node, "tables"))
+                elif query_key == "horizontal_rules" and node.type == "thematic_break":
+                    captures.append((node, "horizontal_rules"))
+                elif query_key == "html_blocks" and node.type == "html_block":
+                    captures.append((node, "html_blocks"))
+                elif query_key == "inline_html" and node.type == "html_tag":
+                    captures.append((node, "inline_html"))
+                elif query_key == "inline_code" and node.type == "code_span":
+                    captures.append((node, "inline_code"))
+                elif query_key == "text_content" and node.type in ["paragraph", "inline"]:
+                    captures.append((node, "text_content"))
+                elif query_key == "all_elements" and node.type in [
+                    "atx_heading", "setext_heading", "fenced_code_block", "indented_code_block",
+                    "inline", "list", "list_item", "block_quote", "pipe_table",
+                    "paragraph", "section"
+                ]:
+                    captures.append((node, "all_elements"))
+            
+            # Python-specific queries
+            elif language == "python":
+                if query_key in ["function", "functions"] and node.type == "function_definition":
+                    captures.append((node, "function"))
+                elif query_key in ["class", "classes"] and node.type == "class_definition":
+                    captures.append((node, "class"))
+                elif query_key in ["import", "imports"] and node.type in ["import_statement", "import_from_statement"]:
+                    captures.append((node, "import"))
+            
+            # JavaScript/TypeScript-specific queries
+            elif language in ["javascript", "typescript"]:
+                if query_key in ["function", "functions"] and node.type in ["function_declaration", "function_expression", "arrow_function", "method_definition"]:
+                    captures.append((node, "function"))
+                elif query_key in ["class", "classes"] and node.type in ["class_declaration", "class_expression"]:
+                    captures.append((node, "class"))
+                elif query_key in ["method", "methods"] and node.type == "method_definition":
+                    captures.append((node, "method"))
+                elif query_key in ["interface", "interfaces"] and node.type == "interface_declaration" and language == "typescript":
+                    captures.append((node, "interface"))
+                elif query_key in ["type", "types"] and node.type == "type_alias_declaration" and language == "typescript":
+                    captures.append((node, "type"))
+                elif query_key in ["variable", "variables"] and node.type in ["variable_declaration", "lexical_declaration"]:
+                    captures.append((node, "variable"))
+                elif query_key in ["import", "imports"] and node.type == "import_statement":
+                    captures.append((node, "import"))
+                elif query_key in ["export", "exports"] and node.type == "export_statement":
+                    captures.append((node, "export"))
+            
+            # Java-specific queries
+            elif language == "java":
+                if query_key in ["method", "methods"] and node.type == "method_declaration":
+                    # Always use "method" as capture name for consistency
+                    captures.append((node, "method"))
+                elif query_key in ["class", "classes"] and node.type == "class_declaration":
+                    captures.append((node, "class"))
+                elif query_key == "field" and node.type == "field_declaration":
+                    captures.append((node, "field"))
+            
+            # Recursively process children
+            for child in node.children:
+                walk_tree(child)
+        
+        walk_tree(root_node)
+        return captures

tree_sitter_analyzer/formatters/base_formatter.py

@@ -1,12 +1,39 @@
 #!/usr/bin/env python3
 """
-Base formatter for language-specific table formatting.
+Base formatter for language-specific formatting.
 """
 
 import csv
 import io
 from abc import ABC, abstractmethod
-from typing import Any
+from typing import Any, Dict
+
+
+class BaseFormatter(ABC):
+    """Base class for language-specific formatters"""
+
+    def __init__(self):
+        pass
+
+    @abstractmethod
+    def format_summary(self, analysis_result: Dict[str, Any]) -> str:
+        """Format summary output"""
+        pass
+
+    @abstractmethod
+    def format_structure(self, analysis_result: Dict[str, Any]) -> str:
+        """Format structure analysis output"""
+        pass
+
+    @abstractmethod
+    def format_advanced(self, analysis_result: Dict[str, Any], output_format: str = "json") -> str:
+        """Format advanced analysis output"""
+        pass
+
+    @abstractmethod
+    def format_table(self, analysis_result: Dict[str, Any], table_type: str = "full") -> str:
+        """Format table output"""
+        pass
 
 
 class BaseTableFormatter(ABC):

tree_sitter_analyzer/formatters/language_formatter_factory.py

@@ -0,0 +1,83 @@
+#!/usr/bin/env python3
+"""
+Factory for creating language-specific formatters for different output types.
+"""
+
+from typing import Dict, Type, Any
+from .base_formatter import BaseFormatter
+from .markdown_formatter import MarkdownFormatter
+
+
+class LanguageFormatterFactory:
+    """Factory for creating language-specific formatters"""
+
+    _formatters: Dict[str, Type[BaseFormatter]] = {
+        "markdown": MarkdownFormatter,
+        "md": MarkdownFormatter,  # Alias
+    }
+
+    @classmethod
+    def create_formatter(cls, language: str) -> BaseFormatter:
+        """
+        Create formatter for specified language
+
+        Args:
+            language: Programming language name
+
+        Returns:
+            Language-specific formatter
+        """
+        formatter_class = cls._formatters.get(language.lower())
+
+        if formatter_class is None:
+            # Return None for unsupported languages
+            return None
+
+        return formatter_class()
+
+    @classmethod
+    def register_formatter(cls, language: str, formatter_class: Type[BaseFormatter]) -> None:
+        """
+        Register new language formatter
+
+        Args:
+            language: Programming language name
+            formatter_class: Formatter class
+        """
+        cls._formatters[language.lower()] = formatter_class
+
+    @classmethod
+    def get_supported_languages(cls) -> list[str]:
+        """
+        Get list of supported languages
+
+        Returns:
+            List of supported languages
+        """
+        return list(cls._formatters.keys())
+
+    @classmethod
+    def supports_language(cls, language: str) -> bool:
+        """
+        Check if language is supported
+
+        Args:
+            language: Programming language name
+
+        Returns:
+            True if language is supported
+        """
+        return language.lower() in cls._formatters
+
+
+def create_language_formatter(language: str) -> BaseFormatter:
+    """
+    Create language formatter (function for compatibility)
+
+    Args:
+        language: Programming language name
+
+    Returns:
+        Language formatter or None if not supported
+    """
+    return LanguageFormatterFactory.create_formatter(language)