tree-sitter-analyzer 1.4.1__py3-none-any.whl → 1.6.0__py3-none-any.whl

tree_sitter_analyzer/mcp/server.py

@@ -419,14 +419,28 @@ class TreeSitterAnalyzerMCPServer:
                 ),
                 Tool(
                     name="analyze_code_structure",
-                    description="Analyze code structure and generate tables with line positions",
+                    description="Analyze code structure and generate tables with line positions, optionally save to file",
                     inputSchema={
                         "type": "object",
                         "properties": {
                             "file_path": {
                                 "type": "string",
                                 "description": "Path to the code file (relative to project root)",
-                            }
+                            },
+                            "format_type": {
+                                "type": "string",
+                                "description": "Table format type",
+                                "enum": ["full", "compact", "csv", "json"],
+                                "default": "full",
+                            },
+                            "language": {
+                                "type": "string",
+                                "description": "Programming language (optional, auto-detected if not specified)",
+                            },
+                            "output_file": {
+                                "type": "string",
+                                "description": "Optional filename to save output to file (extension auto-detected based on content)",
+                            },
                         },
                         "required": ["file_path"],
                         "additionalProperties": False,
@@ -522,6 +536,7 @@ class TreeSitterAnalyzerMCPServer:
                         "file_path": arguments["file_path"],
                         "format_type": arguments.get("format_type", "full"),
                         "language": arguments.get("language"),
+                        "output_file": arguments.get("output_file"),
                     }
                     result = await self.table_format_tool.execute(full_args)
 

tree_sitter_analyzer/mcp/tools/table_format_tool.py

@@ -22,6 +22,7 @@ from ...language_detector import detect_language_from_file
 from ...table_formatter import TableFormatter
 from ...utils import setup_logger
 from ..utils import get_performance_monitor
+from ..utils.file_output_manager import FileOutputManager
 from .base_tool import BaseMCPTool
 
 # Set up logging
@@ -40,6 +41,7 @@ class TableFormatTool(BaseMCPTool):
         """Initialize the table format tool."""
         super().__init__(project_root)
         self.analysis_engine = get_analysis_engine(project_root)
+        self.file_output_manager = FileOutputManager(project_root)
         self.logger = logger
 
     def set_project_path(self, project_path: str) -> None:
