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

tree_sitter_analyzer/__init__.py

@@ -11,7 +11,7 @@ Architecture:
 - Data Models: Generic and language-specific code element representations
 """
 
-__version__ = "1.8.4"
+__version__ = "1.9.0"
 __author__ = "aisheng.yu"
 __email__ = "aimasteracc@gmail.com"
 

tree_sitter_analyzer/api.py

@@ -65,7 +65,7 @@ def analyze_file(
 
         # Perform the analysis
         analysis_result = engine.analyze_file(file_path, language)
-        
+
         # Convert AnalysisResult to expected API format (same as analyze_code)
         result = {
             "success": analysis_result.success,
@@ -375,15 +375,15 @@ def detect_language(file_path: str | Path) -> str:
         # Handle invalid input
         if not file_path:
             return "unknown"
-            
+
         engine = get_engine()
         # Use language_detector instead of language_registry
         result = engine.language_detector.detect_from_extension(str(file_path))
-        
+
         # Ensure result is valid
         if not result or result.strip() == "":
             return "unknown"
-            
+
         return result
     except Exception as e:
         log_error(f"Failed to detect language for {file_path}: {e}")

tree_sitter_analyzer/cli/argument_validator.py

@@ -5,7 +5,7 @@ CLI Argument Validator
 Validates CLI argument combinations and provides clear error messages.
 """
 
-from typing import Any, Optional
+from typing import Any
 
 
 class CLIArgumentValidator:
@@ -15,48 +15,60 @@ class CLIArgumentValidator:
         """Initialize the validator."""
         pass
 
-    def validate_arguments(self, args: Any) -> Optional[str]:
+    def validate_arguments(self, args: Any) -> str | None:
         """
         Validate CLI argument combinations.
-        
+
         Args:
             args: Parsed command line arguments
-            
+
         Returns:
             None if valid, error message string if invalid
         """
         # Check for --table and --query-key combination
-        table_specified = hasattr(args, 'table') and args.table is not None and args.table != ""
-        query_key_specified = hasattr(args, 'query_key') and args.query_key is not None and args.query_key != ""
-        
+        table_specified = (
+            hasattr(args, "table") and args.table is not None and args.table != ""
+        )
+        query_key_specified = (
+            hasattr(args, "query_key")
+            and args.query_key is not None
+            and args.query_key != ""
+        )
+
         if table_specified and query_key_specified:
             return "--table and --query-key cannot be used together. Use --query-key with --filter instead."
-        
+
         # All validations passed
         return None
 
-    def validate_table_query_exclusivity(self, args: Any) -> Optional[str]:
+    def validate_table_query_exclusivity(self, args: Any) -> str | None:
         """
         Validate that --table and --query-key are mutually exclusive.
-        
+
         Args:
             args: Parsed command line arguments
-            
+
         Returns:
             None if valid, error message string if invalid
         """
-        table_specified = hasattr(args, 'table') and args.table is not None and args.table != ""
-        query_key_specified = hasattr(args, 'query_key') and args.query_key is not None and args.query_key != ""
-        
+        table_specified = (
+            hasattr(args, "table") and args.table is not None and args.table != ""
+        )
+        query_key_specified = (
+            hasattr(args, "query_key")
+            and args.query_key is not None
+            and args.query_key != ""
+        )
+
         if table_specified and query_key_specified:
             return "--table and --query-key cannot be used together. Use --query-key with --filter instead."
-        
+
         return None
 
     def get_usage_examples(self) -> str:
         """
         Get usage examples for correct argument combinations.
-        
+
         Returns:
             String containing usage examples
         """
@@ -74,4 +86,4 @@ uv run python -m tree_sitter_analyzer examples/BigService.java --query-key metho
 
 # Invalid combination (will cause error):
 uv run python -m tree_sitter_analyzer examples/BigService.java --table full --query-key methods
-"""
+"""

tree_sitter_analyzer/cli/commands/advanced_command.py

@@ -14,8 +14,8 @@ from ...constants import (
     ELEMENT_TYPE_VARIABLE,
     get_element_type,
 )
-from ...output_manager import output_data, output_json, output_section
 from ...formatters.language_formatter_factory import create_language_formatter
+from ...output_manager import output_data, output_json, output_section
 from .base_command import BaseCommand
 
 if TYPE_CHECKING:
