claude-brain 0.14.2 → 0.14.4

package/src/utils/circuit-breaker.ts

@@ -1,130 +1,130 @@
-import type { Logger } from 'pino'
-
-export enum CircuitState {
-  CLOSED = 'closed',
-  OPEN = 'open',
-  HALF_OPEN = 'half-open'
-}
-
-export interface CircuitBreakerOptions {
-  failureThreshold: number
-  successThreshold: number
-  timeout: number
-  onStateChange?: (state: CircuitState) => void
-}
-
-export class CircuitBreaker {
-  private state: CircuitState = CircuitState.CLOSED
-  private failureCount = 0
-  private successCount = 0
-  private nextAttempt = Date.now()
-  private logger: Logger
-  private options: CircuitBreakerOptions
-
-  constructor(
-    private name: string,
-    logger: Logger,
-    options: Partial<CircuitBreakerOptions> = {}
-  ) {
-    this.logger = logger.child({ component: 'circuit-breaker', name })
-    this.options = {
-      failureThreshold: 5,
-      successThreshold: 2,
-      timeout: 60000,
-      ...options
-    }
-  }
-
-  async execute<T>(fn: () => Promise<T>): Promise<T> {
-    if (this.state === CircuitState.OPEN) {
-      if (Date.now() < this.nextAttempt) {
-        throw new Error(
-          `Circuit breaker "${this.name}" is OPEN. Try again later.`
-        )
-      }
-
-      this.setState(CircuitState.HALF_OPEN)
-    }
-
-    try {
-      const result = await fn()
-
-      this.onSuccess()
-      return result
-
-    } catch (error) {
-      this.onFailure()
-      throw error
-    }
-  }
-
-  private onSuccess(): void {
-    this.failureCount = 0
-
-    if (this.state === CircuitState.HALF_OPEN) {
-      this.successCount++
-
-      if (this.successCount >= this.options.successThreshold) {
-        this.setState(CircuitState.CLOSED)
-      }
-    }
-  }
-
-  private onFailure(): void {
-    this.failureCount++
-    this.successCount = 0
-
-    this.logger.warn(
-      { failureCount: this.failureCount, threshold: this.options.failureThreshold },
-      'Circuit breaker failure recorded'
-    )
-
-    if (this.failureCount >= this.options.failureThreshold) {
-      this.setState(CircuitState.OPEN)
-      this.nextAttempt = Date.now() + this.options.timeout
-    }
-  }
-
-  private setState(newState: CircuitState): void {
-    const oldState = this.state
-    this.state = newState
-
-    this.logger.info(
-      { from: oldState, to: newState },
-      'Circuit breaker state changed'
-    )
-
-    if (this.options.onStateChange) {
-      this.options.onStateChange(newState)
-    }
-
-    if (newState === CircuitState.CLOSED) {
-      this.failureCount = 0
-      this.successCount = 0
-    } else if (newState === CircuitState.HALF_OPEN) {
-      this.successCount = 0
-    }
-  }
-
-  getState(): CircuitState {
-    return this.state
-  }
-
-  reset(): void {
-    this.setState(CircuitState.CLOSED)
-    this.failureCount = 0
-    this.successCount = 0
-  }
-
-  getStats() {
-    return {
-      name: this.name,
-      state: this.state,
-      failureCount: this.failureCount,
-      successCount: this.successCount,
-      nextAttempt: this.state === CircuitState.OPEN
-        ? new Date(this.nextAttempt)
-        : null
-    }
-  }
-}
+import type { Logger } from 'pino'
+
+export enum CircuitState {
+  CLOSED = 'closed',
+  OPEN = 'open',
+  HALF_OPEN = 'half-open'
+}
+
+export interface CircuitBreakerOptions {
+  failureThreshold: number
+  successThreshold: number
+  timeout: number
+  onStateChange?: (state: CircuitState) => void
+}
+
+export class CircuitBreaker {
+  private state: CircuitState = CircuitState.CLOSED
+  private failureCount = 0
+  private successCount = 0
+  private nextAttempt = Date.now()
+  private logger: Logger
+  private options: CircuitBreakerOptions
+
+  constructor(
+    private name: string,
+    logger: Logger,
+    options: Partial<CircuitBreakerOptions> = {}
+  ) {
+    this.logger = logger.child({ component: 'circuit-breaker', name })
+    this.options = {
+      failureThreshold: 5,
+      successThreshold: 2,
+      timeout: 60000,
+      ...options
+    }
+  }
+
+  async execute<T>(fn: () => Promise<T>): Promise<T> {
+    if (this.state === CircuitState.OPEN) {
+      if (Date.now() < this.nextAttempt) {
+        throw new Error(
+          `Circuit breaker "${this.name}" is OPEN. Try again later.`
+        )
+      }
+
+      this.setState(CircuitState.HALF_OPEN)
+    }
+
+    try {
+      const result = await fn()
+
+      this.onSuccess()
+      return result
+
+    } catch (error) {
+      this.onFailure()
+      throw error
+    }
+  }
+
+  private onSuccess(): void {
+    this.failureCount = 0
+
+    if (this.state === CircuitState.HALF_OPEN) {
+      this.successCount++
+
+      if (this.successCount >= this.options.successThreshold) {
+        this.setState(CircuitState.CLOSED)
+      }
+    }
+  }
+
+  private onFailure(): void {
+    this.failureCount++
+    this.successCount = 0
+
+    this.logger.warn(
+      { failureCount: this.failureCount, threshold: this.options.failureThreshold },
+      'Circuit breaker failure recorded'
+    )
+
+    if (this.failureCount >= this.options.failureThreshold) {
+      this.setState(CircuitState.OPEN)
+      this.nextAttempt = Date.now() + this.options.timeout
+    }
+  }
+
+  private setState(newState: CircuitState): void {
+    const oldState = this.state
+    this.state = newState
+
+    this.logger.info(
+      { from: oldState, to: newState },
+      'Circuit breaker state changed'
+    )
+
+    if (this.options.onStateChange) {
+      this.options.onStateChange(newState)
+    }
+
+    if (newState === CircuitState.CLOSED) {
+      this.failureCount = 0
+      this.successCount = 0
+    } else if (newState === CircuitState.HALF_OPEN) {
+      this.successCount = 0
+    }
+  }
+
+  getState(): CircuitState {
+    return this.state
+  }
+
+  reset(): void {
+    this.setState(CircuitState.CLOSED)
+    this.failureCount = 0
+    this.successCount = 0
+  }
+
+  getStats() {
+    return {
+      name: this.name,
+      state: this.state,
+      failureCount: this.failureCount,
+      successCount: this.successCount,
+      nextAttempt: this.state === CircuitState.OPEN
+        ? new Date(this.nextAttempt)
+        : null
+    }
+  }
+}

