tree-sitter-analyzer 1.7.5__py3-none-any.whl → 1.8.2__py3-none-any.whl

tree_sitter_analyzer/formatters/html_formatter.py

@@ -0,0 +1,462 @@
+#!/usr/bin/env python3
+"""
+HTML Formatter
+
+Specialized formatter for HTML/CSS code elements including MarkupElement and StyleElement.
+Provides HTML-specific formatting with element classification and hierarchy display.
+"""
+
+import json
+from typing import Any
+
+from ..models import CodeElement, MarkupElement, StyleElement
+from .formatter_registry import IFormatter
+from .base_formatter import BaseFormatter
+
+
+class HtmlFormatter(BaseFormatter, IFormatter):
+    """HTML-specific formatter for MarkupElement and StyleElement"""
+
+    @staticmethod
+    def get_format_name() -> str:
+        return "html"
+
+    def format(self, elements: list[CodeElement]) -> str:
+        """Format HTML elements with hierarchy and classification"""
+        if not elements:
+            return "No HTML elements found."
+
+        lines = []
+        lines.append("# HTML Structure Analysis")
+        lines.append("")
+
+        # Handle both CodeElement objects and dictionaries
+        markup_elements = []
+        style_elements = []
+        other_elements = []
+        
+        for e in elements:
+            if isinstance(e, MarkupElement):
+                markup_elements.append(e)
+            elif isinstance(e, StyleElement):
+                style_elements.append(e)
+            elif isinstance(e, dict):
+                # Convert dictionary to appropriate element type based on content
+                element_type = e.get('type', e.get('element_type', 'unknown'))
+                if 'tag_name' in e or element_type in ['tag', 'element', 'markup']:
+                    markup_elements.append(self._dict_to_markup_element(e))
+                elif 'selector' in e or element_type in ['rule', 'style']:
+                    style_elements.append(self._dict_to_style_element(e))
+                else:
+                    other_elements.append(e)
+            else:
+                other_elements.append(e)
+
+        # Format markup elements
+        if markup_elements:
+            lines.extend(self._format_markup_elements(markup_elements))
+
+        # Format style elements
+        if style_elements:
+            lines.extend(self._format_style_elements(style_elements))
+
+        # Format other elements
+        if other_elements:
+            lines.extend(self._format_other_elements(other_elements))
+
+        return "\n".join(lines)
+
+    def format_summary(self, analysis_result: dict[str, Any]) -> str:
+        """Format summary output for HTML elements"""
+        elements = analysis_result.get("elements", [])
+        if not elements:
+            return "No HTML elements found."
+        
+        markup_count = sum(1 for e in elements if isinstance(e, MarkupElement))
+        style_count = sum(1 for e in elements if isinstance(e, StyleElement))
+        other_count = len(elements) - markup_count - style_count
+        
+        lines = []
+        lines.append("# HTML Analysis Summary")
+        lines.append("")
+        lines.append(f"**Total Elements:** {len(elements)}")
+        lines.append(f"- Markup Elements: {markup_count}")
+        lines.append(f"- Style Elements: {style_count}")
+        lines.append(f"- Other Elements: {other_count}")
+        
+        return "\n".join(lines)
+
+    def format_structure(self, analysis_result: dict[str, Any]) -> str:
+        """Format structure analysis output"""
+        elements = analysis_result.get("elements", [])
+        return self.format(elements)
+
+    def format_advanced(self, analysis_result: dict[str, Any], output_format: str = "json") -> str:
+        """Format advanced analysis output"""
+        elements = analysis_result.get("elements", [])
+        
+        if output_format == "json":
+            formatter = HtmlJsonFormatter()
+            return formatter.format(elements)
+        else:
+            return self.format(elements)
+
+    def format_table(self, analysis_result: dict[str, Any], table_type: str = "full") -> str:
+        """Format table output"""
+        elements = analysis_result.get("elements", [])
+        
+        if table_type == "compact":
+            formatter = HtmlCompactFormatter()
+            return formatter.format(elements)
+        elif table_type == "json":
+            formatter = HtmlJsonFormatter()
+            return formatter.format(elements)
+        else:
+            # Default to full format (including "html" and "full")
+            return self.format(elements)
+
+    def _format_markup_elements(self, elements: list[MarkupElement]) -> list[str]:
+        """Format MarkupElement list with hierarchy"""
+        lines = []
+        lines.append("## HTML Elements")
+        lines.append("")
+
+        # Group by element class
+        element_groups = {}
+        for element in elements:
+            element_class = element.element_class or "unknown"
+            if element_class not in element_groups:
+                element_groups[element_class] = []
+            element_groups[element_class].append(element)
+
+        # Format each group
+        for element_class, group_elements in element_groups.items():
+            lines.append(f"### {element_class.title()} Elements ({len(group_elements)})")
+            lines.append("")
+            lines.append("| Tag | Name | Lines | Attributes | Children |")
+            lines.append("|-----|------|-------|------------|----------|")
+
+            for element in group_elements:
+                tag_name = element.tag_name or "unknown"
+                name = element.name or tag_name
+                lines_str = f"{element.start_line}-{element.end_line}"
+                
+                # Format attributes
+                attrs = []
+                attributes = element.attributes or {}
+                for key, value in attributes.items():
+                    if value:
+                        attrs.append(f"{key}=\"{value}\"")
+                    else:
+                        attrs.append(key)
+                attrs_str = ", ".join(attrs) if attrs else "-"
+                if len(attrs_str) > 30:
+                    attrs_str = attrs_str[:27] + "..."
+
+                # Count children
+                children_count = len(element.children)
+
+                lines.append(f"| `{tag_name}` | {name} | {lines_str} | {attrs_str} | {children_count} |")
+
+            lines.append("")
+
+        # Show hierarchy for root elements
+        root_elements = [e for e in elements if e.parent is None]
+        if root_elements and len(root_elements) < len(elements):
+            lines.append("### Element Hierarchy")
+            lines.append("")
+            for root in root_elements:
+                lines.extend(self._format_element_tree(root, 0))
+            lines.append("")
+
+        return lines
+
+    def _format_element_tree(self, element: MarkupElement, depth: int) -> list[str]:
+        """Format element tree hierarchy"""
+        lines = []
+        indent = "  " * depth
+        tag_name = element.tag_name or "unknown"
+        
+        # Format element info
+        attrs_info = ""
+        attributes = element.attributes or {}
+        if attributes:
+            key_attrs = []
+            for key, value in attributes.items():
+                if key in ["id", "class", "name"]:
+                    key_attrs.append(f"{key}=\"{value}\"" if value else key)
+            if key_attrs:
+                attrs_info = f" ({', '.join(key_attrs)})"
+
+        lines.append(f"{indent}- `{tag_name}`{attrs_info} [{element.start_line}-{element.end_line}]")
+
+        # Format children
+        for child in element.children:
+            lines.extend(self._format_element_tree(child, depth + 1))
+
+        return lines
+
+    def _format_style_elements(self, elements: list[StyleElement]) -> list[str]:
+        """Format StyleElement list"""
+        lines = []
+        lines.append("## CSS Rules")
+        lines.append("")
+
+        # Group by element class
+        element_groups = {}
+        for element in elements:
+            element_class = element.element_class or "unknown"
+            if element_class not in element_groups:
+                element_groups[element_class] = []
+            element_groups[element_class].append(element)
+
+        # Format each group
+        for element_class, group_elements in element_groups.items():
+            lines.append(f"### {element_class.title()} Rules ({len(group_elements)})")
+            lines.append("")
+            lines.append("| Selector | Properties | Lines |")
+            lines.append("|----------|------------|-------|")
+
+            for element in group_elements:
+                selector = element.selector or element.name
+                lines_str = f"{element.start_line}-{element.end_line}"
+                
+                # Format properties
+                props = []
+                properties = element.properties or {}
+                for key, value in properties.items():
+                    props.append(f"{key}: {value}")
+                props_str = "; ".join(props) if props else "-"
+                if len(props_str) > 40:
+                    props_str = props_str[:37] + "..."
+
+                lines.append(f"| `{selector}` | {props_str} | {lines_str} |")
+
+            lines.append("")
+
+        return lines
+
+    def _format_other_elements(self, elements: list) -> list[str]:
+        """Format other code elements"""
+        lines = []
+        lines.append("## Other Elements")
+        lines.append("")
+        lines.append("| Type | Name | Lines | Language |")
+        lines.append("|------|------|-------|----------|")
+
+        for element in elements:
+            if isinstance(element, dict):
+                element_type = element.get("element_type", element.get("type", "unknown"))
+                name = element.get("name", "unknown")
+                start_line = element.get("start_line", 0)
+                end_line = element.get("end_line", 0)
+                language = element.get("language", "unknown")
+            else:
+                element_type = getattr(element, "element_type", "unknown")
+                name = getattr(element, "name", "unknown")
+                start_line = getattr(element, "start_line", 0)
+                end_line = getattr(element, "end_line", 0)
+                language = getattr(element, "language", "unknown")
+            
+            lines_str = f"{start_line}-{end_line}"
+            lines.append(f"| {element_type} | {name} | {lines_str} | {language} |")
+
+        lines.append("")
+        return lines
+
+    def _dict_to_markup_element(self, data: dict):
+        """Convert dictionary to MarkupElement-like object"""
+        # Create a mock MarkupElement-like object
+        class MockMarkupElement:
+            def __init__(self, data):
+                self.name = data.get('name', 'unknown')
+                self.tag_name = data.get('tag_name', data.get('name', 'unknown'))
+                self.element_class = data.get('element_class', 'unknown')
+                self.start_line = data.get('start_line', 0)
+                self.end_line = data.get('end_line', 0)
+                self.attributes = data.get('attributes', {})
+                self.children = []
+                self.parent = None
+                self.language = data.get('language', 'html')
+        
+        return MockMarkupElement(data)
+
+    def _dict_to_style_element(self, data: dict):
+        """Convert dictionary to StyleElement-like object"""
+        # Create a mock StyleElement-like object
+        class MockStyleElement:
+            def __init__(self, data):
+                self.name = data.get('name', 'unknown')
+                self.selector = data.get('selector', data.get('name', 'unknown'))
+                self.element_class = data.get('element_class', 'unknown')
+                self.start_line = data.get('start_line', 0)
+                self.end_line = data.get('end_line', 0)
+                self.properties = data.get('properties', {})
+                self.language = data.get('language', 'css')
+        
+        return MockStyleElement(data)
+
+
+class HtmlJsonFormatter(IFormatter):
+    """JSON formatter specifically for HTML elements"""
+
+    @staticmethod
+    def get_format_name() -> str:
+        return "html_json"
+
+    def format(self, elements: list[CodeElement]) -> str:
+        """Format HTML elements as JSON with hierarchy"""
+        result = {
+            "html_analysis": {
+                "total_elements": len(elements),
+                "markup_elements": [],
+                "style_elements": [],
+                "other_elements": []
+            }
+        }
+
+        for element in elements:
+            if isinstance(element, MarkupElement):
+                result["html_analysis"]["markup_elements"].append(self._markup_to_dict(element))
+            elif isinstance(element, StyleElement):
+                result["html_analysis"]["style_elements"].append(self._style_to_dict(element))
+            elif isinstance(element, dict):
+                # Handle dictionary format
+                element_type = element.get("element_type", element.get("type", "unknown"))
+                if "tag_name" in element or element_type in ['tag', 'element', 'markup']:
+                    result["html_analysis"]["markup_elements"].append(element)
+                elif "selector" in element or element_type in ['rule', 'style']:
+                    result["html_analysis"]["style_elements"].append(element)
+                else:
+                    result["html_analysis"]["other_elements"].append(element)
+            else:
+                result["html_analysis"]["other_elements"].append(self._element_to_dict(element))
+
+        return json.dumps(result, indent=2, ensure_ascii=False)
+
+    def _markup_to_dict(self, element: MarkupElement) -> dict[str, Any]:
+        """Convert MarkupElement to dictionary"""
+        return {
+            "name": element.name,
+            "tag_name": element.tag_name,
+            "element_class": element.element_class,
+            "start_line": element.start_line,
+            "end_line": element.end_line,
+            "attributes": element.attributes,
+            "children_count": len(element.children),
+            "children": [self._markup_to_dict(child) for child in element.children],
+            "language": element.language
+        }
+
+    def _style_to_dict(self, element: StyleElement) -> dict[str, Any]:
+        """Convert StyleElement to dictionary"""
+        return {
+            "name": element.name,
+            "selector": element.selector,
+            "element_class": element.element_class,
+            "start_line": element.start_line,
+            "end_line": element.end_line,
+            "properties": element.properties,
+            "language": element.language
+        }
+
+    def _element_to_dict(self, element: CodeElement) -> dict[str, Any]:
+        """Convert generic CodeElement to dictionary"""
+        return {
+            "name": element.name,
+            "type": getattr(element, "element_type", "unknown"),
+            "start_line": element.start_line,
+            "end_line": element.end_line,
+            "language": element.language
+        }
+
+
+class HtmlCompactFormatter(IFormatter):
+    """Compact formatter for HTML elements"""
+
+    @staticmethod
+    def get_format_name() -> str:
+        return "html_compact"
+
+    def format(self, elements: list[CodeElement]) -> str:
+        """Format HTML elements in compact format"""
+        if not elements:
+            return "No HTML elements found."
+
+        lines = []
+        lines.append("HTML ELEMENTS")
+        lines.append("-" * 20)
+
+        markup_count = sum(1 for e in elements if isinstance(e, MarkupElement))
+        style_count = sum(1 for e in elements if isinstance(e, StyleElement))
+        other_count = len(elements) - markup_count - style_count
+
+        lines.append(f"Total: {len(elements)} elements")
+        lines.append(f"  Markup: {markup_count}")
+        lines.append(f"  Style: {style_count}")
+        lines.append(f"  Other: {other_count}")
+        lines.append("")
+
+        for element in elements:
+            if isinstance(element, MarkupElement):
+                symbol = "🏷️"
+                info = f"<{element.tag_name}>"
+                if element.attributes.get("id"):
+                    info += f" #{element.attributes['id']}"
+                if element.attributes.get("class"):
+                    info += f" .{element.attributes['class']}"
+                name = element.name
+                start_line = element.start_line
+                end_line = element.end_line
+            elif isinstance(element, StyleElement):
+                symbol = "🎨"
+                info = element.selector
+                name = element.name
+                start_line = element.start_line
+                end_line = element.end_line
+            elif isinstance(element, dict):
+                # Handle dictionary format
+                element_type = element.get("element_type", element.get("type", "unknown"))
+                name = element.get("name", "unknown")
+                start_line = element.get("start_line", 0)
+                end_line = element.get("end_line", 0)
+                
+                if "tag_name" in element or element_type in ['tag', 'element', 'markup']:
+                    symbol = "🏷️"
+                    tag_name = element.get("tag_name", name)
+                    info = f"<{tag_name}>"
+                    attributes = element.get("attributes", {})
+                    if attributes.get("id"):
+                        info += f" #{attributes['id']}"
+                    if attributes.get("class"):
+                        info += f" .{attributes['class']}"
+                elif "selector" in element or element_type in ['rule', 'style']:
+                    symbol = "🎨"
+                    info = element.get("selector", name)
+                else:
+                    symbol = "📄"
+                    info = element_type
+            else:
+                symbol = "📄"
+                info = getattr(element, "element_type", "unknown")
+                name = getattr(element, "name", "unknown")
+                start_line = getattr(element, "start_line", 0)
+                end_line = getattr(element, "end_line", 0)
+
+            lines.append(f"{symbol} {name} {info} [{start_line}-{end_line}]")
+
+        return "\n".join(lines)
+
+
+# Register HTML formatters
+def register_html_formatters() -> None:
+    """Register HTML-specific formatters"""
+    from .formatter_registry import FormatterRegistry
+    
+    FormatterRegistry.register_formatter(HtmlFormatter)
+    FormatterRegistry.register_formatter(HtmlJsonFormatter)
+    FormatterRegistry.register_formatter(HtmlCompactFormatter)
+
+
+# Auto-register when module is imported
+register_html_formatters()

