claude-brain 0.14.2 → 0.14.4

package/src/server/types.ts

@@ -1,39 +1,39 @@
-/**
- * MCP Server Types
- * Type definitions specific to the MCP server implementation
- */
-
-/** Server connection states */
-export type ConnectionState = 'disconnected' | 'connecting' | 'connected'
-
-/** Server status information */
-export interface ServerStatus {
-  /** Whether the server is currently running */
-  running: boolean
-  /** Server name from config */
-  name: string
-  /** Server version from config */
-  version: string
-  /** Current connection state */
-  connectionState: ConnectionState
-  /** Timestamp when server started */
-  startedAt?: Date
-  /** Number of requests processed */
-  requestCount: number
-  /** Phase 6.5: Server capabilities */
-  capabilities?: string[]
-}
-
-/** Server events for lifecycle monitoring */
-export interface ServerEvents {
-  onConnectionStateChange?: (state: ConnectionState) => void
-  onError?: (error: Error) => void
-  onRequest?: (toolName: string, requestId: string) => void
-  onResponse?: (toolName: string, requestId: string, durationMs: number) => void
-}
-
-/** Options for server initialization */
-export interface ServerOptions {
-  /** Event handlers for server lifecycle */
-  events?: ServerEvents
-}
+/**
+ * MCP Server Types
+ * Type definitions specific to the MCP server implementation
+ */
+
+/** Server connection states */
+export type ConnectionState = 'disconnected' | 'connecting' | 'connected'
+
+/** Server status information */
+export interface ServerStatus {
+  /** Whether the server is currently running */
+  running: boolean
+  /** Server name from config */
+  name: string
+  /** Server version from config */
+  version: string
+  /** Current connection state */
+  connectionState: ConnectionState
+  /** Timestamp when server started */
+  startedAt?: Date
+  /** Number of requests processed */
+  requestCount: number
+  /** Phase 6.5: Server capabilities */
+  capabilities?: string[]
+}
+
+/** Server events for lifecycle monitoring */
+export interface ServerEvents {
+  onConnectionStateChange?: (state: ConnectionState) => void
+  onError?: (error: Error) => void
+  onRequest?: (toolName: string, requestId: string) => void
+  onResponse?: (toolName: string, requestId: string, durationMs: number) => void
+}
+
+/** Options for server initialization */
+export interface ServerOptions {
+  /** Event handlers for server lifecycle */
+  events?: ServerEvents
+}

package/src/server/utils/error-handler.ts

