tree-sitter-analyzer 1.9.17.1__py3-none-any.whl

tree_sitter_analyzer/cli/__init__.py

@@ -0,0 +1,39 @@
+#!/usr/bin/env python3
+"""
+CLI Package
+
+Command-line interface components using the Command Pattern.
+"""
+
+from .info_commands import (
+    DescribeQueryCommand,
+    InfoCommand,
+    ListQueriesCommand,
+    ShowExtensionsCommand,
+    ShowLanguagesCommand,
+)
+
+# Modern framework imports
+try:
+    from ..cli_main import main
+    from ..core.analysis_engine import get_analysis_engine
+    from ..query_loader import QueryLoader
+
+    query_loader = QueryLoader()
+except ImportError:
+    # Minimal fallback for import safety
+    get_analysis_engine = None  # type: ignore
+    main = None  # type: ignore
+    query_loader = None  # type: ignore
+
+__all__ = [
+    "InfoCommand",
+    "ListQueriesCommand",
+    "DescribeQueryCommand",
+    "ShowLanguagesCommand",
+    "ShowExtensionsCommand",
+    # Core framework exports
+    "query_loader",
+    "get_analysis_engine",
+    "main",
+]

tree_sitter_analyzer/cli/__main__.py

@@ -0,0 +1,12 @@
+#!/usr/bin/env python3
+"""
+CLI Module Entry Point
+
+This module allows the CLI to be executed as a module with:
+python -m tree_sitter_analyzer.cli
+"""
+
+from ..cli_main import main
+
+if __name__ == "__main__":
+    main()

tree_sitter_analyzer/cli/argument_validator.py

@@ -0,0 +1,89 @@
+#!/usr/bin/env python3
+"""
+CLI Argument Validator
+
+Validates CLI argument combinations and provides clear error messages.
+"""
+
+from typing import Any
+
+
+class CLIArgumentValidator:
+    """Validator for CLI argument combinations."""
+
+    def __init__(self) -> None:
+        """Initialize the validator."""
+        pass
+
+    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 != ""
+        )
+
+        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) -> 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 != ""
+        )
+
+        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/__init__.py

@@ -0,0 +1,26 @@
+#!/usr/bin/env python3
+"""
+CLI Commands Package
+
+This package contains all command implementations for the CLI interface.
+"""
+
+from .advanced_command import AdvancedCommand
+from .base_command import BaseCommand
+from .default_command import DefaultCommand
+from .partial_read_command import PartialReadCommand
+from .query_command import QueryCommand
+from .structure_command import StructureCommand
+from .summary_command import SummaryCommand
+from .table_command import TableCommand
+
+__all__ = [
+    "BaseCommand",
+    "AdvancedCommand",
+    "DefaultCommand",
+    "PartialReadCommand",
+    "QueryCommand",
+    "StructureCommand",
+    "SummaryCommand",
+    "TableCommand",
+]

tree_sitter_analyzer/cli/commands/advanced_command.py

@@ -0,0 +1,226 @@
+#!/usr/bin/env python3
+"""
+Advanced Command
+
+Handles advanced analysis functionality.
+"""
+
+from typing import TYPE_CHECKING
+
+from ...constants import (
+    ELEMENT_TYPE_CLASS,
+    ELEMENT_TYPE_FUNCTION,
+    ELEMENT_TYPE_IMPORT,
+    ELEMENT_TYPE_VARIABLE,
+    get_element_type,
+)
+from ...output_manager import output_data, output_json, output_section
+from .base_command import BaseCommand
+
+if TYPE_CHECKING:
+    from ...models import AnalysisResult
+
+
+class AdvancedCommand(BaseCommand):
+    """Command for advanced analysis."""
+
+    async def execute_async(self, language: str) -> int:
+        analysis_result = await self.analyze_file(language)
+        if not analysis_result:
+            return 1
+
+        if hasattr(self.args, "statistics") and self.args.statistics:
+            self._output_statistics(analysis_result)
+        else:
+            self._output_full_analysis(analysis_result)
+
+        return 0
+
+    def _calculate_file_metrics(self, file_path: str, language: str) -> dict[str, int]:
+        """
+        Calculate accurate file metrics including line counts.
+
+        Args:
+            file_path: Path to the file to analyze
+            language: Programming language
+
+        Returns:
+            Dictionary containing file metrics
+        """
+        try:
+            from ...encoding_utils import read_file_safe
+
+            content, _ = read_file_safe(file_path)
+
+            lines = content.split("\n")
+            total_lines = len(lines)
+
+            # Remove empty line at the end if file ends with newline
+            if lines and not lines[-1]:
+                total_lines -= 1
+
+            # Count different types of lines
+            code_lines = 0
+            comment_lines = 0
+            blank_lines = 0
+            in_multiline_comment = False
+
+            for line in lines:
+                stripped = line.strip()
+
+                # Check for blank lines first
+                if not stripped:
+                    blank_lines += 1
+                    continue
+
+                # Check if we're in a multi-line comment
+                if in_multiline_comment:
+                    comment_lines += 1
+                    # Check if this line ends the multi-line comment
+                    if "*/" in stripped:
+                        in_multiline_comment = False
+                    continue
+
+                # Check for multi-line comment start
+                if stripped.startswith("/**") or stripped.startswith("/*"):
+                    comment_lines += 1
+                    # Check if this line also ends the comment
+                    if "*/" not in stripped:
+                        in_multiline_comment = True
+                    continue
+
+                # Check for single-line comments
+                if stripped.startswith("//"):
+                    comment_lines += 1
+                    continue
+
+                # Check for JavaDoc continuation lines (lines starting with * but not */)
+                if stripped.startswith("*") and not stripped.startswith("*/"):
+                    comment_lines += 1
+                    continue
+
+                # Check for other comment types based on language
+                if (
+                    language == "python"
+                    and stripped.startswith("#")
+                    or language == "sql"
+                    and stripped.startswith("--")
+                ):
+                    comment_lines += 1
+                    continue
+                elif language in ["html", "xml"] and stripped.startswith("<!--"):
+                    comment_lines += 1
+                    if "-->" not in stripped:
+                        in_multiline_comment = True
+                    continue
+
+                # If not a comment, it's code
+                code_lines += 1
+
+            # Ensure the sum equals total_lines (handle any rounding errors)
+            calculated_total = code_lines + comment_lines + blank_lines
+            if calculated_total != total_lines:
+                # Adjust blank_lines to match total (since it's most likely to be off by 1)
+                blank_lines = total_lines - code_lines - comment_lines
+                # Ensure blank_lines is not negative
+                blank_lines = max(0, blank_lines)
+
+            return {
+                "total_lines": total_lines,
+                "code_lines": code_lines,
+                "comment_lines": comment_lines,
+                "blank_lines": blank_lines,
+            }
+        except Exception:
+            # Fallback to basic counting if file read fails
+            return {
+                "total_lines": 0,
+                "code_lines": 0,
+                "comment_lines": 0,
+                "blank_lines": 0,
+            }
+
+    def _output_statistics(self, analysis_result: "AnalysisResult") -> None:
+        """Output statistics only."""
+        stats = {
+            "line_count": analysis_result.line_count,
+            "element_count": len(analysis_result.elements),
+            "node_count": analysis_result.node_count,
+            "language": analysis_result.language,
+        }
+        output_section("Statistics")
+        if self.args.output_format == "json":
+            output_json(stats)
+        else:
+            for key, value in stats.items():
+                output_data(f"{key}: {value}")
+
+    def _output_full_analysis(self, analysis_result: "AnalysisResult") -> None:
+        """Output full analysis results."""
+        output_section("Advanced Analysis Results")
+        if self.args.output_format == "json":
+            result_dict = {
+                "file_path": analysis_result.file_path,
+                "language": analysis_result.language,
+                "line_count": analysis_result.line_count,
+                "element_count": len(analysis_result.elements),
+                "node_count": analysis_result.node_count,
+                "elements": [
+                    {
+                        "name": getattr(element, "name", str(element)),
+                        "type": get_element_type(element),
+                        "start_line": getattr(element, "start_line", 0),
+                        "end_line": getattr(element, "end_line", 0),
+                    }
+                    for element in analysis_result.elements
+                ],
+                "success": analysis_result.success,
+                "analysis_time": analysis_result.analysis_time,
+            }
+            output_json(result_dict)
+        else:
+            self._output_text_analysis(analysis_result)
+
+    def _output_text_analysis(self, analysis_result: "AnalysisResult") -> None:
+        """Output analysis in text format."""
+        output_data(f"File: {analysis_result.file_path}")
+        output_data("Package: (default)")
+        output_data(f"Lines: {analysis_result.line_count}")
+
+        element_counts: dict[str, int] = {}
+        complexity_scores: list[int] = []
+
+        for element in analysis_result.elements:
+            element_type = get_element_type(element)
+            element_counts[element_type] = element_counts.get(element_type, 0) + 1
+
+            # Collect complexity scores for methods
+            if element_type == ELEMENT_TYPE_FUNCTION:
+                complexity = getattr(element, "complexity_score", 1)
+                complexity_scores.append(complexity)
+
+        # Calculate accurate file metrics
+        file_metrics = self._calculate_file_metrics(
+            analysis_result.file_path, analysis_result.language
+        )
+
+        # Calculate complexity statistics
+        total_complexity = sum(complexity_scores) if complexity_scores else 0
+        avg_complexity = (
+            total_complexity / len(complexity_scores) if complexity_scores else 0
+        )
+        max_complexity = max(complexity_scores) if complexity_scores else 0
+
+        output_data(f"Classes: {element_counts.get(ELEMENT_TYPE_CLASS, 0)}")
+        output_data(f"Methods: {element_counts.get(ELEMENT_TYPE_FUNCTION, 0)}")
+        output_data(f"Fields: {element_counts.get(ELEMENT_TYPE_VARIABLE, 0)}")
+        output_data(f"Imports: {element_counts.get(ELEMENT_TYPE_IMPORT, 0)}")
+        output_data("Annotations: 0")
+
+        # Add detailed metrics using accurate calculations
+        output_data(f"Code Lines: {file_metrics['code_lines']}")
+        output_data(f"Comment Lines: {file_metrics['comment_lines']}")
+        output_data(f"Blank Lines: {file_metrics['blank_lines']}")
+        output_data(f"Total Complexity: {total_complexity}")
+        output_data(f"Average Complexity: {avg_complexity:.2f}")
+        output_data(f"Max Complexity: {max_complexity}")

tree_sitter_analyzer/cli/commands/base_command.py

@@ -0,0 +1,181 @@
+#!/usr/bin/env python3
+"""
+Base Command Class
+
+Abstract base class for all CLI commands implementing the Command Pattern.
+"""
+
+import asyncio
+from abc import ABC, abstractmethod
+from argparse import Namespace
+from typing import Optional
+
+from ...core.analysis_engine import AnalysisRequest, get_analysis_engine
+from ...file_handler import read_file_partial
+from ...language_detector import detect_language_from_file, is_language_supported
+from ...models import AnalysisResult
+from ...output_manager import output_error, output_info
+from ...project_detector import detect_project_root
+from ...security import SecurityValidator
+
+
+class BaseCommand(ABC):
+    """
+    Base class for all CLI commands.
+
+    Implements common functionality like file validation, language detection,
+    and analysis engine interaction.
+    """
+
+    def __init__(self, args: Namespace):
+        """Initialize command with parsed arguments."""
+        self.args = args
+
+        # Detect project root with priority handling
+        file_path = getattr(args, "file_path", None)
+        explicit_root = getattr(args, "project_root", None)
+        self.project_root = detect_project_root(file_path, explicit_root)
+
+        # Initialize components with project root
+        self.analysis_engine = get_analysis_engine(self.project_root)
+        self.security_validator = SecurityValidator(self.project_root)
+
+    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:
+            output_error("File path not specified.")
+            return False
+
+        # Security validation
+        is_valid, error_msg = self.security_validator.validate_file_path(
+            self.args.file_path
+        )
+        if not is_valid:
+            output_error(f"Invalid file path: {error_msg}")
+            return False
+
+        from pathlib import Path
+
+        if not Path(self.args.file_path).exists():
+            output_error("Invalid file path: file does not exist")
+            return False
+
+        return True
+
+    def detect_language(self) -> str | None:
+        """Detect or validate the target language."""
+        if hasattr(self.args, "language") and self.args.language:
+            # Sanitize language input
+            sanitized_language = self.security_validator.sanitize_input(
+                self.args.language, max_length=50
+            )
+            target_language = sanitized_language.lower()
+            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 explicitly specified: {target_language}")
+        else:
+            target_language = detect_language_from_file(self.args.file_path)
+            if target_language == "unknown":
+                output_error(
+                    f"ERROR: Could not determine language for file '{self.args.file_path}'."
+                )
+                return None
+            else:
+                if (not hasattr(self.args, "table") or not self.args.table) and (
+                    not hasattr(self.args, "quiet") or not self.args.quiet
+                ):
+                    # Language auto-detected - only show in verbose mode
+                    pass
+
+        # Language support validation
+        if not is_language_supported(target_language):
+            if target_language != "java":
+                if (not hasattr(self.args, "table") or not self.args.table) and (
+                    not hasattr(self.args, "quiet") or not self.args.quiet
+                ):
+                    output_info(
+                        "INFO: Trying with Java analysis engine. May not work correctly."
+                    )
+                target_language = "java"  # Fallback
+
+        return str(target_language) if target_language else None
+
+    async def analyze_file(self, language: str) -> Optional["AnalysisResult"]:
+        """Perform file analysis using the unified analysis engine."""
+        try:
+            # Handle partial read if enabled
+            if hasattr(self.args, "partial_read") and self.args.partial_read:
+                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:
+                        output_error("Failed to read file partially")
+                        return None
+                except Exception as e:
+                    output_error(f"Failed to read file partially: {e}")
+                    return None
+
+            request = AnalysisRequest(
+                file_path=self.args.file_path,
+                language=language,
+                include_complexity=True,
+                include_details=True,
+            )
+            analysis_result = await self.analysis_engine.analyze(request)
+
+            if not analysis_result or not analysis_result.success:
+                error_msg = (
+                    analysis_result.error_message
+                    if analysis_result
+                    else "Unknown error"
+                )
+                output_error(f"Analysis failed: {error_msg}")
+                return None
+
+            return analysis_result
+
+        except Exception as e:
+            output_error(f"An error occurred during analysis: {e}")
+            return None
+
+    def execute(self) -> int:
+        """
+        Execute the command.
+
+        Returns:
+            int: Exit code (0 for success, 1 for failure)
+        """
+        # Validate inputs
+        if not self.validate_file():
+            return 1
+
+        # Detect language
+        language = self.detect_language()
+        if not language:
+            return 1
+
+        # Execute the specific command
+        try:
+            return asyncio.run(self.execute_async(language))
+        except Exception as e:
+            output_error(f"An error occurred during command execution: {e}")
+            return 1
+
+    @abstractmethod
+    async def execute_async(self, language: str) -> int:
+        """
+        Execute the command asynchronously.
+
+        Args:
+            language: Detected/specified target language
+
+        Returns:
+            int: Exit code (0 for success, 1 for failure)
+        """
+        pass

tree_sitter_analyzer/cli/commands/default_command.py

@@ -0,0 +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