package/src/utils/cleanup.ts

@@ -1,34 +1,34 @@
-import type { Logger } from 'pino'
-
-export class CleanupManager {
-  private handlers: Array<() => Promise<void>> = []
-  private logger: Logger
-
-  constructor(logger: Logger) {
-    this.logger = logger.child({ component: 'cleanup-manager' })
-  }
-
-  register(handler: () => Promise<void>): void {
-    this.handlers.push(handler)
-  }
-
-  async cleanup(): Promise<void> {
-    this.logger.info(
-      { handlerCount: this.handlers.length },
-      'Running cleanup handlers'
-    )
-
-    for (const handler of this.handlers) {
-      try {
-        await handler()
-      } catch (error) {
-        this.logger.error(
-          { error },
-          'Cleanup handler failed'
-        )
-      }
-    }
-
-    this.logger.info('Cleanup completed')
-  }
-}
+import type { Logger } from 'pino'
+
+export class CleanupManager {
+  private handlers: Array<() => Promise<void>> = []
+  private logger: Logger
+
+  constructor(logger: Logger) {
+    this.logger = logger.child({ component: 'cleanup-manager' })
+  }
+
+  register(handler: () => Promise<void>): void {
+    this.handlers.push(handler)
+  }
+
+  async cleanup(): Promise<void> {
+    this.logger.info(
+      { handlerCount: this.handlers.length },
+      'Running cleanup handlers'
+    )
+
+    for (const handler of this.handlers) {
+      try {
+        await handler()
+      } catch (error) {
+        this.logger.error(
+          { error },
+          'Cleanup handler failed'
+        )
+      }
+    }
+
+    this.logger.info('Cleanup completed')
+  }
+}

package/src/utils/error-handler.ts

