tree-sitter-analyzer 0.9.2__py3-none-any.whl → 0.9.4__py3-none-any.whl

tree_sitter_analyzer/__init__.py

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

tree_sitter_analyzer/cli/commands/base_command.py

@@ -85,9 +85,8 @@ class BaseCommand(ABC):
                 if (not hasattr(self.args, "table") or not self.args.table) and (
                     not hasattr(self.args, "quiet") or not self.args.quiet
                 ):
-                    output_info(
-                        f"INFO: Language auto-detected from extension: {target_language}"
-                    )
+                    # Language auto-detected - only show in verbose mode
+                    pass
 
         # Language support validation
         if not is_language_supported(target_language):

tree_sitter_analyzer/cli/commands/default_command.py

@@ -1,18 +1,18 @@
-#!/usr/bin/env python3
-"""
-Default Command
-
-Handles default analysis when no specific command is specified.
-"""
-
-from ...output_manager import output_error
-from .base_command import BaseCommand
-
-
-class DefaultCommand(BaseCommand):
-    """Default command that shows error when no specific command is given."""
-
-    async def execute_async(self, language: str) -> int:
-        """Execute default command - show error for missing options."""
-        output_error("Please specify a query or --advanced option")
-        return 1
+#!/usr/bin/env python3
+"""
+Default Command
+
+Handles default analysis when no specific command is specified.
+"""
+
+from ...output_manager import output_error
+from .base_command import BaseCommand
+
+
+class DefaultCommand(BaseCommand):
+    """Default command that shows error when no specific command is given."""
+
+    async def execute_async(self, language: str) -> int:
+        """Execute default command - show error for missing options."""
+        output_error("Please specify a query or --advanced option")
+        return 1

tree_sitter_analyzer/cli/commands/partial_read_command.py

