summarizely-cli/dist/errors.js

YouTube summarizer that respects your existing subscriptions. No API keys required.

"use strict";
Object.defineProperty(exports, "__esModule", { value: true });
exports.SummarizelyError = exports.ErrorCode = void 0;
exports.handleKnownError = handleKnownError;
exports.handleUnknownError = handleUnknownError;
exports.isRecoverableError = isRecoverableError;
var ErrorCode;
(function (ErrorCode) {
    ErrorCode["NO_CAPTIONS"] = "NO_CAPTIONS";
    ErrorCode["PROVIDER_TIMEOUT"] = "PROVIDER_TIMEOUT";
    ErrorCode["PROVIDER_UNAVAILABLE"] = "PROVIDER_UNAVAILABLE";
    ErrorCode["PROVIDER_AUTH"] = "PROVIDER_AUTH";
    ErrorCode["PROVIDER_RATE_LIMIT"] = "PROVIDER_RATE_LIMIT";
    ErrorCode["INVALID_URL"] = "INVALID_URL";
    ErrorCode["INVALID_REQUEST"] = "INVALID_REQUEST";
    ErrorCode["NO_MODELS"] = "NO_MODELS";
    ErrorCode["YTDLP_NOT_FOUND"] = "YTDLP_NOT_FOUND";
    ErrorCode["TRANSCRIPT_TOO_LARGE"] = "TRANSCRIPT_TOO_LARGE";
    ErrorCode["FILE_SYSTEM_ERROR"] = "FILE_SYSTEM_ERROR";
    ErrorCode["NETWORK_ERROR"] = "NETWORK_ERROR";
    ErrorCode["PARSING_ERROR"] = "PARSING_ERROR";
    ErrorCode["UNKNOWN"] = "UNKNOWN";
})(ErrorCode || (exports.ErrorCode = ErrorCode = {}));
class SummarizelyError extends Error {
    constructor(code, message, details) {
        super(message);
        this.code = code;
        this.details = details;
        this.name = 'SummarizelyError';
    }
    static fromProviderError(provider, error) {
        if (error.code === 'unavailable') {
            return new SummarizelyError(ErrorCode.PROVIDER_UNAVAILABLE, `Provider ${provider} is unavailable`, error);
        }
        if (error.code === 'timeout') {
            return new SummarizelyError(ErrorCode.PROVIDER_TIMEOUT, `Provider ${provider} timed out`, error);
        }
        if (error.code === 'auth') {
            return new SummarizelyError(ErrorCode.PROVIDER_AUTH, `Authentication failed for ${provider}`, error);
        }
        if (error.code === 'rate_limit') {
            return new SummarizelyError(ErrorCode.PROVIDER_RATE_LIMIT, `Rate limit exceeded for ${provider}`, error);
        }
        if (error.code === 'no_models') {
            return new SummarizelyError(ErrorCode.NO_MODELS, `No models available for ${provider}`, error);
        }
        return new SummarizelyError(ErrorCode.UNKNOWN, error.message || `Unknown error from ${provider}`, error);
    }
    static noCaptions(url, hasYtDlp) {
        if (!hasYtDlp) {
            return new SummarizelyError(ErrorCode.YTDLP_NOT_FOUND, 'yt-dlp not installed. Install it to fetch captions.', { url });
        }
        return new SummarizelyError(ErrorCode.NO_CAPTIONS, 'No captions available for this video', { url });
    }
    static invalidUrl(url) {
        return new SummarizelyError(ErrorCode.INVALID_URL, 'Invalid YouTube URL provided', { url });
    }
    static transcriptTooLarge(size, maxSize) {
        return new SummarizelyError(ErrorCode.TRANSCRIPT_TOO_LARGE, `Transcript too large (${size} chars, max ${maxSize})`, { size, maxSize });
    }
    static fileSystemError(operation, path, error) {
        return new SummarizelyError(ErrorCode.FILE_SYSTEM_ERROR, `File system error during ${operation}: ${error.message}`, { operation, path, originalError: error });
    }
    static networkError(url, error) {
        return new SummarizelyError(ErrorCode.NETWORK_ERROR, `Network error accessing ${url}: ${error.message}`, { url, originalError: error });
    }
    static parsingError(what, error) {
        return new SummarizelyError(ErrorCode.PARSING_ERROR, `Failed to parse ${what}: ${error.message}`, { what, originalError: error });
    }
}
exports.SummarizelyError = SummarizelyError;
function handleKnownError(error) {
    const messages = {
        [ErrorCode.NO_CAPTIONS]: () => 'No captions available. The video may not have subtitles.',
        [ErrorCode.PROVIDER_TIMEOUT]: (e) => `Request timed out. Try again or use a different provider.`,
        [ErrorCode.PROVIDER_UNAVAILABLE]: (e) => `Provider unavailable. Check your setup or try a different provider.`,
        [ErrorCode.PROVIDER_AUTH]: () => 'Authentication failed. Check your API keys or credentials.',
        [ErrorCode.PROVIDER_RATE_LIMIT]: () => 'Rate limit exceeded. Please wait before trying again.',
        [ErrorCode.INVALID_URL]: () => 'Invalid YouTube URL. Please provide a valid video URL.',
        [ErrorCode.INVALID_REQUEST]: (e) => `Invalid request: ${e.message}`,
        [ErrorCode.NO_MODELS]: () => 'No models available. Install or configure a model first.',
        [ErrorCode.YTDLP_NOT_FOUND]: () => 'yt-dlp not found. Install it: pip install yt-dlp',
        [ErrorCode.TRANSCRIPT_TOO_LARGE]: (e) => {
            const details = e.details;
            return `Transcript too large (${details.size} chars). Use --max-chars to set a lower limit.`;
        },
        [ErrorCode.FILE_SYSTEM_ERROR]: (e) => `File system error: ${e.message}`,
        [ErrorCode.NETWORK_ERROR]: (e) => `Network error: ${e.message}`,
        [ErrorCode.PARSING_ERROR]: (e) => `Parsing error: ${e.message}`,
        [ErrorCode.UNKNOWN]: (e) => e.message || 'An unknown error occurred'
    };
    const handler = messages[error.code];
    return handler ? handler(error) : error.message;
}
function handleUnknownError(error) {
    if (error instanceof Error) {
        return `Unexpected error: ${error.message}`;
    }
    return `Unexpected error: ${String(error)}`;
}
function isRecoverableError(error) {
    const recoverableCodes = [
        ErrorCode.PROVIDER_TIMEOUT,
        ErrorCode.PROVIDER_RATE_LIMIT,
        ErrorCode.NETWORK_ERROR
    ];
    return recoverableCodes.includes(error.code);
}
//# sourceMappingURL=errors.js.map