claude-brain 0.30.2 → 0.30.3

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

@@ -1,84 +1,84 @@
-/**
- * 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
- * Note: No ANSI codes — MCP tool responses should be plain text/markdown
- */
-export const MEMORY_HELPED_BANNER = '🧠 MEMORY ASSISTED'
-
-/**
- * Alternative shorter indicator
- */
-export const MEMORY_HELPED_SHORT = '[memory-assisted]'
-
-/**
- * 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 `📊 Retrieved: ${parts.join(', ')}`
-}
-
-/**
- * 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
+ * Note: No ANSI codes — MCP tool responses should be plain text/markdown
+ */
+export const MEMORY_HELPED_BANNER = '🧠 MEMORY ASSISTED'
+
+/**
+ * Alternative shorter indicator
+ */
+export const MEMORY_HELPED_SHORT = '[memory-assisted]'
+
+/**
+ * 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 `📊 Retrieved: ${parts.join(', ')}`
+}
+
+/**
+ * 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))
+}

package/src/server/utils/response-formatter.ts

@@ -1,129 +1,129 @@
-/**
- * Response Formatter
- * Utilities for formatting MCP tool responses
- */
-
-import { McpError, ErrorCode } from '@modelcontextprotocol/sdk/types.js'
-import type { ToolResponse } from '@/tools/types'
-
-/**
- * ResponseFormatter provides methods for creating properly formatted MCP responses
- */
-export class ResponseFormatter {
-  /**
-   * Format text content for MCP response
-   * @param content - Text content to include in response
-   * @returns Properly formatted ToolResponse
-   */
-  static text(content: string): ToolResponse {
-    return {
-      content: [{
-        type: 'text',
-        text: content
-      }]
-    }
-  }
-
-  /**
-   * Format multiple text blocks for MCP response
-   * @param contents - Array of text content
-   * @returns Properly formatted ToolResponse with multiple content blocks
-   */
-  static multiText(contents: string[]): ToolResponse {
-    return {
-      content: contents.map(text => ({
-        type: 'text' as const,
-        text
-      }))
-    }
-  }
-
-  /**
-   * Format error as MCP error (throws)
-   * @param message - Error message
-   * @param code - MCP error code
-   * @throws McpError
-   */
-  static error(message: string, code: ErrorCode = ErrorCode.InternalError): never {
-    throw new McpError(code, message)
-  }
-
-  /**
-   * Format error response (returns response with isError flag)
-   * @param message - Error message
-   * @returns ToolResponse with error flag
-   */
-  static errorResponse(message: string): ToolResponse {
-    return {
-      content: [{
-        type: 'text',
-        text: `Error: ${message}`
-      }],
-      isError: true
-    }
-  }
-
-  /**
-   * Format structured data as formatted text
-   * @param data - Object to format
-   * @returns Properly formatted ToolResponse
-   */
-  static structured(data: Record<string, unknown>): ToolResponse {
-    const formatted = Object.entries(data)
-      .map(([key, value]) => {
-        const formattedValue = typeof value === 'object'
-          ? JSON.stringify(value, null, 2)
-          : String(value)
-        return `${key}: ${formattedValue}`
-      })
-      .join('\n\n')
-
-    return this.text(formatted)
-  }
-
-  /**
-   * Format JSON data as pretty-printed text
-   * @param data - Data to serialize as JSON
-   * @param label - Optional label to prefix the JSON
-   * @returns Properly formatted ToolResponse
-   */
-  static json(data: unknown, label?: string): ToolResponse {
-    const jsonStr = JSON.stringify(data, null, 2)
-    const content = label ? `${label}:\n${jsonStr}` : jsonStr
-    return this.text(content)
-  }
-
-  /**
-   * Format a list of items
-   * @param items - Array of items to format
-   * @param title - Optional title for the list
-   * @returns Properly formatted ToolResponse
-   */
-  static list(items: string[], title?: string): ToolResponse {
-    const listContent = items.map((item, i) => `${i + 1}. ${item}`).join('\n')
-    const content = title ? `${title}:\n${listContent}` : listContent
-    return this.text(content)
-  }
-
-  /**
-   * Format a success message
-   * @param message - Success message
-   * @param details - Optional additional details
-   * @returns Properly formatted ToolResponse
-   */
-  static success(message: string, details?: Record<string, unknown>): ToolResponse {
-    let content = `✓ ${message}`
-    if (details) {
-      const detailsStr = Object.entries(details)
-        .map(([k, v]) => {
-          const formatted = (v !== null && typeof v === 'object')
-            ? JSON.stringify(v)
-            : String(v ?? '')
-          return `  ${k}: ${formatted}`
-        })
-        .join('\n')
-      content += `\n\nDetails:\n${detailsStr}`
-    }
-    return this.text(content)
-  }
-}
+/**
+ * Response Formatter
+ * Utilities for formatting MCP tool responses
+ */
+
+import { McpError, ErrorCode } from '@modelcontextprotocol/sdk/types.js'
+import type { ToolResponse } from '@/tools/types'
+
+/**
+ * ResponseFormatter provides methods for creating properly formatted MCP responses
+ */
+export class ResponseFormatter {
+  /**
+   * Format text content for MCP response
+   * @param content - Text content to include in response
+   * @returns Properly formatted ToolResponse
+   */
+  static text(content: string): ToolResponse {
+    return {
+      content: [{
+        type: 'text',
+        text: content
+      }]
+    }
+  }
+
+  /**
+   * Format multiple text blocks for MCP response
+   * @param contents - Array of text content
+   * @returns Properly formatted ToolResponse with multiple content blocks
+   */
+  static multiText(contents: string[]): ToolResponse {
+    return {
+      content: contents.map(text => ({
+        type: 'text' as const,
+        text
+      }))
+    }
+  }
+
+  /**
+   * Format error as MCP error (throws)
+   * @param message - Error message
+   * @param code - MCP error code
+   * @throws McpError
+   */
+  static error(message: string, code: ErrorCode = ErrorCode.InternalError): never {
+    throw new McpError(code, message)
+  }
+
+  /**
+   * Format error response (returns response with isError flag)
+   * @param message - Error message
+   * @returns ToolResponse with error flag
+   */
+  static errorResponse(message: string): ToolResponse {
+    return {
+      content: [{
+        type: 'text',
+        text: `Error: ${message}`
+      }],
+      isError: true
+    }
+  }
+
+  /**
+   * Format structured data as formatted text
+   * @param data - Object to format
+   * @returns Properly formatted ToolResponse
+   */
+  static structured(data: Record<string, unknown>): ToolResponse {
+    const formatted = Object.entries(data)
+      .map(([key, value]) => {
+        const formattedValue = typeof value === 'object'
+          ? JSON.stringify(value, null, 2)
+          : String(value)
+        return `${key}: ${formattedValue}`
+      })
+      .join('\n\n')
+
+    return this.text(formatted)
+  }
+
+  /**
+   * Format JSON data as pretty-printed text
+   * @param data - Data to serialize as JSON
+   * @param label - Optional label to prefix the JSON
+   * @returns Properly formatted ToolResponse
+   */
+  static json(data: unknown, label?: string): ToolResponse {
+    const jsonStr = JSON.stringify(data, null, 2)
+    const content = label ? `${label}:\n${jsonStr}` : jsonStr
+    return this.text(content)
+  }
+
+  /**
+   * Format a list of items
+   * @param items - Array of items to format
+   * @param title - Optional title for the list
+   * @returns Properly formatted ToolResponse
+   */
+  static list(items: string[], title?: string): ToolResponse {
+    const listContent = items.map((item, i) => `${i + 1}. ${item}`).join('\n')
+    const content = title ? `${title}:\n${listContent}` : listContent
+    return this.text(content)
+  }
+
+  /**
+   * Format a success message
+   * @param message - Success message
+   * @param details - Optional additional details
+   * @returns Properly formatted ToolResponse
+   */
+  static success(message: string, details?: Record<string, unknown>): ToolResponse {
+    let content = `✓ ${message}`
+    if (details) {
+      const detailsStr = Object.entries(details)
+        .map(([k, v]) => {
+          const formatted = (v !== null && typeof v === 'object')
+            ? JSON.stringify(v)
+            : String(v ?? '')
+          return `  ${k}: ${formatted}`
+        })
+        .join('\n')
+      content += `\n\nDetails:\n${detailsStr}`
+    }
+    return this.text(content)
+  }
+}