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

tree_sitter_analyzer/mcp/tools/read_partial_tool.py

@@ -116,34 +116,70 @@ class ReadPartialTool(BaseMCPTool):
         suppress_output = arguments.get("suppress_output", False)
         output_format = arguments.get("format", "text")
 
+        # Security validation BEFORE path resolution to catch symlinks
+        is_valid, error_msg = self.security_validator.validate_file_path(file_path, self.project_root)
+        if not is_valid:
+            logger.warning(
+                f"Security validation failed for file path: {file_path} - {error_msg}"
+            )
+            return {
+                "success": False,
+                "error": f"Security validation failed: {error_msg}",
+                "file_path": file_path
+            }
+
         # Resolve file path using common path resolver
         resolved_path = self.path_resolver.resolve(file_path)
 
-        # Security validation (validate resolved absolute path when possible)
-        is_valid, error_msg = self.security_validator.validate_file_path(resolved_path)
+        # Additional security validation on resolved path
+        is_valid, error_msg = self.security_validator.validate_file_path(resolved_path, self.project_root)
         if not is_valid:
             logger.warning(
-                f"Security validation failed for file path: {file_path} - {error_msg}"
+                f"Security validation failed for resolved path: {resolved_path} - {error_msg}"
             )
-            raise ValueError(f"Invalid file path: {error_msg}")
+            return {
+                "success": False,
+                "error": f"Security validation failed for resolved path: {error_msg}",
+                "file_path": file_path
+            }
 
         # Validate file exists
         if not Path(resolved_path).exists():
-            raise ValueError("Invalid file path: file does not exist")
+            return {
+                "success": False,
+                "error": "Invalid file path: file does not exist",
+                "file_path": file_path
+            }
 
         # Validate line numbers
         if start_line < 1:
-            raise ValueError("start_line must be >= 1")
+            return {
+                "success": False,
+                "error": "start_line must be >= 1",
+                "file_path": file_path
+            }
 
         if end_line is not None and end_line < start_line:
-            raise ValueError("end_line must be >= start_line")
+            return {
+                "success": False,
+                "error": "end_line must be >= start_line",
+                "file_path": file_path
+            }
 
         # Validate column numbers
         if start_column is not None and start_column < 0:
-            raise ValueError("start_column must be >= 0")
+            return {
+                "success": False,
+                "error": "start_column must be >= 0",
+                "file_path": file_path
+            }
 
         if end_column is not None and end_column < 0:
-            raise ValueError("end_column must be >= 0")
+            return {
+                "success": False,
+                "error": "end_column must be >= 0",
+                "file_path": file_path
+            }
 
         logger.info(
             f"Reading partial content from {file_path}: lines {start_line}-{end_line or 'end'}"
@@ -160,9 +196,19 @@ class ReadPartialTool(BaseMCPTool):
                 )
 
                 if content is None:
-                    raise RuntimeError(
-                        f"Failed to read partial content from file: {file_path}"
-                    )
+                    return {
+                        "success": False,
+                        "error": f"Failed to read partial content from file: {file_path}",
+                        "file_path": file_path
+                    }
+                
+                # Check if content is empty or invalid range
+                if not content or content.strip() == "":
+                    return {
+                        "success": False,
+                        "error": f"Invalid line range or empty content: start_line={start_line}, end_line={end_line}",
+                        "file_path": file_path
+                    }
 
                 # Build result structure compatible with CLI --partial-read format
                 result_data = {
@@ -198,8 +244,14 @@ class ReadPartialTool(BaseMCPTool):
                     f"Successfully read {len(content)} characters from {file_path}"
                 )
 
+                # Calculate lines extracted
+                lines_extracted = len(content.split('\n')) if content else 0
+                if end_line:
+                    lines_extracted = end_line - start_line + 1
+
                 # Build result - conditionally include partial_content_result based on suppress_output
                 result = {
+                    "success": True,
                     "file_path": file_path,
                     "range": {
                         "start_line": start_line,
@@ -208,11 +260,39 @@ class ReadPartialTool(BaseMCPTool):
                         "end_column": end_column,
                     },
                     "content_length": len(content),
+                    "lines_extracted": lines_extracted,
                 }
 
                 # Only include partial_content_result if not suppressed or no output file specified
                 if not suppress_output or not output_file:
