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

tree_sitter_analyzer/mypy_current_errors.txt

@@ -0,0 +1,2 @@
+mcp\server.py: error: Source file found twice under different module names:
+"tree_sitter_analyzer.mcp.server" and "mcp.server"

tree_sitter_analyzer/output_manager.py

@@ -0,0 +1,255 @@
+#!/usr/bin/env python3
+"""
+Output Manager for CLI
+
+Handles different types of outputs: user information, errors, and structured data.
+"""
+
+import json
+import sys
+from typing import Any
+
+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"   Position: Line {result.get('start_line', '?')}-{result.get('end_line', '?')}"
+            )
+            if "content" in result:
+                print(f"   Content:\n{result['content']}")
+
+    def analysis_summary(self, stats: dict[str, Any]) -> None:
+        """Output analysis summary"""
+        # Always print human-readable stats to satisfy CLI expectations in tests
+        self.results_header("Statistics")
+        for key, value in stats.items():
+            print(f"{key}: {value}")
+
+    def language_list(
+        self, languages: list[str], title: str = "Supported Languages"
+    ) -> 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"Available query keys ({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("Supported file extensions:")
+        # Use more efficient chunking
+        from itertools import islice
+
+        chunk_size = 10
+        for i in range(0, len(extensions), chunk_size):
+            chunk = list(islice(extensions, i, i + chunk_size))
+            print(f"  {' '.join(chunk)}")
+            print(f"Total {len(extensions)} extensions supported")
+
+    def output_json(self, data: Any) -> None:
+        """Output JSON data"""
+        print(json.dumps(data, indent=2, ensure_ascii=False))
+
+    def output_list(self, items: str | list[Any], title: str | None = 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"""
+        query_dict = {q: f"Query {q}" for q in queries}
+        self.query_list(query_dict, "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: str | list[Any], title: str | None = 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 = "Supported Languages") -> None:
+    """Output available languages"""
+    _output_manager.language_list(languages, title)
+
+
+def output_queries(queries: list[str], language: str = "All") -> None:
+    """Output available queries"""
+    query_dict = {q: f"Query {q}" for q in queries}
+    _output_manager.query_list(query_dict, 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/platform_compat/__init__.py

@@ -0,0 +1,3 @@
+from .detector import PlatformDetector, PlatformInfo
+
+__all__ = ["PlatformDetector", "PlatformInfo"]

tree_sitter_analyzer/platform_compat/adapter.py

@@ -0,0 +1,324 @@
+import logging
+import re
+from typing import Protocol, TypeVar
+
+from tree_sitter_analyzer.models import (
+    SQLElement,
+    SQLElementType,
+    SQLFunction,
+    SQLTrigger,
+    SQLView,
+)
+from tree_sitter_analyzer.platform_compat.profiles import BehaviorProfile
+
+logger = logging.getLogger(__name__)
+
+T = TypeVar("T", bound=SQLElement)
+
+
+class AdaptationRule(Protocol):
+    """Rule for adapting platform-specific behavior."""
+
+    @property
+    def rule_id(self) -> str:
+        """Unique identifier for the rule."""
+        ...
+
+    @property
+    def description(self) -> str:
+        """Description of what the rule does."""
+        ...
+
+    def apply(self, element: SQLElement, context: dict) -> SQLElement | None:
+        """
+        Applies the rule to an element.
+
+        Args:
+            element: The element to adapt.
+            context: Additional context (e.g. source code).
+
+        Returns:
+            The adapted element, or None if the element should be removed.
+            Returns the original element if no changes are needed.
+        """
+        ...
+
+
+class CompatibilityAdapter:
+    """Applies platform-specific adaptations to SQL parsing results."""
+
+    def __init__(self, profile: BehaviorProfile | None = None):
+        self.profile = profile
+        self.rules: list[AdaptationRule] = []
+        self._load_rules()
+
+    def _load_rules(self):
+        """Loads adaptation rules based on the profile."""
+        # In a real implementation, we might load these dynamically or from a registry.
+        # For now, we'll hardcode the available rules and enable them based on the profile.
+
+        available_rules = {
+            "fix_function_name_keywords": FixFunctionNameKeywordsRule(),
+            "fix_trigger_name_description": FixTriggerNameDescriptionRule(),
+            "remove_phantom_triggers": RemovePhantomTriggersRule(),
+            "remove_phantom_functions": RemovePhantomFunctionsRule(),
+            "recover_views_from_errors": RecoverViewsFromErrorsRule(),
+        }
+
+        if self.profile:
+            for rule_id in self.profile.adaptation_rules:
+                if rule_id in available_rules:
+                    self.rules.append(available_rules[rule_id])
+                elif rule_id == "*":
+                    # Wildcard: enable all rules (useful for testing or "safe mode")
+                    self.rules = list(available_rules.values())
+                    break
+        else:
+            # Default behavior: enable all safe recovery rules?
+            # Or maybe none? Let's enable all for now as they should be safe.
+            self.rules = list(available_rules.values())
+
+    def adapt_elements(
+        self, elements: list[SQLElement], source_code: str
+    ) -> list[SQLElement]:
+        """
+        Main entry point for adapting elements.
+
+        Args:
+            elements: The list of extracted elements.
+            source_code: The original source code.
+
+        Returns:
+            The list of adapted elements.
+        """
+        context = {"source_code": source_code}
+        adapted_elements = []
+
+        # First pass: apply rules to existing elements
+        for element in elements:
+            current_element = element
+            keep_element = True
+
+            for rule in self.rules:
+                result = rule.apply(current_element, context)
+                if result is None:
+                    keep_element = False
+                    break
+                current_element = result
+
+            if keep_element:
+                adapted_elements.append(current_element)
+
+        # Second pass: recover missing elements (if any rule supports it)
+        # Some rules might look at the source code and generate new elements
+        # For example, RecoverViewsFromErrorsRule might want to scan source code
+        # independent of existing elements.
+        # However, the current Protocol definition is element-centric.
+        # We might need a separate method for "generation" rules or handle it differently.
+        # For RecoverViewsFromErrorsRule, we can treat it as a rule that inspects
+        # "ERROR" elements if we had them, or we can just run it once.
+
+        # Let's add a special hook for generation
+        for rule in self.rules:
+            if hasattr(rule, "generate_elements"):
+                new_elements = rule.generate_elements(context)
+                adapted_elements.extend(new_elements)
+
+        return adapted_elements
+
+
+# --- Specific Rules ---
+
+
+class FixFunctionNameKeywordsRule:
+    """
+    Rule: fix_function_name_keywords
+    Detects when function name is a SQL keyword and recovers correct name from raw_text.
+    """
+
+    @property
+    def rule_id(self) -> str:
+        return "fix_function_name_keywords"
+
+    @property
+    def description(self) -> str:
+        return "Recover correct function name when keyword is extracted"
+
+    def apply(self, element: SQLElement, context: dict) -> SQLElement | None:
+        if not isinstance(element, SQLFunction):
+            return element
+
+        # List of keywords that might be incorrectly extracted as names
+        keywords = {
+            "FUNCTION",
+            "PROCEDURE",
+            "CREATE",
+            "OR",
+            "REPLACE",
+            "AUTO_INCREMENT",
+            "KEY",
+            "PRIMARY",
+            "FOREIGN",
+        }
+
+        # Check if name is a keyword OR if we should verify the name generally
+        # This covers cases where the name is just wrong (e.g. garbage) but not necessarily a keyword
+        should_fix = False
+        if element.name.upper() in keywords:
+            should_fix = True
+        else:
+            # General verification: check if the name matches what's in the CREATE statement
+            # If the extracted name doesn't match the regex-extracted name, we should fix it
+            match = re.search(r"FUNCTION\s+([\w]+)", element.raw_text, re.IGNORECASE)
+            if match:
+                correct_name = match.group(1)
+                if element.name != correct_name:
+                    should_fix = True
+
+        if should_fix:
+            # Try to extract name from raw_text
+            # Pattern: CREATE [OR REPLACE] FUNCTION name ...
+            # Use \w+ to match unicode word characters
+            match = re.search(r"FUNCTION\s+([\w]+)", element.raw_text, re.IGNORECASE)
+            if match:
+                element.name = match.group(1)
+
+        return element
+
+
+class FixTriggerNameDescriptionRule:
+    """
+    Rule: fix_trigger_name_description
+    Detects when trigger name is incorrectly set to "description".
+    """
+
+    @property
+    def rule_id(self) -> str:
+        return "fix_trigger_name_description"
+
+    @property
+    def description(self) -> str:
+        return "Recover correct trigger name when 'description' is extracted"
+
+    def apply(self, element: SQLElement, context: dict) -> SQLElement | None:
+        if not isinstance(element, SQLTrigger):
+            return element
+
+        if element.name.lower() == "description":
+            # Try to extract name from raw_text
+            # Pattern: CREATE TRIGGER name ...
+            # Use \w+ to match unicode word characters
+            match = re.search(r"TRIGGER\s+([\w]+)", element.raw_text, re.IGNORECASE)
+            if match:
+                element.name = match.group(1)
+
+        return element
+
+
+class RemovePhantomTriggersRule:
+    """
+    Rule: remove_phantom_triggers
+    Detects elements where type doesn't match content (phantom triggers).
+    """
+
+    @property
+    def rule_id(self) -> str:
+        return "remove_phantom_triggers"
+
+    @property
+    def description(self) -> str:
+        return "Remove phantom triggers with mismatched content"
+
+    def apply(self, element: SQLElement, context: dict) -> SQLElement | None:
+        if isinstance(element, SQLTrigger):
+            # Check if raw_text actually contains CREATE TRIGGER
+            # Phantom triggers often appear in comments or unrelated code
+            # Use regex to handle variable whitespace
+            if not re.search(r"CREATE\s+TRIGGER", element.raw_text, re.IGNORECASE):
+                # It might be a phantom
+                logger.debug(
+                    f"Removing phantom trigger: {element.name} (raw_text: {element.raw_text[:50]}...)"
+                )
+                return None
+        return element
+
+
+class RemovePhantomFunctionsRule:
+    """
+    Rule: remove_phantom_functions
+    Detects elements where type doesn't match content (phantom functions).
+    """
+
+    @property
+    def rule_id(self) -> str:
+        return "remove_phantom_functions"
+
+    @property
+    def description(self) -> str:
+        return "Remove phantom functions with mismatched content"
+
+    def apply(self, element: SQLElement, context: dict) -> SQLElement | None:
+        if isinstance(element, SQLFunction):
+            # Check if raw_text actually contains CREATE FUNCTION
+            # Phantom functions often appear in comments or unrelated code
+            # Use regex to handle variable whitespace
+            if not re.search(r"CREATE\s+FUNCTION", element.raw_text, re.IGNORECASE):
+                # It might be a phantom
+                return None
+        return element
+
+
+class RecoverViewsFromErrorsRule:
+    """
+    Rule: recover_views_from_errors
+    Scans source code for CREATE VIEW statements that might have been missed (e.g. in ERROR nodes).
+    """
+
+    @property
+    def rule_id(self) -> str:
+        return "recover_views_from_errors"
+
+    @property
+    def description(self) -> str:
+        return "Recover views from ERROR nodes"
+
+    def apply(self, element: SQLElement, context: dict) -> SQLElement | None:
+        # This rule doesn't modify existing elements, it generates new ones.
+        return element
+
+    def generate_elements(self, context: dict) -> list[SQLElement]:
+        source_code = context.get("source_code", "")
+        new_elements = []
+
+        # Simple regex to find CREATE VIEW statements
+        # This is a fallback mechanism
+        # Use \w+ to match unicode word characters
+        # Updated to handle IF NOT EXISTS and multiline matching
+        view_pattern = re.compile(
+            r"^\s*CREATE\s+VIEW\s+(?:IF\s+NOT\s+EXISTS\s+)?([\w]+)\s+AS",
+            re.IGNORECASE | re.MULTILINE,
+        )
+
+        for match in view_pattern.finditer(source_code):
+            view_name = match.group(1)
+            # We need to check if this view is already extracted?
+            # For now, let's assume the caller handles duplicates or we just return it.
+            # Ideally we should check if 'view_name' is already in the elements list passed to adapt_elements.
+            # But generate_elements doesn't see the list.
+            # We'll return it and let the merger handle it, or we can improve the architecture.
+
+            # Calculate line number (rough approximation)
+            start_pos = match.start()
+            line_number = source_code.count("\n", 0, start_pos) + 1
+
+            view = SQLView(
+                name=view_name,
+                start_line=line_number,
+                end_line=line_number,  # We don't know end line easily
+                raw_text=match.group(0),  # Partial text
+                sql_element_type=SQLElementType.VIEW,
+                element_type="view",
+            )
+            new_elements.append(view)
+
+        return new_elements