tree-sitter-analyzer 1.7.7__py3-none-any.whl → 1.8.2__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.7.7"
+__version__ = "1.8.2"
 __author__ = "aisheng.yu"
 __email__ = "aimasteracc@gmail.com"
 

tree_sitter_analyzer/api.py

@@ -58,30 +58,20 @@ def analyze_file(
         include_complexity: Whether to include complexity metrics (backward compatibility)
 
     Returns:
-        Analysis results dictionary containing:
-        - success: Whether the analysis was successful
-        - file_info: Basic file information
-        - language_info: Detected/specified language information
-        - ast_info: Abstract syntax tree information
-        - query_results: Results from executed queries (if include_queries=True)
-        - elements: Extracted code elements (if include_elements=True)
-        - error: Error message (if success=False)
+        Analysis results dictionary
     """
     try:
         engine = get_engine()
 
         # Perform the analysis
         analysis_result = engine.analyze_file(file_path, language)
-
-        # Convert AnalysisResult to expected API format
+        
+        # Convert AnalysisResult to expected API format (same as analyze_code)
         result = {
             "success": analysis_result.success,
             "file_info": {
                 "path": str(file_path),
-                "exists": Path(file_path).exists(),
-                "size": (
-                    Path(file_path).stat().st_size if Path(file_path).exists() else 0
-                ),
+                "exists": True,
             },
             "language_info": {
                 "language": analysis_result.language,
@@ -177,21 +167,14 @@ def analyze_file(
     except FileNotFoundError as e:
         # Re-raise FileNotFoundError for tests that expect it
         raise e
-    except (ValueError, TypeError, OSError) as e:
-        # Handle specific expected errors
-        log_error(f"API analyze_file failed with {type(e).__name__}: {e}")
-        return {
-            "success": False,
-            "error": f"{type(e).__name__}: {str(e)}",
-            "file_info": {"path": str(file_path), "exists": Path(file_path).exists()},
-        }
     except Exception as e:
-        # Handle unexpected errors
-        log_error(f"API analyze_file failed with unexpected error: {e}")
+        log_error(f"API analyze_file failed: {e}")
         return {
             "success": False,
-            "error": f"Unexpected error: {str(e)}",
-            "file_info": {"path": str(file_path), "exists": Path(file_path).exists()},
+            "error": str(e),
+            "file_info": {"path": str(file_path), "exists": False},
+            "language_info": {"language": language or "unknown", "detected": False},
+            "ast_info": {"node_count": 0, "line_count": 0},
         }
 
 
@@ -378,7 +361,7 @@ def is_language_supported(language: str) -> bool:
         return False
 
 
-def detect_language(file_path: str | Path) -> str | None:
+def detect_language(file_path: str | Path) -> str:
     """
     Detect programming language from file path.
 
@@ -386,15 +369,25 @@ def detect_language(file_path: str | Path) -> str | None:
         file_path: Path to the file
 
     Returns:
-        Detected language name or None
+        Detected language name - 常に有効な文字列を返す
     """
     try:
+        # Handle invalid input
+        if not file_path:
+            return "unknown"
+            
         engine = get_engine()
         # Use language_detector instead of language_registry
-        return engine.language_detector.detect_from_extension(str(file_path))
+        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}")
-        return None
+        return "unknown"
 
 
 def get_file_extensions(language: str) -> list[str]:

tree_sitter_analyzer/cli/argument_validator.py

@@ -0,0 +1,77 @@
+#!/usr/bin/env python3
+"""
+CLI Argument Validator
+
+Validates CLI argument combinations and provides clear error messages.
+"""
+
+from typing import Any, Optional
+
+
+class CLIArgumentValidator:
+    """Validator for CLI argument combinations."""
+
+    def __init__(self):
+        """Initialize the validator."""
+        pass
+
+    def validate_arguments(self, args: Any) -> Optional[str]:
+        """
+        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 != ""
+        
+        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]:
+        """
+        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 != ""
+        
+        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
+        """
+        return """
+Correct usage examples:
+
+# Use table format only:
+uv run python -m tree_sitter_analyzer examples/BigService.java --table full
+
+# Use query-key only:
+uv run python -m tree_sitter_analyzer examples/BigService.java --query-key methods
+
+# Use query-key with filter:
+uv run python -m tree_sitter_analyzer examples/BigService.java --query-key methods --filter "name=main"
+
+# 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/table_command.py

@@ -16,7 +16,7 @@ from ...constants import (
     ELEMENT_TYPE_VARIABLE,
     get_element_type,
 )
-from ...output_manager import output_error
+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 .base_command import BaseCommand
@@ -25,10 +25,14 @@ from .base_command import BaseCommand
 class TableCommand(BaseCommand):
     """Command for generating table format output."""
 
+    def __init__(self, args):
+        """Initialize the table command."""
+        super().__init__(args)
+
     async def execute_async(self, language: str) -> int:
         """Execute table format generation."""
         try:
-            # Perform analysis
+            # Perform standard analysis
             analysis_result = await self.analyze_file(language)
             if not analysis_result:
                 return 1
@@ -64,6 +68,7 @@ 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 {

tree_sitter_analyzer/cli_main.py

@@ -25,6 +25,7 @@ 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:
@@ -33,6 +34,14 @@ 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)
+        if validation_error:
+            output_error(validation_error)
+            output_info(validator.get_usage_examples())
+            return None
 
         # Information commands (no file analysis required)
         if args.list_queries:
@@ -62,6 +71,7 @@ class CLICommandFactory:
         if hasattr(args, "partial_read") and args.partial_read:
             return PartialReadCommand(args)
 
+        # Handle table command with or without query-key
         if hasattr(args, "table") and args.table:
             return TableCommand(args)
 
@@ -274,14 +284,18 @@ def main() -> None:
     if "--quiet" in sys.argv:
         os.environ["LOG_LEVEL"] = "ERROR"
     else:
-        # Set default log level to WARNING to reduce output
-        os.environ.setdefault("LOG_LEVEL", "WARNING")
+        # Set default log level to ERROR to prevent log output in CLI
+        os.environ["LOG_LEVEL"] = "ERROR"
 
     parser = create_argument_parser()
     args = parser.parse_args()
 
-    # Configure default logging levels to reduce output
+    # Configure all logging to ERROR level to prevent output contamination
+    logging.getLogger().setLevel(logging.ERROR)
+    logging.getLogger("tree_sitter_analyzer").setLevel(logging.ERROR)
     logging.getLogger("tree_sitter_analyzer.performance").setLevel(logging.ERROR)
+    logging.getLogger("tree_sitter_analyzer.plugins").setLevel(logging.ERROR)
+    logging.getLogger("tree_sitter_analyzer.plugins.manager").setLevel(logging.ERROR)
 
     # Configure logging for table output
     if hasattr(args, "table") and args.table:

tree_sitter_analyzer/core/cache_service.py

@@ -225,7 +225,10 @@ class CacheService:
             for key in self._stats:
                 self._stats[key] = 0
 
-            log_info("All caches cleared")
+            # 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")
 
     def size(self) -> int:
         """
