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

tree_sitter_analyzer/cli/commands/search_content_cli.py

@@ -0,0 +1,161 @@
+#!/usr/bin/env python3
+"""
+Standalone CLI for search_content (ripgrep wrapper)
+
+Maps CLI flags to the MCP SearchContentTool and prints JSON/text.
+"""
+
+from __future__ import annotations
+
+import argparse
+import asyncio
+import sys
+from typing import Any
+
+from ...mcp.tools.search_content_tool import SearchContentTool
+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="Search text content in files using ripgrep via MCP wrapper.",
+    )
+
+    roots_or_files = parser.add_mutually_exclusive_group(required=True)
+    roots_or_files.add_argument(
+        "--roots",
+        nargs="+",
+        help="Directory roots to search recursively",
+    )
+    roots_or_files.add_argument(
+        "--files",
+        nargs="+",
+        help="Explicit file list to search",
+    )
+
+    parser.add_argument("--query", required=True, help="Search pattern")
+
+    # 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",
+    )
+
+    # rg options
+    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("--follow-symlinks", action="store_true")
+    parser.add_argument("--hidden", action="store_true")
+    parser.add_argument("--no-ignore", action="store_true")
+    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 = SearchContentTool(project_root)
+
+    payload: dict[str, Any] = {
+        "query": args.query,
+    }
+    if args.roots:
+        payload["roots"] = list(args.roots)
+    if args.files:
+        payload["files"] = list(args.files)
+
+    # Options mapping
+    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.follow_symlinks:
+        payload["follow_symlinks"] = True
+    if args.hidden:
+        payload["hidden"] = True
+    if args.no_ignore:
+        payload["no_ignore"] = True
+    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/structure_command.py

@@ -0,0 +1,156 @@
+#!/usr/bin/env python3
+"""
+Structure Command
+
+Handles structure analysis functionality with appropriate Japanese output.
+"""
+
+from typing import TYPE_CHECKING
+
+from ...constants import (
+    ELEMENT_TYPE_CLASS,
+    ELEMENT_TYPE_FUNCTION,
+    ELEMENT_TYPE_IMPORT,
+    ELEMENT_TYPE_PACKAGE,
+    ELEMENT_TYPE_VARIABLE,
+    is_element_of_type,
+)
+from ...output_manager import output_data, output_json, output_section
+from .base_command import BaseCommand
+
+if TYPE_CHECKING:
+    from ...models import AnalysisResult
+
+
+class StructureCommand(BaseCommand):
+    """Command for structure analysis with Japanese output."""
+
+    async def execute_async(self, language: str) -> int:
+        analysis_result = await self.analyze_file(language)
+        if not analysis_result:
+            return 1
+
+        self._output_structure_analysis(analysis_result)
+        return 0
+
+    def _output_structure_analysis(self, analysis_result: "AnalysisResult") -> None:
+        """Output structure analysis results with appropriate header."""
+        output_section("Structure Analysis Results")
+
+        # Convert to legacy structure format expected by tests
+        structure_dict = self._convert_to_legacy_format(analysis_result)
+
+        if self.args.output_format == "json":
+            output_json(structure_dict)
+        else:
+            self._output_text_format(structure_dict)
+
+    def _convert_to_legacy_format(self, analysis_result: "AnalysisResult") -> dict:
+        """Convert AnalysisResult to legacy structure format expected by tests."""
+        import time
+
+        # Extract elements by type
+        classes = [
+            e
+            for e in analysis_result.elements
+            if is_element_of_type(e, ELEMENT_TYPE_CLASS)
+        ]
+        methods = [
+            e
+            for e in analysis_result.elements
+            if is_element_of_type(e, ELEMENT_TYPE_FUNCTION)
+        ]
+        fields = [
+            e
+            for e in analysis_result.elements
+            if is_element_of_type(e, ELEMENT_TYPE_VARIABLE)
+        ]
+        imports = [
+            e
+            for e in analysis_result.elements
+            if is_element_of_type(e, ELEMENT_TYPE_IMPORT)
+        ]
+        packages = [
+            e
+            for e in analysis_result.elements
+            if is_element_of_type(e, ELEMENT_TYPE_PACKAGE)
+        ]
+
+        return {
+            "file_path": analysis_result.file_path,
+            "language": analysis_result.language,
+            "package": (
+                {
+                    "name": packages[0].name,
+                    "line_range": {
+                        "start": packages[0].start_line,
+                        "end": packages[0].end_line,
+                    },
+                }
+                if packages
+                else None
+            ),
+            "classes": [{"name": getattr(c, "name", "unknown")} for c in classes],
+            "methods": [{"name": getattr(m, "name", "unknown")} for m in methods],
+            "fields": [{"name": getattr(f, "name", "unknown")} for f in fields],
+            "imports": [
+                {
+                    "name": getattr(i, "name", "unknown"),
+                    "is_static": getattr(i, "is_static", False),
+                    "is_wildcard": getattr(i, "is_wildcard", False),
+                    "statement": getattr(i, "import_statement", ""),
+                    "line_range": {
+                        "start": getattr(i, "start_line", 0),
+                        "end": getattr(i, "end_line", 0),
+                    },
+                }
+                for i in imports
+            ],
+            "annotations": [],
+            "statistics": {
+                "class_count": len(classes),
+                "method_count": len(methods),
+                "field_count": len(fields),
+                "import_count": len(imports),
+                "total_lines": analysis_result.line_count,
+                "annotation_count": 0,
+            },
+            "analysis_metadata": {
+                "analysis_time": getattr(analysis_result, "analysis_time", 0.0),
+                "language": analysis_result.language,
+                "file_path": analysis_result.file_path,
+                "analyzer_version": "2.0.0",
+                "timestamp": time.time(),
+            },
+        }
+
+    def _output_text_format(self, structure_dict: dict) -> None:
+        """Output structure analysis in human-readable text format."""
+        output_data(f"File: {structure_dict['file_path']}")
+        output_data(f"Language: {structure_dict['language']}")
+
+        if structure_dict["package"]:
+            output_data(f"Package: {structure_dict['package']['name']}")
+
+        stats = structure_dict["statistics"]
+        output_data("Statistics:")
+        output_data(f"  Classes: {stats['class_count']}")
+        output_data(f"  Methods: {stats['method_count']}")
+        output_data(f"  Fields: {stats['field_count']}")
+        output_data(f"  Imports: {stats['import_count']}")
+        output_data(f"  Total lines: {stats['total_lines']}")
+
+        if structure_dict["classes"]:
+            output_data("Classes:")
+            for cls in structure_dict["classes"]:
+                output_data(f"  - {cls['name']}")
+
+        if structure_dict["methods"]:
+            output_data("Methods:")
+            for method in structure_dict["methods"]:
+                output_data(f"  - {method['name']}")
+
+        if structure_dict["fields"]:
+            output_data("Fields:")
+            for field in structure_dict["fields"]:
+                output_data(f"  - {field['name']}")

