orquesta-cli 0.1.12

package/src/errors/index.ts

@@ -0,0 +1,95 @@
+/**
+ * Error Classes Export
+ *
+ * Export all custom error classes
+ */
+
+import { BaseError as BaseErrorClass } from './base.js';
+
+// Base
+export { BaseError } from './base.js';
+export type { ErrorDetails, ErrorOptions } from './base.js';
+
+// Network
+export {
+  NetworkError,
+  APIError,
+  TimeoutError,
+  ConnectionError,
+} from './network.js';
+
+// Validation
+export {
+  ValidationError,
+  InputError,
+  RequiredFieldError,
+  InvalidFormatError,
+} from './validation.js';
+
+// LLM
+export {
+  LLMError,
+  StreamingError,
+  ModelError,
+  TokenLimitError,
+  RateLimitError,
+  ContextLengthError,
+} from './llm.js';
+
+// File System
+export {
+  FileSystemError,
+  FileNotFoundError,
+  DirectoryNotFoundError,
+  PermissionError,
+  FileReadError,
+  FileWriteError,
+  InvalidPathError,
+} from './file.js';
+
+/**
+ * Error type check utility
+ */
+export function isRecoverableError(error: unknown): boolean {
+  if (error && typeof error === 'object' && 'canRecover' in error) {
+    const baseError = error as BaseErrorClass;
+    return baseError.canRecover();
+  }
+  return false;
+}
+
+/**
+ * Extract user message utility
+ */
+export function getUserMessage(error: unknown): string {
+  if (error && typeof error === 'object') {
+    if ('getUserMessage' in error) {
+      const baseError = error as BaseErrorClass;
+      return baseError.getUserMessage();
+    }
+    if (error instanceof Error) {
+      return error.message;
+    }
+  }
+  return String(error);
+}
+
+/**
+ * Convert error to JSON
+ */
+export function errorToJSON(error: unknown): Record<string, unknown> {
+  if (error && typeof error === 'object' && 'toJSON' in error) {
+    const baseError = error as BaseErrorClass;
+    return baseError.toJSON();
+  }
+  if (error instanceof Error) {
+    return {
+      name: error.name,
+      message: error.message,
+      stack: error.stack,
+    };
+  }
+  return {
+    error: String(error),
+  };
+}

package/src/errors/llm.ts