tree_sitter_analyzer/formatters/language_formatter_factory.py

@@ -6,6 +6,7 @@ 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
+from .html_formatter import HtmlFormatter
 
 
 class LanguageFormatterFactory:
@@ -14,6 +15,8 @@ class LanguageFormatterFactory:
     _formatters: Dict[str, Type[BaseFormatter]] = {
         "markdown": MarkdownFormatter,
         "md": MarkdownFormatter,  # Alias
+        "html": HtmlFormatter,
+        "css": HtmlFormatter,   # CSS files also use HTML formatter
     }
 
     @classmethod

tree_sitter_analyzer/formatters/markdown_formatter.py

@@ -442,7 +442,7 @@ class MarkdownFormatter(BaseFormatter):
         """Format advanced analysis in text format"""
         output = ["--- Advanced Analysis Results ---"]
         
-        # Basic info
+        # Basic info - format with quotes to match expected output
         output.append(f'"File: {data["file_path"]}"')
         output.append(f'"Language: {data["language"]}"')
         output.append(f'"Lines: {data["line_count"]}"')

tree_sitter_analyzer/interfaces/mcp_server.py

@@ -12,6 +12,8 @@ import logging
 import sys
 from typing import Any
 
+from .. import __version__
+
 try:
     from mcp.server import Server
     from mcp.server.models import InitializationOptions