@@ -163,8 +163,10 @@ class AdvancedCommand(BaseCommand):
         formatter = create_language_formatter(analysis_result.language)
         if formatter:
             # Use language-specific formatter
-            output_format = getattr(self.args, 'output_format', 'json')
-            formatted_output = formatter.format_advanced(self._convert_to_formatter_format(analysis_result), output_format)
+            output_format = getattr(self.args, "output_format", "json")
+            formatted_output = formatter.format_advanced(
+                self._convert_to_formatter_format(analysis_result), output_format
+            )
             print(formatted_output)
             return
 
@@ -220,7 +222,7 @@ class AdvancedCommand(BaseCommand):
                     "line_range": {
                         "start": getattr(element, "start_line", 0),
                         "end": getattr(element, "end_line", 0),
-                    }
+                    },
                 }
                 for element in analysis_result.elements
             ],
@@ -231,7 +233,7 @@ class AdvancedCommand(BaseCommand):
                 "language": analysis_result.language,
                 "file_path": analysis_result.file_path,
                 "analyzer_version": "2.0.0",
-            }
+            },
         }
 
     def _output_text_analysis(self, analysis_result: "AnalysisResult") -> None:

tree_sitter_analyzer/cli/commands/structure_command.py

@@ -15,8 +15,8 @@ from ...constants import (
     ELEMENT_TYPE_VARIABLE,
     is_element_of_type,
 )
-from ...output_manager import output_data, output_json, output_section
 from ...formatters.language_formatter_factory import create_language_formatter
+from ...output_manager import output_data, output_json, output_section
 from .base_command import BaseCommand
 
 if TYPE_CHECKING:
@@ -40,7 +40,9 @@ class StructureCommand(BaseCommand):
         formatter = create_language_formatter(analysis_result.language)
         if formatter:
             # Use language-specific formatter
-            formatted_output = formatter.format_structure(self._convert_to_formatter_format(analysis_result))
+            formatted_output = formatter.format_structure(
+                self._convert_to_formatter_format(analysis_result)
+            )
             print(formatted_output)
             return
 
@@ -58,7 +60,7 @@ class StructureCommand(BaseCommand):
     def _convert_to_formatter_format(self, analysis_result: "AnalysisResult") -> dict:
         """Convert AnalysisResult to format expected by formatters."""
         from ...constants import get_element_type
-        
+
         return {
             "file_path": analysis_result.file_path,
             "language": analysis_result.language,
@@ -82,7 +84,7 @@ class StructureCommand(BaseCommand):
                     "line_range": {
                         "start": getattr(element, "start_line", 0),
                         "end": getattr(element, "end_line", 0),
-                    }
+                    },
                 }
                 for element in analysis_result.elements
             ],
@@ -91,7 +93,7 @@ class StructureCommand(BaseCommand):
                 "language": analysis_result.language,
                 "file_path": analysis_result.file_path,
                 "analyzer_version": "2.0.0",
-            }
+            },
         }
 
     def _convert_to_legacy_format(self, analysis_result: "AnalysisResult") -> dict:

tree_sitter_analyzer/cli/commands/summary_command.py

@@ -14,8 +14,8 @@ from ...constants import (
     ELEMENT_TYPE_VARIABLE,
     is_element_of_type,
 )
-from ...output_manager import output_data, output_json, output_section
 from ...formatters.language_formatter_factory import create_language_formatter
+from ...output_manager import output_data, output_json, output_section
 from .base_command import BaseCommand
 
 if TYPE_CHECKING:
@@ -39,7 +39,9 @@ class SummaryCommand(BaseCommand):
         formatter = create_language_formatter(analysis_result.language)
         if formatter:
             # Use language-specific formatter
-            formatted_output = formatter.format_summary(self._convert_to_formatter_format(analysis_result))
+            formatted_output = formatter.format_summary(
+                self._convert_to_formatter_format(analysis_result)
+            )
             print(formatted_output)
             return
 
@@ -106,10 +108,12 @@ class SummaryCommand(BaseCommand):
         else:
             self._output_text_format(summary_data, requested_types)
 
-    def _convert_to_formatter_format(self, analysis_result: "AnalysisResult") -> dict[str, Any]:
+    def _convert_to_formatter_format(
+        self, analysis_result: "AnalysisResult"
+    ) -> dict[str, Any]:
         """Convert AnalysisResult to format expected by formatters."""
         from ...constants import get_element_type