@@ -1,155 +1,155 @@
-/**
- * Error Handler
- * Utilities for handling and converting errors
- */
-
-import { McpError, ErrorCode } from '@modelcontextprotocol/sdk/types.js'
-import type { Logger } from 'pino'
-
-/**
- * Structured error information for logging
- */
-export interface ErrorInfo {
-  message: string
-  name: string
-  code?: string | number
-  stack?: string
-}
-
-/**
- * ErrorHandler provides methods for error handling and conversion
- */
-export class ErrorHandler {
-  /**
-   * Convert any error to MCP error format
-   * @param error - Error to convert
-   * @returns McpError instance
-   */
-  static toMcpError(error: unknown): McpError {
-    if (error instanceof McpError) {
-      return error
-    }
-
-    if (error instanceof Error) {
-      // Check for common error types and map to appropriate codes
-      const message = error.message.toLowerCase()
-
-      if (message.includes('not found') || message.includes('does not exist')) {
-        return new McpError(ErrorCode.InvalidParams, error.message)
-      }
-
-      if (message.includes('permission') || message.includes('unauthorized')) {
-        return new McpError(ErrorCode.InvalidRequest, error.message)
-      }
-
-      if (message.includes('timeout')) {
-        return new McpError(ErrorCode.InternalError, `Operation timed out: ${error.message}`)
-      }
-
-      return new McpError(ErrorCode.InternalError, error.message)
-    }
-
-    if (typeof error === 'string') {
-      return new McpError(ErrorCode.InternalError, error)
-    }
-
-    return new McpError(ErrorCode.InternalError, 'An unknown error occurred')
-  }
-
-  /**
-   * Extract error information for logging
-   * @param error - Error to extract info from
-   * @returns Structured error information
-   */
-  static getErrorInfo(error: unknown): ErrorInfo {
-    if (error instanceof McpError) {
-      return {
-        message: error.message,
-        name: 'McpError',
-        code: error.code,
-        stack: error.stack
-      }
-    }
-
-    if (error instanceof Error) {
-      return {
-        message: error.message,
-        name: error.name,
-        stack: error.stack
-      }
-    }
-
-    return {
-      message: String(error),
-      name: 'UnknownError'
-    }
-  }
-
-  /**
-   * Log error with context
-   * @param logger - Logger instance
-   * @param error - Error to log
-   * @param context - Additional context for the log
-   */
-  static logError(
-    logger: Logger,
-    error: unknown,
-    context: Record<string, unknown> = {}
-  ): void {
-    const errorInfo = this.getErrorInfo(error)
-
-    logger.error({
-      error: errorInfo,
-      ...context
-    }, errorInfo.message)
-  }
-
-  /**
-   * Create an MCP error for invalid parameters
-   * @param message - Error message
-   * @returns McpError with InvalidParams code
-   */
-  static invalidParams(message: string): McpError {
-    return new McpError(ErrorCode.InvalidParams, message)
-  }
-
-  /**
-   * Create an MCP error for method not found
-   * @param method - Method name that was not found
-   * @returns McpError with MethodNotFound code
-   */
-  static methodNotFound(method: string): McpError {
-    return new McpError(ErrorCode.MethodNotFound, `Method not found: ${method}`)
-  }
-
-  /**
-   * Create an MCP error for internal errors
-   * @param message - Error message
-   * @returns McpError with InternalError code
-   */
-  static internalError(message: string): McpError {
-    return new McpError(ErrorCode.InternalError, message)
-  }
-
-  /**
-   * Wrap an async function with error handling
-   * @param fn - Async function to wrap
-   * @param logger - Logger for error logging
-   * @param context - Context for error logging
-   * @returns Wrapped function that converts errors to McpError
-   */
-  static wrapAsync<T extends unknown[], R>(
-    fn: (...args: T) => Promise<R>,
-    logger: Logger,
-    context: Record<string, unknown> = {}
-  ): (...args: T) => Promise<R> {
-    return async (...args: T): Promise<R> => {
-      try {
-        return await fn(...args)
-      } catch (error) {
-        this.logError(logger, error, context)
-        throw this.toMcpError(error)
-      }
-    }
-  }
-}
+/**
+ * Error Handler
+ * Utilities for handling and converting errors
+ */
+
+import { McpError, ErrorCode } from '@modelcontextprotocol/sdk/types.js'
+import type { Logger } from 'pino'
+
+/**
+ * Structured error information for logging
+ */
+export interface ErrorInfo {
+  message: string
+  name: string
+  code?: string | number
+  stack?: string
+}
+
+/**
+ * ErrorHandler provides methods for error handling and conversion
+ */
+export class ErrorHandler {
+  /**
+   * Convert any error to MCP error format
+   * @param error - Error to convert
+   * @returns McpError instance
+   */
+  static toMcpError(error: unknown): McpError {
+    if (error instanceof McpError) {
+      return error
+    }
+
+    if (error instanceof Error) {
+      // Check for common error types and map to appropriate codes
+      const message = error.message.toLowerCase()
+
+      if (message.includes('not found') || message.includes('does not exist')) {
+        return new McpError(ErrorCode.InvalidParams, error.message)
+      }
+
+      if (message.includes('permission') || message.includes('unauthorized')) {
+        return new McpError(ErrorCode.InvalidRequest, error.message)
+      }
+
+      if (message.includes('timeout')) {
+        return new McpError(ErrorCode.InternalError, `Operation timed out: ${error.message}`)
+      }
+
+      return new McpError(ErrorCode.InternalError, error.message)
+    }
+
+    if (typeof error === 'string') {
+      return new McpError(ErrorCode.InternalError, error)
+    }
+
+    return new McpError(ErrorCode.InternalError, 'An unknown error occurred')
+  }
+
+  /**
+   * Extract error information for logging
+   * @param error - Error to extract info from
+   * @returns Structured error information
+   */
+  static getErrorInfo(error: unknown): ErrorInfo {
+    if (error instanceof McpError) {
+      return {
+        message: error.message,
+        name: 'McpError',
+        code: error.code,
+        stack: error.stack
+      }
+    }
+
+    if (error instanceof Error) {
+      return {
+        message: error.message,
+        name: error.name,
+        stack: error.stack
+      }
+    }
+
+    return {
+      message: String(error),
+      name: 'UnknownError'
+    }
+  }
+
+  /**
+   * Log error with context
+   * @param logger - Logger instance
+   * @param error - Error to log
+   * @param context - Additional context for the log
+   */
+  static logError(
+    logger: Logger,
+    error: unknown,
+    context: Record<string, unknown> = {}
+  ): void {
+    const errorInfo = this.getErrorInfo(error)
+
+    logger.error({
+      error: errorInfo,
+      ...context
+    }, errorInfo.message)
+  }
+
+  /**
+   * Create an MCP error for invalid parameters
+   * @param message - Error message
+   * @returns McpError with InvalidParams code
+   */
+  static invalidParams(message: string): McpError {
+    return new McpError(ErrorCode.InvalidParams, message)
+  }
+
+  /**
+   * Create an MCP error for method not found
+   * @param method - Method name that was not found
+   * @returns McpError with MethodNotFound code
+   */
+  static methodNotFound(method: string): McpError {
+    return new McpError(ErrorCode.MethodNotFound, `Method not found: ${method}`)
+  }
+
+  /**
+   * Create an MCP error for internal errors
+   * @param message - Error message
+   * @returns McpError with InternalError code
+   */
+  static internalError(message: string): McpError {
+    return new McpError(ErrorCode.InternalError, message)
+  }
+
+  /**
+   * Wrap an async function with error handling
+   * @param fn - Async function to wrap
+   * @param logger - Logger for error logging
+   * @param context - Context for error logging
+   * @returns Wrapped function that converts errors to McpError
+   */
+  static wrapAsync<T extends unknown[], R>(
+    fn: (...args: T) => Promise<R>,
+    logger: Logger,
+    context: Record<string, unknown> = {}
+  ): (...args: T) => Promise<R> {
+    return async (...args: T): Promise<R> => {
+      try {
+        return await fn(...args)
+      } catch (error) {
+        this.logError(logger, error, context)
+        throw this.toMcpError(error)
+      }
+    }
+  }
+}

