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

tree_sitter_analyzer/languages/typescript_plugin.py

@@ -1726,4 +1726,133 @@ class TypeScriptPlugin(LanguagePlugin):
         all_elements.extend(extractor.extract_variables(tree, source_code))
         all_elements.extend(extractor.extract_imports(tree, source_code))
         
-        return all_elements
+        return all_elements
+
+    def execute_query_strategy(self, tree: "tree_sitter.Tree", source_code: str, query_key: str) -> list[CodeElement]:
+        """Execute TypeScript-specific query strategy based on query_key"""
+        if not tree or not source_code:
+            return []
+
+        # Initialize extractor with source code
+        self._extractor.source_code = source_code
+        self._extractor.content_lines = source_code.split("\n")
+        self._extractor._reset_caches()
+        self._extractor._detect_file_characteristics()
+
+        # Map query_key to appropriate extraction method
+        query_mapping = {
+            # Function-related queries
+            "function": lambda: self._extractor.extract_functions(tree, source_code),
+            "async_function": lambda: [f for f in self._extractor.extract_functions(tree, source_code) if getattr(f, 'is_async', False)],
+            "arrow_function": lambda: [f for f in self._extractor.extract_functions(tree, source_code) if getattr(f, 'is_arrow', False)],
+            "method": lambda: [f for f in self._extractor.extract_functions(tree, source_code) if getattr(f, 'is_method', False)],
+            "constructor": lambda: [f for f in self._extractor.extract_functions(tree, source_code) if getattr(f, 'is_constructor', False)],
+            "signature": lambda: [f for f in self._extractor.extract_functions(tree, source_code) if getattr(f, 'is_signature', False)],
+            
+            # Class-related queries
+            "class": lambda: self._extractor.extract_classes(tree, source_code),
+            "interface": lambda: [c for c in self._extractor.extract_classes(tree, source_code) if getattr(c, 'class_type', '') == 'interface'],
+            "type_alias": lambda: [c for c in self._extractor.extract_classes(tree, source_code) if getattr(c, 'class_type', '') == 'type'],
+            "enum": lambda: [c for c in self._extractor.extract_classes(tree, source_code) if getattr(c, 'class_type', '') == 'enum'],
+            
+            # Variable-related queries
+            "variable": lambda: self._extractor.extract_variables(tree, source_code),
+            
+            # Import/Export queries
+            "import": lambda: self._extractor.extract_imports(tree, source_code),
+            "export": lambda: [i for i in self._extractor.extract_imports(tree, source_code) if 'export' in getattr(i, 'raw_text', '')],
+            
+            # TypeScript-specific queries
+            "generic": lambda: [c for c in self._extractor.extract_classes(tree, source_code) if 'generics' in getattr(c, 'raw_text', '')],
+            "decorator": lambda: [f for f in self._extractor.extract_functions(tree, source_code) if '@' in getattr(f, 'raw_text', '')],
+            
+            # Framework-specific queries
+            "react_component": lambda: [c for c in self._extractor.extract_classes(tree, source_code) if getattr(c, 'is_react_component', False)],
+            "angular_component": lambda: [c for c in self._extractor.extract_classes(tree, source_code) if getattr(c, 'framework_type', '') == 'angular'],
+            "vue_component": lambda: [c for c in self._extractor.extract_classes(tree, source_code) if getattr(c, 'framework_type', '') == 'vue'],
+        }
+
+        # Execute the appropriate extraction method
+        if query_key in query_mapping:
+            try:
+                return query_mapping[query_key]()
+            except Exception as e:
+                log_error(f"Error executing TypeScript query '{query_key}': {e}")
+                return []
+        else:
+            log_warning(f"Unsupported TypeScript query key: {query_key}")
+            return []
+
+    def get_element_categories(self) -> dict[str, list[str]]:
+        """Get TypeScript element categories mapping query_key to node_types"""
+        return {
+            # Function-related categories
+            "function": [
+                "function_declaration",
+                "function_expression",
+                "arrow_function",
+                "generator_function_declaration"
+            ],
+            "async_function": [
+                "function_declaration",
+                "function_expression",
+                "arrow_function",
+                "method_definition"
+            ],
+            "arrow_function": ["arrow_function"],
+            "method": [
+                "method_definition",
+                "method_signature"
+            ],
+            "constructor": ["method_definition"],
+            "signature": ["method_signature"],
+            
+            # Class-related categories
+            "class": [
+                "class_declaration",
+                "abstract_class_declaration"
+            ],
+            "interface": ["interface_declaration"],
+            "type_alias": ["type_alias_declaration"],
+            "enum": ["enum_declaration"],
+            
+            # Variable-related categories
+            "variable": [
+                "variable_declaration",
+                "lexical_declaration",
+                "property_definition",
+                "property_signature"
+            ],
+            
+            # Import/Export categories
+            "import": ["import_statement"],
+            "export": [
+                "export_statement",
+                "export_declaration"
+            ],
+            
+            # TypeScript-specific categories
+            "generic": [
+                "type_parameters",
+                "type_parameter"
+            ],
+            "decorator": [
+                "decorator",
+                "decorator_call_expression"
+            ],
+            
+            # Framework-specific categories
+            "react_component": [
+                "class_declaration",
+                "function_declaration",
+                "arrow_function"
+            ],
+            "angular_component": [
+                "class_declaration",
+                "decorator"
+            ],
+            "vue_component": [
+                "class_declaration",
+                "function_declaration"
+            ]
+        }

