claude-brain 0.14.0 → 0.14.2

package/src/utils/phase12-helper.ts

@@ -1,56 +1,56 @@
-/**
- * Phase 12 Helper
- * Utilities for checking Phase 12 availability
- * Allows Phase 6.5 to gracefully degrade if Phase 12 isn't fully implemented
- */
-
-import type { Phase12Manager } from '@/automation/phase12-manager'
-
-// Cache for Phase 12 availability check
-let phase12Available: boolean | null = null
-
-/**
- * Check if Phase 12 features are available
- */
-export function isPhase12Available(): boolean {
-  if (phase12Available !== null) {
-    return phase12Available
-  }
-
-  try {
-    // Check if the module can be loaded
-    require('@/automation/phase12-manager')
-    phase12Available = true
-    return true
-  } catch {
-    phase12Available = false
-    return false
-  }
-}
-
-/**
- * Get Phase 12 instance if available
- * Returns null if Phase 12 is not available or not initialized
- */
-export function getPhase12Instance(): Phase12Manager | null {
-  try {
-    // Import the service getter
-    const { getPhase12Service, isServicesInitialized } = require('@/server/services')
-
-    if (!isServicesInitialized()) {
-      return null
-    }
-
-    return getPhase12Service()
-  } catch {
-    return null
-  }
-}
-
-/**
- * Reset the Phase 12 availability cache
- * Useful for testing
- */
-export function resetPhase12Cache(): void {
-  phase12Available = null
-}
+/**
+ * Phase 12 Helper
+ * Utilities for checking Phase 12 availability
+ * Allows Phase 6.5 to gracefully degrade if Phase 12 isn't fully implemented
+ */
+
+import type { Phase12Manager } from '@/automation/phase12-manager'
+
+// Cache for Phase 12 availability check
+let phase12Available: boolean | null = null
+
+/**
+ * Check if Phase 12 features are available
+ */
+export function isPhase12Available(): boolean {
+  if (phase12Available !== null) {
+    return phase12Available
+  }
+
+  try {
+    // Check if the module can be loaded
+    require('@/automation/phase12-manager')
+    phase12Available = true
+    return true
+  } catch {
+    phase12Available = false
+    return false
+  }
+}
+
+/**
+ * Get Phase 12 instance if available
+ * Returns null if Phase 12 is not available or not initialized
+ */
+export function getPhase12Instance(): Phase12Manager | null {
+  try {
+    // Import the service getter
+    const { getPhase12Service, isServicesInitialized } = require('@/server/services')
+
+    if (!isServicesInitialized()) {
+      return null
+    }
+
+    return getPhase12Service()
+  } catch {
+    return null
+  }
+}
+
+/**
+ * Reset the Phase 12 availability cache
+ * Useful for testing
+ */
+export function resetPhase12Cache(): void {
+  phase12Available = null
+}

package/src/utils/retry.ts