@@ -0,0 +1,151 @@
+/**
+ * LLM Error Classes
+ *
+ * LLM-related errors
+ */
+
+import { BaseError, ErrorOptions } from './base.js';
+
+/**
+ * LLMError - General LLM error
+ */
+export class LLMError extends BaseError {
+  constructor(message: string, options: ErrorOptions = {}) {
+    super(
+      message,
+      'LLM_ERROR',
+      {
+        ...options,
+        isRecoverable: options.isRecoverable ?? true,
+        userMessage: options.userMessage ?? 'An error occurred during LLM request.',
+      }
+    );
+  }
+}
+
+/**
+ * StreamingError - Streaming error
+ */
+export class StreamingError extends BaseError {
+  constructor(message: string, options: ErrorOptions = {}) {
+    super(
+      message,
+      'STREAMING_ERROR',
+      {
+        ...options,
+        isRecoverable: true,
+        userMessage: options.userMessage ?? 'An error occurred during streaming response.',
+      }
+    );
+  }
+}
+
+/**
+ * ModelError - Model-related error
+ */
+export class ModelError extends BaseError {
+  public readonly modelId?: string;
+
+  constructor(message: string, modelId?: string, options: ErrorOptions = {}) {
+    super(
+      message,
+      'MODEL_ERROR',
+      {
+        ...options,
+        details: {
+          ...options.details,
+          modelId,
+        },
+        isRecoverable: false,
+        userMessage: options.userMessage ?? `There is a problem with the model${modelId ? ` (model: ${modelId})` : ''}.`,
+      }
+    );
+    this.modelId = modelId;
+  }
+}
+
+/**
+ * TokenLimitError - Token limit exceeded error
+ */
+export class TokenLimitError extends BaseError {
+  public readonly limit: number;
+  public readonly actual?: number;
+
+  constructor(
+    limit: number,
+    actual?: number,
+    options: ErrorOptions = {}
+  ) {
+    super(
+      `Token limit exceeded. Limit: ${limit}${actual ? `, Actual: ${actual}` : ''}`,
+      'TOKEN_LIMIT_ERROR',
+      {
+        ...options,
+        details: {
+          ...options.details,
+          limit,
+          actual,
+        },
+        isRecoverable: true,
+        userMessage: options.userMessage ?? `Token limit exceeded (max: ${limit}${actual ? `, current: ${actual}` : ''}). Please reduce message length.`,
+      }
+    );
+    this.limit = limit;
+    this.actual = actual;
+  }
+}
+
+/**
+ * RateLimitError - API rate limit error
+ */
+export class RateLimitError extends BaseError {
+  public readonly retryAfter?: number;
+
+  constructor(retryAfter?: number, options: ErrorOptions = {}) {
+    super(
+      `Rate limit exceeded${retryAfter ? `. Retry after ${retryAfter}s` : ''}`,
+      'RATE_LIMIT_ERROR',
+      {
+        ...options,
+        details: {
+          ...options.details,
+          retryAfter,
+        },
+        isRecoverable: true,
+        userMessage: options.userMessage ?? `API rate limit exceeded${retryAfter ? `. Please retry after ${retryAfter} seconds` : '. Please try again later'}.`,
+      }
+    );
+    this.retryAfter = retryAfter;
+  }
+}
+
+/**
+ * ContextLengthError - Context length exceeded error
+ */
+export class ContextLengthError extends BaseError {
+  public readonly maxLength: number;
+  public readonly actualLength?: number;
+
+  constructor(
+    maxLength: number,
+    actualLength?: number,
+    options: ErrorOptions = {}
+  ) {
+    super(
+      `Context length exceeded. Max: ${maxLength}${actualLength ? `, Actual: ${actualLength}` : ''}`,
+      'CONTEXT_LENGTH_ERROR',
+      {
+        ...options,
+        details: {
+          ...options.details,
+          maxLength,
+          actualLength,
+        },
+        isRecoverable: true,
+        userMessage: options.userMessage ?? `Conversation context is too long (max: ${maxLength}${actualLength ? `, current: ${actualLength}` : ''}). Use /clear command to reset the conversation.`,
+      }
+    );
+    this.maxLength = maxLength;
+    this.actualLength = actualLength;
+  }
+}

package/src/errors/network.ts

@@ -0,0 +1,124 @@
+/**
+ * Network Error Classes
+ *
+ * Network-related errors
+ */
+
+import { BaseError, ErrorOptions } from './base.js';
+
+/**
+ * NetworkError - General network error
+ */
+export class NetworkError extends BaseError {
+  constructor(message: string, options: ErrorOptions = {}) {
+    super(
+      message,
+      'NETWORK_ERROR',
+      {
+        ...options,
+        isRecoverable: options.isRecoverable ?? true,
+        userMessage: options.userMessage ?? 'Network error occurred. Please check your internet connection.',
+      }
+    );
+  }
+}
+
+/**
+ * APIError - API call error
+ */
+export class APIError extends BaseError {
+  public readonly statusCode?: number;
+  public readonly endpoint?: string;
+
+  constructor(
+    message: string,
+    statusCode?: number,
+    endpoint?: string,
+    options: ErrorOptions = {}
+  ) {
+    super(
+      message,
+      'API_ERROR',
+      {
+        ...options,
+        details: {
+          ...options.details,
+          statusCode,
+          endpoint,
+        },
+        isRecoverable: options.isRecoverable ?? (statusCode ? statusCode >= 500 : true),
+        userMessage: options.userMessage ?? APIError.getAPIErrorMessage(statusCode),
+      }
+    );
+    this.statusCode = statusCode;
+    this.endpoint = endpoint;
+  }
+
+  static getAPIErrorMessage(statusCode?: number): string {
+    if (!statusCode) {
+      return 'An error occurred during API request.';
+    }
+
+    if (statusCode === 401) {
+      return 'API authentication failed. Please check your API Key.';
+    } else if (statusCode === 403) {
+      return 'Access denied. Please check your API Key permissions.';
+    } else if (statusCode === 404) {
+      return 'API endpoint not found.';
+    } else if (statusCode === 429) {
+      return 'API rate limit exceeded. Please try again later.';
+    } else if (statusCode >= 500) {
+      return 'API server error occurred. Please try again later.';
+    } else {
+      return `An error occurred during API request (status code: ${statusCode}).`;
+    }
+  }
+}
+
+/**
+ * TimeoutError - Request timeout error
+ */
+export class TimeoutError extends BaseError {
+  public readonly timeout: number;
+
+  constructor(timeout: number, options: ErrorOptions = {}) {
+    super(
+      `Request timed out after ${timeout}ms`,
+      'TIMEOUT_ERROR',
+      {
+        ...options,
+        details: {
+          ...options.details,
+          timeout,
+        },
+        isRecoverable: true,
+        userMessage: options.userMessage ?? `Request timed out (${timeout}ms). Please try again.`,
+      }
+    );
+    this.timeout = timeout;
+  }
+}
+
+/**
+ * ConnectionError - Connection failure error
+ */
+export class ConnectionError extends BaseError {
+  public readonly host?: string;
+
+  constructor(host?: string, options: ErrorOptions = {}) {
+    super(
+      `Failed to connect${host ? ` to ${host}` : ''}`,
+      'CONNECTION_ERROR',
+      {
+        ...options,
+        details: {
+          ...options.details,
+          host,
+        },
+        isRecoverable: true,
+        userMessage: options.userMessage ?? `Failed to connect to server${host ? ` (${host})` : ''}. Please check your network connection.`,
+      }
+    );
+    this.host = host;
+  }
+}

package/src/errors/validation.ts

@@ -0,0 +1,111 @@
+/**
+ * Validation Error Classes
+ *
+ * Validation-related errors
+ */
+
+import { BaseError, ErrorOptions } from './base.js';
+
+/**
+ * ValidationError - General validation error
+ */
+export class ValidationError extends BaseError {
+  public readonly field?: string;
+  public readonly value?: unknown;
+
+  constructor(
+    message: string,
+    field?: string,
+    value?: unknown,
+    options: ErrorOptions = {}
+  ) {
+    super(
+      message,
+      'VALIDATION_ERROR',
+      {
+        ...options,
+        details: {
+          ...options.details,
+          field,
+          value,
+        },
+        isRecoverable: true,
+        userMessage: options.userMessage ?? `Invalid input value${field ? ` (field: ${field})` : ''}.`,
+      }
+    );
+    this.field = field;
+    this.value = value;
+  }
+}
+
+/**
+ * InputError - User input error
+ */
+export class InputError extends BaseError {
+  constructor(message: string, options: ErrorOptions = {}) {
+    super(
+      message,
+      'INPUT_ERROR',
+      {
+        ...options,
+        isRecoverable: true,
+        userMessage: options.userMessage ?? 'Please check your input.',
+      }
+    );
+  }
+}
+
+/**
+ * RequiredFieldError - Required field missing error
+ */
+export class RequiredFieldError extends BaseError {
+  public readonly field: string;
+
+  constructor(field: string, options: ErrorOptions = {}) {
+    super(
+      `Required field missing: ${field}`,
+      'REQUIRED_FIELD_ERROR',
+      {
+        ...options,
+        details: {
+          ...options.details,
+          field,
+        },
+        isRecoverable: true,
+        userMessage: options.userMessage ?? `Required field missing: ${field}`,
+      }
+    );
+    this.field = field;
+  }
+}
+
+/**
+ * InvalidFormatError - Invalid format error
+ */
+export class InvalidFormatError extends BaseError {
+  public readonly expected: string;
+  public readonly actual?: string;
+
+  constructor(
+    expected: string,
+    actual?: string,
+    options: ErrorOptions = {}
+  ) {
+    super(
+      `Invalid format. Expected: ${expected}${actual ? `, got: ${actual}` : ''}`,
+      'INVALID_FORMAT_ERROR',
+      {
+        ...options,
+        details: {
+          ...options.details,
+          expected,
+          actual,
+        },
+        isRecoverable: true,
+        userMessage: options.userMessage ?? `Invalid format. Expected format: ${expected}`,
+      }
+    );
+    this.expected = expected;
+    this.actual = actual;
+  }
+}