claude-brain 0.14.2 → 0.14.4

package/src/tools/index.ts

@@ -1,24 +1,24 @@
-/**
- * Tools Module Exports
- */
-
-export { TOOLS, getToolNames, type ToolDefinition, type ToolName } from './schemas'
-export { ToolRegistry } from './registry'
-export type {
-  // Input types
-  GetProjectContextInput,
-  UpdateProgressInput,
-  RememberDecisionInput,
-  RecallSimilarInput,
-  GetCodeStandardsInput,
-  ListProjectsInput,
-  ToolInput,
-  // Output types
-  ToolResponse,
-  ProjectContext,
-  ProgressUpdateResult,
-  DecisionStorageResult,
-  SimilarMemory,
-  CodeStandards,
-  ProjectListItem
-} from './types'
+/**
+ * Tools Module Exports
+ */
+
+export { TOOLS, getToolNames, type ToolDefinition, type ToolName } from './schemas'
+export { ToolRegistry } from './registry'
+export type {
+  // Input types
+  GetProjectContextInput,
+  UpdateProgressInput,
+  RememberDecisionInput,
+  RecallSimilarInput,
+  GetCodeStandardsInput,
+  ListProjectsInput,
+  ToolInput,
+  // Output types
+  ToolResponse,
+  ProjectContext,
+  ProgressUpdateResult,
+  DecisionStorageResult,
+  SimilarMemory,
+  CodeStandards,
+  ProjectListItem
+} from './types'

package/src/tools/registry.ts

@@ -1,115 +1,115 @@
-/**
- * Tool Registry
- * Central registry for all MCP tools, providing lookup and validation
- */
-
-import { TOOLS, type ToolDefinition, type ToolName } from './schemas'
-
-/**
- * ToolRegistry provides access to all registered tools
- * and validation methods for tool operations
- */
-export class ToolRegistry {
-  /**
-   * Get all registered tools
-   * @returns Array of all tool definitions
-   */
-  static getAllTools(): ToolDefinition[] {
-    return Object.values(TOOLS)
-  }
-
-  /**
-   * Find a tool by its name
-   * @param name - The tool name to search for
-   * @returns The tool definition or undefined if not found
-   */
-  static getToolByName(name: string): ToolDefinition | undefined {
-    return Object.values(TOOLS).find(tool => tool.name === name)
-  }
-
-  /**
-   * Check if a tool exists in the registry
-   * @param name - The tool name to validate
-   * @returns true if the tool exists, false otherwise
-   */
-  static validateToolExists(name: string): boolean {
-    return this.getToolByName(name) !== undefined
-  }
-
-  /**
-   * Get the count of registered tools
-   * @returns Number of registered tools
-   */
-  static getToolCount(): number {
-    return Object.keys(TOOLS).length
-  }
-
-  /**
-   * Get all tool names
-   * @returns Array of tool names
-   */
-  static getToolNames(): ToolName[] {
-    return Object.values(TOOLS).map(tool => tool.name) as ToolName[]
-  }
-
-  /**
-   * Check if a tool name is valid (type guard)
-   * @param name - The name to check
-   * @returns true if name is a valid ToolName
-   */
-  static isValidToolName(name: string): name is ToolName {
-    return this.validateToolExists(name)
-  }
-
-  /**
-   * Get tools formatted for MCP tools/list response
-   * @returns Array of tools in MCP format
-   */
-  static getToolsForListResponse(): ToolDefinition[] {
-    return Object.values(TOOLS)
-  }
-
-  /**
-   * Get only the unified brain tool (Phase 16)
-   * @returns Array containing only the brain tool
-   */
-  static getUnifiedTools(): ToolDefinition[] {
-    const brain = this.getToolByName('brain')
-    return brain ? [brain] : []
-  }
-
-  /**
-   * Validate that required parameters are present
-   * @param toolName - Name of the tool
-   * @param args - Arguments provided
-   * @returns Object with valid flag and optional error message
-   */
-  static validateRequiredParams(
-    toolName: string,
-    args: Record<string, unknown>
-  ): { valid: boolean; error?: string } {
-    const tool = this.getToolByName(toolName)
-
-    if (!tool) {
-      return { valid: false, error: `Unknown tool: ${toolName}` }
-    }
-
-    const required = tool.inputSchema.required || []
-    const missingParams: string[] = []
-
-    for (const param of required) {
-      if (args[param] === undefined || args[param] === null) {
-        missingParams.push(param)
-      }
-    }
-
-    if (missingParams.length > 0) {
-      return {
-        valid: false,
-        error: `Missing required parameters: ${missingParams.join(', ')}`
-      }
-    }
-
-    return { valid: true }
-  }
-}
+/**
+ * Tool Registry
+ * Central registry for all MCP tools, providing lookup and validation
+ */
+
+import { TOOLS, type ToolDefinition, type ToolName } from './schemas'
+
+/**
+ * ToolRegistry provides access to all registered tools
+ * and validation methods for tool operations
+ */
+export class ToolRegistry {
+  /**
+   * Get all registered tools
+   * @returns Array of all tool definitions
+   */
+  static getAllTools(): ToolDefinition[] {
+    return Object.values(TOOLS)
+  }
+
+  /**
+   * Find a tool by its name
+   * @param name - The tool name to search for
+   * @returns The tool definition or undefined if not found
+   */
+  static getToolByName(name: string): ToolDefinition | undefined {
+    return Object.values(TOOLS).find(tool => tool.name === name)
+  }
+
+  /**
+   * Check if a tool exists in the registry
+   * @param name - The tool name to validate
+   * @returns true if the tool exists, false otherwise
+   */
+  static validateToolExists(name: string): boolean {
+    return this.getToolByName(name) !== undefined
+  }
+
+  /**
+   * Get the count of registered tools
+   * @returns Number of registered tools
+   */
+  static getToolCount(): number {
+    return Object.keys(TOOLS).length
+  }
+
+  /**
+   * Get all tool names
+   * @returns Array of tool names
+   */
+  static getToolNames(): ToolName[] {
+    return Object.values(TOOLS).map(tool => tool.name) as ToolName[]
+  }
+
+  /**
+   * Check if a tool name is valid (type guard)
+   * @param name - The name to check
+   * @returns true if name is a valid ToolName
+   */
+  static isValidToolName(name: string): name is ToolName {
+    return this.validateToolExists(name)
+  }
+
+  /**
+   * Get tools formatted for MCP tools/list response
+   * @returns Array of tools in MCP format
+   */
+  static getToolsForListResponse(): ToolDefinition[] {
+    return Object.values(TOOLS)
+  }
+
+  /**
+   * Get only the unified brain tool (Phase 16)
+   * @returns Array containing only the brain tool
+   */
+  static getUnifiedTools(): ToolDefinition[] {
+    const brain = this.getToolByName('brain')
+    return brain ? [brain] : []
+  }
+
+  /**
+   * Validate that required parameters are present
+   * @param toolName - Name of the tool
+   * @param args - Arguments provided
+   * @returns Object with valid flag and optional error message
+   */
+  static validateRequiredParams(
+    toolName: string,
+    args: Record<string, unknown>
+  ): { valid: boolean; error?: string } {
+    const tool = this.getToolByName(toolName)
+
+    if (!tool) {
+      return { valid: false, error: `Unknown tool: ${toolName}` }
+    }
+
+    const required = tool.inputSchema.required || []
+    const missingParams: string[] = []
+
+    for (const param of required) {
+      if (args[param] === undefined || args[param] === null) {
+        missingParams.push(param)
+      }
+    }
+
+    if (missingParams.length > 0) {
+      return {
+        valid: false,
+        error: `Missing required parameters: ${missingParams.join(', ')}`
+      }
+    }
+
+    return { valid: true }
+  }
+}