@@ -1,141 +1,139 @@
-#!/usr/bin/env python3
-"""
-Partial Read Command
-
-Handles partial file reading functionality, extracting specified line ranges.
-"""
-
-from typing import TYPE_CHECKING, Any
-
-from ...file_handler import read_file_partial
-from ...output_manager import output_data, output_json, output_section
-from .base_command import BaseCommand
-
-if TYPE_CHECKING:
-    pass
-
-
-class PartialReadCommand(BaseCommand):
-    """Command for reading partial file content by line range."""
-
-    def __init__(self, args: Any) -> None:
-        """Initialize with arguments but skip base class analysis engine setup."""
-        self.args = args
-        # Don't call super().__init__() to avoid unnecessary analysis engine setup
-
-    def validate_file(self) -> bool:
-        """Validate input file exists and is accessible."""
-        if not hasattr(self.args, "file_path") or not self.args.file_path:
-            from ...output_manager import output_error
-
-            output_error("File path not specified.")
-            return False
-
-        import os
-
-        if not os.path.exists(self.args.file_path):
-            from ...output_manager import output_error
-
-            output_error(f"File not found: {self.args.file_path}")
-            return False
-
-        return True
-
-    def execute(self) -> int:
-        """
-        Execute partial read command.
-
-        Returns:
-            int: Exit code (0 for success, 1 for failure)
-        """
-        # Validate inputs
-        if not self.validate_file():
-            return 1
-
-        # Validate partial read arguments
-        if not self.args.start_line:
-            from ...output_manager import output_error
-
-            output_error("--start-line is required")
-            return 1
-
-        if self.args.start_line < 1:
-            from ...output_manager import output_error
-
-            output_error("--start-line must be 1 or greater")
-            return 1
-
-        if self.args.end_line and self.args.end_line < self.args.start_line:
-            from ...output_manager import output_error
-
-            output_error(
-                "--end-line must be greater than or equal to --start-line"
-            )
-            return 1
-
-        # Read partial content
-        try:
-            partial_content = read_file_partial(
-                self.args.file_path,
-                start_line=self.args.start_line,
-                end_line=getattr(self.args, "end_line", None),
-                start_column=getattr(self.args, "start_column", None),
-                end_column=getattr(self.args, "end_column", None),
-            )
-
-            if partial_content is None:
-                from ...output_manager import output_error
-
-                output_error("Failed to read file partially")
-                return 1
-
-            # Output the result
-            self._output_partial_content(partial_content)
-            return 0
-
-        except Exception as e:
-            from ...output_manager import output_error
-
-            output_error(f"Failed to read file partially: {e}")
-            return 1
-
-    def _output_partial_content(self, content: str) -> None:
-        """Output the partial content in the specified format."""
-        # Build result data
-        result_data = {
-            "file_path": self.args.file_path,
-            "range": {
-                "start_line": self.args.start_line,
-                "end_line": getattr(self.args, "end_line", None),
-                "start_column": getattr(self.args, "start_column", None),
-                "end_column": getattr(self.args, "end_column", None),
-            },
-            "content": content,
-            "content_length": len(content),
-        }
-
-        # Build range info for header
-        range_info = f"Line {self.args.start_line}"
-        if hasattr(self.args, "end_line") and self.args.end_line:
-            range_info += f"-{self.args.end_line}"
-
-        # Output format selection
-        output_format = getattr(self.args, "output_format", "text")
-
-        if output_format == "json":
-            # Pure JSON output
-            output_json(result_data)
-        else:
-            # Human-readable format with header
-            output_section("Partial Read Result")
-            output_data(f"File: {self.args.file_path}")
-            output_data(f"Range: {range_info}")
-            output_data(f"Characters read: {len(content)}")
-            output_data("")  # Empty line for separation
-
-            # Output the actual content
-            print(content, end="")  # Use print to avoid extra formatting
-
-    async def execute_async(self, language: str) -> int:
-        """Not used for partial read command."""
-        return self.execute()
+#!/usr/bin/env python3
+"""
+Partial Read Command
+
+Handles partial file reading functionality, extracting specified line ranges.
+"""
+
+from typing import TYPE_CHECKING, Any
+
+from ...file_handler import read_file_partial
+from ...output_manager import output_data, output_json, output_section
+from .base_command import BaseCommand
+
+if TYPE_CHECKING:
+    pass
+
+
+class PartialReadCommand(BaseCommand):
+    """Command for reading partial file content by line range."""
+
+    def __init__(self, args: Any) -> None:
+        """Initialize with arguments but skip base class analysis engine setup."""
+        self.args = args
+        # Don't call super().__init__() to avoid unnecessary analysis engine setup
+
+    def validate_file(self) -> bool:
+        """Validate input file exists and is accessible."""
+        if not hasattr(self.args, "file_path") or not self.args.file_path:
+            from ...output_manager import output_error
+
+            output_error("File path not specified.")
+            return False
+
+        import os
+
+        if not os.path.exists(self.args.file_path):
+            from ...output_manager import output_error
+
+            output_error(f"File not found: {self.args.file_path}")
+            return False
+
+        return True
+
+    def execute(self) -> int:
+        """
+        Execute partial read command.
+
+        Returns:
+            int: Exit code (0 for success, 1 for failure)
+        """
+        # Validate inputs
+        if not self.validate_file():
+            return 1
+
+        # Validate partial read arguments
+        if not self.args.start_line:
+            from ...output_manager import output_error
+
+            output_error("--start-line is required")
+            return 1
+
+        if self.args.start_line < 1:
+            from ...output_manager import output_error
+
+            output_error("--start-line must be 1 or greater")
+            return 1
+
+        if self.args.end_line and self.args.end_line < self.args.start_line:
+            from ...output_manager import output_error
+
+            output_error("--end-line must be greater than or equal to --start-line")
+            return 1
+
+        # Read partial content
+        try:
+            partial_content = read_file_partial(
+                self.args.file_path,
+                start_line=self.args.start_line,
+                end_line=getattr(self.args, "end_line", None),
+                start_column=getattr(self.args, "start_column", None),
+                end_column=getattr(self.args, "end_column", None),
+            )
+
+            if partial_content is None:
+                from ...output_manager import output_error
+
+                output_error("Failed to read file partially")
+                return 1
+
+            # Output the result
+            self._output_partial_content(partial_content)
+            return 0
+
+        except Exception as e:
+            from ...output_manager import output_error
+
+            output_error(f"Failed to read file partially: {e}")
+            return 1
+
+    def _output_partial_content(self, content: str) -> None:
+        """Output the partial content in the specified format."""
+        # Build result data
+        result_data = {
+            "file_path": self.args.file_path,
+            "range": {
+                "start_line": self.args.start_line,
+                "end_line": getattr(self.args, "end_line", None),
+                "start_column": getattr(self.args, "start_column", None),
+                "end_column": getattr(self.args, "end_column", None),
+            },
+            "content": content,
+            "content_length": len(content),
+        }
+
+        # Build range info for header
+        range_info = f"Line {self.args.start_line}"
+        if hasattr(self.args, "end_line") and self.args.end_line:
+            range_info += f"-{self.args.end_line}"
+
+        # Output format selection
+        output_format = getattr(self.args, "output_format", "text")
+
+        if output_format == "json":
+            # Pure JSON output
+            output_json(result_data)
+        else:
+            # Human-readable format with header
+            output_section("Partial Read Result")
+            output_data(f"File: {self.args.file_path}")
+            output_data(f"Range: {range_info}")
+            output_data(f"Characters read: {len(content)}")
+            output_data("")  # Empty line for separation
+
+            # Output the actual content
+            print(content, end="")  # Use print to avoid extra formatting
+
+    async def execute_async(self, language: str) -> int:
+        """Not used for partial read command."""
+        return self.execute()

