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

tree_sitter_analyzer/output_manager.py

@@ -0,0 +1,264 @@
+#!/usr/bin/env python3
+# -*- coding: utf-8 -*-
+"""
+Output Manager for CLI
+
+Handles different types of outputs: user information, errors, and structured data.
+"""
+
+import json
+import sys
+from typing import Any, Dict, List, Optional, Union
+
+from .utils import log_error, log_warning
+
+
+class OutputManager:
+    """Manages different types of output for CLI"""
+
+    def __init__(self, quiet: bool = False, json_output: bool = False):
+        self.quiet = quiet
+        self.json_output = json_output
+
+    def info(self, message: str) -> None:
+        """Output informational message to user"""
+        if not self.quiet:
+            print(message)
+
+    def warning(self, message: str) -> None:
+        """Output warning message"""
+        if not self.quiet:
+            print(f"WARNING: {message}", file=sys.stderr)
+        log_warning(message)
+
+    def error(self, message: str) -> None:
+        """Output error message"""
+        print(f"ERROR: {message}", file=sys.stderr)
+        log_error(message)
+
+    def success(self, message: str) -> None:
+        """Output success message"""
+        if not self.quiet:
+            print(f"✓ {message}")
+
+    def output_info(self, message: str) -> None:
+        """Output info message (alias for info)"""
+        self.info(message)
+
+    def output_warning(self, message: str) -> None:
+        """Output warning message (alias for warning)"""
+        self.warning(message)
+
+    def output_error(self, message: str) -> None:
+        """Output error message (alias for error)"""
+        self.error(message)
+
+    def output_success(self, message: str) -> None:
+        """Output success message (alias for success)"""
+        self.success(message)
+
+    def data(self, data: Any, format_type: str = "json") -> None:
+        """Output structured data"""
+        if self.json_output or format_type == "json":
+            print(json.dumps(data, indent=2, ensure_ascii=False))
+        else:
+            self._format_data(data)
+
+    def _format_data(self, data: Any) -> None:
+        """Format data for human-readable output"""
+        if isinstance(data, dict):
+            for key, value in data.items():
+                print(f"{key}: {value}")
+        elif isinstance(data, list):
+            for i, item in enumerate(data, 1):
+                print(f"{i}. {item}")
+        else:
+            print(str(data))
+
+    def results_header(self, title: str) -> None:
+        """Output results section header"""
+        if not self.quiet:
+            print(f"\n--- {title} ---")
+
+    def query_result(self, index: int, result: Dict[str, Any]) -> None:
+        """Output query result in formatted way"""
+        if not self.quiet:
+            print(
+                f"\n{index}. {result.get('capture_name', 'Unknown')} ({result.get('node_type', 'Unknown')})"
+            )
+            print(
+                f"   位置: 行 {result.get('start_line', '?')}-{result.get('end_line', '?')}"
+            )
+            if "content" in result:
+                print(f"   内容:\n{result['content']}")
+
+    def analysis_summary(self, stats: Dict[str, Any]) -> None:
+        """Output analysis summary"""
+        if self.json_output:
+            self.data(stats)
+        else:
+            self.results_header("統計情報")
+            for key, value in stats.items():
+                print(f"{key}: {value}")
+
+    def language_list(
+        self, languages: List[str], title: str = "サポートされている言語"
+    ) -> None:
+        """Output language list"""
+        if not self.quiet:
+            print(f"{title}:")
+            for lang in languages:
+                print(f"  {lang}")
+
+    def query_list(self, queries: Dict[str, str], language: str) -> None:
+        """Output query list for a language"""
+        if not self.quiet:
+            print(f"利用可能なクエリキー ({language}):")
+            for query_key, description in queries.items():
+                print(f"  {query_key:<20} - {description}")
+
+    def extension_list(self, extensions: List[str]) -> None:
+        """Output supported extensions"""
+        if not self.quiet:
+            print("サポートされている拡張子:")
+            for i in range(0, len(extensions), 10):
+                chunk = extensions[i : i + 10]
+                print(f"  {' '.join(chunk)}")
+            print(f"合計 {len(extensions)} 個の拡張子をサポート")
+
+    def output_json(self, data: Any) -> None:
+        """Output JSON data"""
+        print(json.dumps(data, indent=2, ensure_ascii=False))
+
+    def output_list(
+        self, items: Union[str, List[Any]], title: Optional[str] = None
+    ) -> None:
+        """Output a list of items"""
+        if title and not self.quiet:
+            print(f"{title}:")
+        # 文字列が単一要素として渡された場合の処理
+        if isinstance(items, str):
+            items = [items]
+        for item in items:
+            if not self.quiet:
+                print(f"  {item}")
+
+    def output_section(self, title: str) -> None:
+        """Output a section header"""
+        if not self.quiet:
+            print(f"\n--- {title} ---")
+
+    def output_query_results(self, results: Any) -> None:
+        """Output query results"""
+        self.data(results)
+
+    def output_statistics(self, stats: Dict[str, Any]) -> None:
+        """Output statistics"""
+        self.analysis_summary(stats)
+
+    def output_languages(self, languages: List[str]) -> None:
+        """Output available languages"""
+        self.language_list(languages)
+
+    def output_queries(self, queries: List[str]) -> None:
+        """Output available queries"""
+        if isinstance(queries, list):
+            query_dict = {q: f"Query {q}" for q in queries}
+            self.query_list(query_dict, "All")
+        else:
+            self.query_list(queries, "All")
+
+    def output_extensions(self, extensions: List[str]) -> None:
+        """Output file extensions"""
+        self.extension_list(extensions)
+
+    def output_data(self, data: Any, format_type: str = "json") -> None:
+        """Output data (alias for data)"""
+        self.data(data, format_type)
+
+
+# Default instance for backward compatibility
+_output_manager = OutputManager()
+
+
+def set_output_mode(quiet: bool = False, json_output: bool = False) -> None:
+    """Set global output mode"""
+    global _output_manager
+    _output_manager = OutputManager(quiet=quiet, json_output=json_output)
+
+
+def get_output_manager() -> OutputManager:
+    """Get current output manager"""
+    return _output_manager
+
+
+# Convenience functions
+def output_info(message: str) -> None:
+    """Output info message"""
+    _output_manager.info(message)
+
+
+def output_warning(message: str) -> None:
+    """Output warning message"""
+    _output_manager.warning(message)
+
+
+def output_error(message: str) -> None:
+    """Output error message using the global output manager"""
+    _output_manager.error(message)
+
+
+def output_success(message: str) -> None:
+    """Output success message using the global output manager"""
+    _output_manager.success(message)
+
+
+def output_json(data: Any) -> None:
+    """Output JSON data using the global output manager"""
+    _output_manager.output_json(data)
+
+
+def output_list(items: Union[str, List[Any]], title: Optional[str] = None) -> None:
+    """Output a list of items"""
+    _output_manager.output_list(items, title)
+
+
+def output_section(title: str) -> None:
+    """Output a section header"""
+    _output_manager.output_section(title)
+
+
+def output_query_results(results: Any) -> None:
+    """Output query results"""
+    _output_manager.output_query_results(results)
+
+
+def output_statistics(stats: Dict[str, Any]) -> None:
+    """Output statistics"""
+    _output_manager.output_statistics(stats)
+
+
+def output_languages(
+    languages: List[str], title: str = "サポートされている言語"
+) -> None:
+    """Output available languages"""
+    _output_manager.language_list(languages, title)
+
+
+def output_queries(queries: List[str], language: str = "All") -> None:
+    """Output available queries"""
+    if isinstance(queries, list):
+        query_dict = {q: f"Query {q}" for q in queries}
+        _output_manager.query_list(query_dict, language)
+    else:
+        _output_manager.query_list(queries, language)
+
+
+def output_extensions(extensions: List[str]) -> None:
+    """Output file extensions"""
+    _output_manager.output_extensions(extensions)
+
+
+def output_data(data: Any, format_type: str = "json") -> None:
+    """Output structured data"""
+    _output_manager.data(data, format_type)