tree_sitter_analyzer/cli/commands/summary_command.py

@@ -0,0 +1,116 @@
+#!/usr/bin/env python3
+"""
+Summary Command
+
+Handles summary functionality with specified element types.
+"""
+
+from typing import TYPE_CHECKING, Any
+
+from ...constants import (
+    ELEMENT_TYPE_CLASS,
+    ELEMENT_TYPE_FUNCTION,
+    ELEMENT_TYPE_IMPORT,
+    ELEMENT_TYPE_VARIABLE,
+    is_element_of_type,
+)
+from ...output_manager import output_data, output_json, output_section
+from .base_command import BaseCommand
+
+if TYPE_CHECKING:
+    from ...models import AnalysisResult
+
+
+class SummaryCommand(BaseCommand):
+    """Command for summary analysis with specified element types."""
+
+    async def execute_async(self, language: str) -> int:
+        analysis_result = await self.analyze_file(language)
+        if not analysis_result:
+            return 1
+
+        self._output_summary_analysis(analysis_result)
+        return 0
+
+    def _output_summary_analysis(self, analysis_result: "AnalysisResult") -> None:
+        """Output summary analysis results."""
+        output_section("Summary Results")
+
+        # Get summary types from args (default: classes,methods)
+        summary_types = getattr(self.args, "summary", "classes,methods")
+        if summary_types:
+            requested_types = [t.strip() for t in summary_types.split(",")]
+        else:
+            requested_types = ["classes", "methods"]
+
+        # Extract elements by type
+        classes = [
+            e
+            for e in analysis_result.elements
+            if is_element_of_type(e, ELEMENT_TYPE_CLASS)
+        ]
+        methods = [
+            e
+            for e in analysis_result.elements
+            if is_element_of_type(e, ELEMENT_TYPE_FUNCTION)
+        ]
+        fields = [
+            e
+            for e in analysis_result.elements
+            if is_element_of_type(e, ELEMENT_TYPE_VARIABLE)
+        ]
+        imports = [
+            e
+            for e in analysis_result.elements
+            if is_element_of_type(e, ELEMENT_TYPE_IMPORT)
+        ]
+
+        summary_data: dict[str, Any] = {
+            "file_path": analysis_result.file_path,
+            "language": analysis_result.language,
+            "summary": {},
+        }
+
+        if "classes" in requested_types:
+            summary_data["summary"]["classes"] = [
+                {"name": getattr(c, "name", "unknown")} for c in classes
+            ]
+
+        if "methods" in requested_types:
+            summary_data["summary"]["methods"] = [
+                {"name": getattr(m, "name", "unknown")} for m in methods
+            ]
+
+        if "fields" in requested_types:
+            summary_data["summary"]["fields"] = [
+                {"name": getattr(f, "name", "unknown")} for f in fields
+            ]
+
+        if "imports" in requested_types:
+            summary_data["summary"]["imports"] = [
+                {"name": getattr(i, "name", "unknown")} for i in imports
+            ]
+
+        if self.args.output_format == "json":
+            output_json(summary_data)
+        else:
+            self._output_text_format(summary_data, requested_types)
+
+    def _output_text_format(self, summary_data: dict, requested_types: list) -> None:
+        """Output summary in human-readable text format."""
+        output_data(f"File: {summary_data['file_path']}")
+        output_data(f"Language: {summary_data['language']}")
+
+        for element_type in requested_types:
+            if element_type in summary_data["summary"]:
+                elements = summary_data["summary"][element_type]
+                type_name_map = {
+                    "classes": "Classes",
+                    "methods": "Methods",
+                    "fields": "Fields",
+                    "imports": "Imports",
+                }
+                type_name = type_name_map.get(element_type, element_type)
+                output_data(f"\n{type_name} ({len(elements)} items):")
+                for element in elements:
+                    output_data(f"  - {element['name']}")