tree-sitter-analyzer 1.8.4__py3-none-any.whl → 1.9.1__py3-none-any.whl

tree_sitter_analyzer/mcp/utils/file_output_factory.py

@@ -9,7 +9,6 @@ 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
@@ -24,95 +23,105 @@ class FileOutputManagerFactory:
     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] = {}
-    
+    _instances: dict[str, FileOutputManager] = {}
+
     @classmethod
-    def get_instance(cls, project_root: Optional[str] = None) -> FileOutputManager:
+    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}")
+                    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}")
+                    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}")
-            
+            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:
+    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: Optional[str] = None) -> bool:
+    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}")
+                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}")
+                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
         """
@@ -124,81 +133,85 @@ class FileOutputManagerFactory:
             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:
+    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}")
+
+                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}")
+                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:
+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)
+    return FileOutputManagerFactory.get_instance(project_root)

tree_sitter_analyzer/mcp/utils/file_output_manager.py

@@ -12,7 +12,6 @@ instance management across MCP tools.
 import json
 import os
 from pathlib import Path
-from typing import Any, Optional
 
 from ...utils import setup_logger
 
@@ -24,12 +23,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: Optional[str] = None):
+    def __init__(self, project_root: str | None = None):
         """
         Initialize the file output manager.
 
@@ -39,22 +38,24 @@ 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':
+    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.
@@ -62,23 +63,26 @@ class FileOutputManager:
         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}")
+            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':
+    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
         """
@@ -159,14 +163,18 @@ class FileOutputManager:
             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
+                    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):
+        if any(
+            content_stripped.startswith(indicator) for indicator in markdown_indicators
+        ):
             return "markdown"
 
         # Check for table format (pipe-separated)
@@ -193,7 +201,7 @@ class FileOutputManager:
             "json": ".json",
             "csv": ".csv",
             "markdown": ".md",
-            "text": ".txt"
+            "text": ".txt",
         }
         return extension_map.get(content_type, ".txt")
 
@@ -210,13 +218,15 @@ class FileOutputManager:
         """
         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:
+    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.
 
@@ -252,7 +262,7 @@ class FileOutputManager:
         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)
 
@@ -272,7 +282,7 @@ class FileOutputManager:
         """
         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():
@@ -304,4 +314,4 @@ class FileOutputManager:
         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()
+            self._initialize_output_path()

tree_sitter_analyzer/mcp/utils/gitignore_detector.py

@@ -207,9 +207,11 @@ class GitignoreDetector:
         try:
             # Check if paths exist before resolving
             if not search_dir.exists() or not pattern_dir.exists():
-                logger.debug(f"Path does not exist: {search_dir} or {pattern_dir}, assuming affected")
+                logger.debug(
+                    f"Path does not exist: {search_dir} or {pattern_dir}, assuming affected"
+                )
                 return True
-                
+
             # If search_dir is the same as pattern_dir or is a subdirectory of pattern_dir
             search_resolved = search_dir.resolve()
             pattern_resolved = pattern_dir.resolve()
@@ -220,7 +222,9 @@ class GitignoreDetector:
             ).startswith(str(pattern_resolved) + os.sep)
         except (OSError, ValueError, RuntimeError):
             # If path resolution fails, assume it could be affected
-            logger.debug(f"Path resolution failed for {search_dir} or {pattern_dir}, assuming affected")
+            logger.debug(
+                f"Path resolution failed for {search_dir} or {pattern_dir}, assuming affected"
+            )
             return True
 
     def _directory_has_searchable_files(self, directory: Path) -> bool:
@@ -280,7 +284,7 @@ class GitignoreDetector:
             # Check if project path exists
             if not project_path.exists():
                 raise FileNotFoundError(f"Project root does not exist: {project_root}")
-                
+
             gitignore_files = self._find_gitignore_files(project_path)
             info["detected_gitignore_files"] = [str(f) for f in gitignore_files]
 

tree_sitter_analyzer/models.py

@@ -161,14 +161,14 @@ 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 {
@@ -186,12 +186,14 @@ class StyleElement(CodeElement):
     CSSルールを表現するデータモデル。
     CodeElementを継承する。
     """
-    
+
     selector: str = ""
     properties: dict[str, str] = field(default_factory=dict)
-    element_class: str = ""  # 分類システムのカテゴリ (例: 'layout', 'typography', 'color')
+    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 {

tree_sitter_analyzer/plugins/base.py

@@ -181,7 +181,7 @@ class LanguagePlugin(ABC):
     def get_supported_element_types(self) -> list[str]:
         """
         Return list of supported CodeElement types.
-        
+
         Returns:
             List of element types (e.g., ["function", "class", "variable"])
         """
@@ -190,20 +190,22 @@ class LanguagePlugin(ABC):
     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:
+    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
         """
@@ -213,7 +215,7 @@ class LanguagePlugin(ABC):
     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
         """
@@ -222,7 +224,7 @@ class LanguagePlugin(ABC):
     def get_element_categories(self) -> dict[str, list[str]]:
         """
         Return element categories for HTML/CSS languages.
-        
+
         Returns:
             Dictionary mapping category names to element lists
         """

tree_sitter_analyzer/plugins/manager.py

@@ -66,6 +66,7 @@ class PluginManager:
         final_plugins = list(unique_plugins.values())
         # 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")

tree_sitter_analyzer/queries/css.py

@@ -32,7 +32,6 @@ CSS_QUERIES: dict[str, str] = {
     (declaration
         value: (_) @property_value)
     """,
-    
     # --- Selectors ---
     "selector": """
     (selectors
@@ -74,7 +73,6 @@ CSS_QUERIES: dict[str, str] = {
     "adjacent_sibling_selector": """
     (adjacent_sibling_selector) @adjacent_sibling_selector
     """,
-    
     # --- At-Rules ---
     "at_rule": """
     (at_rule) @at_rule
@@ -103,7 +101,6 @@ CSS_QUERIES: dict[str, str] = {
     "font_face_statement": """
     (font_face_statement) @font_face_statement
     """,
-    
     # --- Media Queries ---
     "media_query": """
     (media_query) @media_query
@@ -114,7 +111,6 @@ CSS_QUERIES: dict[str, str] = {
     "media_type": """
     (media_type) @media_type
     """,
-    
     # --- Values ---
     "string_value": """
     (string_value) @string_value
@@ -181,7 +177,6 @@ CSS_QUERIES: dict[str, str] = {
         (#match? @func_name "^hsla$")
         arguments: (arguments) @hsla_args) @hsla
     """,
-    
     # --- Units ---
     "dimension": """
     (dimension) @dimension
@@ -193,7 +188,6 @@ CSS_QUERIES: dict[str, str] = {
     (dimension
         unit: (unit) @unit)
     """,
-    
     # --- Layout Properties ---
     "display": """
     (declaration
@@ -237,7 +231,6 @@ CSS_QUERIES: dict[str, str] = {
         (#match? @prop_name "^z-index$")
         value: (_) @z_index_value) @z_index
     """,
-    
     # --- Box Model Properties ---
     "width": """
     (declaration
@@ -275,7 +268,6 @@ CSS_QUERIES: dict[str, str] = {
         (#match? @prop_name "^box-sizing$")
         value: (_) @box_sizing_value) @box_sizing
     """,
-    
     # --- Typography Properties ---
     "font": """
     (declaration
@@ -313,7 +305,6 @@ CSS_QUERIES: dict[str, str] = {
         (#match? @prop_name "^word-spacing$")
         value: (_) @word_spacing_value) @word_spacing
     """,
-    
     # --- Background Properties ---
     "background": """
     (declaration
@@ -321,7 +312,6 @@ CSS_QUERIES: dict[str, str] = {
         (#match? @prop_name "^background")
         value: (_) @background_value) @background
     """,
-    
     # --- Flexbox Properties ---
     "flex": """
     (declaration
@@ -347,7 +337,6 @@ CSS_QUERIES: dict[str, str] = {
         (#match? @prop_name "^align-content$")
         value: (_) @align_content_value) @align_content
     """,
-    
     # --- Grid Properties ---
     "grid": """
     (declaration
@@ -355,7 +344,6 @@ CSS_QUERIES: dict[str, str] = {
         (#match? @prop_name "^grid")
         value: (_) @grid_value) @grid
     """,
-    
     # --- Animation Properties ---
     "animation": """
     (declaration
@@ -375,12 +363,10 @@ CSS_QUERIES: dict[str, str] = {
         (#match? @prop_name "^transform")
         value: (_) @transform_value) @transform
     """,
-    
     # --- Comments ---
     "comment": """
     (comment) @comment
     """,
-    
     # --- Custom Properties (CSS Variables) ---
     "custom_property": """
     (declaration
@@ -388,7 +374,6 @@ CSS_QUERIES: dict[str, str] = {
         (#match? @prop_name "^--")
         value: (_) @custom_value) @custom_property
     """,
-    
     # --- Important Declarations ---
     "important": """
     (declaration
@@ -396,7 +381,6 @@ CSS_QUERIES: dict[str, str] = {
         "!" @important_mark
         "important" @important_keyword) @important
     """,
-    
     # --- Keyframe Rules ---
     "keyframe_block": """
     (keyframe_block) @keyframe_block
@@ -410,7 +394,6 @@ CSS_QUERIES: dict[str, str] = {
     "to": """
     (to) @to
     """,
-    
     # --- Name-only Extraction ---
     "class_name": """
     (class_selector
@@ -585,9 +568,7 @@ def get_css_query(name: str) -> str:
     """
     if name not in CSS_QUERIES:
         available = list(CSS_QUERIES.keys())
-        raise ValueError(
-            f"CSS query '{name}' does not exist. Available: {available}"
-        )
+        raise ValueError(f"CSS query '{name}' does not exist. Available: {available}")
 
     return CSS_QUERIES[name]
 
@@ -631,4 +612,4 @@ def get_available_css_queries() -> list[str]:
     Returns:
         List of query names
     """
-    return list(CSS_QUERIES.keys())
+    return list(CSS_QUERIES.keys())