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

tree_sitter_analyzer/mcp/utils/file_output_factory.py

@@ -0,0 +1,204 @@
+#!/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 typing import Dict, Optional
+
+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: Optional[str] = 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: Optional[str]) -> 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: Optional[str] = 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: Optional[str], 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: Optional[str] = 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

@@ -4,12 +4,15 @@ 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 typing import Any
+from typing import Any, Optional
 
 from ...utils import setup_logger
 
@@ -21,9 +24,12 @@ 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):
+    def __init__(self, project_root: Optional[str] = None):
         """
         Initialize the file output manager.
 
@@ -33,6 +39,50 @@ class FileOutputManager:
         self.project_root = project_root
         self._output_path = None
         self._initialize_output_path()
+    
+    @classmethod
+    def get_managed_instance(cls, project_root: Optional[str] = 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: Optional[str] = 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."""

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