tree_sitter_analyzer/cli/commands/query_command.py

@@ -1,88 +1,92 @@
-#!/usr/bin/env python3
-"""
-Query Command
-
-Handles query execution functionality.
-"""
-
-from ...output_manager import output_data, output_error, output_info, output_json
-from ...query_loader import query_loader
-from .base_command import BaseCommand
-
-
-class QueryCommand(BaseCommand):
-    """Command for executing queries."""
-
-    async def execute_async(self, language: str) -> int:
-        # Get the query to execute
-        query_to_execute = None
-
-        if hasattr(self.args, "query_key") and self.args.query_key:
-            # Sanitize query key input
-            sanitized_query_key = self.security_validator.sanitize_input(self.args.query_key, max_length=100)
-            try:
-                query_to_execute = query_loader.get_query(language, sanitized_query_key)
-                if query_to_execute is None:
-                    output_error(
-                        f"Query '{sanitized_query_key}' not found for language '{language}'"
-                    )
-                    return 1
-            except ValueError as e:
-                output_error(f"{e}")
-                return 1
-        elif hasattr(self.args, "query_string") and self.args.query_string:
-            # Security check for query string (potential regex patterns)
-            is_safe, error_msg = self.security_validator.regex_checker.validate_pattern(self.args.query_string)
-            if not is_safe:
-                output_error(f"Unsafe query pattern: {error_msg}")
-                return 1
-            query_to_execute = self.args.query_string
-
-        if not query_to_execute:
-            output_error("No query specified.")
-            return 1
-
-        # Perform analysis
-        analysis_result = await self.analyze_file(language)
-        if not analysis_result:
-            return 1
-
-        # Process query results
-        results = []
-        if hasattr(analysis_result, "query_results") and analysis_result.query_results:
-            results = analysis_result.query_results.get("captures", [])
-        else:
-            # Create basic results from elements
-            if hasattr(analysis_result, "elements") and analysis_result.elements:
-                for element in analysis_result.elements:
-                    results.append(
-                        {
-                            "capture_name": getattr(
-                                element, "__class__", type(element)
-                            ).__name__.lower(),
-                            "node_type": getattr(
-                                element, "__class__", type(element)
-                            ).__name__,
-                            "start_line": getattr(element, "start_line", 0),
-                            "end_line": getattr(element, "end_line", 0),
-                            "content": getattr(element, "name", str(element)),
-                        }
-                    )
-
-        # Output results
-        if results:
-            if self.args.output_format == "json":
-                output_json(results)
-            else:
-                for i, query_result in enumerate(results, 1):
-                    output_data(
-                        f"\n{i}. {query_result['capture_name']} ({query_result['node_type']})"
-                    )
-                    output_data(
-                        f"   Position: Line {query_result['start_line']}-{query_result['end_line']}"
-                    )
-                    output_data(f"   Content:\n{query_result['content']}")
-        else:
-            output_info("\nINFO: No results found matching the query.")
-
-        return 0
+#!/usr/bin/env python3
+"""
+Query Command
+
+Handles query execution functionality.
+"""
+
+from ...output_manager import output_data, output_error, output_info, output_json
+from ...query_loader import query_loader
+from .base_command import BaseCommand
+
+
+class QueryCommand(BaseCommand):
+    """Command for executing queries."""
+
+    async def execute_async(self, language: str) -> int:
+        # Get the query to execute
+        query_to_execute = None
+
+        if hasattr(self.args, "query_key") and self.args.query_key:
+            # Sanitize query key input
+            sanitized_query_key = self.security_validator.sanitize_input(
+                self.args.query_key, max_length=100
+            )
+            try:
+                query_to_execute = query_loader.get_query(language, sanitized_query_key)
+                if query_to_execute is None:
+                    output_error(
+                        f"Query '{sanitized_query_key}' not found for language '{language}'"
+                    )
+                    return 1
+            except ValueError as e:
+                output_error(f"{e}")
+                return 1
+        elif hasattr(self.args, "query_string") and self.args.query_string:
+            # Security check for query string (potential regex patterns)
+            is_safe, error_msg = self.security_validator.regex_checker.validate_pattern(
+                self.args.query_string
+            )
+            if not is_safe:
+                output_error(f"Unsafe query pattern: {error_msg}")
+                return 1
+            query_to_execute = self.args.query_string
+
+        if not query_to_execute:
+            output_error("No query specified.")
+            return 1
+
+        # Perform analysis
+        analysis_result = await self.analyze_file(language)
+        if not analysis_result:
+            return 1
+
+        # Process query results
+        results = []
+        if hasattr(analysis_result, "query_results") and analysis_result.query_results:
+            results = analysis_result.query_results.get("captures", [])
+        else:
+            # Create basic results from elements
+            if hasattr(analysis_result, "elements") and analysis_result.elements:
+                for element in analysis_result.elements:
+                    results.append(
+                        {
+                            "capture_name": getattr(
+                                element, "__class__", type(element)
+                            ).__name__.lower(),
+                            "node_type": getattr(
+                                element, "__class__", type(element)
+                            ).__name__,
+                            "start_line": getattr(element, "start_line", 0),
+                            "end_line": getattr(element, "end_line", 0),
+                            "content": getattr(element, "name", str(element)),
+                        }
+                    )
+
+        # Output results
+        if results:
+            if self.args.output_format == "json":
+                output_json(results)
+            else:
+                for i, query_result in enumerate(results, 1):
+                    output_data(
+                        f"\n{i}. {query_result['capture_name']} ({query_result['node_type']})"
+                    )
+                    output_data(
+                        f"   Position: Line {query_result['start_line']}-{query_result['end_line']}"
+                    )
+                    output_data(f"   Content:\n{query_result['content']}")
+        else:
+            output_info("\nINFO: No results found matching the query.")
+
+        return 0