claude-brain 0.30.2 → 0.30.3

package/src/tools/schemas.ts

@@ -1,666 +1,666 @@
-/**
- * MCP Tool Schemas
- * Defines all available tools that Claude Code can call
- *
- * Each tool has:
- * - name: Unique identifier for the tool
- * - description: Explains when and how to use the tool
- * - inputSchema: JSON Schema for validating input parameters
- */
-
-/** Tool definition type */
-export interface ToolDefinition {
-  name: string
-  description: string
-  inputSchema: {
-    type: 'object'
-    properties: Record<string, unknown>
-    required?: string[]
-  }
-}
-
-/**
- * All available tools for Claude Brain MCP server
- */
-export const TOOLS = {
-  /**
-   * GET_PROJECT_CONTEXT
-   * Primary tool for retrieving complete project context
-   *
-   * Use this when:
-   * - Starting work on a project
-   * - Need to understand project standards and conventions
-   * - Want to see recent decisions and progress
-   *
-   * Returns: Project description, standards, progress, and optionally relevant memories
-   */
-  GET_PROJECT_CONTEXT: {
-    name: 'get_project_context',
-    description: 'Retrieves complete project context including standards, progress, past decisions, and relevant memories. This is the primary tool for getting context about a project.',
-    inputSchema: {
-      type: 'object' as const,
-      properties: {
-        project_name: {
-          type: 'string',
-          description: 'Name of the project to get context for'
-        },
-        include_memories: {
-          type: 'boolean',
-          description: 'Whether to include similar past decisions from semantic memory',
-          default: true
-        },
-        memory_limit: {
-          type: 'number',
-          description: 'Maximum number of relevant memories to include',
-          default: 5
-        }
-      },
-      required: ['project_name']
-    }
-  },
-
-  /**
-   * UPDATE_PROGRESS
-   * Track project progress and completed work
-   *
-   * Use this when:
-   * - Completing a task or milestone
-   * - Making significant progress
-   * - Updating what should happen next
-   *
-   * Returns: Confirmation of progress update
-   */
-  UPDATE_PROGRESS: {
-    name: 'update_progress',
-    description: 'Updates project progress tracking with completed tasks and next steps. Use this when you complete a task or make significant progress.',
-    inputSchema: {
-      type: 'object' as const,
-      properties: {
-        project_name: {
-          type: 'string',
-          description: 'Name of the project'
-        },
-        completed_task: {
-          type: 'string',
-          description: 'Description of what was just completed'
-        },
-        next_steps: {
-          type: 'string',
-          description: 'What should be done next'
-        },
-        notes: {
-          type: 'string',
-          description: 'Optional additional notes or context'
-        }
-      },
-      required: ['project_name', 'completed_task', 'next_steps']
-    }
-  },
-
-  /**
-   * REMEMBER_DECISION
-   * Store important decisions in long-term memory
-   *
-   * Use this when:
-   * - Making architectural decisions
-   * - Choosing between alternatives
-   * - Establishing patterns that should persist
-   *
-   * Returns: Confirmation with memory ID
-   */
-  REMEMBER_DECISION: {
-    name: 'remember_decision',
-    description: 'Stores an important architectural or technical decision in long-term memory. Use this for decisions that should influence future development.',
-    inputSchema: {
-      type: 'object' as const,
-      properties: {
-        project_name: {
-          type: 'string',
-          description: 'Project this decision relates to'
-        },
-        context: {
-          type: 'string',
-          description: 'What situation or problem led to this decision'
-        },
-        decision: {
-          type: 'string',
-          description: 'The decision that was made'
-        },
-        reasoning: {
-          type: 'string',
-          description: 'Why this decision was made'
-        },
-        alternatives_considered: {
-          type: 'string',
-          description: 'Other options that were considered'
-        },
-        tags: {
-          type: 'array',
-          items: { type: 'string' },
-          description: 'Tags for categorizing this decision (e.g., "architecture", "performance", "security")'
-        }
-      },
-      required: ['project_name', 'context', 'decision', 'reasoning']
-    }
-  },
-
-  /**
-   * RECALL_SIMILAR
-   * Semantic search through past decisions and context
-   *
-   * Use this when:
-   * - Facing a similar situation to past work
-   * - Want to learn from previous decisions
-   * - Need context from related work
-   *
-   * Returns: Array of similar decisions with similarity scores
-   */
-  RECALL_SIMILAR: {
-    name: 'recall_similar',
-    description: 'Finds past decisions and context similar to the current situation using semantic search. Helps learn from past experience.',
-    inputSchema: {
-      type: 'object' as const,
-      properties: {
-        query: {
-          type: 'string',
-          description: 'Description of current situation or question'
-        },
-        project_filter: {
-          type: 'string',
-          description: 'Optional: only search within specific project'
-        },
-        limit: {
-          type: 'number',
-          description: 'Maximum number of results to return',
-          default: 5
-        },
-        min_similarity: {
-          type: 'number',
-          description: 'Minimum similarity score (0-1)',
-          default: 0.7
-        }
-      },
-      required: ['query']
-    }
-  },
-
-  /**
-   * GET_CODE_STANDARDS
-   * Retrieve coding standards and conventions
-   *
-   * Use this when:
-   * - Need to follow project coding style
-   * - Want to ensure consistency
-   * - Starting to write new code
-   *
-   * Returns: Merged global and project-specific standards
-   */
-  GET_CODE_STANDARDS: {
-    name: 'get_code_standards',
-    description: 'Retrieves coding standards, patterns, and conventions for a project. Includes global standards merged with project-specific rules.',
-    inputSchema: {
-      type: 'object' as const,
-      properties: {
-        project_name: {
-          type: 'string',
-          description: 'Name of the project'
-        },
-        language: {
-          type: 'string',
-          description: 'Optional: filter standards by programming language (e.g., "typescript", "python")'
-        }
-      },
-      required: ['project_name']
-    }
-  },
-
-  /**
-   * LIST_PROJECTS
-   * Get available projects from the vault
-   *
-   * Use this when:
-   * - Need to see what projects exist
-   * - Want project metadata and status
-   * - Looking for active vs archived projects
-   *
-   * Returns: Array of project summaries with metadata
-   */
-  LIST_PROJECTS: {
-    name: 'list_projects',
-    description: 'Lists all available projects in the Obsidian vault with their metadata and status.',
-    inputSchema: {
-      type: 'object' as const,
-      properties: {
-        status_filter: {
-          type: 'string',
-          enum: ['active', 'archived', 'planning', 'all'],
-          description: 'Filter projects by status',
-          default: 'active'
-        }
-      }
-    }
-  },
-
-  /**
-   * SMART_CONTEXT
-   * Intelligent context with proactive memory recall
-   *
-   * Use this when:
-   * - Starting work and want automatic relevant memory recall
-   * - Asking a question and want past decisions automatically searched
-   * - Need context + relevant memories in one call
-   */
-  SMART_CONTEXT: {
-    name: 'smart_context',
-    description: 'Gets project context AND automatically searches for relevant past decisions based on your current question or task. More intelligent than get_project_context - use this when you have a specific question or task.',
-    inputSchema: {
-      type: 'object' as const,
-      properties: {
-        project_name: {
-          type: 'string',
-          description: 'Name of the project'
-        },
-        current_task: {
-          type: 'string',
-          description: 'What you are currently working on or asking about. This triggers proactive memory recall.'
-        },
-        min_similarity: {
-          type: 'number',
-          description: 'Minimum similarity for memory recall (0-1). Lower = more results.',
-          default: 0.3
-        }
-      },
-      required: ['project_name', 'current_task']
-    }
-  },
-
-  /**
-   * AUTO_REMEMBER
-   * Automatically detects and saves decisions from text
-   *
-   * Use this when:
-   * - Claude made a recommendation and wants to auto-save it
-   * - Processing a response that might contain decisions
-   * - Want Claude Brain to detect decisions automatically
-   */
-  AUTO_REMEMBER: {
-    name: 'auto_remember',
-    description: 'Automatically detects decisions in text and saves them. Pass any text containing recommendations like "I recommend X because Y" or "We should use X". Decisions with >70% confidence are auto-saved.',
-    inputSchema: {
-      type: 'object' as const,
-      properties: {
-        project_name: {
-          type: 'string',
-          description: 'Project to associate the decision with'
-        },
-        text: {
-          type: 'string',
-          description: 'Text to analyze for decisions (e.g., Claude\'s response containing recommendations)'
-        },
-        confidence_threshold: {
-          type: 'number',
-          description: 'Minimum confidence to auto-save (0-1)',
-          default: 0.7
-        }
-      },
-      required: ['project_name', 'text']
-    }
-  },
-
-  /**
-   * GET_PHASE12_STATUS
-   * Get status of intelligent automation features
-   */
-  GET_PHASE12_STATUS: {
-    name: 'get_phase12_status',
-    description: 'Shows status of Claude Brain\'s intelligent automation: current project, patterns detected, learning insights, and recall statistics.',
-    inputSchema: {
-      type: 'object' as const,
-      properties: {}
-    }
-  },
-
-  /**
-   * CREATE_PROJECT
-   * Create a new project in the vault with all necessary files
-   *
-   * Use this when:
-   * - Starting a brand new project
-   * - User wants to track a project with Claude Brain
-   * - Need to set up project structure automatically
-   */
-  CREATE_PROJECT: {
-    name: 'create_project',
-    description: 'Creates a new project in the Obsidian vault with all necessary files (context.md, progress.md, decisions.md, standards.md). Use this when starting a new project.',
-    inputSchema: {
-      type: 'object' as const,
-      properties: {
-        project_name: {
-          type: 'string',
-          description: 'Name of the project (lowercase with hyphens, e.g., "my-awesome-app")'
-        },
-        description: {
-          type: 'string',
-          description: 'Brief description of the project'
-        },
-        tech_stack: {
-          type: 'array',
-          items: { type: 'string' },
-          description: 'Technologies used (e.g., ["typescript", "react", "node"])'
-        },
-        status: {
-          type: 'string',
-          enum: ['planning', 'active', 'on-hold', 'completed'],
-          description: 'Initial project status',
-          default: 'planning'
-        },
-        tags: {
-          type: 'array',
-          items: { type: 'string' },
-          description: 'Tags for categorizing the project (e.g., ["web", "frontend", "personal"])'
-        }
-      },
-      required: ['project_name']
-    }
-  },
-
-  /**
-   * INIT_PROJECT
-   * Analyze existing codebase and initialize in Claude Brain
-   *
-   * Use this when:
-   * - Opening Claude Code in an existing project
-   * - Want to auto-detect tech stack, structure, conventions
-   * - Similar to `claude init` but for Claude Brain
-   *
-   * LOW USAGE: Pure file reading, no LLM calls
-   */
-  INIT_PROJECT: {
-    name: 'init_project',
-    description: 'Analyzes an existing codebase and creates/updates project in Claude Brain. Reads package.json, config files, and structure to auto-detect tech stack, frameworks, and conventions. Similar to `claude init`. Use this when starting work on an existing project.',
-    inputSchema: {
-      type: 'object' as const,
-      properties: {
-        project_path: {
-          type: 'string',
-          description: 'Path to be project directory. Defaults to current working directory.'
-        },
-        project_name: {
-          type: 'string',
-          description: 'Override project name (otherwise detected from package.json or folder name)'
-        },
-        save_to_memory: {
-          type: 'boolean',
-          description: 'Whether to save project context to semantic memory for future recall',
-          default: true
-        }
-      }
-    }
-  },
-
-  /**
-   * RECOGNIZE_PATTERN
-   * Save a recognized pattern to ChromaDB
-   *
-   * Use this when:
-   * - You notice a recurring solution approach
-   * - You identify an anti-pattern
-   * - You find a best practice that should be documented
-   *
-   * Patterns are stored in ChromaDB patterns collection for semantic recall
-   */
-  RECOGNIZE_PATTERN: {
-    name: 'recognize_pattern',
-    description: 'Saves a recognized pattern (solution, anti-pattern, best-practice, or common-issue) to ChromaDB semantic memory. Patterns help identify recurring approaches and avoid mistakes.',
-    inputSchema: {
-      type: 'object' as const,
-      properties: {
-        project_name: {
-          type: 'string',
-          description: 'Project this pattern relates to'
-        },
-        pattern_type: {
-          type: 'string',
-          enum: ['solution', 'anti-pattern', 'best-practice', 'common-issue'],
-          description: 'Type of pattern'
-        },
-        description: {
-          type: 'string',
-          description: 'Detailed description of the pattern'
-        },
-        example: {
-          type: 'string',
-          description: 'Code example illustrating the pattern (optional)'
-        },
-        confidence: {
-          type: 'number',
-          minimum: 0,
-          maximum: 1,
-          description: 'Confidence in this pattern (0-1, default 0.8)'
-        },
-        context: {
-          type: 'string',
-          description: 'When this pattern was observed or applicable'
-        }
-      },
-      required: ['project_name', 'pattern_type', 'description']
-    }
-  },
-
-  /**
-   * RECORD_CORRECTION
-   * Save a correction/lesson learned to ChromaDB
-   *
-   * Use this when:
-   * - You made a mistake that should be documented
-   * - You learned a better approach after an error
-   * - You want to track lessons learned
-   *
-   * Corrections are stored in ChromaDB corrections collection for learning from mistakes
-   */
-  RECORD_CORRECTION: {
-    name: 'record_correction',
-    description: 'Saves a correction or lesson learned to ChromaDB semantic memory. Use this when you made a mistake, learned something new, or want to document what NOT to do.',
-    inputSchema: {
-      type: 'object' as const,
-      properties: {
-        project_name: {
-          type: 'string',
-          description: 'Project this correction relates to'
-        },
-        original: {
-          type: 'string',
-          description: 'What was wrong or the mistake that was made'
-        },
-        correction: {
-          type: 'string',
-          description: 'What should have been done instead'
-        },
-        reasoning: {
-          type: 'string',
-          description: 'Why the correction is better than the original approach'
-        },
-        context: {
-          type: 'string',
-          description: 'When this correction was identified or applicable'
-        },
-        confidence: {
-          type: 'number',
-          minimum: 0,
-          maximum: 1,
-          description: 'Confidence in this correction (0-1, default 0.9)'
-        }
-      },
-      required: ['project_name', 'original', 'correction', 'reasoning']
-    }
-  },
-
-  /**
-   * GET_PATTERNS
-   * Retrieve recognized patterns from ChromaDB
-   *
-   * Use this when:
-   * - You want to review documented patterns
-   * - You need to know what solutions have worked before
-   * - You want to avoid known anti-patterns
-   *
-   * Results are ranked by similarity to your query
-   */
-  GET_PATTERNS: {
-    name: 'get_patterns',
-    description: 'Retrieves recognized patterns from ChromaDB semantic memory. Use this to review documented solutions, best practices, anti-patterns, and common issues. Patterns are returned ranked by semantic similarity.',
-    inputSchema: {
-      type: 'object' as const,
-      properties: {
-        project_name: {
-          type: 'string',
-          description: 'Project to retrieve patterns from (optional, returns all projects if not specified)'
-        },
-        pattern_type: {
-          type: 'string',
-          enum: ['solution', 'anti-pattern', 'best-practice', 'common-issue'],
-          description: 'Filter by pattern type (optional)'
-        },
-        limit: {
-          type: 'number',
-          minimum: 1,
-          description: 'Maximum number of patterns to return (default 10)'
-        },
-        query: {
-          type: 'string',
-          description: 'Search query to find relevant patterns (optional, uses semantic search if not provided)'
-        }
-      }
-    }
-  },
-
-  /**
-   * GET_CORRECTIONS
-   * Retrieve corrections/lessons learned from ChromaDB
-   *
-   * Use this when:
-   * - You want to review past mistakes and lessons learned
-   * - You need to know what corrections have been documented
-   * - You want to avoid repeating previous errors
-   *
-   * Results are ranked by similarity to your query
-   */
-  GET_CORRECTIONS: {
-    name: 'get_corrections',
-    description: 'Retrieves corrections and lessons learned from ChromaDB semantic memory. Use this to review past mistakes, what was fixed, and why it was better. Corrections are returned ranked by semantic similarity.',
-    inputSchema: {
-      type: 'object' as const,
-      properties: {
-        project_name: {
-          type: 'string',
-          description: 'Project to retrieve corrections from (optional, returns all projects if not specified)'
-        },
-        limit: {
-          type: 'number',
-          minimum: 1,
-          description: 'Maximum number of corrections to return (default 10)'
-        },
-        query: {
-          type: 'string',
-          description: 'Search query to find relevant corrections (optional, uses semantic search if not provided)'
-        }
-      }
-    }
-  },
-
-  // =========================================================================
-  // Phase 16 - Unified Brain Tool
-  // =========================================================================
-  // Phase 19: Removed 9 redundant MCP tools whose functionality is now
-  // absorbed into brain(). Removed: rate_memory, search_knowledge_graph,
-  // get_episode, list_episodes, get_decision_timeline,
-  // analyze_decision_evolution, detect_trends, what_if_analysis,
-  // get_recommendations, find_cross_project_patterns.
-  // The underlying modules are still available internally.
-
-  /**
-   * BRAIN
-   * Unified intelligent tool that replaces all 25 tools
-   *
-   * Use this when:
-   * - You want a single tool for all Claude Brain interactions
-   * - Enabled via unifiedToolMode config flag
-   *
-   * The server classifies intent and routes internally
-   */
-  BRAIN: {
-    name: 'brain',
-    description: 'Your persistent memory. Tell it decisions, ask it questions, or update/delete past notes. Most context is captured automatically — only call this for intentional storage or recall. Search returns compact summaries — use brain("details {ID}") for full context.',
-    inputSchema: {
-      type: 'object' as const,
-      properties: {
-        message: {
-          type: 'string',
-          description: 'What you are doing, decided, learned, or need. Natural language.'
-        },
-        project: {
-          type: 'string',
-          description: 'Project name (IMPORTANT: pass this to scope memories correctly, e.g. "my-app"). Auto-detected from message if omitted, defaults to "general".'
-        },
-        action: {
-          type: 'string',
-          enum: ['auto', 'store', 'recall', 'update', 'delete'],
-          description: 'Force a specific action instead of auto-detecting intent. "store" = always save, "recall" = always search, "update" = modify last stored, "delete" = remove. Default: auto (use intent classifier).'
-        }
-      },
-      required: ['message']
-    }
-  },
-
-  /**
-   * SEARCH_CODE
-   * Search indexed code symbols, files, and dependencies
-   *
-   * Use this when:
-   * - Looking for a function, class, or type definition
-   * - Need to find which file contains a symbol
-   * - Want to see imports/dependencies of a file
-   * - Faster than grep for known symbol names
-   */
-  SEARCH_CODE: {
-    name: 'search_code',
-    description: 'Search indexed code for symbols (functions, classes, types), files, or dependencies. Faster than grep when the project is indexed. Run `claude-brain reindex` first if no results.',
-    inputSchema: {
-      type: 'object' as const,
-      properties: {
-        query: {
-          type: 'string',
-          description: 'Symbol name, file name, or search term'
-        },
-        project: {
-          type: 'string',
-          description: 'Project name (usually the directory name, e.g. "claude-brain")'
-        },
-        type: {
-          type: 'string',
-          enum: ['symbols', 'files', 'dependencies'],
-          description: 'What to search for: symbols (functions/classes/types), files, or dependencies of a file',
-          default: 'symbols'
-        },
-        file_path: {
-          type: 'string',
-          description: 'File path (required when type is "dependencies")'
-        },
-        limit: {
-          type: 'number',
-          description: 'Maximum results to return',
-          default: 20
-        }
-      },
-      required: ['query', 'project']
-    }
-  }
-} as const satisfies Record<string, ToolDefinition>
-
-/** Tool names as a union type */
-export type ToolName = typeof TOOLS[keyof typeof TOOLS]['name']
-
-/** Get all tool names as an array */
-export function getToolNames(): ToolName[] {
-  return Object.values(TOOLS).map(tool => tool.name)
-}
+/**
+ * MCP Tool Schemas
+ * Defines all available tools that Claude Code can call
+ *
+ * Each tool has:
+ * - name: Unique identifier for the tool
+ * - description: Explains when and how to use the tool
+ * - inputSchema: JSON Schema for validating input parameters
+ */
+
+/** Tool definition type */
+export interface ToolDefinition {
+  name: string
+  description: string
+  inputSchema: {
+    type: 'object'
+    properties: Record<string, unknown>
+    required?: string[]
+  }
+}
+
+/**
+ * All available tools for Claude Brain MCP server
+ */
+export const TOOLS = {
+  /**
+   * GET_PROJECT_CONTEXT
+   * Primary tool for retrieving complete project context
+   *
+   * Use this when:
+   * - Starting work on a project
+   * - Need to understand project standards and conventions
+   * - Want to see recent decisions and progress
+   *
+   * Returns: Project description, standards, progress, and optionally relevant memories
+   */
+  GET_PROJECT_CONTEXT: {
+    name: 'get_project_context',
+    description: 'Retrieves complete project context including standards, progress, past decisions, and relevant memories. This is the primary tool for getting context about a project.',
+    inputSchema: {
+      type: 'object' as const,
+      properties: {
+        project_name: {
+          type: 'string',
+          description: 'Name of the project to get context for'
+        },
+        include_memories: {
+          type: 'boolean',
+          description: 'Whether to include similar past decisions from semantic memory',
+          default: true
+        },
+        memory_limit: {
+          type: 'number',
+          description: 'Maximum number of relevant memories to include',
+          default: 5
+        }
+      },
+      required: ['project_name']
+    }
+  },
+
+  /**
+   * UPDATE_PROGRESS
+   * Track project progress and completed work
+   *
+   * Use this when:
+   * - Completing a task or milestone
+   * - Making significant progress
+   * - Updating what should happen next
+   *
+   * Returns: Confirmation of progress update
+   */
+  UPDATE_PROGRESS: {
+    name: 'update_progress',
+    description: 'Updates project progress tracking with completed tasks and next steps. Use this when you complete a task or make significant progress.',
+    inputSchema: {
+      type: 'object' as const,
+      properties: {
+        project_name: {
+          type: 'string',
+          description: 'Name of the project'
+        },
+        completed_task: {
+          type: 'string',
+          description: 'Description of what was just completed'
+        },
+        next_steps: {
+          type: 'string',
+          description: 'What should be done next'
+        },
+        notes: {
+          type: 'string',
+          description: 'Optional additional notes or context'
+        }
+      },
+      required: ['project_name', 'completed_task', 'next_steps']
+    }
+  },
+
+  /**
+   * REMEMBER_DECISION
+   * Store important decisions in long-term memory
+   *
+   * Use this when:
+   * - Making architectural decisions
+   * - Choosing between alternatives
+   * - Establishing patterns that should persist
+   *
+   * Returns: Confirmation with memory ID
+   */
+  REMEMBER_DECISION: {
+    name: 'remember_decision',
+    description: 'Stores an important architectural or technical decision in long-term memory. Use this for decisions that should influence future development.',
+    inputSchema: {
+      type: 'object' as const,
+      properties: {
+        project_name: {
+          type: 'string',
+          description: 'Project this decision relates to'
+        },
+        context: {
+          type: 'string',
+          description: 'What situation or problem led to this decision'
+        },
+        decision: {
+          type: 'string',
+          description: 'The decision that was made'
+        },
+        reasoning: {
+          type: 'string',
+          description: 'Why this decision was made'
+        },
+        alternatives_considered: {
+          type: 'string',
+          description: 'Other options that were considered'
+        },
+        tags: {
+          type: 'array',
+          items: { type: 'string' },
+          description: 'Tags for categorizing this decision (e.g., "architecture", "performance", "security")'
+        }
+      },
+      required: ['project_name', 'context', 'decision', 'reasoning']
+    }
+  },
+
+  /**
+   * RECALL_SIMILAR
+   * Semantic search through past decisions and context
+   *
+   * Use this when:
+   * - Facing a similar situation to past work
+   * - Want to learn from previous decisions
+   * - Need context from related work
+   *
+   * Returns: Array of similar decisions with similarity scores
+   */
+  RECALL_SIMILAR: {
+    name: 'recall_similar',
+    description: 'Finds past decisions and context similar to the current situation using semantic search. Helps learn from past experience.',
+    inputSchema: {
+      type: 'object' as const,
+      properties: {
+        query: {
+          type: 'string',
+          description: 'Description of current situation or question'
+        },
+        project_filter: {
+          type: 'string',
+          description: 'Optional: only search within specific project'
+        },
+        limit: {
+          type: 'number',
+          description: 'Maximum number of results to return',
+          default: 5
+        },
+        min_similarity: {
+          type: 'number',
+          description: 'Minimum similarity score (0-1)',
+          default: 0.7
+        }
+      },
+      required: ['query']
+    }
+  },
+
+  /**
+   * GET_CODE_STANDARDS
+   * Retrieve coding standards and conventions
+   *
+   * Use this when:
+   * - Need to follow project coding style
+   * - Want to ensure consistency
+   * - Starting to write new code
+   *
+   * Returns: Merged global and project-specific standards
+   */
+  GET_CODE_STANDARDS: {
+    name: 'get_code_standards',
+    description: 'Retrieves coding standards, patterns, and conventions for a project. Includes global standards merged with project-specific rules.',
+    inputSchema: {
+      type: 'object' as const,
+      properties: {
+        project_name: {
+          type: 'string',
+          description: 'Name of the project'
+        },
+        language: {
+          type: 'string',
+          description: 'Optional: filter standards by programming language (e.g., "typescript", "python")'
+        }
+      },
+      required: ['project_name']
+    }
+  },
+
+  /**
+   * LIST_PROJECTS
+   * Get available projects from the vault
+   *
+   * Use this when:
+   * - Need to see what projects exist
+   * - Want project metadata and status
+   * - Looking for active vs archived projects
+   *
+   * Returns: Array of project summaries with metadata
+   */
+  LIST_PROJECTS: {
+    name: 'list_projects',
+    description: 'Lists all available projects in the Obsidian vault with their metadata and status.',
+    inputSchema: {
+      type: 'object' as const,
+      properties: {
+        status_filter: {
+          type: 'string',
+          enum: ['active', 'archived', 'planning', 'all'],
+          description: 'Filter projects by status',
+          default: 'active'
+        }
+      }
+    }
+  },
+
+  /**
+   * SMART_CONTEXT
+   * Intelligent context with proactive memory recall
+   *
+   * Use this when:
+   * - Starting work and want automatic relevant memory recall
+   * - Asking a question and want past decisions automatically searched
+   * - Need context + relevant memories in one call
+   */
+  SMART_CONTEXT: {
+    name: 'smart_context',
+    description: 'Gets project context AND automatically searches for relevant past decisions based on your current question or task. More intelligent than get_project_context - use this when you have a specific question or task.',
+    inputSchema: {
+      type: 'object' as const,
+      properties: {
+        project_name: {
+          type: 'string',
+          description: 'Name of the project'
+        },
+        current_task: {
+          type: 'string',
+          description: 'What you are currently working on or asking about. This triggers proactive memory recall.'
+        },
+        min_similarity: {
+          type: 'number',
+          description: 'Minimum similarity for memory recall (0-1). Lower = more results.',
+          default: 0.3
+        }
+      },
+      required: ['project_name', 'current_task']
+    }
+  },
+
+  /**
+   * AUTO_REMEMBER
+   * Automatically detects and saves decisions from text
+   *
+   * Use this when:
+   * - Claude made a recommendation and wants to auto-save it
+   * - Processing a response that might contain decisions
+   * - Want Claude Brain to detect decisions automatically
+   */
+  AUTO_REMEMBER: {
+    name: 'auto_remember',
+    description: 'Automatically detects decisions in text and saves them. Pass any text containing recommendations like "I recommend X because Y" or "We should use X". Decisions with >70% confidence are auto-saved.',
+    inputSchema: {
+      type: 'object' as const,
+      properties: {
+        project_name: {
+          type: 'string',
+          description: 'Project to associate the decision with'
+        },
+        text: {
+          type: 'string',
+          description: 'Text to analyze for decisions (e.g., Claude\'s response containing recommendations)'
+        },
+        confidence_threshold: {
+          type: 'number',
+          description: 'Minimum confidence to auto-save (0-1)',
+          default: 0.7
+        }
+      },
+      required: ['project_name', 'text']
+    }
+  },
+
+  /**
+   * GET_PHASE12_STATUS
+   * Get status of intelligent automation features
+   */
+  GET_PHASE12_STATUS: {
+    name: 'get_phase12_status',
+    description: 'Shows status of Claude Brain\'s intelligent automation: current project, patterns detected, learning insights, and recall statistics.',
+    inputSchema: {
+      type: 'object' as const,
+      properties: {}
+    }
+  },
+
+  /**
+   * CREATE_PROJECT
+   * Create a new project in the vault with all necessary files
+   *
+   * Use this when:
+   * - Starting a brand new project
+   * - User wants to track a project with Claude Brain
+   * - Need to set up project structure automatically
+   */
+  CREATE_PROJECT: {
+    name: 'create_project',
+    description: 'Creates a new project in the Obsidian vault with all necessary files (context.md, progress.md, decisions.md, standards.md). Use this when starting a new project.',
+    inputSchema: {
+      type: 'object' as const,
+      properties: {
+        project_name: {
+          type: 'string',
+          description: 'Name of the project (lowercase with hyphens, e.g., "my-awesome-app")'
+        },
+        description: {
+          type: 'string',
+          description: 'Brief description of the project'
+        },
+        tech_stack: {
+          type: 'array',
+          items: { type: 'string' },
+          description: 'Technologies used (e.g., ["typescript", "react", "node"])'
+        },
+        status: {
+          type: 'string',
+          enum: ['planning', 'active', 'on-hold', 'completed'],
+          description: 'Initial project status',
+          default: 'planning'
+        },
+        tags: {
+          type: 'array',
+          items: { type: 'string' },
+          description: 'Tags for categorizing the project (e.g., ["web", "frontend", "personal"])'
+        }
+      },
+      required: ['project_name']
+    }
+  },
+
+  /**
+   * INIT_PROJECT
+   * Analyze existing codebase and initialize in Claude Brain
+   *
+   * Use this when:
+   * - Opening Claude Code in an existing project
+   * - Want to auto-detect tech stack, structure, conventions
+   * - Similar to `claude init` but for Claude Brain
+   *
+   * LOW USAGE: Pure file reading, no LLM calls
+   */
+  INIT_PROJECT: {
+    name: 'init_project',
+    description: 'Analyzes an existing codebase and creates/updates project in Claude Brain. Reads package.json, config files, and structure to auto-detect tech stack, frameworks, and conventions. Similar to `claude init`. Use this when starting work on an existing project.',
+    inputSchema: {
+      type: 'object' as const,
+      properties: {
+        project_path: {
+          type: 'string',
+          description: 'Path to be project directory. Defaults to current working directory.'
+        },
+        project_name: {
+          type: 'string',
+          description: 'Override project name (otherwise detected from package.json or folder name)'
+        },
+        save_to_memory: {
+          type: 'boolean',
+          description: 'Whether to save project context to semantic memory for future recall',
+          default: true
+        }
+      }
+    }
+  },
+
+  /**
+   * RECOGNIZE_PATTERN
+   * Save a recognized pattern to ChromaDB
+   *
+   * Use this when:
+   * - You notice a recurring solution approach
+   * - You identify an anti-pattern
+   * - You find a best practice that should be documented
+   *
+   * Patterns are stored in ChromaDB patterns collection for semantic recall
+   */
+  RECOGNIZE_PATTERN: {
+    name: 'recognize_pattern',
+    description: 'Saves a recognized pattern (solution, anti-pattern, best-practice, or common-issue) to ChromaDB semantic memory. Patterns help identify recurring approaches and avoid mistakes.',
+    inputSchema: {
+      type: 'object' as const,
+      properties: {
+        project_name: {
+          type: 'string',
+          description: 'Project this pattern relates to'
+        },
+        pattern_type: {
+          type: 'string',
+          enum: ['solution', 'anti-pattern', 'best-practice', 'common-issue'],
+          description: 'Type of pattern'
+        },
+        description: {
+          type: 'string',
+          description: 'Detailed description of the pattern'
+        },
+        example: {
+          type: 'string',
+          description: 'Code example illustrating the pattern (optional)'
+        },
+        confidence: {
+          type: 'number',
+          minimum: 0,
+          maximum: 1,
+          description: 'Confidence in this pattern (0-1, default 0.8)'
+        },
+        context: {
+          type: 'string',
+          description: 'When this pattern was observed or applicable'
+        }
+      },
+      required: ['project_name', 'pattern_type', 'description']
+    }
+  },
+
+  /**
+   * RECORD_CORRECTION
+   * Save a correction/lesson learned to ChromaDB
+   *
+   * Use this when:
+   * - You made a mistake that should be documented
+   * - You learned a better approach after an error
+   * - You want to track lessons learned
+   *
+   * Corrections are stored in ChromaDB corrections collection for learning from mistakes
+   */
+  RECORD_CORRECTION: {
+    name: 'record_correction',
+    description: 'Saves a correction or lesson learned to ChromaDB semantic memory. Use this when you made a mistake, learned something new, or want to document what NOT to do.',
+    inputSchema: {
+      type: 'object' as const,
+      properties: {
+        project_name: {
+          type: 'string',
+          description: 'Project this correction relates to'
+        },
+        original: {
+          type: 'string',
+          description: 'What was wrong or the mistake that was made'
+        },
+        correction: {
+          type: 'string',
+          description: 'What should have been done instead'
+        },
+        reasoning: {
+          type: 'string',
+          description: 'Why the correction is better than the original approach'
+        },
+        context: {
+          type: 'string',
+          description: 'When this correction was identified or applicable'
+        },
+        confidence: {
+          type: 'number',
+          minimum: 0,
+          maximum: 1,
+          description: 'Confidence in this correction (0-1, default 0.9)'
+        }
+      },
+      required: ['project_name', 'original', 'correction', 'reasoning']
+    }
+  },
+
+  /**
+   * GET_PATTERNS
+   * Retrieve recognized patterns from ChromaDB
+   *
+   * Use this when:
+   * - You want to review documented patterns
+   * - You need to know what solutions have worked before
+   * - You want to avoid known anti-patterns
+   *
+   * Results are ranked by similarity to your query
+   */
+  GET_PATTERNS: {
+    name: 'get_patterns',
+    description: 'Retrieves recognized patterns from ChromaDB semantic memory. Use this to review documented solutions, best practices, anti-patterns, and common issues. Patterns are returned ranked by semantic similarity.',
+    inputSchema: {
+      type: 'object' as const,
+      properties: {
+        project_name: {
+          type: 'string',
+          description: 'Project to retrieve patterns from (optional, returns all projects if not specified)'
+        },
+        pattern_type: {
+          type: 'string',
+          enum: ['solution', 'anti-pattern', 'best-practice', 'common-issue'],
+          description: 'Filter by pattern type (optional)'
+        },
+        limit: {
+          type: 'number',
+          minimum: 1,
+          description: 'Maximum number of patterns to return (default 10)'
+        },
+        query: {
+          type: 'string',
+          description: 'Search query to find relevant patterns (optional, uses semantic search if not provided)'
+        }
+      }
+    }
+  },
+
+  /**
+   * GET_CORRECTIONS
+   * Retrieve corrections/lessons learned from ChromaDB
+   *
+   * Use this when:
+   * - You want to review past mistakes and lessons learned
+   * - You need to know what corrections have been documented
+   * - You want to avoid repeating previous errors
+   *
+   * Results are ranked by similarity to your query
+   */
+  GET_CORRECTIONS: {
+    name: 'get_corrections',
+    description: 'Retrieves corrections and lessons learned from ChromaDB semantic memory. Use this to review past mistakes, what was fixed, and why it was better. Corrections are returned ranked by semantic similarity.',
+    inputSchema: {
+      type: 'object' as const,
+      properties: {
+        project_name: {
+          type: 'string',
+          description: 'Project to retrieve corrections from (optional, returns all projects if not specified)'
+        },
+        limit: {
+          type: 'number',
+          minimum: 1,
+          description: 'Maximum number of corrections to return (default 10)'
+        },
+        query: {
+          type: 'string',
+          description: 'Search query to find relevant corrections (optional, uses semantic search if not provided)'
+        }
+      }
+    }
+  },
+
+  // =========================================================================
+  // Phase 16 - Unified Brain Tool
+  // =========================================================================
+  // Phase 19: Removed 9 redundant MCP tools whose functionality is now
+  // absorbed into brain(). Removed: rate_memory, search_knowledge_graph,
+  // get_episode, list_episodes, get_decision_timeline,
+  // analyze_decision_evolution, detect_trends, what_if_analysis,
+  // get_recommendations, find_cross_project_patterns.
+  // The underlying modules are still available internally.
+
+  /**
+   * BRAIN
+   * Unified intelligent tool that replaces all 25 tools
+   *
+   * Use this when:
+   * - You want a single tool for all Claude Brain interactions
+   * - Enabled via unifiedToolMode config flag
+   *
+   * The server classifies intent and routes internally
+   */
+  BRAIN: {
+    name: 'brain',
+    description: 'Your persistent memory. Tell it decisions, ask it questions, or update/delete past notes. Most context is captured automatically — only call this for intentional storage or recall. Search returns compact summaries — use brain("details {ID}") for full context.',
+    inputSchema: {
+      type: 'object' as const,
+      properties: {
+        message: {
+          type: 'string',
+          description: 'What you are doing, decided, learned, or need. Natural language.'
+        },
+        project: {
+          type: 'string',
+          description: 'Project name (IMPORTANT: pass this to scope memories correctly, e.g. "my-app"). Auto-detected from message if omitted, defaults to "general".'
+        },
+        action: {
+          type: 'string',
+          enum: ['auto', 'store', 'recall', 'update', 'delete'],
+          description: 'Force a specific action instead of auto-detecting intent. "store" = always save, "recall" = always search, "update" = modify last stored, "delete" = remove. Default: auto (use intent classifier).'
+        }
+      },
+      required: ['message']
+    }
+  },
+
+  /**
+   * SEARCH_CODE
+   * Search indexed code symbols, files, and dependencies
+   *
+   * Use this when:
+   * - Looking for a function, class, or type definition
+   * - Need to find which file contains a symbol
+   * - Want to see imports/dependencies of a file
+   * - Faster than grep for known symbol names
+   */
+  SEARCH_CODE: {
+    name: 'search_code',
+    description: 'Search indexed code for symbols (functions, classes, types), files, or dependencies. Faster than grep when the project is indexed. Run `claude-brain reindex` first if no results.',
+    inputSchema: {
+      type: 'object' as const,
+      properties: {
+        query: {
+          type: 'string',
+          description: 'Symbol name, file name, or search term'
+        },
+        project: {
+          type: 'string',
+          description: 'Project name (usually the directory name, e.g. "claude-brain")'
+        },
+        type: {
+          type: 'string',
+          enum: ['symbols', 'files', 'dependencies'],
+          description: 'What to search for: symbols (functions/classes/types), files, or dependencies of a file',
+          default: 'symbols'
+        },
+        file_path: {
+          type: 'string',
+          description: 'File path (required when type is "dependencies")'
+        },
+        limit: {
+          type: 'number',
+          description: 'Maximum results to return',
+          default: 20
+        }
+      },
+      required: ['query', 'project']
+    }
+  }
+} as const satisfies Record<string, ToolDefinition>
+
+/** Tool names as a union type */
+export type ToolName = typeof TOOLS[keyof typeof TOOLS]['name']
+
+/** Get all tool names as an array */
+export function getToolNames(): ToolName[] {
+  return Object.values(TOOLS).map(tool => tool.name)
+}