tree-sitter-analyzer 1.8.4__py3-none-any.whl → 1.9.1__py3-none-any.whl

tree_sitter_analyzer/exceptions.py

@@ -403,7 +403,7 @@ class RegexSecurityError(SecurityError):
 # MCP-specific exceptions for enhanced error handling
 class MCPToolError(MCPError):
     """Raised when MCP tool execution fails."""
-    
+
     def __init__(
         self,
         message: str,
@@ -419,17 +419,17 @@ class MCPToolError(MCPError):
             context["input_params"] = sanitized_params
         if execution_stage:
             context["execution_stage"] = execution_stage
-        
+
         super().__init__(message, tool_name=tool_name, context=context, **kwargs)
         self.input_params = input_params
         self.execution_stage = execution_stage
-    
+
     @staticmethod
     def _sanitize_params(params: dict[str, Any]) -> dict[str, Any]:
         """Sanitize sensitive information from parameters."""
         sanitized = {}
         sensitive_keys = {"password", "token", "key", "secret", "auth", "credential"}
-        
+
         for key, value in params.items():
             if any(sensitive in key.lower() for sensitive in sensitive_keys):
                 sanitized[key] = "***REDACTED***"
@@ -437,13 +437,13 @@ class MCPToolError(MCPError):
                 sanitized[key] = value[:100] + "...[TRUNCATED]"
             else:
                 sanitized[key] = value
-        
+
         return sanitized
 
 
 class MCPResourceError(MCPError):
     """Raised when MCP resource access fails."""
-    
+
     def __init__(
         self,
         message: str,
@@ -457,7 +457,7 @@ class MCPResourceError(MCPError):
             context["resource_type"] = resource_type
         if access_mode:
             context["access_mode"] = access_mode
-        
+
         super().__init__(message, resource_uri=resource_uri, context=context, **kwargs)
         self.resource_type = resource_type
         self.access_mode = access_mode
@@ -465,7 +465,7 @@ class MCPResourceError(MCPError):
 
 class MCPTimeoutError(MCPError):
     """Raised when MCP operation times out."""
-    
+
     def __init__(
         self,
         message: str,
@@ -478,7 +478,7 @@ class MCPTimeoutError(MCPError):
             context["timeout_seconds"] = timeout_seconds
         if operation_type:
             context["operation_type"] = operation_type
-        
+
         super().__init__(message, context=context, **kwargs)
         self.timeout_seconds = timeout_seconds
         self.operation_type = operation_type
@@ -486,7 +486,7 @@ class MCPTimeoutError(MCPError):
 
 class MCPValidationError(ValidationError):
     """Raised when MCP input validation fails."""
-    
+
     def __init__(
         self,
         message: str,
@@ -503,15 +503,17 @@ class MCPValidationError(ValidationError):
             context["parameter_name"] = parameter_name
         if validation_rule:
             context["validation_rule"] = validation_rule
-        
+
         # Sanitize parameter value for logging
         if parameter_value is not None:
             if isinstance(parameter_value, str) and len(parameter_value) > 200:
                 context["parameter_value"] = parameter_value[:200] + "...[TRUNCATED]"
             else:
                 context["parameter_value"] = parameter_value
-        
-        super().__init__(message, validation_type="mcp_parameter", context=context, **kwargs)
+
+        super().__init__(
+            message, validation_type="mcp_parameter", context=context, **kwargs
+        )
         self.tool_name = tool_name
         self.parameter_name = parameter_name
         self.validation_rule = validation_rule
@@ -519,7 +521,7 @@ class MCPValidationError(ValidationError):
 
 class FileRestrictionError(SecurityError):
     """Raised when file access is restricted by mode or security policy."""
-    
+
     def __init__(
         self,
         message: str,
@@ -533,13 +535,13 @@ class FileRestrictionError(SecurityError):
             context["current_mode"] = current_mode
         if allowed_patterns:
             context["allowed_patterns"] = allowed_patterns
-        
+
         super().__init__(
             message,
             security_type="file_restriction",
             file_path=file_path,
             context=context,
-            **kwargs
+            **kwargs,
         )
         self.current_mode = current_mode
         self.allowed_patterns = allowed_patterns
@@ -554,52 +556,52 @@ def create_mcp_error_response(
 ) -> dict[str, Any]:
     """
     Create standardized MCP error response dictionary.
-    
+
     Args:
         exception: The exception to convert
         tool_name: Name of the MCP tool that failed
         include_debug_info: Whether to include debug information
         sanitize_sensitive: Whether to sanitize sensitive information
-    
+
     Returns:
         MCP-compliant error response dictionary
     """
     import traceback
-    
+
     response: dict[str, Any] = {
         "success": False,
         "error": {
             "type": exception.__class__.__name__,
             "message": str(exception),
-            "timestamp": __import__("datetime").datetime.utcnow().isoformat() + "Z"
-        }
+            "timestamp": __import__("datetime").datetime.utcnow().isoformat() + "Z",
+        },
     }
-    
+
     # Add tool name if provided
     if tool_name:
         response["error"]["tool"] = tool_name
-    
+
     # Add context if available
     if hasattr(exception, "context") and exception.context:
         context = exception.context.copy()
-        
+
         # Sanitize sensitive information if requested
         if sanitize_sensitive:
             context = _sanitize_error_context(context)
-        
+
         response["error"]["context"] = context
-    
+
     # Add error code if available
     if hasattr(exception, "error_code"):
         response["error"]["code"] = exception.error_code
-    
+
     # Add debug information if requested
     if include_debug_info:
         response["error"]["debug"] = {
             "traceback": traceback.format_exc(),
-            "exception_args": list(exception.args) if exception.args else []
+            "exception_args": list(exception.args) if exception.args else [],
         }
-    
+
     # Add specific error details for known exception types
     if isinstance(exception, MCPToolError):
         response["error"]["execution_stage"] = exception.execution_stage
@@ -608,7 +610,7 @@ def create_mcp_error_response(
     elif isinstance(exception, FileRestrictionError):
         response["error"]["current_mode"] = exception.current_mode
         response["error"]["allowed_patterns"] = exception.allowed_patterns
-    
+
     return response
 
 
@@ -616,10 +618,18 @@ def _sanitize_error_context(context: dict[str, Any]) -> dict[str, Any]:
     """Sanitize sensitive information from error context."""
     sanitized = {}
     sensitive_keys = {
-        "password", "token", "key", "secret", "auth", "credential",
-        "api_key", "access_token", "private_key", "session_id"
+        "password",
+        "token",
+        "key",
+        "secret",
+        "auth",
+        "credential",
+        "api_key",
+        "access_token",
+        "private_key",
+        "session_id",
     }
-    
+
     for key, value in context.items():
         if any(sensitive in key.lower() for sensitive in sensitive_keys):
             sanitized[key] = "***REDACTED***"
@@ -634,7 +644,7 @@ def _sanitize_error_context(context: dict[str, Any]) -> dict[str, Any]:
             sanitized[key]["__truncated__"] = True
         else:
             sanitized[key] = value
-    
+
     return sanitized
 
 
@@ -648,14 +658,14 @@ async def safe_execute_async(
 ) -> Any:
     """
     Safely execute an async function with exception handling.
-    
+
     Args:
         coro: Coroutine to execute
         default_return: Value to return on exception
         exception_types: Exception types to catch
         log_errors: Whether to log errors
         tool_name: Name of the tool for error context
-    
+
     Returns:
         Coroutine result or default_return on exception
     """
@@ -664,10 +674,10 @@ async def safe_execute_async(
     except exception_types as e:
         if log_errors:
             from .utils import log_error
-            
+
             error_context = {"tool_name": tool_name} if tool_name else {}
             log_error(f"Async execution failed: {e}", extra=error_context)
-        
+
         return default_return
 
 
@@ -678,57 +688,58 @@ def mcp_exception_handler(
 ) -> Any:
     """
     Decorator for MCP tool exception handling.
-    
+
     Args:
         tool_name: Name of the MCP tool
         include_debug: Whether to include debug information
         sanitize_sensitive: Whether to sanitize sensitive information
     """
+
     def decorator(func: Any) -> Any:
         async def async_wrapper(*args: Any, **kwargs: Any) -> Any:
             try:
                 return await func(*args, **kwargs)
             except Exception as e:
                 from .utils import log_error
-                
+
                 # Log the error with tool context
                 log_error(
                     f"MCP tool '{tool_name}' failed: {e}",
-                    extra={"tool_name": tool_name, "exception_type": type(e).__name__}
+                    extra={"tool_name": tool_name, "exception_type": type(e).__name__},
                 )
-                
+
                 # Return standardized error response
                 return create_mcp_error_response(
                     e,
                     tool_name=tool_name,
                     include_debug_info=include_debug,
-                    sanitize_sensitive=sanitize_sensitive
+                    sanitize_sensitive=sanitize_sensitive,
                 )
-        
+
         def sync_wrapper(*args: Any, **kwargs: Any) -> Any:
             try:
                 return func(*args, **kwargs)
             except Exception as e:
                 from .utils import log_error
-                
+
                 # Log the error with tool context
                 log_error(
                     f"MCP tool '{tool_name}' failed: {e}",
-                    extra={"tool_name": tool_name, "exception_type": type(e).__name__}
+                    extra={"tool_name": tool_name, "exception_type": type(e).__name__},
                 )
-                
+
                 # Return standardized error response
                 return create_mcp_error_response(
                     e,
                     tool_name=tool_name,
                     include_debug_info=include_debug,
-                    sanitize_sensitive=sanitize_sensitive
+                    sanitize_sensitive=sanitize_sensitive,
                 )
-        
+
         # Return appropriate wrapper based on function type
         if __import__("asyncio").iscoroutinefunction(func):
             return async_wrapper
         else:
             return sync_wrapper
-    
+
     return decorator

tree_sitter_analyzer/file_handler.py

@@ -13,14 +13,17 @@ from .utils import setup_logger
 # Set up logger for this module
 logger = setup_logger(__name__)
 
+
 def log_error(message: str, *args, **kwargs) -> None:
     """Log error message"""
     logger.error(message, *args, **kwargs)
 
+
 def log_info(message: str, *args, **kwargs) -> None:
     """Log info message"""
     logger.info(message, *args, **kwargs)
 
+
 def log_warning(message: str, *args, **kwargs) -> None:
     """Log warning message"""
     logger.warning(message, *args, **kwargs)

tree_sitter_analyzer/formatters/base_formatter.py

@@ -6,32 +6,37 @@ Base formatter for language-specific formatting.
 import csv
 import io
 from abc import ABC, abstractmethod
-from typing import Any, Dict
+from typing import Any
 
 
 class BaseFormatter(ABC):
     """Base class for language-specific formatters"""
 
+    @abstractmethod
     def __init__(self):
         pass
 
     @abstractmethod
-    def format_summary(self, analysis_result: Dict[str, Any]) -> str:
+    def format_summary(self, analysis_result: dict[str, Any]) -> str:
         """Format summary output"""
         pass
 
     @abstractmethod
-    def format_structure(self, analysis_result: Dict[str, Any]) -> str:
+    def format_structure(self, analysis_result: dict[str, Any]) -> str:
         """Format structure analysis output"""
         pass
 
     @abstractmethod
-    def format_advanced(self, analysis_result: Dict[str, Any], output_format: str = "json") -> str:
+    def format_advanced(
+        self, analysis_result: dict[str, Any], output_format: str = "json"
+    ) -> str:
         """Format advanced analysis output"""
         pass
 
     @abstractmethod
-    def format_table(self, analysis_result: Dict[str, Any], table_type: str = "full") -> str:
+    def format_table(
+        self, analysis_result: dict[str, Any], table_type: str = "full"
+    ) -> str:
         """Format table output"""
         pass