@@ -68,7 +70,7 @@ class TreeSitterAnalyzerMCPServer:
 
         self.server: Server | None = None
         self.name = "tree-sitter-analyzer"
-        self.version = "2.0.0"
+        self.version = __version__
 
         log_info(f"Initializing {self.name} v{self.version}")
 

tree_sitter_analyzer/language_detector.py

@@ -66,6 +66,19 @@ class LanguageDetector:
         ".mkd": "markdown",
         ".mkdn": "markdown",
         ".mdx": "markdown",
+        # HTML系
+        ".html": "html",
+        ".htm": "html",
+        ".xhtml": "html",
+        # CSS系
+        ".css": "css",
+        ".scss": "css",
+        ".sass": "css",
+        ".less": "css",
+        # JSON系
+        ".json": "json",
+        ".jsonc": "json",
+        ".json5": "json",
     }
 
     # Ambiguous extensions (map to multiple languages)
@@ -100,6 +113,9 @@ class LanguageDetector:
         "rust",
         "go",
         "markdown",
+        "html",
+        "css",
+        "json",
     }
 
     def __init__(self) -> None:
@@ -143,6 +159,19 @@ class LanguageDetector:
             ".mkd": ("markdown", 0.8),
             ".mkdn": ("markdown", 0.8),
             ".mdx": ("markdown", 0.7),  # MDX might be mixed with JSX