package/src/tools/schemas.test.ts

@@ -1,30 +1,30 @@
-export interface GetPatternsInput {
-  project_name?: string
-  pattern_type?: 'solution' | 'anti-pattern' | 'best-practice' | 'common-issue'
-  limit?: number
-  query?: string
-}
-
-export interface GetCorrectionsInput {
-  project_name?: string
-  limit?: number
-  query?: string
-}
-
-export interface RecognizePatternInput {
-  project_name: string
-  pattern_type: 'solution' | 'anti-pattern' | 'best-practice' | 'common-issue'
-  description: string
-  example?: string
-  confidence?: number
-  context?: string
-}
-
-export interface RecordCorrectionInput {
-  project_name: string
-  original: string
-  correction: string
-  reasoning: string
-  context?: string
-  confidence?: number
-}
+export interface GetPatternsInput {
+  project_name?: string
+  pattern_type?: 'solution' | 'anti-pattern' | 'best-practice' | 'common-issue'
+  limit?: number
+  query?: string
+}
+
+export interface GetCorrectionsInput {
+  project_name?: string
+  limit?: number
+  query?: string
+}
+
+export interface RecognizePatternInput {
+  project_name: string
+  pattern_type: 'solution' | 'anti-pattern' | 'best-practice' | 'common-issue'
+  description: string
+  example?: string
+  confidence?: number
+  context?: string
+}
+
+export interface RecordCorrectionInput {
+  project_name: string
+  original: string
+  correction: string
+  reasoning: string
+  context?: string
+  confidence?: number
+}