@@ -1,132 +1,132 @@
-import type { Logger } from 'pino'
-
-export class GlobalErrorHandler {
-  private logger: Logger
-  private isShuttingDown = false
-
-  constructor(logger: Logger) {
-    this.logger = logger.child({ component: 'error-handler' })
-    this.setupHandlers()
-  }
-
-  private setupHandlers(): void {
-    process.on('uncaughtException', (error: Error) => {
-      this.handleUncaughtException(error)
-    })
-
-    process.on('unhandledRejection', (reason: unknown, promise: Promise<unknown>) => {
-      this.handleUnhandledRejection(reason, promise)
-    })
-
-    process.on('warning', (warning: Error) => {
-      this.handleWarning(warning)
-    })
-
-    process.on('SIGTERM', () => {
-      this.handleShutdown('SIGTERM')
-    })
-
-    process.on('SIGINT', () => {
-      this.handleShutdown('SIGINT')
-    })
-  }
-
-  private handleUncaughtException(error: Error): void {
-    this.logger.fatal(
-      {
-        error: {
-          name: error.name,
-          message: error.message,
-          stack: error.stack
-        }
-      },
-      'Uncaught exception'
-    )
-
-    this.emergencyShutdown('uncaughtException')
-  }
-
-  private handleUnhandledRejection(reason: unknown, promise: Promise<unknown>): void {
-    this.logger.error(
-      {
-        reason: reason instanceof Error ? {
-          name: reason.name,
-          message: reason.message,
-          stack: reason.stack
-        } : reason,
-        promise: String(promise)
-      },
-      'Unhandled promise rejection'
-    )
-  }
-
-  private handleWarning(warning: Error): void {
-    this.logger.warn(
-      {
-        name: warning.name,
-        message: warning.message,
-        stack: warning.stack
-      },
-      'Process warning'
-    )
-  }
-
-  private handleShutdown(signal: string): void {
-    if (this.isShuttingDown) {
-      return
-    }
-
-    this.isShuttingDown = true
-
-    this.logger.info({ signal }, 'Received shutdown signal, closing gracefully...')
-
-    setTimeout(() => {
-      this.logger.info('Graceful shutdown complete')
-      process.exit(0)
-    }, 5000)
-  }
-
-  private emergencyShutdown(reason: string): void {
-    console.error(`FATAL: Emergency shutdown due to ${reason}`)
-
-    setTimeout(() => {
-      process.exit(1)
-    }, 1000)
-  }
-
-  static createError(
-    message: string,
-    code: string,
-    context?: Record<string, unknown>
-  ): AppError {
-    return new AppError(message, code, context)
-  }
-}
-
-export class AppError extends Error {
-  code: string
-  context?: Record<string, unknown>
-  isOperational: boolean
-
-  constructor(
-    message: string,
-    code: string,
-    context?: Record<string, unknown>,
-    isOperational = true
-  ) {
-    super(message)
-    this.name = 'AppError'
-    this.code = code
-    this.context = context
-    this.isOperational = isOperational
-
-    Error.captureStackTrace(this, this.constructor)
-  }
-}
-
-export function isOperationalError(error: Error): boolean {
-  if (error instanceof AppError) {
-    return error.isOperational
-  }
-  return false
-}
+import type { Logger } from 'pino'
+
+export class GlobalErrorHandler {
+  private logger: Logger
+  private isShuttingDown = false
+
+  constructor(logger: Logger) {
+    this.logger = logger.child({ component: 'error-handler' })
+    this.setupHandlers()
+  }
+
+  private setupHandlers(): void {
+    process.on('uncaughtException', (error: Error) => {
+      this.handleUncaughtException(error)
+    })
+
+    process.on('unhandledRejection', (reason: unknown, promise: Promise<unknown>) => {
+      this.handleUnhandledRejection(reason, promise)
+    })
+
+    process.on('warning', (warning: Error) => {
+      this.handleWarning(warning)
+    })
+
+    process.on('SIGTERM', () => {
+      this.handleShutdown('SIGTERM')
+    })
+
+    process.on('SIGINT', () => {
+      this.handleShutdown('SIGINT')
+    })
+  }
+
+  private handleUncaughtException(error: Error): void {
+    this.logger.fatal(
+      {
+        error: {
+          name: error.name,
+          message: error.message,
+          stack: error.stack
+        }
+      },
+      'Uncaught exception'
+    )
+
+    this.emergencyShutdown('uncaughtException')
+  }
+
+  private handleUnhandledRejection(reason: unknown, promise: Promise<unknown>): void {
+    this.logger.error(
+      {
+        reason: reason instanceof Error ? {
+          name: reason.name,
+          message: reason.message,
+          stack: reason.stack
+        } : reason,
+        promise: String(promise)
+      },
+      'Unhandled promise rejection'
+    )
+  }
+
+  private handleWarning(warning: Error): void {
+    this.logger.warn(
+      {
+        name: warning.name,
+        message: warning.message,
+        stack: warning.stack
+      },
+      'Process warning'
+    )
+  }
+
+  private handleShutdown(signal: string): void {
+    if (this.isShuttingDown) {
+      return
+    }
+
+    this.isShuttingDown = true
+
+    this.logger.info({ signal }, 'Received shutdown signal, closing gracefully...')
+
+    setTimeout(() => {
+      this.logger.info('Graceful shutdown complete')
+      process.exit(0)
+    }, 5000)
+  }
+
+  private emergencyShutdown(reason: string): void {
+    console.error(`FATAL: Emergency shutdown due to ${reason}`)
+
+    setTimeout(() => {
+      process.exit(1)
+    }, 1000)
+  }
+
+  static createError(
+    message: string,
+    code: string,
+    context?: Record<string, unknown>
+  ): AppError {
+    return new AppError(message, code, context)
+  }
+}
+
+export class AppError extends Error {
+  code: string
+  context?: Record<string, unknown>
+  isOperational: boolean
+
+  constructor(
+    message: string,
+    code: string,
+    context?: Record<string, unknown>,
+    isOperational = true
+  ) {
+    super(message)
+    this.name = 'AppError'
+    this.code = code
+    this.context = context
+    this.isOperational = isOperational
+
+    Error.captureStackTrace(this, this.constructor)
+  }
+}
+
+export function isOperationalError(error: Error): boolean {
+  if (error instanceof AppError) {
+    return error.isOperational
+  }
+  return false
+}