+            # HTML extensions
+            ".html": ("html", 0.9),
+            ".htm": ("html", 0.9),
+            ".xhtml": ("html", 0.8),
+            # CSS extensions
+            ".css": ("css", 0.9),
+            ".scss": ("css", 0.8),  # Sass/SCSS
+            ".sass": ("css", 0.8),  # Sass
+            ".less": ("css", 0.8),  # Less
+            # JSON extensions
+            ".json": ("json", 0.9),
+            ".jsonc": ("json", 0.8),  # JSON with comments
+            ".json5": ("json", 0.8),  # JSON5 format
         }
 
         # Content-based detection patterns
@@ -194,6 +223,26 @@ class LanguageDetector:
                 (r"^\s*\|.*\|", 0.2),  # Tables
                 (r"^[-=]{3,}$", 0.2),  # Setext headers or horizontal rules
             ],
+            "html": [
+                (r"<!DOCTYPE\s+html", 0.4),  # HTML5 doctype
+                (r"<html[^>]*>", 0.3),  # HTML tag
+                (r"<head[^>]*>", 0.3),  # Head tag
+                (r"<body[^>]*>", 0.3),  # Body tag
+                (r"<div[^>]*>", 0.2),  # Div tag
+                (r"<p[^>]*>", 0.2),  # Paragraph tag
+                (r"<a\s+href=", 0.2),  # Link tag with href
+                (r"<img\s+src=", 0.2),  # Image tag with src
+            ],
+            "css": [
+                (r"[.#][\w-]+\s*{", 0.4),  # CSS selectors
+                (r"@media\s+", 0.3),  # Media queries
+                (r"@import\s+", 0.3),  # Import statements
+                (r"@keyframes\s+", 0.3),  # Keyframes
+                (r":\s*[\w-]+\s*;", 0.2),  # Property declarations
+                (r"color\s*:", 0.2),  # Color property
+                (r"font-", 0.2),  # Font properties
+                (r"margin\s*:", 0.2),  # Margin property
+            ],
         }
 
         from .utils import log_debug, log_warning
@@ -212,14 +261,22 @@ class LanguageDetector:
             content: ファイルコンテンツ（任意、曖昧性解決用）
 
         Returns:
-            (言語名, 信頼度) のタプル
+            (言語名, 信頼度) のタプル - 常に有効な言語名を返す
         """
+        # Handle invalid input
+        if not file_path or not isinstance(file_path, str):
+            return "unknown", 0.0
+            
         path = Path(file_path)
         extension = path.suffix.lower()
 
         # Direct mapping by extension
         if extension in self.EXTENSION_MAPPING:
             language = self.EXTENSION_MAPPING[extension]
+            
+            # Ensure language is valid
+            if not language or language.strip() == "":
+                return "unknown", 0.0
 
             # Use confidence from extension_map if available
             if extension in self.extension_map:
@@ -233,11 +290,14 @@ class LanguageDetector:
             # Resolve ambiguity using content
             if content:
                 refined_language = self._resolve_ambiguity(extension, content)
+                # Ensure refined language is valid
+                if not refined_language or refined_language.strip() == "":
+                    refined_language = "unknown"
                 return refined_language, 0.9 if refined_language != language else 0.7
             else:
                 return language, 0.7  # Lower confidence without content
 
-        # Unknown extension
+        # Unknown extension - always return "unknown" instead of None
         return "unknown", 0.0
 
     def detect_from_extension(self, file_path: str) -> str:
@@ -248,10 +308,22 @@ class LanguageDetector:
             file_path: File path
 
         Returns:
-            Detected language name
+            Detected language name - 常に有効な文字列を返す
         """
-        language, _ = self.detect_language(file_path)
-        return language
+        # Handle invalid input
+        if not file_path or not isinstance(file_path, str):
+            return "unknown"
+            
+        result = self.detect_language(file_path)
+        if isinstance(result, tuple):
+            language, _ = result
+            # Ensure language is valid
+            if not language or language.strip() == "":
+                return "unknown"
+            return language
+        else:
+            # Fallback for unexpected result format
+            return "unknown"
 
     def is_supported(self, language: str) -> bool:
         """
@@ -410,9 +482,21 @@ def detect_language_from_file(file_path: str) -> str:
         file_path: File path
 
     Returns:
-        Detected language name
+        Detected language name - 常に有効な文字列を返す
     """
-    return detector.detect_from_extension(file_path)
+    # Handle invalid input
+    if not file_path or not isinstance(file_path, str):
+        return "unknown"
+        
+    # Create a fresh instance to ensure latest configuration
+    fresh_detector = LanguageDetector()
+    result = fresh_detector.detect_from_extension(file_path)
+    
+    # Ensure result is valid
+    if not result or result.strip() == "":
+        return "unknown"
+    
+    return result
 
 
 def is_language_supported(language: str) -> bool: