obsidian_ollama/src/error-handler.js

"use strict";
// src/error-handler.ts
Object.defineProperty(exports, "__esModule", { value: true });
exports.ErrorHandler = void 0;
const obsidian_1 = require("obsidian");
const types_1 = require("./types");
class ErrorHandler {
    static handleError(error, context) {
        const message = this.getUserFriendlyMessage(error);
        new obsidian_1.Notice(message);
        if (error instanceof Error) {
            const ctx = context ? ` [${context}]` : '';
            // Use console.error instead of ErrorHandler.error for fatal errors
            console.error(`Ollama Plugin Error${ctx}: ${error.message}`);
            if (error.stack) {
                console.error(error.stack);
            }
        }
        else {
            const ctx = context ? ` [${context}]` : '';
            console.error(`Ollama Plugin Error${ctx}:`, error);
        }
    }
    static getUserFriendlyMessage(error) {
        if (error instanceof types_1.OllamaError) {
            return this.getUserFriendlyMessageFromOllamaError(error);
        }
        if (error instanceof Error) {
            return this.getUserFriendlyMessageFromError(error);
        }
        return 'An unexpected error occurred';
    }
    static getUserFriendlyMessageFromOllamaError(error) {
        switch (error.type) {
            case types_1.ErrorType.NETWORK_ERROR:
                return 'Connection error. Please check if Ollama is running.';
            case types_1.ErrorType.API_ERROR:
                return `API error: ${error.message}`;
            case types_1.ErrorType.VALIDATION_ERROR:
                return this.getUserFriendlyValidationMessage(error);
            case types_1.ErrorType.STREAMING_ERROR:
                return 'Response too long. Please try a shorter request.';
            case types_1.ErrorType.TOOL_EXECUTION_ERROR:
                return `Tool error for ${error.toolName}. ${error.message}`;
            case types_1.ErrorType.PATH_VALIDATION_ERROR:
                return `Invalid file path: ${error.path}`;
            case types_1.ErrorType.UNKNOWN_ERROR:
                return 'An unexpected error occurred';
            default:
                return 'An unexpected error occurred';
        }
    }
    static getUserFriendlyValidationMessage(error) {
        if (error instanceof types_1.ValidationError && error.details?.field) {
            const fieldMsg = error.details.field.charAt(0).toUpperCase() + error.details.field.slice(1);
            return `Invalid ${fieldMsg.toLowerCase()}. ${error.details.message ?? error.message}`;
        }
        return 'Input validation error. Please correct your input.';
    }
    static getUserFriendlyMessageFromError(error) {
        const msg = error.message.toLowerCase();
        // Check timeout BEFORE network (more specific matches first)
        if (msg.includes('timeout') || msg.includes('timed out') || msg.includes('time out')) {
            return 'Request timed out. Please check your Ollama connection.';
        }
        if (msg.includes('network') || msg.includes('connection') || msg.includes('fetch')) {
            return 'Connection error. Please check if Ollama is running.';
        }
        if (msg.includes('validation') || msg.includes('invalid')) {
            return 'Invalid input. Please correct your input.';
        }
        if (msg.includes('stream') || msg.includes('chunk')) {
            return 'Response too long. Please try a shorter request.';
        }
        if (msg.includes('tool') || msg.includes('function')) {
            return 'Tool error. Please try again.';
        }
        if (msg.includes('path') || msg.includes('file')) {
            return 'Invalid file path. Please check the path and try again.';
        }
        return 'An unexpected error occurred';
    }
    // -- Factory methods --
    static createNetworkError(message, statusCode) {
        return new types_1.NetworkError(message, statusCode);
    }
    static createApiError(message, statusCode) {
        return new types_1.ApiError(message, statusCode);
    }
    static createValidationError(message, field) {
        const details = field ? { field, message } : undefined;
        return new types_1.ValidationError(message, details);
    }
    static createStreamingError(message) {
        return new types_1.StreamingError(message);
    }
    static createToolExecutionError(message, toolName) {
        return new types_1.ToolExecutionError(message, toolName ?? 'unknown');
    }
    static createPathValidationError(message, path) {
        return new types_1.PathValidationError(message, path ?? '');
    }
    static createUnknownError(message) {
        return new types_1.OllamaError(message, types_1.ErrorType.UNKNOWN_ERROR);
    }
}
exports.ErrorHandler = ErrorHandler;