tree_sitter_analyzer/plugins/__init__.py

@@ -0,0 +1,334 @@
+#!/usr/bin/env python3
+# -*- coding: utf-8 -*-
+"""
+Plugin System for Multi-Language Code Analysis
+
+This package provides a plugin-based architecture for extending
+the tree-sitter analyzer with language-specific parsers and extractors.
+"""
+
+from abc import ABC, abstractmethod
+from typing import TYPE_CHECKING, Any, Dict, List, Optional, Type
+
+if TYPE_CHECKING:
+    import tree_sitter
+
+from ..models import Class as ModelClass
+from ..models import (
+    CodeElement,
+)
+from ..models import Function as ModelFunction
+from ..models import Import as ModelImport
+from ..models import Variable as ModelVariable
+from ..utils import log_debug, log_error, log_warning
+
+__all__ = ["LanguagePlugin", "ElementExtractor", "PluginRegistry", "plugin_registry"]
+
+
+class ElementExtractor(ABC):
+    """Abstract base class for language-specific element extractors"""
+
+    @abstractmethod
+    def extract_functions(
+        self, tree: "tree_sitter.Tree", source_code: str
+    ) -> List[ModelFunction]:
+        """Extract function definitions from the syntax tree"""
+        log_warning("extract_functions not implemented in subclass")
+        return []
+
+    @abstractmethod
+    def extract_classes(
+        self, tree: "tree_sitter.Tree", source_code: str
+    ) -> List[ModelClass]:
+        """Extract class definitions from the syntax tree"""
+        log_warning("extract_classes not implemented in subclass")
+        return []
+
+    @abstractmethod
+    def extract_variables(
+        self, tree: "tree_sitter.Tree", source_code: str
+    ) -> List[ModelVariable]:
+        """Extract variable declarations from the syntax tree"""
+        log_warning("extract_variables not implemented in subclass")
+        return []
+
+    @abstractmethod
+    def extract_imports(
+        self, tree: "tree_sitter.Tree", source_code: str
+    ) -> List[ModelImport]:
+        """Extract import statements from the syntax tree"""
+        log_warning("extract_imports not implemented in subclass")
+        return []
+
+
+class LanguagePlugin(ABC):
+    """Abstract base class for language-specific plugins"""
+
+    @abstractmethod
+    def get_language_name(self) -> str:
+        """Return the name of the programming language this plugin supports"""
+        return "unknown"
+
+    @abstractmethod
+    def get_file_extensions(self) -> List[str]:
+        """Return list of file extensions this plugin supports"""
+        return []
+
+    @abstractmethod
+    def create_extractor(self) -> ElementExtractor:
+        """Create and return an element extractor for this language"""
+        return DefaultExtractor()
+
+    def is_applicable(self, file_path: str) -> bool:
+        """Check if this plugin is applicable for the given file"""
+        extensions = self.get_file_extensions()
+        return any(file_path.lower().endswith(ext.lower()) for ext in extensions)
+
+
+class DefaultExtractor(ElementExtractor):
+    """Default implementation of ElementExtractor with basic functionality"""
+
+    def extract_functions(
+        self, tree: "tree_sitter.Tree", source_code: str
+    ) -> List[ModelFunction]:
+        """Basic function extraction implementation"""
+        functions: List[ModelFunction] = []
+        try:
+            if hasattr(tree, "root_node"):
+                # Generic function extraction logic
+                self._traverse_for_functions(
+                    tree.root_node, functions, source_code.splitlines()
+                )
+        except Exception as e:
+            log_error(f"Error in function extraction: {e}")
+        return functions
+
+    def extract_classes(
+        self, tree: "tree_sitter.Tree", source_code: str
+    ) -> List[ModelClass]:
+        """Basic class extraction implementation"""
+        classes: List[ModelClass] = []
+        try:
+            if hasattr(tree, "root_node"):
+                # Generic class extraction logic
+                self._traverse_for_classes(
+                    tree.root_node, classes, source_code.splitlines()
+                )
+        except Exception as e:
+            log_error(f"Error in class extraction: {e}")
+        return classes
+
+    def extract_variables(
+        self, tree: "tree_sitter.Tree", source_code: str
+    ) -> List[ModelVariable]:
+        """Basic variable extraction implementation"""
+        variables: List[ModelVariable] = []
+        try:
+            if hasattr(tree, "root_node"):
+                # Generic variable extraction logic
+                self._traverse_for_variables(
+                    tree.root_node, variables, source_code.splitlines()
+                )
+        except Exception as e:
+            log_error(f"Error in variable extraction: {e}")
+        return variables
+
+    def extract_imports(
+        self, tree: "tree_sitter.Tree", source_code: str
+    ) -> List[ModelImport]:
+        """Basic import extraction implementation"""
+        imports: List[ModelImport] = []
+        try:
+            if hasattr(tree, "root_node"):
+                # Generic import extraction logic
+                self._traverse_for_imports(
+                    tree.root_node, imports, source_code.splitlines()
+                )
+        except Exception as e:
+            log_error(f"Error in import extraction: {e}")
+        return imports
+
+    def _traverse_for_functions(
+        self, node: "tree_sitter.Node", functions: List[ModelFunction], lines: List[str]
+    ) -> None:
+        """Traverse tree to find function-like nodes"""
+        if hasattr(node, "type") and "function" in node.type.lower():
+            try:
+                func = ModelFunction(
+                    name=self._extract_node_name(node) or "unknown",
+                    start_line=(
+                        node.start_point[0] + 1 if hasattr(node, "start_point") else 0
+                    ),
+                    end_line=node.end_point[0] + 1 if hasattr(node, "end_point") else 0,
+                    raw_text="",
+                    language="unknown",
+                )
+                functions.append(func)
+            except Exception as e:
+                log_debug(f"Failed to extract function: {e}")
+
+        if hasattr(node, "children"):
+            for child in node.children:
+                self._traverse_for_functions(child, functions, lines)
+
+    def _traverse_for_classes(
+        self, node: "tree_sitter.Node", classes: List[ModelClass], lines: List[str]
+    ) -> None:
+        """Traverse tree to find class-like nodes"""
+        if hasattr(node, "type") and "class" in node.type.lower():
+            try:
+                cls = ModelClass(
+                    name=self._extract_node_name(node) or "unknown",
+                    start_line=(
+                        node.start_point[0] + 1 if hasattr(node, "start_point") else 0
+                    ),
+                    end_line=node.end_point[0] + 1 if hasattr(node, "end_point") else 0,
+                    raw_text="",
+                    language="unknown",
+                )
+                classes.append(cls)
+            except Exception as e:
+                log_debug(f"Failed to extract class: {e}")
+
+        if hasattr(node, "children"):
+            for child in node.children:
+                self._traverse_for_classes(child, classes, lines)
+
+    def _traverse_for_variables(
+        self, node: "tree_sitter.Node", variables: List[ModelVariable], lines: List[str]
+    ) -> None:
+        """Traverse tree to find variable declarations"""
+        if hasattr(node, "type") and (
+            "variable" in node.type.lower() or "declaration" in node.type.lower()
+        ):
+            try:
+                var = ModelVariable(
+                    name=self._extract_node_name(node) or "unknown",
+                    start_line=(
+                        node.start_point[0] + 1 if hasattr(node, "start_point") else 0
+                    ),
+                    end_line=node.end_point[0] + 1 if hasattr(node, "end_point") else 0,
+                    raw_text="",
+                    language="unknown",
+                )
+                variables.append(var)
+            except Exception as e:
+                log_debug(f"Failed to extract variable: {e}")
+
+        if hasattr(node, "children"):
+            for child in node.children:
+                self._traverse_for_variables(child, variables, lines)
+
+    def _traverse_for_imports(
+        self, node: "tree_sitter.Node", imports: List[ModelImport], lines: List[str]
+    ) -> None:
+        """Traverse tree to find import statements"""
+        if hasattr(node, "type") and "import" in node.type.lower():
+            try:
+                imp = ModelImport(
+                    name=self._extract_node_name(node) or "unknown",
+                    start_line=(
+                        node.start_point[0] + 1 if hasattr(node, "start_point") else 0
+                    ),
+                    end_line=node.end_point[0] + 1 if hasattr(node, "end_point") else 0,
+                    raw_text="",
+                    language="unknown",
+                )
+                imports.append(imp)
+            except Exception as e:
+                log_debug(f"Failed to extract import: {e}")
+
+        if hasattr(node, "children"):
+            for child in node.children:
+                self._traverse_for_imports(child, imports, lines)
+
+    def _extract_node_name(self, node: "tree_sitter.Node") -> Optional[str]:
+        """Extract name from a tree-sitter node"""
+        try:
+            # Look for identifier children
+            if hasattr(node, "children"):
+                for child in node.children:
+                    if hasattr(child, "type") and child.type == "identifier":
+                        # This would need actual text extraction in real implementation
+                        return f"element_{child.start_point[0]}_{child.start_point[1]}"
+            return None
+        except Exception:
+            return None
+
+
+class PluginRegistry:
+    """Registry for managing language plugins"""
+
+    def __init__(self) -> None:
+        self._plugins: Dict[str, LanguagePlugin] = {}
+        self._extension_map: Dict[str, LanguagePlugin] = {}
+        self._default_plugin = DefaultLanguagePlugin()
+
+    def register_plugin(self, plugin: LanguagePlugin) -> None:
+        """Register a language plugin"""
+        try:
+            language = plugin.get_language_name()
+            self._plugins[language] = plugin
+
+            # Register file extensions
+            for ext in plugin.get_file_extensions():
+                self._extension_map[ext] = plugin
+
+            log_debug(f"Registered plugin for language: {language}")
+        except Exception as e:
+            log_error(f"Failed to register plugin: {e}")
+
+    def get_plugin(self, language: str) -> Optional[LanguagePlugin]:
+        """Get plugin for specified language"""
+        return self._plugins.get(language)
+
+    def get_plugin_by_extension(self, extension: str) -> Optional[LanguagePlugin]:
+        """Get plugin for specified file extension"""
+        return self._extension_map.get(extension)
+
+    def get_plugin_for_file(self, file_path: str) -> LanguagePlugin:
+        """Get appropriate plugin for a file"""
+        for plugin in self._plugins.values():
+            if plugin.is_applicable(file_path):
+                return plugin
+        return self._default_plugin
+
+    def list_supported_languages(self) -> List[str]:
+        """List all supported languages"""
+        return list(self._plugins.keys())
+
+    def list_supported_extensions(self) -> List[str]:
+        """List all supported file extensions"""
+        return list(self._extension_map.keys())
+
+
+class DefaultLanguagePlugin(LanguagePlugin):
+    """Default plugin that provides basic functionality for any language"""
+
+    def get_language_name(self) -> str:
+        return "generic"
+
+    def get_file_extensions(self) -> List[str]:
+        return [".txt", ".md"]  # Fallback extensions
+
+    def create_extractor(self) -> ElementExtractor:
+        return DefaultExtractor()
+
+
+# Global plugin registry instance
+plugin_registry = PluginRegistry()
+
+
+# Auto-load all plugins when the package is imported
+try:
+    from .plugin_loader import (
+        get_supported_extensions,
+        get_supported_languages,
+        load_all_plugins,
+    )
+
+    # Plugins are automatically loaded when plugin_loader is imported
+except ImportError as e:
+    from ..utils import log_warning
+
+    log_warning(f"Could not load plugin loader: {e}")