gthinking 1.3.0 → 2.1.1

package/src/core/errors.ts

@@ -0,0 +1,349 @@
+/**
+ * Core Error Classes for gthinking v2.0.0
+ * Comprehensive error handling
+ */
+
+import { ThinkingStage } from '../types';
+
+/**
+ * Base error class for all gthinking errors
+ */
+export class GThinkingError extends Error {
+  public readonly code: string;
+  public readonly timestamp: Date;
+  public readonly details: Record<string, unknown>;
+
+  constructor(
+    message: string,
+    code: string,
+    details: Record<string, unknown> = {}
+  ) {
+    super(message);
+    this.name = 'GThinkingError';
+    this.code = code;
+    this.timestamp = new Date();
+    this.details = details;
+    Error.captureStackTrace(this, this.constructor);
+  }
+
+  toJSON(): Record<string, unknown> {
+    return {
+      name: this.name,
+      message: this.message,
+      code: this.code,
+      timestamp: this.timestamp,
+      details: this.details,
+      stack: this.stack,
+    };
+  }
+}
+
+/**
+ * Validation error for invalid input
+ */
+export class ValidationError extends GThinkingError {
+  constructor(message: string, details: Record<string, unknown> = {}) {
+    super(message, 'VALIDATION_ERROR', details);
+    this.name = 'ValidationError';
+  }
+}
+
+/**
+ * Timeout error for operations that exceed time limit
+ */
+export class TimeoutError extends GThinkingError {
+  public readonly stage?: ThinkingStage;
+
+  constructor(message: string, stage?: ThinkingStage) {
+    super(message, 'TIMEOUT_ERROR', { stage });
+    this.name = 'TimeoutError';
+    this.stage = stage;
+  }
+}
+
+/**
+ * Cache error for caching operations
+ */
+export class CacheError extends GThinkingError {
+  constructor(message: string, details: Record<string, unknown> = {}) {
+    super(message, 'CACHE_ERROR', details);
+    this.name = 'CacheError';
+  }
+}
+
+/**
+ * Stage error for thinking stage failures
+ */
+export class StageError extends GThinkingError {
+  public readonly stage: ThinkingStage;
+  public readonly retryable: boolean;
+
+  constructor(
+    message: string,
+    stage: ThinkingStage,
+    retryable = false,
+    details: Record<string, unknown> = {}
+  ) {
+    super(message, 'STAGE_ERROR', { stage, retryable, ...details });
+    this.name = 'StageError';
+    this.stage = stage;
+    this.retryable = retryable;
+  }
+}
+
+/**
+ * LLM error for LLM service failures
+ */
+export class LLMError extends GThinkingError {
+  public readonly provider: string;
+  public readonly statusCode?: number;
+
+  constructor(
+    message: string,
+    provider: string,
+    statusCode?: number,
+    details: Record<string, unknown> = {}
+  ) {
+    super(message, 'LLM_ERROR', { provider, statusCode, ...details });
+    this.name = 'LLMError';
+    this.provider = provider;
+    this.statusCode = statusCode;
+  }
+}
+
+/**
+ * Search error for search operation failures
+ */
+export class SearchError extends GThinkingError {
+  public readonly provider: string;
+
+  constructor(
+    message: string,
+    provider: string,
+    details: Record<string, unknown> = {}
+  ) {
+    super(message, 'SEARCH_ERROR', { provider, ...details });
+    this.name = 'SearchError';
+    this.provider = provider;
+  }
+}
+
+/**
+ * Configuration error for invalid configuration
+ */
+export class ConfigurationError extends GThinkingError {
+  constructor(message: string, details: Record<string, unknown> = {}) {
+    super(message, 'CONFIGURATION_ERROR', details);
+    this.name = 'ConfigurationError';
+  }
+}
+
+/**
+ * Security error for security-related issues
+ */
+export class SecurityError extends GThinkingError {
+  constructor(message: string, details: Record<string, unknown> = {}) {
+    super(message, 'SECURITY_ERROR', details);
+    this.name = 'SecurityError';
+  }
+}
+
+/**
+ * Rate limit error for rate limiting
+ */
+export class RateLimitError extends GThinkingError {
+  public readonly retryAfter: number;
+
+  constructor(message: string, retryAfter: number) {
+    super(message, 'RATE_LIMIT_ERROR', { retryAfter });
+    this.name = 'RateLimitError';
+    this.retryAfter = retryAfter;
+  }
+}
+
+/**
+ * Error codes enum
+ */
+export enum ErrorCode {
+  VALIDATION_ERROR = 'VALIDATION_ERROR',
+  TIMEOUT_ERROR = 'TIMEOUT_ERROR',
+  CACHE_ERROR = 'CACHE_ERROR',
+  STAGE_ERROR = 'STAGE_ERROR',
+  LLM_ERROR = 'LLM_ERROR',
+  SEARCH_ERROR = 'SEARCH_ERROR',
+  CONFIGURATION_ERROR = 'CONFIGURATION_ERROR',
+  SECURITY_ERROR = 'SECURITY_ERROR',
+  RATE_LIMIT_ERROR = 'RATE_LIMIT_ERROR',
+  UNKNOWN_ERROR = 'UNKNOWN_ERROR',
+}
+
+/**
+ * Error handler function type
+ */
+export type ErrorHandler = (error: Error) => void | Promise<void>;
+
+/**
+ * Global error handler registry
+ */
+class ErrorHandlerRegistry {
+  private handlers: Map<string, ErrorHandler[]> = new Map();
+
+  /**
+   * Register an error handler
+   * @param errorCode - The error code to handle
+   * @param handler - The error handler function
+   */
+  public register(errorCode: string, handler: ErrorHandler): void {
+    if (!this.handlers.has(errorCode)) {
+      this.handlers.set(errorCode, []);
+    }
+    this.handlers.get(errorCode)!.push(handler);
+  }
+
+  /**
+   * Unregister an error handler
+   * @param errorCode - The error code
+   * @param handler - The handler to remove
+   */
+  public unregister(errorCode: string, handler: ErrorHandler): void {
+    const handlers = this.handlers.get(errorCode);
+    if (handlers) {
+      const index = handlers.indexOf(handler);
+      if (index > -1) {
+        handlers.splice(index, 1);
+      }
+    }
+  }
+
+  /**
+   * Handle an error
+   * @param error - The error to handle
+   */
+  public async handle(error: Error): Promise<void> {
+    const gError = error as GThinkingError;
+    const errorCode = gError.code || ErrorCode.UNKNOWN_ERROR;
+    
+    const handlers = this.handlers.get(errorCode) || [];
+    
+    for (const handler of handlers) {
+      try {
+        await handler(error);
+      } catch (handlerError) {
+        console.error('Error handler failed:', handlerError);
+      }
+    }
+  }
+
+  /**
+   * Clear all handlers
+   */
+  public clear(): void {
+    this.handlers.clear();
+  }
+}
+
+// Export singleton instance
+export const errorHandlerRegistry = new ErrorHandlerRegistry();
+
+/**
+ * Retry configuration interface
+ */
+export interface RetryConfig {
+  maxRetries: number;
+  retryDelay: number;
+  backoffMultiplier: number;
+  maxDelay: number;
+  retryableErrors: string[];
+}
+
+/**
+ * Default retry configuration
+ */
+export const defaultRetryConfig: RetryConfig = {
+  maxRetries: 3,
+  retryDelay: 1000,
+  backoffMultiplier: 2,
+  maxDelay: 30000,
+  retryableErrors: [
+    ErrorCode.TIMEOUT_ERROR,
+    ErrorCode.LLM_ERROR,
+    ErrorCode.SEARCH_ERROR,
+    ErrorCode.CACHE_ERROR,
+  ],
+};
+
+/**
+ * Retry a function with exponential backoff
+ * @param fn - The function to retry
+ * @param config - Retry configuration
+ * @returns Function result
+ */
+export async function withRetry<T>(
+  fn: () => Promise<T>,
+  config: Partial<RetryConfig> = {}
+): Promise<T> {
+  const mergedConfig = { ...defaultRetryConfig, ...config };
+  let lastError: Error | undefined;
+  
+  for (let attempt = 0; attempt <= mergedConfig.maxRetries; attempt++) {
+    try {
+      return await fn();
+    } catch (error) {
+      lastError = error as Error;
+      const gError = error as GThinkingError;
+      
+      // Check if error is retryable
+      if (!mergedConfig.retryableErrors.includes(gError.code)) {
+        throw error;
+      }
+      
+      // Don't retry on last attempt
+      if (attempt === mergedConfig.maxRetries) {
+        break;
+      }
+      
+      // Calculate delay with exponential backoff
+      const delay = Math.min(
+        mergedConfig.retryDelay * Math.pow(mergedConfig.backoffMultiplier, attempt),
+        mergedConfig.maxDelay
+      );
+      
+      await new Promise(resolve => setTimeout(resolve, delay));
+    }
+  }
+  
+  throw lastError;
+}
+
+/**
+ * Wrap a function with error handling
+ * @param fn - The function to wrap
+ * @param errorHandler - Custom error handler
+ * @returns Wrapped function
+ */
+export function withErrorHandling<T extends (...args: unknown[]) => unknown>(
+  fn: T,
+  errorHandler?: (error: Error) => void
+): T {
+  return function (...args: Parameters<T>): ReturnType<T> {
+    try {
+      const result = fn(...args);
+      
+      if (result instanceof Promise) {
+        return result.catch(error => {
+          if (errorHandler) {
+            errorHandler(error as Error);
+          }
+          throw error;
+        }) as ReturnType<T>;
+      }
+      
+      return result as ReturnType<T>;
+    } catch (error) {
+      if (errorHandler) {
+        errorHandler(error as Error);
+      }
+      throw error;
+    }
+  } as T;
+}

package/src/core/index.ts

@@ -0,0 +1,12 @@
+/**
+ * Core Module Index for gthinking v2.0.0
+ */
+
+// Errors
+export * from './errors';
+
+// Configuration
+export * from './config';
+
+// Engine
+export * from './engine';