tree_sitter_analyzer/mcp/tools/query_tool.py

@@ -97,7 +97,6 @@ class QueryTool(BaseMCPTool):
             },
         }
 
-    @handle_mcp_errors("query_code")
     async def execute(self, arguments: dict[str, Any]) -> dict[str, Any]:
         """
         Execute query tool
@@ -108,53 +107,78 @@ class QueryTool(BaseMCPTool):
         Returns:
             Query results
         """
-        # Validate input parameters
-        file_path = arguments.get("file_path")
-        if not file_path:
-            raise ValueError("file_path is required")
+        try:
+            # Validate input parameters - check for empty arguments first
+            if not arguments:
+                from ..utils.error_handler import AnalysisError
+                raise AnalysisError(
+                    "file_path is required",
+                    operation="query_code"
+                )
+                
+            file_path = arguments.get("file_path")
+            if not file_path:
+                from ..utils.error_handler import AnalysisError
+                raise AnalysisError(
+                    "file_path is required",
+                    operation="query_code"
+                )
+
+            # Check that either query_key or query_string is provided early
+            query_key = arguments.get("query_key")
+            query_string = arguments.get("query_string")
+            
+            if not query_key and not query_string:
+                from ..utils.error_handler import AnalysisError
+                raise AnalysisError(
+                    "Either query_key or query_string must be provided",
+                    operation="query_code"
+                )
+
+            # Security validation BEFORE path resolution to catch symlinks
+            is_valid, error_msg = self.security_validator.validate_file_path(file_path)
+            if not is_valid:
+                return {
+                    "success": False,
+                    "error": f"Invalid or unsafe file path: {error_msg or file_path}"
+                }
 
-        # Security validation BEFORE path resolution to catch symlinks
-        is_valid, error_msg = self.security_validator.validate_file_path(file_path)
-        if not is_valid:
-            raise ValueError(
-                f"Invalid or unsafe file path: {error_msg or file_path}"
-            )
+            # Resolve file path to absolute path
+            resolved_file_path = self.path_resolver.resolve(file_path)
+            logger.info(f"Querying file: {file_path} (resolved to: {resolved_file_path})")
 