-                    result["partial_content_result"] = cli_output
+                    if output_format == "json":
+                        # For JSON format, return structured data with exact line count
+                        lines = content.split('\n') if content else []
+                        
+                        # If end_line is specified, ensure we return exactly the requested number of lines
+                        if end_line and len(lines) > lines_extracted:
+                            lines = lines[:lines_extracted]
+                        elif end_line and len(lines) < lines_extracted:
+                            # Pad with empty lines if needed (shouldn't normally happen)
+                            lines.extend([''] * (lines_extracted - len(lines)))
+                        
+                        result["partial_content_result"] = {
+                            "lines": lines,
+                            "metadata": {
+                                "file_path": file_path,
+                                "range": {
+                                    "start_line": start_line,
+                                    "end_line": end_line,
+                                    "start_column": start_column,
+                                    "end_column": end_column,
+                                },
+                                "content_length": len(content),
+                                "lines_count": len(lines)
+                            }
+                        }
+                    else:
+                        # For text/raw format, return CLI-compatible string
+                        result["partial_content_result"] = cli_output
 
                 # Handle file output if requested
                 if output_file:
@@ -254,7 +334,11 @@ class ReadPartialTool(BaseMCPTool):
 
         except Exception as e:
             logger.error(f"Error reading partial content from {file_path}: {e}")
-            raise
+            return {
+                "success": False,
+                "error": str(e),
+                "file_path": file_path
+            }
 
     def _read_file_partial(
         self,

tree_sitter_analyzer/mcp/tools/search_content_tool.py

@@ -289,6 +289,15 @@ class SearchContentTool(BaseMCPTool):
 
     @handle_mcp_errors("search_content")
     async def execute(self, arguments: dict[str, Any]) -> dict[str, Any] | int:
+        # Check if rg command is available
+        if not fd_rg_utils.check_external_command("rg"):
+            return {
+                "success": False,
+                "error": "rg (ripgrep) command not found. Please install ripgrep (https://github.com/BurntSushi/ripgrep) to use this tool.",
+                "count": 0,
+                "results": []
+            }
+        
         self.validate_arguments(arguments)
 
         roots = arguments.get("roots")

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:
@@ -242,6 +246,7 @@ class TableFormatTool(BaseMCPTool):
             package_info = {"name": packages[0].name}
 
         return {
+            "success": True,
             "file_path": result.file_path,
             "language": result.language,
             "package": package_info,
@@ -378,18 +383,26 @@ class TableFormatTool(BaseMCPTool):
             output_file = args.get("output_file")
             suppress_output = args.get("suppress_output", False)
 
+            # Security validation BEFORE path resolution to catch symlinks
+            is_valid, error_msg = self.security_validator.validate_file_path(file_path)
+            if not is_valid:
+                self.logger.warning(
+                    f"Security validation failed for file path: {file_path} - {error_msg}"
+                )
+                raise ValueError(f"Invalid file path: {error_msg}")
+
             # Resolve file path using common path resolver
             resolved_path = self.path_resolver.resolve(file_path)
 
-            # Security validation
+            # Additional security validation on resolved path
             is_valid, error_msg = self.security_validator.validate_file_path(
                 resolved_path
             )
             if not is_valid:
                 self.logger.warning(
-                    f"Security validation failed for file path: {file_path} - {error_msg}"
+                    f"Security validation failed for resolved path: {resolved_path} - {error_msg}"
                 )
-                raise ValueError(f"Invalid file path: {error_msg}")
+                raise ValueError(f"Invalid resolved path: {error_msg}")
 
             # Sanitize format_type input
             if format_type:
@@ -439,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)
@@ -470,6 +493,7 @@ class TableFormatTool(BaseMCPTool):
 
                 # Build result - conditionally include table_output based on suppress_output
                 result = {
+                    "success": True,
                     "format_type": format_type,
                     "file_path": file_path,
                     "language": language,

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]: