tree-sitter-analyzer 1.9.17.1__py3-none-any.whl

tree_sitter_analyzer/mcp/utils/file_output_factory.py

@@ -0,0 +1,217 @@
+#!/usr/bin/env python3
+"""
+File Output Manager Factory
+
+This module provides a Managed Singleton Factory Pattern for FileOutputManager
+to prevent duplicate initialization and ensure consistent instance management
+across MCP tools.
+"""
+
+import threading
+from pathlib import Path
+
+from ...utils import setup_logger
+from .file_output_manager import FileOutputManager
+
+# Set up logging
+logger = setup_logger(__name__)
+
+
+class FileOutputManagerFactory:
+    """
+    Factory class that manages FileOutputManager instances using a Managed Singleton
+    pattern. Each project root gets its own singleton instance, ensuring consistency
+    across MCP tools while preventing duplicate initialization.
+    """
+
+    # Class-level lock for thread safety
+    _lock = threading.RLock()
+
+    # Dictionary to store instances by project root
+    _instances: dict[str, FileOutputManager] = {}
+
+    @classmethod
+    def get_instance(cls, project_root: str | None = None) -> FileOutputManager:
+        """
+        Get or create a FileOutputManager instance for the specified project root.
+
+        This method implements the Managed Singleton pattern - one instance per
+        project root, ensuring consistency across all MCP tools.
+
+        Args:
+            project_root: Project root directory. If None, uses current working directory.
+
+        Returns:
+            FileOutputManager instance for the specified project root
+        """
+        # Normalize project root path
+        normalized_root = cls._normalize_project_root(project_root)
+
+        # Double-checked locking pattern for thread safety
+        if normalized_root not in cls._instances:
+            with cls._lock:
+                if normalized_root not in cls._instances:
+                    logger.info(
+                        f"Creating new FileOutputManager instance for project root: {normalized_root}"
+                    )
+                    cls._instances[normalized_root] = FileOutputManager(normalized_root)
+                else:
+                    logger.debug(
+                        f"Using existing FileOutputManager instance for project root: {normalized_root}"
+                    )
+        else:
+            logger.debug(
+                f"Using existing FileOutputManager instance for project root: {normalized_root}"
+            )
+
+        return cls._instances[normalized_root]
+
+    @classmethod
+    def _normalize_project_root(cls, project_root: str | None) -> str:
+        """
+        Normalize project root path for consistent key generation.
+
+        Args:
+            project_root: Raw project root path
+
+        Returns:
+            Normalized absolute path string
+        """
+        if project_root is None:
+            return str(Path.cwd().resolve())
+
+        try:
+            return str(Path(project_root).resolve())
+        except Exception as e:
+            logger.warning(f"Failed to resolve project root path '{project_root}': {e}")
+            return str(Path.cwd().resolve())
+
+    @classmethod
+    def clear_instance(cls, project_root: str | None = None) -> bool:
+        """
+        Clear a specific FileOutputManager instance from the factory.
+
+        This method is primarily for testing purposes or when you need to
+        force recreation of an instance.
+
+        Args:
+            project_root: Project root directory. If None, uses current working directory.
+
+        Returns:
+            True if instance was cleared, False if it didn't exist
+        """
+        normalized_root = cls._normalize_project_root(project_root)
+
+        with cls._lock:
+            if normalized_root in cls._instances:
+                logger.info(
+                    f"Clearing FileOutputManager instance for project root: {normalized_root}"
+                )
+                del cls._instances[normalized_root]
+                return True
+            else:
+                logger.debug(
+                    f"No FileOutputManager instance found for project root: {normalized_root}"
+                )
+                return False
+
+    @classmethod
+    def clear_all_instances(cls) -> int:
+        """
+        Clear all FileOutputManager instances from the factory.
+
+        This method is primarily for testing purposes or cleanup.
+
+        Returns:
+            Number of instances that were cleared
+        """
+        with cls._lock:
+            count = len(cls._instances)
+            if count > 0:
+                logger.info(f"Clearing all {count} FileOutputManager instances")
+                cls._instances.clear()
+            else:
+                logger.debug("No FileOutputManager instances to clear")
+            return count
+
+    @classmethod
+    def get_instance_count(cls) -> int:
+        """
+        Get the current number of managed instances.
+
+        Returns:
+            Number of currently managed FileOutputManager instances
+        """
+        with cls._lock:
+            return len(cls._instances)
+
+    @classmethod
+    def get_managed_project_roots(cls) -> list[str]:
+        """
+        Get list of all currently managed project roots.
+
+        Returns:
+            List of project root paths that have managed instances
+        """
+        with cls._lock:
+            return list(cls._instances.keys())
+
+    @classmethod
+    def update_project_root(cls, old_root: str | None, new_root: str) -> bool:
+        """
+        Update the project root for an existing instance.
+
+        This method moves an existing instance from one project root key to another,
+        and updates the instance's internal project root.
+
+        Args:
+            old_root: Current project root (None for current working directory)
+            new_root: New project root
+
+        Returns:
+            True if update was successful, False if old instance didn't exist
+        """
+        old_normalized = cls._normalize_project_root(old_root)
+        new_normalized = cls._normalize_project_root(new_root)
+
+        if old_normalized == new_normalized:
+            logger.debug(f"Project root update not needed: {old_normalized}")
+            return True
+
+        with cls._lock:
+            if old_normalized in cls._instances:
+                instance = cls._instances[old_normalized]
+
+                # Update the instance's internal project root
+                instance.set_project_root(new_root)
+
+                # Move to new key
+                cls._instances[new_normalized] = instance
+                del cls._instances[old_normalized]
+
+                logger.info(
+                    f"Updated FileOutputManager project root: {old_normalized} -> {new_normalized}"
+                )
+                return True
+            else:
+                logger.warning(
+                    f"No FileOutputManager instance found for old project root: {old_normalized}"
+                )
+                return False
+
+
+# Convenience function for backward compatibility and ease of use
+def get_file_output_manager(project_root: str | None = None) -> FileOutputManager:
+    """
+    Convenience function to get a FileOutputManager instance.
+
+    This function provides a simple interface to the factory while maintaining
+    the singleton behavior per project root.
+
+    Args:
+        project_root: Project root directory. If None, uses current working directory.
+
+    Returns:
+        FileOutputManager instance for the specified project root
+    """
+    return FileOutputManagerFactory.get_instance(project_root)