-        # Resolve file path to absolute path
-        resolved_file_path = self.path_resolver.resolve(file_path)
-        logger.info(f"Querying file: {file_path} (resolved to: {resolved_file_path})")
-
-        # Additional security validation on resolved path
-        is_valid, error_msg = self.security_validator.validate_file_path(
-            resolved_file_path
-        )
-        if not is_valid:
-            raise ValueError(
-                f"Invalid or unsafe resolved path: {error_msg or resolved_file_path}"
+            # Additional security validation on resolved path
+            is_valid, error_msg = self.security_validator.validate_file_path(
+                resolved_file_path
             )
+            if not is_valid:
+                return {
+                    "success": False,
+                    "error": f"Invalid or unsafe resolved path: {error_msg or resolved_file_path}"
+                }
 
-        # Get query parameters
-        query_key = arguments.get("query_key")
-        query_string = arguments.get("query_string")
-        filter_expression = arguments.get("filter")
-        output_format = arguments.get("output_format", "json")
-        output_file = arguments.get("output_file")
-        suppress_output = arguments.get("suppress_output", False)
-
-        if not query_key and not query_string:
-            raise ValueError("Either query_key or query_string must be provided")
+            # Get query parameters (already validated above)
+            filter_expression = arguments.get("filter")
+            output_format = arguments.get("output_format", "json")
+            output_file = arguments.get("output_file")
+            suppress_output = arguments.get("suppress_output", False)
 
-        if query_key and query_string:
-            raise ValueError("Cannot provide both query_key and query_string")
+            if query_key and query_string:
+                return {
+                    "success": False,
+                    "error": "Cannot provide both query_key and query_string"
+                }
 
-        # Detect language
-        language = arguments.get("language")
-        if not language:
-            language = detect_language_from_file(resolved_file_path)
+            # Detect language
+            language = arguments.get("language")
             if not language:
-                raise ValueError(f"Could not detect language for file: {file_path}")
+                language = detect_language_from_file(resolved_file_path)
+                if not language:
+                    return {
+                        "success": False,
+                        "error": f"Could not detect language for file: {file_path}"
+                    }
 
-        try:
             # Execute query
             results = await self.query_service.execute_query(
                 resolved_file_path, language, query_key, query_string, filter_expression
@@ -170,7 +194,9 @@ class QueryTool(BaseMCPTool):
 
             # Format output
             if output_format == "summary":
-                formatted_result = self._format_summary(results, query_key or "custom", language)
+                formatted_result = self._format_summary(
+                    results, query_key or "custom", language
+                )
             else:
                 formatted_result = {
                     "success": True,
@@ -185,28 +211,31 @@ class QueryTool(BaseMCPTool):
             if output_file:
                 try:
                     import json
-                    
+
                     # Generate base name from original file path if not provided
                     if not output_file or output_file.strip() == "":
-                        base_name = f"{Path(file_path).stem}_query_{query_key or 'custom'}"
+                        base_name = (
+                            f"{Path(file_path).stem}_query_{query_key or 'custom'}"
+                        )
                     else:
                         base_name = output_file
 
                     # Convert result to JSON string for file output
-                    json_content = json.dumps(formatted_result, indent=2, ensure_ascii=False)
+                    json_content = json.dumps(
+                        formatted_result, indent=2, ensure_ascii=False
+                    )
 
                     # Save to file with automatic extension detection
                     saved_file_path = self.file_output_manager.save_to_file(
-                        content=json_content,
-                        base_name=base_name
+                        content=json_content, base_name=base_name
                     )
-                    
+
                     # Add file output info to result
                     formatted_result["output_file_path"] = saved_file_path
                     formatted_result["file_saved"] = True
-                    
+
                     logger.info(f"Query output saved to: {saved_file_path}")
-                    
+
                 except Exception as e:
                     logger.error(f"Failed to save output to file: {e}")
                     formatted_result["file_save_error"] = str(e)
@@ -222,26 +251,35 @@ class QueryTool(BaseMCPTool):
                     "language": language,
                     "query": query_key or query_string,
                 }
-                
+
                 # Include file output info if present
                 if "output_file_path" in formatted_result:
-                    minimal_result["output_file_path"] = formatted_result["output_file_path"]
+                    minimal_result["output_file_path"] = formatted_result[
+                        "output_file_path"
+                    ]
                     minimal_result["file_saved"] = formatted_result["file_saved"]
                 if "file_save_error" in formatted_result:
-                    minimal_result["file_save_error"] = formatted_result["file_save_error"]
+                    minimal_result["file_save_error"] = formatted_result[
+                        "file_save_error"
+                    ]
                     minimal_result["file_saved"] = formatted_result["file_saved"]
-                
+
                 return minimal_result
             else:
                 return formatted_result
 
         except Exception as e:
+            from ..utils.error_handler import AnalysisError
+            # Re-raise AnalysisError to maintain proper error handling
+            if isinstance(e, AnalysisError):
+                raise
+            
             logger.error(f"Query execution failed: {e}")
             return {
                 "success": False,
                 "error": str(e),
-                "file_path": file_path,
-                "language": language,
+                "file_path": arguments.get("file_path", "unknown"),
+                "language": arguments.get("language", "unknown"),
             }
 
     def _format_summary(
@@ -259,7 +297,7 @@ class QueryTool(BaseMCPTool):
             Summary formatted results
         """
         # Group by capture name
-        by_capture = {}
+        by_capture: dict[str, list[dict[str, Any]]] = {}
         for result in results:
             capture_name = result["capture_name"]
             if capture_name not in by_capture:
@@ -267,7 +305,7 @@ class QueryTool(BaseMCPTool):
             by_capture[capture_name].append(result)
 
         # Create summary
-        summary = {
+        summary: dict[str, Any] = {
             "success": True,
             "query_type": query_type,
             "language": language,
@@ -309,6 +347,9 @@ class QueryTool(BaseMCPTool):
 
             # Match common declaration patterns
             patterns = [
+                # Markdown headers
+                r"^#{1,6}\s+(.+)$",  # Markdown headers (# Title, ## Subtitle, etc.)
+                # Programming language patterns
                 r"(?:public|private|protected)?\s*(?:static)?\s*(?:class|interface)\s+(\w+)",  # class/interface
                 r"(?:public|private|protected)?\s*(?:static)?\s*\w+\s+(\w+)\s*\(",  # method
                 r"(\w+)\s*\(",  # simple function call
@@ -317,7 +358,7 @@ class QueryTool(BaseMCPTool):
             for pattern in patterns:
                 match = re.search(pattern, first_line)
                 if match:
-                    return match.group(1)
+                    return match.group(1).strip()
 
         return "unnamed"
 

tree_sitter_analyzer/mcp/tools/table_format_tool.py

@@ -18,6 +18,7 @@ from ...constants import (
     is_element_of_type,
 )
 from ...core.analysis_engine import AnalysisRequest, get_analysis_engine
+from ...formatters.formatter_registry import FormatterRegistry
 from ...language_detector import detect_language_from_file
 from ...table_formatter import TableFormatter
 from ...utils import setup_logger
@@ -73,7 +74,7 @@ class TableFormatTool(BaseMCPTool):
                 "format_type": {
                     "type": "string",
                     "description": "Table format type",
-                    "enum": ["full", "compact", "csv", "json"],
+                    "enum": list(set(FormatterRegistry.get_available_formats() + ["full", "compact", "csv", "json"])),
                     "default": "full",
                 },
                 "language": {
@@ -123,8 +124,11 @@ class TableFormatTool(BaseMCPTool):
             format_type = arguments["format_type"]
             if not isinstance(format_type, str):
                 raise ValueError("format_type must be a string")
-            if format_type not in ["full", "compact", "csv", "json"]:
-                raise ValueError("format_type must be one of: full, compact, csv, json")
+            
+            # Check both new FormatterRegistry formats and legacy formats
+            available_formats = list(set(FormatterRegistry.get_available_formats() + ["full", "compact", "csv", "json"]))
+            if format_type not in available_formats:
+                raise ValueError(f"format_type must be one of: {', '.join(sorted(available_formats))}")
 
         # Validate language if provided
         if "language" in arguments:
@@ -448,14 +452,24 @@ class TableFormatTool(BaseMCPTool):
                         f"Failed to analyze structure for file: {file_path}"
                     )
 
-                # Create table formatter
-                formatter = TableFormatter(format_type)
-
-                # Convert AnalysisResult to dict format for TableFormatter
+                # Always convert analysis result to dict for metadata extraction
                 structure_dict = self._convert_analysis_result_to_dict(structure_result)
-
-                # Format table
-                table_output = formatter.format_structure(structure_dict)
+                
+                # Try to use new FormatterRegistry first, fallback to legacy TableFormatter
+                try:
+                    if FormatterRegistry.is_format_supported(format_type):
+                        # Use new FormatterRegistry
+                        formatter = FormatterRegistry.get_formatter(format_type)
+                        table_output = formatter.format(structure_result.elements)
+                    else:
+                        # Fallback to legacy TableFormatter for backward compatibility
+                        formatter = TableFormatter(format_type)
+                        table_output = formatter.format_structure(structure_dict)
+                except Exception as e:
+                    # If FormatterRegistry fails, fallback to legacy TableFormatter
+                    logger.warning(f"FormatterRegistry failed, using legacy formatter: {e}")
+                    formatter = TableFormatter(format_type)
+                    table_output = formatter.format_structure(structure_dict)
 
                 # Ensure output format matches CLI exactly
                 # Fix line ending differences: normalize to Unix-style LF (\n)

tree_sitter_analyzer/models.py

@@ -150,6 +150,59 @@ class Package(CodeElement):
     element_type: str = "package"
 
 
+# ========================================
+# HTML/CSS-Specific Models
+# ========================================
+
+
+@dataclass(frozen=False)
+class MarkupElement(CodeElement):
+    """
+    HTML要素を表現するデータモデル。
+    CodeElementを継承し、マークアップ固有の属性を追加する。
+    """
+    
+    tag_name: str = ""
+    attributes: dict[str, str] = field(default_factory=dict)
+    parent: "MarkupElement | None" = None
+    children: list["MarkupElement"] = field(default_factory=list)
+    element_class: str = ""  # 分類システムのカテゴリ (例: 'structure', 'media', 'form')
+    element_type: str = "html_element"
+    
+    def to_summary_item(self) -> dict[str, Any]:
+        """Return dictionary for summary item"""
+        return {
+            "name": self.name,
+            "tag_name": self.tag_name,
+            "type": "html_element",
+            "element_class": self.element_class,
+            "lines": {"start": self.start_line, "end": self.end_line},
+        }
+
+
+@dataclass(frozen=False)
+class StyleElement(CodeElement):
+    """
+    CSSルールを表現するデータモデル。
+    CodeElementを継承する。
+    """
+    
+    selector: str = ""
+    properties: dict[str, str] = field(default_factory=dict)
+    element_class: str = ""  # 分類システムのカテゴリ (例: 'layout', 'typography', 'color')
+    element_type: str = "css_rule"
+    
+    def to_summary_item(self) -> dict[str, Any]:
+        """Return dictionary for summary item"""
+        return {
+            "name": self.name,
+            "selector": self.selector,
+            "type": "css_rule",
+            "element_class": self.element_class,
+            "lines": {"start": self.start_line, "end": self.end_line},
+        }
+
+
 # ========================================
 # Java-Specific Models
 # ========================================

tree_sitter_analyzer/output_manager.py

@@ -28,7 +28,7 @@ class OutputManager:
         """Output warning message"""
         if not self.quiet:
             print(f"WARNING: {message}", file=sys.stderr)
-        log_warning(message)
+            log_warning(message)
 
     def error(self, message: str) -> None:
         """Output error message"""

tree_sitter_analyzer/plugins/base.py

@@ -178,6 +178,56 @@ class LanguagePlugin(ABC):
         """
         pass
 
+    def get_supported_element_types(self) -> list[str]:
+        """
+        Return list of supported CodeElement types.
+        
+        Returns:
+            List of element types (e.g., ["function", "class", "variable"])
+        """
+        return ["function", "class", "variable", "import"]
+
+    def get_queries(self) -> dict[str, str]:
+        """
+        Return language-specific tree-sitter queries.
+        
+        Returns:
+            Dictionary mapping query names to query strings
+        """
+        return {}
+
+    def execute_query_strategy(self, query_key: str | None, language: str) -> str | None:
+        """
+        Execute query strategy for this language plugin.
+        
+        Args:
+            query_key: Query key to execute
+            language: Programming language
+            
+        Returns:
+            Query string or None if not supported
+        """
+        queries = self.get_queries()
+        return queries.get(query_key) if query_key else None
+
+    def get_formatter_map(self) -> dict[str, str]:
+        """
+        Return mapping of format types to formatter class names.
+        
+        Returns:
+            Dictionary mapping format names to formatter classes
+        """
+        return {}
+
+    def get_element_categories(self) -> dict[str, list[str]]:
+        """
+        Return element categories for HTML/CSS languages.
+        
+        Returns:
+            Dictionary mapping category names to element lists
+        """
+        return {}
+
     def is_applicable(self, file_path: str) -> bool:
         """
         Check if this plugin is applicable for the given file.

tree_sitter_analyzer/plugins/manager.py

@@ -64,7 +64,11 @@ class PluginManager:
                 log_debug(f"Skipping duplicate plugin for language: {language}")
 
         final_plugins = list(unique_plugins.values())
-        log_info(f"Successfully loaded {len(final_plugins)} plugins")
+        # Only log if not in CLI mode (check if we're in quiet mode)
+        import os
+        log_level = os.environ.get("LOG_LEVEL", "WARNING")
+        if log_level != "ERROR":
+            log_info(f"Successfully loaded {len(final_plugins)} plugins")
         return final_plugins
 
     def _load_from_entry_points(self) -> list[LanguagePlugin]: