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

tree_sitter_analyzer/cli/commands/find_and_grep_cli.py

@@ -0,0 +1,188 @@
+#!/usr/bin/env python3
+"""
+Standalone CLI for find_and_grep (fd → ripgrep composition)
+
+Maps CLI flags to the MCP FindAndGrepTool and prints JSON/text.
+"""
+
+from __future__ import annotations
+
+import argparse
+import asyncio
+import sys
+from typing import Any
+
+from ...mcp.tools.find_and_grep_tool import FindAndGrepTool
+from ...output_manager import output_data, output_error, set_output_mode
+from ...project_detector import detect_project_root
+
+
+def _build_parser() -> argparse.ArgumentParser:
+    parser = argparse.ArgumentParser(
+        description="Two-stage search: fd for files, then ripgrep for content.",
+    )
+
+    # Required
+    parser.add_argument("--roots", nargs="+", required=True, help="Search roots")
+    parser.add_argument("--query", required=True, help="Content query")
+
+    # Output
+    parser.add_argument(
+        "--output-format",
+        choices=["json", "text"],
+        default="json",
+        help="Output format (default: json)",
+    )
+    parser.add_argument(
+        "--quiet",
+        action="store_true",
+        help="Suppress non-essential output",
+    )
+
+    # fd options (subset mirrors ListFiles)
+    parser.add_argument("--pattern")
+    parser.add_argument("--glob", action="store_true")
+    parser.add_argument("--types", nargs="+")
+    parser.add_argument("--extensions", nargs="+")
+    parser.add_argument("--exclude", nargs="+")
+    parser.add_argument("--depth", type=int)
+    parser.add_argument("--follow-symlinks", action="store_true")
+    parser.add_argument("--hidden", action="store_true")
+    parser.add_argument("--no-ignore", action="store_true")
+    parser.add_argument("--size", nargs="+")
+    parser.add_argument("--changed-within")
+    parser.add_argument("--changed-before")
+    parser.add_argument("--full-path-match", action="store_true")
+    parser.add_argument("--file-limit", type=int)
+    parser.add_argument("--sort", choices=["path", "mtime", "size"])
+
+    # rg options (subset mirrors SearchContent)
+    parser.add_argument(
+        "--case", choices=["smart", "insensitive", "sensitive"], default="smart"
+    )
+    parser.add_argument("--fixed-strings", action="store_true")
+    parser.add_argument("--word", action="store_true")
+    parser.add_argument("--multiline", action="store_true")
+    parser.add_argument("--include-globs", nargs="+")
+    parser.add_argument("--exclude-globs", nargs="+")
+    parser.add_argument("--max-filesize")
+    parser.add_argument("--context-before", type=int)
+    parser.add_argument("--context-after", type=int)
+    parser.add_argument("--encoding")
+    parser.add_argument("--max-count", type=int)
+    parser.add_argument("--timeout-ms", type=int)
+    parser.add_argument("--count-only-matches", action="store_true")
+    parser.add_argument("--summary-only", action="store_true")
+    parser.add_argument("--optimize-paths", action="store_true")
+    parser.add_argument("--group-by-file", action="store_true")
+    parser.add_argument("--total-only", action="store_true")
+
+    # project root
+    parser.add_argument(
+        "--project-root",
+        help="Project root directory for security boundary (auto-detected if omitted)",
+    )
+
+    return parser
+
+
+async def _run(args: argparse.Namespace) -> int:
+    set_output_mode(quiet=bool(args.quiet), json_output=(args.output_format == "json"))
+
+    project_root = detect_project_root(None, args.project_root)
+    tool = FindAndGrepTool(project_root)
+
+    payload: dict[str, Any] = {
+        "roots": list(args.roots),
+        "query": args.query,
+    }
+
+    # fd stage mappings
+    if args.pattern:
+        payload["pattern"] = args.pattern
+    if args.glob:
+        payload["glob"] = True
+    if args.types:
+        payload["types"] = args.types
+    if args.extensions:
+        payload["extensions"] = args.extensions
+    if args.exclude:
+        payload["exclude"] = args.exclude
+    if args.depth is not None:
+        payload["depth"] = int(args.depth)
+    if args.follow_symlinks:
+        payload["follow_symlinks"] = True
+    if args.hidden:
+        payload["hidden"] = True
+    if args.no_ignore:
+        payload["no_ignore"] = True
+    if args.size:
+        payload["size"] = args.size
+    if args.changed_within:
+        payload["changed_within"] = args.changed_within
+    if args.changed_before:
+        payload["changed_before"] = args.changed_before
+    if args.full_path_match:
+        payload["full_path_match"] = True
+    if args.file_limit is not None:
+        payload["file_limit"] = int(args.file_limit)
+    if args.sort:
+        payload["sort"] = args.sort
+
+    # rg stage mappings
+    if args.case:
+        payload["case"] = args.case
+    if args.fixed_strings:
+        payload["fixed_strings"] = True
+    if args.word:
+        payload["word"] = True
+    if args.multiline:
+        payload["multiline"] = True
+    if args.include_globs:
+        payload["include_globs"] = args.include_globs
+    if args.exclude_globs:
+        payload["exclude_globs"] = args.exclude_globs
+    if args.max_filesize:
+        payload["max_filesize"] = args.max_filesize
+    if args.context_before is not None:
+        payload["context_before"] = int(args.context_before)
+    if args.context_after is not None:
+        payload["context_after"] = int(args.context_after)
+    if args.encoding:
+        payload["encoding"] = args.encoding
+    if args.max_count is not None:
+        payload["max_count"] = int(args.max_count)
+    if args.timeout_ms is not None:
+        payload["timeout_ms"] = int(args.timeout_ms)
+    if args.count_only_matches:
+        payload["count_only_matches"] = True
+    if args.summary_only:
+        payload["summary_only"] = True
+    if args.optimize_paths:
+        payload["optimize_paths"] = True
+    if args.group_by_file:
+        payload["group_by_file"] = True
+    if args.total_only:
+        payload["total_only"] = True
+
+    try:
+        result = await tool.execute(payload)
+        output_data(result, args.output_format)
+        return 0 if (isinstance(result, dict) or isinstance(result, int)) else 0
+    except Exception as e:
+        output_error(str(e))
+        return 1
+
+
+def main() -> None:
+    parser = _build_parser()
+    args = parser.parse_args()
+    try:
+        rc = asyncio.run(_run(args))
+    except KeyboardInterrupt:
+        rc = 1
+    sys.exit(rc)
+
+
+if __name__ == "__main__":
+    main()

tree_sitter_analyzer/cli/commands/list_files_cli.py

@@ -0,0 +1,133 @@
+#!/usr/bin/env python3
+"""
+Standalone CLI for list_files (fd wrapper)
+
+Maps CLI flags to the MCP ListFilesTool and prints JSON/text via OutputManager.
+"""
+
+from __future__ import annotations
+
+import argparse
+import asyncio
+import sys
+from typing import Any
+
+from ...mcp.tools.list_files_tool import ListFilesTool
+from ...output_manager import output_data, output_error, set_output_mode
+from ...project_detector import detect_project_root
+
+
+def _build_parser() -> argparse.ArgumentParser:
+    parser = argparse.ArgumentParser(
+        description="List files and directories using fd via MCP wrapper.",
+    )
+
+    # Roots
+    parser.add_argument(
+        "roots",
+        nargs="+",
+        help="One or more root directories to search in",
+    )
+
+    # Output
+    parser.add_argument(
+        "--output-format",
+        choices=["json", "text"],
+        default="json",
+        help="Output format (default: json)",
+    )
+    parser.add_argument(
+        "--quiet",
+        action="store_true",
+        help="Suppress non-essential output",
+    )
+
+    # fd options
+    parser.add_argument("--pattern")
+    parser.add_argument("--glob", action="store_true")
+    parser.add_argument("--types", nargs="+")
+    parser.add_argument("--extensions", nargs="+")
+    parser.add_argument("--exclude", nargs="+")
+    parser.add_argument("--depth", type=int)
+    parser.add_argument("--follow-symlinks", action="store_true")
+    parser.add_argument("--hidden", action="store_true")
+    parser.add_argument("--no-ignore", action="store_true")
+    parser.add_argument("--size", nargs="+")
+    parser.add_argument("--changed-within")
+    parser.add_argument("--changed-before")
+    parser.add_argument("--full-path-match", action="store_true")
+    parser.add_argument("--limit", type=int)
+    parser.add_argument("--count-only", action="store_true")
+
+    # project root
+    parser.add_argument(
+        "--project-root",
+        help="Project root directory for security boundary (auto-detected if omitted)",
+    )
+
+    return parser
+
+
+async def _run(args: argparse.Namespace) -> int:
+    set_output_mode(quiet=bool(args.quiet), json_output=(args.output_format == "json"))
+
+    project_root = detect_project_root(None, args.project_root)
+    tool = ListFilesTool(project_root)
+
+    payload: dict[str, Any] = {
+        "roots": list(args.roots),
+    }
+
+    # Optional mappings
+    if args.pattern:
+        payload["pattern"] = args.pattern
+    if args.glob:
+        payload["glob"] = True
+    if args.types:
+        payload["types"] = args.types
+    if args.extensions:
+        payload["extensions"] = args.extensions
+    if args.exclude:
+        payload["exclude"] = args.exclude
+    if args.depth is not None:
+        payload["depth"] = int(args.depth)
+    if args.follow_symlinks:
+        payload["follow_symlinks"] = True
+    if args.hidden:
+        payload["hidden"] = True
+    if args.no_ignore:
+        payload["no_ignore"] = True
+    if args.size:
+        payload["size"] = args.size
+    if args.changed_within:
+        payload["changed_within"] = args.changed_within
+    if args.changed_before:
+        payload["changed_before"] = args.changed_before
+    if args.full_path_match:
+        payload["full_path_match"] = True
+    if args.limit is not None:
+        payload["limit"] = int(args.limit)
+    if args.count_only:
+        payload["count_only"] = True
+
+    try:
+        result = await tool.execute(payload)
+        output_data(result, args.output_format)
+        return 0 if (isinstance(result, dict) and result.get("success", True)) else 0
+    except Exception as e:
+        output_error(str(e))
+        return 1
+
+
+def main() -> None:
+    parser = _build_parser()
+    args = parser.parse_args()
+    try:
+        rc = asyncio.run(_run(args))
+    except KeyboardInterrupt:
+        rc = 1
+    sys.exit(rc)
+
+
+if __name__ == "__main__":
+    main()

tree_sitter_analyzer/cli/commands/partial_read_command.py

@@ -0,0 +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
+
+        from pathlib import Path
+
+        if not Path(self.args.file_path).exists():
+            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

@@ -0,0 +1,109 @@
+#!/usr/bin/env python3
+"""
+Query Command
+
+Handles query execution functionality.
+"""
+
+from typing import Any
+
+from ...core.query_service import QueryService
+from ...output_manager import output_data, output_error, output_info, output_json
+from .base_command import BaseCommand
+
+
+class QueryCommand(BaseCommand):
+    """Command for executing queries."""
+
+    def __init__(self, args: Any) -> None:
+        """Initialize the query command with QueryService."""
+        super().__init__(args)
+        self.query_service = QueryService()
+
+    async def execute_query(
+        self, language: str, query: str, query_name: str = "custom"
+    ) -> list[dict] | None:
+        """Execute a specific tree-sitter query using QueryService."""
+        try:
+            # Get filter expression if provided
+            filter_expression = getattr(self.args, "filter", None)
+
+            if query_name != "custom":
+                # Use predefined query key
+                results = await self.query_service.execute_query(
+                    self.args.file_path,
+                    language,
+                    query_key=query_name,
+                    filter_expression=filter_expression,
+                )
+            else:
+                # Use custom query string
+                results = await self.query_service.execute_query(
+                    self.args.file_path,
+                    language,
+                    query_string=query,
+                    filter_expression=filter_expression,
+                )
+
+            return results
+
+        except Exception as e:
+            output_error(f"Query execution failed: {e}")
+            return None
+
+    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
+            )
+            # Check if query exists
+            available_queries = self.query_service.get_available_queries(language)
+            if sanitized_query_key not in available_queries:
+                output_error(
+                    f"Query '{sanitized_query_key}' not found for language '{language}'"
+                )
+                return 1
+            # Store query name - QueryService will resolve the query string
+            query_to_execute = sanitized_query_key  # This is actually the query key now
+            query_name = sanitized_query_key
+        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
+            query_name = "custom"
+
+        if not query_to_execute:
+            output_error("No query specified.")
+            return 1
+
+        # Execute specific query
+        results = await self.execute_query(language, query_to_execute, query_name)
+        if results is None:
+            return 1
+
+        # 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