@@ -1,94 +1,94 @@
-import type { Logger } from 'pino'
-
-export interface RetryOptions {
-  maxRetries: number
-  initialDelay: number
-  maxDelay: number
-  backoffMultiplier: number
-  retryCondition?: (error: Error) => boolean
-  onRetry?: (error: Error, attempt: number) => void
-}
-
-export class RetryManager {
-  private logger: Logger
-
-  constructor(logger: Logger) {
-    this.logger = logger.child({ component: 'retry-manager' })
-  }
-
-  async execute<T>(
-    fn: () => Promise<T>,
-    options: Partial<RetryOptions> = {}
-  ): Promise<T> {
-    const opts: RetryOptions = {
-      maxRetries: 3,
-      initialDelay: 1000,
-      maxDelay: 30000,
-      backoffMultiplier: 2,
-      ...options
-    }
-
-    let lastError: Error | undefined
-    let attempt = 0
-
-    while (attempt <= opts.maxRetries) {
-      try {
-        return await fn()
-
-      } catch (error) {
-        lastError = error as Error
-        attempt++
-
-        if (attempt > opts.maxRetries) {
-          this.logger.error(
-            { error: lastError, attempts: attempt },
-            'Max retries exceeded'
-          )
-          throw lastError
-        }
-
-        if (opts.retryCondition && !opts.retryCondition(lastError)) {
-          this.logger.debug(
-            { error: lastError },
-            'Retry condition not met, not retrying'
-          )
-          throw lastError
-        }
-
-        const delay = Math.min(
-          opts.initialDelay * Math.pow(opts.backoffMultiplier, attempt - 1),
-          opts.maxDelay
-        )
-
-        this.logger.info(
-          { error: lastError.message, attempt, delay },
-          'Retrying after delay'
-        )
-
-        if (opts.onRetry) {
-          opts.onRetry(lastError, attempt)
-        }
-
-        await this.sleep(delay)
-      }
-    }
-
-    throw lastError!
-  }
-
-  static isRetryableError(error: Error): boolean {
-    if (error.message.includes('ECONNREFUSED')) return true
-    if (error.message.includes('ETIMEDOUT')) return true
-    if (error.message.includes('ENOTFOUND')) return true
-    if (error.message.includes('SQLITE_BUSY')) return true
-    if (error.message.includes('database is locked')) return true
-    if (error.message.includes('EBUSY')) return true
-    if (error.message.includes('EMFILE')) return true
-
-    return false
-  }
-
-  private sleep(ms: number): Promise<void> {
-    return new Promise(resolve => setTimeout(resolve, ms))
-  }
-}
+import type { Logger } from 'pino'
+
+export interface RetryOptions {
+  maxRetries: number
+  initialDelay: number
+  maxDelay: number
+  backoffMultiplier: number
+  retryCondition?: (error: Error) => boolean
+  onRetry?: (error: Error, attempt: number) => void
+}
+
+export class RetryManager {
+  private logger: Logger
+
+  constructor(logger: Logger) {
+    this.logger = logger.child({ component: 'retry-manager' })
+  }
+
+  async execute<T>(
+    fn: () => Promise<T>,
+    options: Partial<RetryOptions> = {}
+  ): Promise<T> {
+    const opts: RetryOptions = {
+      maxRetries: 3,
+      initialDelay: 1000,
+      maxDelay: 30000,
+      backoffMultiplier: 2,
+      ...options
+    }
+
+    let lastError: Error | undefined
+    let attempt = 0
+
+    while (attempt <= opts.maxRetries) {
+      try {
+        return await fn()
+
+      } catch (error) {
+        lastError = error as Error
+        attempt++
+
+        if (attempt > opts.maxRetries) {
+          this.logger.error(
+            { error: lastError, attempts: attempt },
+            'Max retries exceeded'
+          )
+          throw lastError
+        }
+
+        if (opts.retryCondition && !opts.retryCondition(lastError)) {
+          this.logger.debug(
+            { error: lastError },
+            'Retry condition not met, not retrying'
+          )
+          throw lastError
+        }
+
+        const delay = Math.min(
+          opts.initialDelay * Math.pow(opts.backoffMultiplier, attempt - 1),
+          opts.maxDelay
+        )
+
+        this.logger.info(
+          { error: lastError.message, attempt, delay },
+          'Retrying after delay'
+        )
+
+        if (opts.onRetry) {
+          opts.onRetry(lastError, attempt)
+        }
+
+        await this.sleep(delay)
+      }
+    }
+
+    throw lastError!
+  }
+
+  static isRetryableError(error: Error): boolean {
+    if (error.message.includes('ECONNREFUSED')) return true
+    if (error.message.includes('ETIMEDOUT')) return true
+    if (error.message.includes('ENOTFOUND')) return true
+    if (error.message.includes('SQLITE_BUSY')) return true
+    if (error.message.includes('database is locked')) return true
+    if (error.message.includes('EBUSY')) return true
+    if (error.message.includes('EMFILE')) return true
+
+    return false
+  }
+
+  private sleep(ms: number): Promise<void> {
+    return new Promise(resolve => setTimeout(resolve, ms))
+  }
+}

package/src/utils/timing.ts

