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

tree_sitter_analyzer/exceptions.py

@@ -0,0 +1,340 @@
+#!/usr/bin/env python3
+# -*- coding: utf-8 -*-
+"""
+Tree-sitter Analyzer Custom Exceptions
+
+Unified exception handling system for consistent error management
+across the entire framework.
+"""
+
+from typing import Any, Dict, Optional, Union
+from pathlib import Path
+
+
+class TreeSitterAnalyzerError(Exception):
+    """Base exception for all tree-sitter analyzer errors."""
+    
+    def __init__(
+        self, 
+        message: str, 
+        error_code: Optional[str] = None,
+        context: Optional[Dict[str, Any]] = None
+    ) -> None:
+        super().__init__(message)
+        self.message = message
+        self.error_code = error_code or self.__class__.__name__
+        self.context = context or {}
+    
+    def to_dict(self) -> Dict[str, Any]:
+        """Convert exception to dictionary format."""
+        return {
+            "error_type": self.__class__.__name__,
+            "error_code": self.error_code,
+            "message": self.message,
+            "context": self.context
+        }
+
+
+class AnalysisError(TreeSitterAnalyzerError):
+    """Raised when file analysis fails."""
+    
+    def __init__(
+        self, 
+        message: str, 
+        file_path: Optional[Union[str, Path]] = None,
+        language: Optional[str] = None,
+        **kwargs
+    ) -> None:
+        context = kwargs.get('context', {})
+        if file_path:
+            context['file_path'] = str(file_path)
+        if language:
+            context['language'] = language
+        super().__init__(message, context=context, **kwargs)
+
+
+class ParseError(TreeSitterAnalyzerError):
+    """Raised when parsing fails."""
+    
+    def __init__(
+        self, 
+        message: str, 
+        language: Optional[str] = None,
+        source_info: Optional[Dict[str, Any]] = None,
+        **kwargs
+    ) -> None:
+        context = kwargs.get('context', {})
+        if language:
+            context['language'] = language
+        if source_info:
+            context.update(source_info)
+        super().__init__(message, context=context, **kwargs)
+
+
+class LanguageNotSupportedError(TreeSitterAnalyzerError):
+    """Raised when a language is not supported."""
+    
+    def __init__(
+        self, 
+        language: str, 
+        supported_languages: Optional[list] = None,
+        **kwargs
+    ) -> None:
+        message = f"Language '{language}' is not supported"
+        context = kwargs.get('context', {})
+        context['language'] = language
+        if supported_languages:
+            context['supported_languages'] = supported_languages
+            message += f". Supported languages: {', '.join(supported_languages)}"
+        super().__init__(message, context=context, **kwargs)
+
+
+class PluginError(TreeSitterAnalyzerError):
+    """Raised when plugin operations fail."""
+    
+    def __init__(
+        self, 
+        message: str, 
+        plugin_name: Optional[str] = None,
+        operation: Optional[str] = None,
+        **kwargs
+    ) -> None:
+        context = kwargs.get('context', {})
+        if plugin_name:
+            context['plugin_name'] = plugin_name
+        if operation:
+            context['operation'] = operation
+        super().__init__(message, context=context, **kwargs)
+
+
+class QueryError(TreeSitterAnalyzerError):
+    """Raised when query execution fails."""
+    
+    def __init__(
+        self, 
+        message: str, 
+        query_name: Optional[str] = None,
+        query_string: Optional[str] = None,
+        language: Optional[str] = None,
+        **kwargs
+    ) -> None:
+        context = kwargs.get('context', {})
+        if query_name:
+            context['query_name'] = query_name
+        if query_string:
+            context['query_string'] = query_string
+        if language:
+            context['language'] = language
+        super().__init__(message, context=context, **kwargs)
+
+
+class FileHandlingError(TreeSitterAnalyzerError):
+    """Raised when file operations fail."""
+    
+    def __init__(
+        self, 
+        message: str, 
+        file_path: Optional[Union[str, Path]] = None,
+        operation: Optional[str] = None,
+        **kwargs
+    ) -> None:
+        context = kwargs.get('context', {})
+        if file_path:
+            context['file_path'] = str(file_path)
+        if operation:
+            context['operation'] = operation
+        super().__init__(message, context=context, **kwargs)
+
+
+class ConfigurationError(TreeSitterAnalyzerError):
+    """Raised when configuration is invalid."""
+    
+    def __init__(
+        self, 
+        message: str, 
+        config_key: Optional[str] = None,
+        config_value: Optional[Any] = None,
+        **kwargs
+    ) -> None:
+        context = kwargs.get('context', {})
+        if config_key:
+            context['config_key'] = config_key
+        if config_value is not None:
+            context['config_value'] = config_value
+        super().__init__(message, context=context, **kwargs)
+
+
+class ValidationError(TreeSitterAnalyzerError):
+    """Raised when validation fails."""
+    
+    def __init__(
+        self, 
+        message: str, 
+        validation_type: Optional[str] = None,
+        invalid_value: Optional[Any] = None,
+        **kwargs
+    ) -> None:
+        context = kwargs.get('context', {})
+        if validation_type:
+            context['validation_type'] = validation_type
+        if invalid_value is not None:
+            context['invalid_value'] = invalid_value
+        super().__init__(message, context=context, **kwargs)
+
+
+class MCPError(TreeSitterAnalyzerError):
+    """Raised when MCP operations fail."""
+    
+    def __init__(
+        self, 
+        message: str, 
+        tool_name: Optional[str] = None,
+        resource_uri: Optional[str] = None,
+        **kwargs
+    ) -> None:
+        context = kwargs.get('context', {})
+        if tool_name:
+            context['tool_name'] = tool_name
+        if resource_uri:
+            context['resource_uri'] = resource_uri
+        super().__init__(message, context=context, **kwargs)
+
+
+# Exception handling utilities
+def handle_exception(
+    exception: Exception,
+    context: Optional[Dict[str, Any]] = None,
+    reraise_as: Optional[type] = None
+) -> None:
+    """
+    Handle exceptions with optional context and re-raising.
+    
+    Args:
+        exception: The original exception
+        context: Additional context information
+        reraise_as: Exception class to re-raise as
+    """
+    from .utils import log_error
+    
+    # Log the original exception
+    error_context = context or {}
+    if hasattr(exception, 'context'):
+        error_context.update(exception.context)
+    
+    log_error(f"Exception handled: {exception}", extra=error_context)
+    
+    # Re-raise as different exception type if requested
+    if reraise_as and not isinstance(exception, reraise_as):
+        if issubclass(reraise_as, TreeSitterAnalyzerError):
+            raise reraise_as(str(exception), context=error_context)
+        else:
+            raise reraise_as(str(exception))
+    
+    # Re-raise original exception
+    raise exception
+
+
+def safe_execute(
+    func,
+    *args,
+    default_return=None,
+    exception_types: tuple = (Exception,),
+    log_errors: bool = True,
+    **kwargs
+):
+    """
+    Safely execute a function with exception handling.
+    
+    Args:
+        func: Function to execute
+        *args: Function arguments
+        default_return: Value to return on exception
+        exception_types: Exception types to catch
+        log_errors: Whether to log errors
+        **kwargs: Function keyword arguments
+    
+    Returns:
+        Function result or default_return on exception
+    """
+    try:
+        return func(*args, **kwargs)
+    except exception_types as e:
+        if log_errors:
+            from .utils import log_error
+            log_error(f"Safe execution failed for {func.__name__}: {e}")
+        return default_return
+
+
+def create_error_response(
+    exception: Exception,
+    include_traceback: bool = False
+) -> Dict[str, Any]:
+    """
+    Create standardized error response dictionary.
+    
+    Args:
+        exception: The exception to convert
+        include_traceback: Whether to include traceback
+    
+    Returns:
+        Error response dictionary
+    """
+    import traceback
+    
+    response = {
+        "success": False,
+        "error": {
+            "type": exception.__class__.__name__,
+            "message": str(exception)
+        }
+    }
+    
+    # Add context if available
+    if hasattr(exception, 'context'):
+        response["error"]["context"] = exception.context
+    
+    # Add error code if available
+    if hasattr(exception, 'error_code'):
+        response["error"]["code"] = exception.error_code
+    
+    # Add traceback if requested
+    if include_traceback:
+        response["error"]["traceback"] = traceback.format_exc()
+    
+    return response
+
+
+# Decorator for exception handling
+def handle_exceptions(
+    default_return=None,
+    exception_types: tuple = (Exception,),
+    reraise_as: Optional[type] = None,
+    log_errors: bool = True
+):
+    """
+    Decorator for automatic exception handling.
+    
+    Args:
+        default_return: Value to return on exception
+        exception_types: Exception types to catch
+        reraise_as: Exception class to re-raise as
+        log_errors: Whether to log errors
+    """
+    def decorator(func):
+        def wrapper(*args, **kwargs):
+            try:
+                return func(*args, **kwargs)
+            except exception_types as e:
+                if log_errors:
+                    from .utils import log_error
+                    log_error(f"Exception in {func.__name__}: {e}")
+                
+                if reraise_as:
+                    if issubclass(reraise_as, TreeSitterAnalyzerError):
+                        raise reraise_as(str(e))
+                    else:
+                        raise reraise_as(str(e))
+                
+                return default_return
+        return wrapper
+    return decorator

tree_sitter_analyzer/file_handler.py

@@ -0,0 +1,222 @@
+#!/usr/bin/env python3
+# -*- coding: utf-8 -*-
+"""
+File Handler Module
+
+This module provides file reading functionality with encoding detection and fallback.
+"""
+
+import os
+import sys
+from pathlib import Path
+from typing import Optional
+
+from .encoding_utils import detect_encoding, read_file_safe, safe_decode
+from .utils import log_error, log_info, log_warning
+
+
+def detect_language_from_extension(file_path: str) -> str:
+    """
+    ファイル拡張子から言語を判定
+
+    Args:
+        file_path: ファイルパス
+
+    Returns:
+        言語名または'unknown'
+    """
+    extension = os.path.splitext(file_path)[1].lower()
+
+    extension_map = {
+        ".java": "java",
+        ".py": "python",
+        ".js": "javascript",
+        ".ts": "typescript",
+        ".cpp": "cpp",
+        ".c": "c",
+        ".h": "c",
+        ".hpp": "cpp",
+        ".cs": "csharp",
+        ".go": "go",
+        ".rs": "rust",
+        ".rb": "ruby",
+        ".php": "php",
+        ".kt": "kotlin",
+        ".scala": "scala",
+        ".swift": "swift",
+    }
+
+    return extension_map.get(extension, "unknown")
+
+
+def read_file_with_fallback(file_path: str) -> Optional[bytes]:
+    """
+    Read file with encoding fallback using unified encoding utilities
+
+    Args:
+        file_path: Path to the file to read
+
+    Returns:
+        File content as bytes, or None if file doesn't exist
+    """
+    # まずファイルの存在を確認
+    if not os.path.exists(file_path):
+        log_error(f"File does not exist: {file_path}")
+        return None
+
+    try:
+        content, detected_encoding = read_file_safe(file_path)
+        if content is not None:  # 空文字列も有効なコンテンツ
+            log_info(
+                f"Successfully read file {file_path} with encoding: {detected_encoding}"
+            )
+            return content.encode("utf-8")
+        else:
+            log_warning(f"File {file_path} is empty or could not be read")
+            return b""
+
+    except Exception as e:
+        log_error(f"Failed to read file {file_path}: {e}")
+        return None
+
+
+def read_file_partial(
+    file_path: str,
+    start_line: int,
+    end_line: Optional[int] = None,
+    start_column: Optional[int] = None,
+    end_column: Optional[int] = None,
+) -> Optional[str]:
+    """
+    指定した行番号・列番号範囲でファイルの一部を読み込み
+
+    Args:
+        file_path: 読み込むファイルのパス
+        start_line: 開始行番号（1ベース）
+        end_line: 終了行番号（Noneの場合はファイル末尾まで、1ベース）
+        start_column: 開始列番号（0ベース、省略可）
+        end_column: 終了列番号（0ベース、省略可）
+
+    Returns:
+        指定範囲のファイル内容（文字列）、エラーの場合はNone
+    """
+    # ファイルの存在確認
+    if not os.path.exists(file_path):
+        log_error(f"File does not exist: {file_path}")
+        return None
+
+    # パラメータ検証
+    if start_line < 1:
+        log_error(f"Invalid start_line: {start_line}. Line numbers start from 1.")
+        return None
+
+    if end_line is not None and end_line < start_line:
+        log_error(f"Invalid range: end_line ({end_line}) < start_line ({start_line})")
+        return None
+
+    try:
+        # ファイル全体を安全に読み込み
+        content, detected_encoding = read_file_safe(file_path)
+        if content is None:
+            log_error(f"Failed to read file: {file_path}")
+            return None
+
+        # 行に分割
+        lines = content.splitlines(keepends=True)
+        total_lines = len(lines)
+
+        # 行範囲の調整
+        start_idx = start_line - 1  # 0ベースに変換
+        end_idx = min(
+            end_line - 1 if end_line is not None else total_lines - 1, total_lines - 1
+        )
+
+        # 範囲チェック
+        if start_idx >= total_lines:
+            log_warning(
+                f"start_line ({start_line}) exceeds file length ({total_lines})"
+            )
+            return ""
+
+        # 指定範囲の行を取得
+        selected_lines = lines[start_idx : end_idx + 1]
+
+        # 列範囲の処理
+        if start_column is not None or end_column is not None:
+            processed_lines = []
+            for i, line in enumerate(selected_lines):
+                # 改行文字を除去して処理
+                line_content = line.rstrip("\r\n")
+
+                if i == 0 and start_column is not None:
+                    # 最初の行：開始列から
+                    line_content = (
+                        line_content[start_column:]
+                        if start_column < len(line_content)
+                        else ""
+                    )
+
+                if i == len(selected_lines) - 1 and end_column is not None:
+                    # 最後の行：終了列まで
+                    if i == 0 and start_column is not None:
+                        # 単一行の場合：開始列と終了列の両方を適用
+                        col_start = 0  # 既に開始列でカット済み
+                        col_end = (
+                            end_column - start_column
+                            if end_column >= start_column
+                            else 0
+                        )
+                        line_content = line_content[:col_end] if col_end > 0 else ""
+                    else:
+                        line_content = (
+                            line_content[:end_column]
+                            if end_column < len(line_content)
+                            else line_content
+                        )
+
+                # 元の改行文字を保持（最後の行以外）
+                if i < len(selected_lines) - 1:
+                    # 元の行の改行文字を取得
+                    original_line = lines[start_idx + i]
+                    if original_line.endswith("\r\n"):
+                        line_content += "\r\n"
+                    elif original_line.endswith("\n"):
+                        line_content += "\n"
+                    elif original_line.endswith("\r"):
+                        line_content += "\r"
+
+                processed_lines.append(line_content)
+
+            result = "".join(processed_lines)
+        else:
+            # 列指定なしの場合は行をそのまま結合
+            result = "".join(selected_lines)
+
+        log_info(
+            f"Successfully read partial file {file_path}: "
+            f"lines {start_line}-{end_line or total_lines}"
+            f"{f', columns {start_column}-{end_column}' if start_column is not None or end_column is not None else ''}"
+        )
+
+        return result
+
+    except Exception as e:
+        log_error(f"Failed to read partial file {file_path}: {e}")
+        return None
+
+
+def read_file_lines_range(
+    file_path: str, start_line: int, end_line: Optional[int] = None
+) -> Optional[str]:
+    """
+    指定した行番号範囲でファイルの一部を読み込み（列指定なし）
+
+    Args:
+        file_path: 読み込むファイルのパス
+        start_line: 開始行番号（1ベース）
+        end_line: 終了行番号（Noneの場合はファイル末尾まで、1ベース）
+
+    Returns:
+        指定範囲のファイル内容（文字列）、エラーの場合はNone
+    """
+    return read_file_partial(file_path, start_line, end_line)

tree_sitter_analyzer/formatters/__init__.py

@@ -0,0 +1 @@
+# Language-specific formatters