@@ -315,7 +318,14 @@ class CacheService:
     def __del__(self) -> None:
         """デストラクタ - リソースクリーンアップ"""
         try:
-            self.clear()
-            log_debug("CacheService destroyed and cleaned up")
-        except Exception as e:
-            log_error(f"Error during CacheService cleanup: {e}")
+            # 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:
+                    self._l1_cache.clear()
+                    self._l2_cache.clear()
+                    self._l3_cache.clear()
+        except Exception:
+            # Silently ignore all errors during shutdown to prevent ImportError
+            pass

tree_sitter_analyzer/core/query.py

@@ -13,6 +13,7 @@ from typing import Any
 from tree_sitter import Language, Node, Tree
 
 from ..query_loader import get_query_loader
+from ..utils.tree_sitter_compat import TreeSitterQueryCompat, get_node_text_safe
 
 # Configure logging
 logger = logging.getLogger(__name__)
@@ -69,18 +70,33 @@ class QueryExecutor:
                     "Language is None", query_name=query_name
                 )
 
-            # Get the query string
-            language_name = language.name if hasattr(language, "name") else "unknown"
+            # Get the query string with robust language name handling
+            language_name = None
+            if language:
+                # Try multiple ways to get language name
+                language_name = getattr(language, "name", None)
+                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
+            
+            # Ensure we have a valid language name
+            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(
                     f"Query '{query_name}' not found", query_name=query_name
                 )
 
-            # Create and execute the query
+            # Create and execute the query using modern API
             try:
-                query = language.query(query_string)
-                captures = query.captures(tree.root_node)
+                captures = TreeSitterQueryCompat.safe_execute_query(
+                    language, query_string, tree.root_node, fallback_result=[]
+                )
 
                 # Process captures
                 try:
@@ -146,10 +162,11 @@ class QueryExecutor:
             if language is None:
                 return self._create_error_result("Language is None")  # type: ignore[unreachable]
 
-            # Create and execute the query
+            # Create and execute the query using modern API
             try:
-                query = language.query(query_string)
-                captures = query.captures(tree.root_node)
+                captures = TreeSitterQueryCompat.safe_execute_query(
+                    language, query_string, tree.root_node, fallback_result=[]
+                )
 
                 # Process captures
                 try:
@@ -223,14 +240,13 @@ class QueryExecutor:
         try:
             for capture in captures:
                 try:
-                    # Handle both dictionary and tuple formats
-                    if isinstance(capture, dict):
-                        # New Tree-sitter API format
-                        node = capture.get("node")
-                        name = capture.get("name", "unknown")
-                    elif isinstance(capture, tuple) and len(capture) == 2:
-                        # Old Tree-sitter API format
+                    # Handle tuple format from modern API
+                    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:
+                        node = capture["node"]
+                        name = capture["name"]
                     else:
                         logger.warning(f"Unexpected capture format: {type(capture)}")
                         continue
@@ -265,13 +281,8 @@ class QueryExecutor:
             Dictionary containing node information
         """
         try:
-            # Extract node text
-            node_text = ""
-            if hasattr(node, "text") and node.text:
-                try:
-                    node_text = node.text.decode("utf-8", errors="replace")
-                except Exception:
-                    node_text = str(node.text)
+            # Extract node text using safe utility
+            node_text = get_node_text_safe(node, source_code)
 
             return {
                 "capture_name": capture_name,