@@ -1,47 +1,47 @@
-/**
- * Timing Utility
- * Phase 22: Wraps async operations with performance timing.
- * Logs warnings for operations exceeding 200ms.
- */
-
-const SLOW_THRESHOLD_MS = 200
-
-/**
- * Wrap an async operation with timing instrumentation.
- * Logs a warning if the operation exceeds 200ms.
- */
-export async function timed<T>(label: string, fn: () => Promise<T>): Promise<T> {
-  const start = performance.now()
-  try {
-    const result = await fn()
-    const elapsed = performance.now() - start
-    if (elapsed > SLOW_THRESHOLD_MS) {
-      // Use console.error to avoid interfering with MCP stdio
-      console.error(`[SLOW] ${label}: ${Math.round(elapsed)}ms (budget: ${SLOW_THRESHOLD_MS}ms)`)
-    }
-    return result
-  } catch (error) {
-    const elapsed = performance.now() - start
-    console.error(`[ERROR] ${label}: ${Math.round(elapsed)}ms — ${error instanceof Error ? error.message : 'unknown'}`)
-    throw error
-  }
-}
-
-/**
- * Synchronous version for non-async operations.
- */
-export function timedSync<T>(label: string, fn: () => T): T {
-  const start = performance.now()
-  try {
-    const result = fn()
-    const elapsed = performance.now() - start
-    if (elapsed > SLOW_THRESHOLD_MS) {
-      console.error(`[SLOW] ${label}: ${Math.round(elapsed)}ms (budget: ${SLOW_THRESHOLD_MS}ms)`)
-    }
-    return result
-  } catch (error) {
-    const elapsed = performance.now() - start
-    console.error(`[ERROR] ${label}: ${Math.round(elapsed)}ms — ${error instanceof Error ? error.message : 'unknown'}`)
-    throw error
-  }
-}
+/**
+ * Timing Utility
+ * Phase 22: Wraps async operations with performance timing.
+ * Logs warnings for operations exceeding 200ms.
+ */
+
+const SLOW_THRESHOLD_MS = 200
+
+/**
+ * Wrap an async operation with timing instrumentation.
+ * Logs a warning if the operation exceeds 200ms.
+ */
+export async function timed<T>(label: string, fn: () => Promise<T>): Promise<T> {
+  const start = performance.now()
+  try {
+    const result = await fn()
+    const elapsed = performance.now() - start
+    if (elapsed > SLOW_THRESHOLD_MS) {
+      // Use console.error to avoid interfering with MCP stdio
+      console.error(`[SLOW] ${label}: ${Math.round(elapsed)}ms (budget: ${SLOW_THRESHOLD_MS}ms)`)
+    }
+    return result
+  } catch (error) {
+    const elapsed = performance.now() - start
+    console.error(`[ERROR] ${label}: ${Math.round(elapsed)}ms — ${error instanceof Error ? error.message : 'unknown'}`)
+    throw error
+  }
+}
+
+/**
+ * Synchronous version for non-async operations.
+ */
+export function timedSync<T>(label: string, fn: () => T): T {
+  const start = performance.now()
+  try {
+    const result = fn()
+    const elapsed = performance.now() - start
+    if (elapsed > SLOW_THRESHOLD_MS) {
+      console.error(`[SLOW] ${label}: ${Math.round(elapsed)}ms (budget: ${SLOW_THRESHOLD_MS}ms)`)
+    }
+    return result
+  } catch (error) {
+    const elapsed = performance.now() - start
+    console.error(`[ERROR] ${label}: ${Math.round(elapsed)}ms — ${error instanceof Error ? error.message : 'unknown'}`)
+    throw error
+  }
+}

package/src/utils/transaction.ts

@@ -1,63 +1,63 @@
-import type { Logger } from 'pino'
-
-export class TransactionManager {
-  private logger: Logger
-  private operations: Array<() => Promise<void>> = []
-  private rollbacks: Array<() => Promise<void>> = []
-
-  constructor(logger: Logger) {
-    this.logger = logger.child({ component: 'transaction-manager' })
-  }
-
-  add(
-    operation: () => Promise<void>,
-    rollback: () => Promise<void>
-  ): void {
-    this.operations.push(operation)
-    this.rollbacks.unshift(rollback)
-  }
-
-  async execute(): Promise<void> {
-    const executedCount = 0
-
-    try {
-      for (let i = 0; i < this.operations.length; i++) {
-        await this.operations[i]()
-      }
-
-      this.logger.info(
-        { operationCount: this.operations.length },
-        'Transaction completed successfully'
-      )
-
-    } catch (error) {
-      this.logger.error(
-        { error, executedCount },
-        'Transaction failed, rolling back'
-      )
-
-      await this.rollback()
-      throw error
-    }
-  }
-
-  private async rollback(): Promise<void> {
-    for (const rollback of this.rollbacks) {
-      try {
-        await rollback()
-      } catch (error) {
-        this.logger.error(
-          { error },
-          'Rollback operation failed'
-        )
-      }
-    }
-
-    this.logger.info('Rollback completed')
-  }
-
-  clear(): void {
-    this.operations = []
-    this.rollbacks = []
-  }
-}
+import type { Logger } from 'pino'
+
+export class TransactionManager {
+  private logger: Logger
+  private operations: Array<() => Promise<void>> = []
+  private rollbacks: Array<() => Promise<void>> = []
+
+  constructor(logger: Logger) {
+    this.logger = logger.child({ component: 'transaction-manager' })
+  }
+
+  add(
+    operation: () => Promise<void>,
+    rollback: () => Promise<void>
+  ): void {
+    this.operations.push(operation)
+    this.rollbacks.unshift(rollback)
+  }
+
+  async execute(): Promise<void> {
+    const executedCount = 0
+
+    try {
+      for (let i = 0; i < this.operations.length; i++) {
+        await this.operations[i]()
+      }
+
+      this.logger.info(
+        { operationCount: this.operations.length },
+        'Transaction completed successfully'
+      )
+
+    } catch (error) {
+      this.logger.error(
+        { error, executedCount },
+        'Transaction failed, rolling back'
+      )
+
+      await this.rollback()
+      throw error
+    }
+  }
+
+  private async rollback(): Promise<void> {
+    for (const rollback of this.rollbacks) {
+      try {
+        await rollback()
+      } catch (error) {
+        this.logger.error(
+          { error },
+          'Rollback operation failed'
+        )
+      }
+    }
+
+    this.logger.info('Rollback completed')
+  }
+
+  clear(): void {
+    this.operations = []
+    this.rollbacks = []
+  }
+}