@@ -51,6 +53,7 @@ class TableFormatTool(BaseMCPTool):
         """
         super().set_project_path(project_path)
         self.analysis_engine = get_analysis_engine(project_path)
+        self.file_output_manager.set_project_root(project_path)
         logger.info(f"TableFormatTool project path updated to: {project_path}")
 
     def get_tool_schema(self) -> dict[str, Any]:
@@ -70,13 +73,17 @@ class TableFormatTool(BaseMCPTool):
                 "format_type": {
                     "type": "string",
                     "description": "Table format type",
-                    "enum": ["full", "compact", "csv"],
+                    "enum": ["full", "compact", "csv", "json"],
                     "default": "full",
                 },
                 "language": {
                     "type": "string",
                     "description": "Programming language (optional, auto-detected if not specified)",
                 },
+                "output_file": {
+                    "type": "string",
+                    "description": "Optional filename to save output to file (extension auto-detected based on content)",
+                },
             },
             "required": ["file_path"],
             "additionalProperties": False,
@@ -111,8 +118,8 @@ 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"]:
-                raise ValueError("format_type must be one of: full, compact, csv")
+            if format_type not in ["full", "compact", "csv", "json"]:
+                raise ValueError("format_type must be one of: full, compact, csv, json")
 
         # Validate language if provided
         if "language" in arguments:
@@ -120,6 +127,14 @@ class TableFormatTool(BaseMCPTool):
             if not isinstance(language, str):
                 raise ValueError("language must be a string")
 
+        # Validate output_file if provided
+        if "output_file" in arguments:
+            output_file = arguments["output_file"]
+            if not isinstance(output_file, str):
+                raise ValueError("output_file must be a string")
+            if not output_file.strip():
+                raise ValueError("output_file cannot be empty")
+
         return True
 
     def _convert_parameters(self, parameters: Any) -> list[dict[str, str]]:
@@ -286,6 +301,59 @@ class TableFormatTool(BaseMCPTool):
             },
         }
 
+    def _write_output_file(
+        self, output_file: str, content: str, format_type: str
+    ) -> str:
+        """
+        Write output content to file with automatic extension detection.
+
+        Args:
+            output_file: Base filename for output
+            content: Content to write
+            format_type: Format type (full, compact, csv, json)
+
+        Returns:
+            Full path of the written file
+        """
+        from pathlib import Path
+
+        # Determine file extension based on format type
+        extension_map = {
+            "full": ".md",
+            "compact": ".md",
+            "csv": ".csv",
+            "json": ".json",
+        }
+
+        # Get the appropriate extension
+        extension = extension_map.get(format_type, ".txt")
+
+        # Add extension if not already present
+        if not output_file.endswith(extension):
+            output_file = output_file + extension
+
+        # Resolve output path relative to project root
+        output_path = self.path_resolver.resolve(output_file)
+
+        # Security validation for output path
+        is_valid, error_msg = self.security_validator.validate_file_path(output_path)
+        if not is_valid:
+            raise ValueError(f"Invalid output file path: {error_msg}")
+
+        # Ensure output directory exists
+        output_dir = Path(output_path).parent
+        output_dir.mkdir(parents=True, exist_ok=True)
+
+        # Write content to file
+        try:
+            with open(output_path, "w", encoding="utf-8") as f:
+                f.write(content)
+            self.logger.info(f"Output written to file: {output_path}")
+            return output_path
+        except Exception as e:
+            self.logger.error(f"Failed to write output file {output_path}: {e}")
+            raise RuntimeError(f"Failed to write output file: {e}") from e
+
     async def execute(self, args: dict[str, Any]) -> dict[str, Any]:
         """Execute code structure analysis tool."""
         try:
@@ -296,6 +364,7 @@ class TableFormatTool(BaseMCPTool):
             file_path = args["file_path"]
             format_type = args.get("format_type", "full")
             language = args.get("language")
+            output_file = args.get("output_file")
 
             # Resolve file path using common path resolver
             resolved_path = self.path_resolver.resolve(file_path)
@@ -322,6 +391,12 @@ class TableFormatTool(BaseMCPTool):
                     language, max_length=50
                 )
 
+            # Sanitize output_file input
+            if output_file:
+                output_file = self.security_validator.sanitize_input(
+                    output_file, max_length=255
+                )
+
             # Validate file exists
             if not Path(resolved_path).exists():
                 # Tests expect FileNotFoundError here
@@ -377,7 +452,7 @@ class TableFormatTool(BaseMCPTool):
                         "total_lines": stats.get("total_lines", 0),
                     }
 
-                return {
+                result = {
                     "table_output": table_output,
                     "format_type": format_type,
                     "file_path": file_path,
@@ -385,6 +460,33 @@ class TableFormatTool(BaseMCPTool):
                     "metadata": metadata,
                 }
 
+                # Handle file output if requested
+                if output_file:
+                    try:
+                        # Generate base name from original file path if not provided
+                        if not output_file or output_file.strip() == "":
+                            base_name = Path(file_path).stem + "_analysis"
+                        else:
+                            base_name = output_file
+
+                        # Save to file with automatic extension detection
+                        saved_file_path = self.file_output_manager.save_to_file(
+                            content=table_output,
+                            base_name=base_name
+                        )
+                        
+                        result["output_file_path"] = saved_file_path
+                        result["file_saved"] = True
+                        
+                        self.logger.info(f"Analysis output saved to: {saved_file_path}")
+                        
+                    except Exception as e:
+                        self.logger.error(f"Failed to save output to file: {e}")
+                        result["file_save_error"] = str(e)
+                        result["file_saved"] = False
+
+                return result
+
         except Exception as e:
             self.logger.error(f"Error in code structure analysis tool: {e}")
             raise

tree_sitter_analyzer/mcp/utils/file_output_manager.py

@@ -0,0 +1,257 @@
+#!/usr/bin/env python3
+"""
+File Output Manager for MCP Tools
+
+This module provides functionality to save analysis results to files with
+appropriate extensions based on content type, with security validation.
+"""
+
+import json
+import os
+from pathlib import Path
+from typing import Any
+
+from ...utils import setup_logger
+
+# Set up logging
+logger = setup_logger(__name__)
+
+
+class FileOutputManager:
+    """
+    Manages file output for analysis results with automatic extension detection
+    and security validation.
+    """
+
+    def __init__(self, project_root: str | None = None):
+        """
+        Initialize the file output manager.
+
+        Args:
+            project_root: Optional project root directory for fallback output path
+        """
+        self.project_root = project_root
+        self._output_path = None
+        self._initialize_output_path()
+
+    def _initialize_output_path(self) -> None:
+        """Initialize the output path from environment variables or project root."""
+        # Priority 1: Environment variable TREE_SITTER_OUTPUT_PATH
+        env_output_path = os.environ.get("TREE_SITTER_OUTPUT_PATH")
+        if env_output_path and Path(env_output_path).exists():
+            self._output_path = env_output_path
+            logger.info(f"Using output path from environment: {self._output_path}")
+            return
+
+        # Priority 2: Project root if available
+        if self.project_root and Path(self.project_root).exists():
+            self._output_path = self.project_root
+            logger.info(f"Using project root as output path: {self._output_path}")
+            return
+
+        # Priority 3: Current working directory as fallback
+        self._output_path = str(Path.cwd())
+        logger.warning(f"Using current directory as output path: {self._output_path}")
+
+    def get_output_path(self) -> str:
+        """
+        Get the current output path.
+
+        Returns:
+            Current output path
+        """
+        return self._output_path or str(Path.cwd())
+
+    def set_output_path(self, output_path: str) -> None:
+        """
+        Set a custom output path.
+
+        Args:
+            output_path: New output path
+
+        Raises:
+            ValueError: If the path doesn't exist or is not a directory
+        """
+        path_obj = Path(output_path)
+        if not path_obj.exists():
+            raise ValueError(f"Output path does not exist: {output_path}")
+        if not path_obj.is_dir():
+            raise ValueError(f"Output path is not a directory: {output_path}")
+
+        self._output_path = str(path_obj.resolve())
+        logger.info(f"Output path updated to: {self._output_path}")
+
+    def detect_content_type(self, content: str) -> str:
+        """
+        Detect content type based on content structure.
+
+        Args:
+            content: Content to analyze
+
+        Returns:
+            Detected content type ('json', 'csv', 'markdown', or 'text')
+        """
+        content_stripped = content.strip()
+
+        # Check for JSON
+        if content_stripped.startswith(("{", "[")):
+            try:
+                json.loads(content_stripped)
+                return "json"
+            except (json.JSONDecodeError, ValueError):
+                pass
+
+        # Check for CSV (simple heuristic)
+        lines = content_stripped.split("\n")
+        if len(lines) >= 2:
+            # Check if first few lines have consistent comma separation
+            first_line_commas = lines[0].count(",")
+            if first_line_commas > 0:
+                # Check if at least 2 more lines have similar comma counts
+                similar_comma_lines = sum(
+                    1 for line in lines[1:4] if abs(line.count(",") - first_line_commas) <= 1
+                )
+                if similar_comma_lines >= 1:
+                    return "csv"
+
+        # Check for Markdown (simple heuristic)
+        markdown_indicators = ["#", "##", "###", "|", "```", "*", "-", "+"]
+        if any(content_stripped.startswith(indicator) for indicator in markdown_indicators):
+            return "markdown"
+
+        # Check for table format (pipe-separated)
+        if "|" in content and "\n" in content:
+            lines = content_stripped.split("\n")
+            pipe_lines = sum(1 for line in lines if "|" in line)
+            if pipe_lines >= 2:  # At least header and one data row
+                return "markdown"
+
+        # Default to text
+        return "text"
+
+    def get_file_extension(self, content_type: str) -> str:
+        """
+        Get file extension for content type.
+
+        Args:
+            content_type: Content type ('json', 'csv', 'markdown', 'text')
+
+        Returns:
+            File extension including the dot
+        """
+        extension_map = {
+            "json": ".json",
+            "csv": ".csv",
+            "markdown": ".md",
+            "text": ".txt"
+        }
+        return extension_map.get(content_type, ".txt")
+
+    def generate_output_filename(self, base_name: str, content: str) -> str:
+        """
+        Generate output filename with appropriate extension.
+
+        Args:
+            base_name: Base filename (without extension)
+            content: Content to analyze for type detection
+
+        Returns:
+            Complete filename with extension
+        """
+        content_type = self.detect_content_type(content)
+        extension = self.get_file_extension(content_type)
+        
+        # Remove existing extension if present
+        base_name_clean = Path(base_name).stem
+        
+        return f"{base_name_clean}{extension}"
+
+    def save_to_file(self, content: str, filename: str | None = None, base_name: str | None = None) -> str:
+        """
+        Save content to file with automatic extension detection.
+
+        Args:
+            content: Content to save
+            filename: Optional specific filename (overrides base_name)
+            base_name: Optional base name for auto-generated filename
+
+        Returns:
+            Path to the saved file
+
+        Raises:
+            ValueError: If neither filename nor base_name is provided
+            OSError: If file cannot be written
+        """
+        if not filename and not base_name:
+            raise ValueError("Either filename or base_name must be provided")
+
+        output_path = Path(self.get_output_path())
+
+        if filename:
+            # Use provided filename as-is
+            output_file = output_path / filename
+        else:
+            # Generate filename with appropriate extension
+            generated_filename = self.generate_output_filename(base_name, content)
+            output_file = output_path / generated_filename
+
+        # Ensure output directory exists
+        output_file.parent.mkdir(parents=True, exist_ok=True)
+
+        # Write content to file
+        try:
+            with open(output_file, "w", encoding="utf-8") as f:
+                f.write(content)
+            
+            logger.info(f"Content saved to file: {output_file}")
+            return str(output_file)
+
+        except OSError as e:
+            logger.error(f"Failed to save content to file {output_file}: {e}")
+            raise
+
+    def validate_output_path(self, path: str) -> tuple[bool, str | None]:
+        """
+        Validate if a path is safe for output.
+
+        Args:
+            path: Path to validate
+
+        Returns:
+            Tuple of (is_valid, error_message)
+        """
+        try:
+            path_obj = Path(path).resolve()
+            
+            # Check if parent directory exists or can be created
+            parent_dir = path_obj.parent
+            if not parent_dir.exists():
+                try:
+                    parent_dir.mkdir(parents=True, exist_ok=True)
+                except OSError as e:
+                    return False, f"Cannot create parent directory: {e}"
+
+            # Check if we can write to the directory
+            if not os.access(parent_dir, os.W_OK):
+                return False, f"No write permission for directory: {parent_dir}"
+
+            # Check if file already exists and is writable
+            if path_obj.exists() and not os.access(path_obj, os.W_OK):
+                return False, f"No write permission for existing file: {path_obj}"
+
+            return True, None
+
+        except Exception as e:
+            return False, f"Path validation error: {str(e)}"
+
+    def set_project_root(self, project_root: str) -> None:
+        """
+        Update the project root and reinitialize output path if needed.
+
+        Args:
+            project_root: New project root directory
+        """
+        self.project_root = project_root
+        # Only reinitialize if we don't have an explicit output path from environment
+        if not os.environ.get("TREE_SITTER_OUTPUT_PATH"):
+            self._initialize_output_path()

tree_sitter_analyzer/mcp/utils/path_resolver.py

@@ -52,7 +52,7 @@ def _normalize_path_cross_platform(path_str: str) -> str:
             from ctypes import wintypes
 
             # GetLongPathNameW function
-            _GetLongPathNameW = ctypes.windll.kernel32.GetLongPathNameW
+            _GetLongPathNameW = ctypes.windll.kernel32.GetLongPathNameW  # type: ignore[attr-defined]
             _GetLongPathNameW.argtypes = [
                 wintypes.LPCWSTR,
                 wintypes.LPWSTR,

tree_sitter_analyzer/models.py

@@ -67,6 +67,15 @@ class Function(CodeElement):
     complexity_score: int = 1
     is_abstract: bool = False
     is_final: bool = False
+    # JavaScript-specific fields
+    is_generator: bool = False
+    is_arrow: bool = False
+    is_method: bool = False
+    framework_type: str | None = None
+    # Python-specific fields
+    is_property: bool = False
+    is_classmethod: bool = False
+    is_staticmethod: bool = False
 
 
 @dataclass(frozen=False)
@@ -90,6 +99,14 @@ class Class(CodeElement):
     implements_interfaces: list[str] = field(
         default_factory=list
     )  # Alias for interfaces
+    # JavaScript-specific fields
+    is_react_component: bool = False
+    framework_type: str | None = None
+    is_exported: bool = False
+    # Python-specific fields
+    is_dataclass: bool = False
+    is_abstract: bool = False
+    is_exception: bool = False
 
 
 @dataclass(frozen=False)