-        
+
         return {
             "file_path": analysis_result.file_path,
             "language": analysis_result.language,
@@ -133,7 +137,7 @@ class SummaryCommand(BaseCommand):
                     "line_range": {
                         "start": getattr(element, "start_line", 0),
                         "end": getattr(element, "end_line", 0),
-                    }
+                    },
                 }
                 for element in analysis_result.elements
             ],
@@ -142,7 +146,7 @@ class SummaryCommand(BaseCommand):
                 "language": analysis_result.language,
                 "file_path": analysis_result.file_path,
                 "analyzer_version": "2.0.0",
-            }
+            },
         }
 
     def _output_text_format(self, summary_data: dict, requested_types: list) -> None:

tree_sitter_analyzer/cli/commands/table_command.py

@@ -16,9 +16,9 @@ from ...constants import (
     ELEMENT_TYPE_VARIABLE,
     get_element_type,
 )
-from ...output_manager import output_error, output_info
-from ...table_formatter import create_table_formatter
 from ...formatters.language_formatter_factory import create_language_formatter
+from ...output_manager import output_error
+from ...table_formatter import create_table_formatter
 from .base_command import BaseCommand
 
 
@@ -41,8 +41,10 @@ class TableCommand(BaseCommand):
             formatter = create_language_formatter(analysis_result.language)
             if formatter:
                 # Use language-specific formatter
-                table_type = getattr(self.args, 'table', 'full')
-                formatted_output = formatter.format_table(self._convert_to_formatter_format(analysis_result), table_type)
+                table_type = getattr(self.args, "table", "full")
+                formatted_output = formatter.format_table(
+                    self._convert_to_formatter_format(analysis_result), table_type
+                )
                 self._output_table(formatted_output)
                 return 0
 
@@ -68,7 +70,6 @@ class TableCommand(BaseCommand):
             output_error(f"An error occurred during table format analysis: {e}")
             return 1
 
-
     def _convert_to_formatter_format(self, analysis_result: Any) -> dict[str, Any]:
         """Convert AnalysisResult to format expected by formatters."""
         return {
@@ -94,7 +95,7 @@ class TableCommand(BaseCommand):
                     "line_range": {
                         "start": getattr(element, "start_line", 0),
                         "end": getattr(element, "end_line", 0),
-                    }
+                    },
                 }
                 for element in analysis_result.elements
             ],
@@ -103,7 +104,7 @@ class TableCommand(BaseCommand):
                 "language": analysis_result.language,
                 "file_path": analysis_result.file_path,
                 "analyzer_version": "2.0.0",