tree_sitter_analyzer/mcp/utils/file_output_manager.py

@@ -0,0 +1,322 @@
+#!/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.
+
+Enhanced with Managed Singleton Factory Pattern support for consistent
+instance management across MCP tools.
+"""
+
+import json
+import os
+from pathlib import Path
+
+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.
+
+    Enhanced with factory method support for consistent instance management
+    across MCP tools while maintaining full backward compatibility.
+    """
+
+    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: str | None = None
+        self._initialize_output_path()
+
+    @classmethod
+    def get_managed_instance(
+        cls, project_root: str | None = None
+    ) -> "FileOutputManager":
+        """
+        Get a managed FileOutputManager instance using the factory pattern.
+
+        This method provides access to the Managed Singleton Factory Pattern,
+        ensuring one instance per project root for optimal resource usage
+        and consistency across MCP tools.
+
+        Args:
+            project_root: Project root directory. If None, uses current working directory.
+
+        Returns:
+            FileOutputManager instance managed by the factory
+
+        Note:
+            This method requires the factory module to be available. If the factory
+            is not available, it falls back to creating a new instance directly.
+        """
+        try:
+            # Import here to avoid circular imports
+            from .file_output_factory import FileOutputManagerFactory
+
+            return FileOutputManagerFactory.get_instance(project_root)
+        except ImportError as e:
+            logger.warning(
+                f"Factory not available, creating new instance directly: {e}"
+            )
+            return cls(project_root)
+
+    @classmethod
+    def create_instance(cls, project_root: str | None = None) -> "FileOutputManager":
+        """
+        Create a new FileOutputManager instance directly (bypass factory).
+
+        This method creates a new instance without using the factory pattern.
+        Use this when you specifically need a separate instance that won't
+        be managed by the factory.
+
+        Args:
+            project_root: Project root directory. If None, uses current working directory.
+
+        Returns:
+            New FileOutputManager instance
+        """
+        return cls(project_root)
+
+    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
+            if base_name is None:
+                raise ValueError(
+                    "base_name cannot be None when filename is not provided"
+                )
+            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:
+            from ...encoding_utils import write_file_safe
+
+            write_file_safe(output_file, 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()