package/src/server/utils/index.ts

@@ -1,13 +1,13 @@
-/**
- * Server Utilities Exports
- */
-
-export { ResponseFormatter } from './response-formatter'
-export { ToolValidator } from './validators'
-export { ErrorHandler, type ErrorInfo } from './error-handler'
-export {
-  RequestContext,
-  Timer,
-  createTimer,
-  generateShortId
-} from './request-context'
+/**
+ * Server Utilities Exports
+ */
+
+export { ResponseFormatter } from './response-formatter'
+export { ToolValidator } from './validators'
+export { ErrorHandler, type ErrorInfo } from './error-handler'
+export {
+  RequestContext,
+  Timer,
+  createTimer,
+  generateShortId
+} from './request-context'

package/src/server/utils/memory-indicator.ts

@@ -1,83 +1,83 @@
-/**
- * Memory Indicator
- * Shows a visual indicator when Claude Brain provides helpful data
- */
-
-// ANSI color codes for terminal output
-const ANSI = {
-  reset: '\x1b[0m',
-  red: '\x1b[31m',
-  brightRed: '\x1b[91m',
-  bold: '\x1b[1m',
-  dim: '\x1b[2m',
-  bgRed: '\x1b[41m',
-  white: '\x1b[37m',
-} as const
-
-/**
- * Memory indicator banner shown when Claude Brain provides helpful data
- */
-export const MEMORY_HELPED_BANNER = `${ANSI.brightRed}${ANSI.bold}🧠 MEMORY ASSISTED${ANSI.reset}`
-
-/**
- * Alternative shorter indicator
- */
-export const MEMORY_HELPED_SHORT = `${ANSI.brightRed}[memory-assisted]${ANSI.reset}`
-
-/**
- * Wrap content with the memory helped indicator
- * @param content - The content to wrap
- * @param count - Optional count of items found
- * @returns Content with the indicator prepended
- */
-export function withMemoryIndicator(content: string, count?: number): string {
-  const countText = count !== undefined ? ` (${count} item${count !== 1 ? 's' : ''})` : ''
-  return `${MEMORY_HELPED_BANNER}${countText}\n\n${content}`
-}
-
-/**
- * Create a memory stats line
- * @param stats - Object with retrieval statistics
- * @returns Formatted stats line in red
- */
-export function formatMemoryStats(stats: {
-  recalled?: number
-  patterns?: number
-  corrections?: number
-  similarity?: number
-}): string {
-  const parts: string[] = []
-
-  if (stats.recalled !== undefined && stats.recalled > 0) {
-    parts.push(`${stats.recalled} memories`)
-  }
-  if (stats.patterns !== undefined && stats.patterns > 0) {
-    parts.push(`${stats.patterns} patterns`)
-  }
-  if (stats.corrections !== undefined && stats.corrections > 0) {
-    parts.push(`${stats.corrections} corrections`)
-  }
-  if (stats.similarity !== undefined) {
-    parts.push(`${Math.round(stats.similarity * 100)}% match`)
-  }
-
-  if (parts.length === 0) return ''
-
-  return `${ANSI.red}📊 Retrieved: ${parts.join(', ')}${ANSI.reset}`
-}
-
-/**
- * Check if this is a "helpful" response (has actual data, not just errors/suggestions)
- */
-export function isHelpfulResponse(content: string): boolean {
-  const unhelpfulIndicators = [
-    'No similar memories found',
-    'No relevant past decisions found',
-    'No patterns found',
-    'No corrections found',
-    'not initialized',
-    'Error:',
-  ]
-
-  return !unhelpfulIndicators.some(indicator => content.includes(indicator))
-}
+/**
+ * Memory Indicator
+ * Shows a visual indicator when Claude Brain provides helpful data
+ */
+
+// ANSI color codes for terminal output
+const ANSI = {
+  reset: '\x1b[0m',
+  red: '\x1b[31m',
+  brightRed: '\x1b[91m',
+  bold: '\x1b[1m',
+  dim: '\x1b[2m',
+  bgRed: '\x1b[41m',
+  white: '\x1b[37m',
+} as const
+
+/**
+ * Memory indicator banner shown when Claude Brain provides helpful data
+ */
+export const MEMORY_HELPED_BANNER = `${ANSI.brightRed}${ANSI.bold}🧠 MEMORY ASSISTED${ANSI.reset}`
+
+/**
+ * Alternative shorter indicator
+ */
+export const MEMORY_HELPED_SHORT = `${ANSI.brightRed}[memory-assisted]${ANSI.reset}`
+
+/**
+ * Wrap content with the memory helped indicator
+ * @param content - The content to wrap
+ * @param count - Optional count of items found
+ * @returns Content with the indicator prepended
+ */
+export function withMemoryIndicator(content: string, count?: number): string {
+  const countText = count !== undefined ? ` (${count} item${count !== 1 ? 's' : ''})` : ''
+  return `${MEMORY_HELPED_BANNER}${countText}\n\n${content}`
+}
+
+/**
+ * Create a memory stats line
+ * @param stats - Object with retrieval statistics
+ * @returns Formatted stats line in red
+ */
+export function formatMemoryStats(stats: {
+  recalled?: number
+  patterns?: number
+  corrections?: number
+  similarity?: number
+}): string {
+  const parts: string[] = []
+
+  if (stats.recalled !== undefined && stats.recalled > 0) {
+    parts.push(`${stats.recalled} memories`)
+  }
+  if (stats.patterns !== undefined && stats.patterns > 0) {
+    parts.push(`${stats.patterns} patterns`)
+  }
+  if (stats.corrections !== undefined && stats.corrections > 0) {
+    parts.push(`${stats.corrections} corrections`)
+  }
+  if (stats.similarity !== undefined) {
+    parts.push(`${Math.round(stats.similarity * 100)}% match`)
+  }
+
+  if (parts.length === 0) return ''
+
+  return `${ANSI.red}📊 Retrieved: ${parts.join(', ')}${ANSI.reset}`
+}
+
+/**
+ * Check if this is a "helpful" response (has actual data, not just errors/suggestions)
+ */
+export function isHelpfulResponse(content: string): boolean {
+  const unhelpfulIndicators = [
+    'No similar memories found',
+    'No relevant past decisions found',
+    'No patterns found',
+    'No corrections found',
+    'not initialized',
+    'Error:',
+  ]
+
+  return !unhelpfulIndicators.some(indicator => content.includes(indicator))
+}