-            }
+            },
         }
 
     def _convert_to_structure_format(

tree_sitter_analyzer/cli/info_commands.py

@@ -101,7 +101,7 @@ class ShowLanguagesCommand(InfoCommand):
             info = detector.get_language_info(language)
             extensions = ", ".join(info["extensions"][:5])
             if len(info["extensions"]) > 5:
-                extensions += f", ... ({len(info['extensions'])-5} more)"
+                extensions += f", ... ({len(info['extensions']) - 5} more)"
             output_list(f"  {language:<12} - Extensions: {extensions}")
         return 0
 

tree_sitter_analyzer/cli_main.py

@@ -7,6 +7,8 @@ import os
 import sys
 from typing import Any
 
+from .cli.argument_validator import CLIArgumentValidator
+
 # Import command classes
 from .cli.commands import (
     AdvancedCommand,
@@ -25,7 +27,6 @@ from .cli.info_commands import (
 )
 from .output_manager import output_error, output_info, output_list
 from .query_loader import query_loader
-from .cli.argument_validator import CLIArgumentValidator
 
 
 class CLICommandFactory:
@@ -34,7 +35,7 @@ class CLICommandFactory:
     @staticmethod
     def create_command(args: argparse.Namespace) -> Any:
         """Create appropriate command based on arguments."""
-        
+
         # Validate argument combinations first
         validator = CLIArgumentValidator()
         validation_error = validator.validate_arguments(args)

tree_sitter_analyzer/core/analysis_engine.py

@@ -207,7 +207,7 @@ class UnifiedAnalysisEngine:
     _instances: dict[str, "UnifiedAnalysisEngine"] = {}
     _lock: threading.Lock = threading.Lock()
 
-    def __new__(cls, project_root: str = None) -> "UnifiedAnalysisEngine":
+    def __new__(cls, project_root: str | None = None) -> "UnifiedAnalysisEngine":
         """Singleton instance sharing (project_root aware)"""
         # Create a key based on project_root for different instances
         instance_key = project_root or "default"
@@ -218,13 +218,13 @@ class UnifiedAnalysisEngine:
                     instance = super().__new__(cls)
                     cls._instances[instance_key] = instance
                     # Mark as not initialized for this instance
-                    instance._initialized = False
+                    instance._initialized: bool = False
 
         return cls._instances[instance_key]
 
-    def __init__(self, project_root: str = None) -> None:
+    def __init__(self, project_root: str | None = None) -> None:
         """Initialize (executed only once per instance)"""
-        if hasattr(self, "_initialized") and self._initialized:
+        if hasattr(self, "_initialized") and getattr(self, "_initialized", False):
             return
 
         self._cache_service = CacheService()
@@ -566,7 +566,7 @@ class MockLanguagePlugin:
         )
 
 
-def get_analysis_engine(project_root: str = None) -> UnifiedAnalysisEngine:
+def get_analysis_engine(project_root: str | None = None) -> UnifiedAnalysisEngine:
     """
     Get unified analysis engine instance
 

tree_sitter_analyzer/core/cache_service.py

@@ -20,7 +20,7 @@ from typing import Any
 
 from cachetools import LRUCache, TTLCache
 
-from ..utils import log_debug, log_error, log_info
+from ..utils import log_debug, log_info
 
 
 @dataclass(frozen=True)
@@ -227,6 +227,7 @@ class CacheService:
 
             # Only log if not in quiet mode (check log level)
             import logging
+
             if logging.getLogger("tree_sitter_analyzer").level <= logging.INFO:
                 log_info("All caches cleared")
 
@@ -320,6 +321,7 @@ class CacheService:
         try:
             # Only clear if not in shutdown mode
             import sys
+
             if sys.meta_path is not None:  # Check if Python is not shutting down
                 # Clear caches without logging to avoid shutdown issues
                 with self._lock:

tree_sitter_analyzer/core/query.py

@@ -78,14 +78,22 @@ class QueryExecutor:
                 if not language_name:
                     language_name = getattr(language, "_name", None)
                 if not language_name:
-                    language_name = str(language).split('.')[-1] if hasattr(language, '__class__') else None
-            
+                    language_name = (
+                        str(language).split(".")[-1]
+                        if hasattr(language, "__class__")
+                        else None
+                    )
+
             # Ensure we have a valid language name
-            if not language_name or language_name.strip() == "" or language_name == "None":
+            if (
+                not language_name
+                or language_name.strip() == ""
+                or language_name == "None"
+            ):
                 language_name = "unknown"
             else:
                 language_name = language_name.strip().lower()
-            
+
             query_string = self._query_loader.get_query(language_name, query_name)
             if query_string is None:
                 return self._create_error_result(
@@ -244,7 +252,11 @@ class QueryExecutor:
                     if isinstance(capture, tuple) and len(capture) == 2:
                         node, name = capture
                     # Handle dictionary format (legacy API compatibility)
-                    elif isinstance(capture, dict) and "node" in capture and "name" in capture:
+                    elif (
+                        isinstance(capture, dict)
+                        and "node" in capture
+                        and "name" in capture
+                    ):
                         node = capture["node"]
                         name = capture["name"]
                     else:

tree_sitter_analyzer/core/query_service.py

@@ -298,7 +298,7 @@ class QueryService:
             node_type = getattr(node, "type", "")
             if not isinstance(node_type, str):
                 node_type = str(node_type)
-            
+
             # Generic node type matching (support both singular and plural forms)
             if query_key in ("function", "functions") and "function" in node_type:
                 captures.append((node, query_key))

tree_sitter_analyzer/encoding_utils.py

@@ -72,9 +72,9 @@ class EncodingCache:
             max_size: Maximum number of cached entries
             ttl_seconds: Time-to-live for cache entries in seconds
         """
-        self._cache: dict[str, tuple[str, float]] = (
-            {}
-        )  # file_path -> (encoding, timestamp)
+        self._cache: dict[
+            str, tuple[str, float]
+        ] = {}  # file_path -> (encoding, timestamp)
         self._lock = threading.RLock()
         self._max_size = max_size
         self._ttl_seconds = ttl_seconds