claude-brain 0.3.0

package/src/tools/schemas.ts

@@ -0,0 +1,907 @@
+/**
+ * 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 */
+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)'
+        }
+      }
+    }
+  },
+
+  /**
+   * RATE_MEMORY
+   * Provide feedback on retrieved memories for adaptive learning
+   *
+   * Use this when:
+   * - A retrieved memory was helpful or not helpful
+   * - You want to improve future retrieval quality
+   * - The system should learn from retrieval feedback
+   *
+   * Feedback is used to adapt retrieval thresholds and weights
+   */
+  RATE_MEMORY: {
+    name: 'rate_memory',
+    description: 'Rate how helpful a retrieved memory was. This feedback helps improve future retrieval quality through adaptive learning. Rate 1-5 where 1=not helpful and 5=very helpful.',
+    inputSchema: {
+      type: 'object' as const,
+      properties: {
+        memory_id: {
+          type: 'string',
+          description: 'ID of the memory to rate (from recall_similar or smart_context results)'
+        },
+        rating: {
+          type: 'number',
+          enum: [1, 2, 3, 4, 5],
+          description: 'Rating from 1 (not helpful) to 5 (very helpful)'
+        },
+        query: {
+          type: 'string',
+          description: 'The original query that retrieved this memory'
+        },
+        was_used: {
+          type: 'boolean',
+          description: 'Whether you actually used this memory in your response',
+          default: true
+        },
+        feedback_text: {
+          type: 'string',
+          description: 'Optional text explaining why this rating was given'
+        },
+        project_name: {
+          type: 'string',
+          description: 'Project this feedback relates to (optional)'
+        }
+      },
+      required: ['memory_id', 'rating', 'query']
+    }
+  },
+
+  /**
+   * SEARCH_KNOWLEDGE_GRAPH
+   * Search the knowledge graph for related entities, decisions, and relationships
+   *
+   * Use this when:
+   * - You want to find how technologies/decisions are connected
+   * - You need to explore relationships between entities
+   * - You want to find related decisions for a technology
+   */
+  SEARCH_KNOWLEDGE_GRAPH: {
+    name: 'search_knowledge_graph',
+    description: 'Searches the knowledge graph for related nodes and edges. Use this to explore relationships between technologies, decisions, and concepts.',
+    inputSchema: {
+      type: 'object' as const,
+      properties: {
+        query: {
+          type: 'string',
+          description: 'Search query (technology name, concept, etc.)'
+        },
+        node_type: {
+          type: 'string',
+          enum: ['project', 'technology', 'concept', 'person', 'file', 'decision', 'pattern', 'correction', 'date'],
+          description: 'Filter by node type (optional)'
+        },
+        start_node_id: {
+          type: 'string',
+          description: 'Start from a specific node ID for graph expansion (optional)'
+        },
+        hops: {
+          type: 'number',
+          description: 'Number of hops to expand from matching nodes (default 2)',
+          default: 2
+        },
+        limit: {
+          type: 'number',
+          description: 'Maximum number of results (default 20)',
+          default: 20
+        }
+      }
+    }
+  },
+
+  /**
+   * GET_EPISODE
+   * Get a specific episode or the active episode for a project
+   *
+   * Use this when:
+   * - You want to review a past conversation session
+   * - You need to find what was discussed in an episode
+   * - You want to see the active episode for a project
+   */
+  GET_EPISODE: {
+    name: 'get_episode',
+    description: 'Get episode by ID or get active episode for project. Episodes represent conversation sessions with summaries and linked decisions.',
+    inputSchema: {
+      type: 'object' as const,
+      properties: {
+        episode_id: {
+          type: 'string',
+          description: 'Specific episode ID to retrieve'
+        },
+        project_name: {
+          type: 'string',
+          description: 'Get active episode for this project'
+        }
+      }
+    }
+  },
+
+  /**
+   * LIST_EPISODES
+   * List recent episodes, filtered by project or status
+   *
+   * Use this when:
+   * - You want to see recent conversation sessions
+   * - You need to find past episodes for a project
+   * - You want to review episode summaries
+   */
+  LIST_EPISODES: {
+    name: 'list_episodes',
+    description: 'List recent episodes with summaries. Filter by project or status to find past conversation sessions.',
+    inputSchema: {
+      type: 'object' as const,
+      properties: {
+        project_name: {
+          type: 'string',
+          description: 'Filter episodes by project (optional)'
+        },
+        limit: {
+          type: 'number',
+          description: 'Maximum number of episodes to return (default 10)',
+          default: 10
+        },
+        status: {
+          type: 'string',
+          enum: ['active', 'completed'],
+          description: 'Filter by episode status (optional)'
+        }
+      }
+    }
+  },
+  // =========================================================================
+  // Phase 15 - Advanced Intelligence & Temporal Reasoning
+  // =========================================================================
+
+  /**
+   * GET_DECISION_TIMELINE
+   * Build a chronological timeline of decisions
+   */
+  GET_DECISION_TIMELINE: {
+    name: 'get_decision_timeline',
+    description: 'Builds a chronological timeline of decisions, patterns, and corrections. Supports temporal expressions like "last month", "since January", etc. Use this to see how a project or topic has evolved over time.',
+    inputSchema: {
+      type: 'object' as const,
+      properties: {
+        project_name: {
+          type: 'string',
+          description: 'Filter timeline by project (optional)'
+        },
+        topic: {
+          type: 'string',
+          description: 'Filter timeline by topic via semantic search (optional)'
+        },
+        time_range: {
+          type: 'string',
+          description: 'Natural language time range, e.g. "last month", "since January 2025", "this week" (optional)'
+        },
+        limit: {
+          type: 'number',
+          description: 'Maximum number of entries (default 50)',
+          default: 50
+        }
+      }
+    }
+  },
+
+  /**
+   * ANALYZE_DECISION_EVOLUTION
+   * Track how decisions on a topic change over time
+   */
+  ANALYZE_DECISION_EVOLUTION: {
+    name: 'analyze_decision_evolution',
+    description: 'Tracks how decisions on a specific topic have evolved over time. Shows changes, stability assessment, and current state. Use this to understand decision drift or consistency.',
+    inputSchema: {
+      type: 'object' as const,
+      properties: {
+        topic: {
+          type: 'string',
+          description: 'The topic to analyze evolution for (e.g., "database choice", "authentication")'
+        },
+        project_name: {
+          type: 'string',
+          description: 'Filter by project (optional)'
+        },
+        limit: {
+          type: 'number',
+          description: 'Maximum decisions to analyze (default 20)',
+          default: 20
+        }
+      },
+      required: ['topic']
+    }
+  },
+
+  /**
+   * DETECT_TRENDS
+   * Detect emerging and declining technology/pattern trends
+   */
+  DETECT_TRENDS: {
+    name: 'detect_trends',
+    description: 'Detects emerging, stable, and declining trends across decisions. Identifies frequently mentioned technologies, concepts, and approaches, and whether they are gaining or losing momentum.',
+    inputSchema: {
+      type: 'object' as const,
+      properties: {
+        project_name: {
+          type: 'string',
+          description: 'Filter by project (optional, analyzes all projects if omitted)'
+        },
+        period_days: {
+          type: 'number',
+          description: 'Analysis period in days (default 90)',
+          default: 90
+        },
+        min_occurrences: {
+          type: 'number',
+          description: 'Minimum occurrences to include (default 2)',
+          default: 2
+        },
+        limit: {
+          type: 'number',
+          description: 'Maximum trends to return (default 20)',
+          default: 20
+        }
+      }
+    }
+  },
+
+  /**
+   * WHAT_IF_ANALYSIS
+   * Counterfactual what-if analysis
+   */
+  WHAT_IF_ANALYSIS: {
+    name: 'what_if_analysis',
+    description: 'Performs what-if analysis: "What would happen if we changed X?" Finds all affected decisions, connected technologies, and assesses risk level. Uses knowledge graph for impact analysis.',
+    inputSchema: {
+      type: 'object' as const,
+      properties: {
+        change: {
+          type: 'string',
+          description: 'The hypothetical change to analyze (e.g., "switch from React to Vue", "remove TypeScript")'
+        },
+        project_name: {
+          type: 'string',
+          description: 'Filter by project (optional)'
+        },
+        max_results: {
+          type: 'number',
+          description: 'Maximum affected decisions to return (default 20)',
+          default: 20
+        }
+      },
+      required: ['change']
+    }
+  },
+
+  /**
+   * GET_RECOMMENDATIONS
+   * Get intelligent recommendations based on history
+   */
+  GET_RECOMMENDATIONS: {
+    name: 'get_recommendations',
+    description: 'Provides intelligent recommendations based on past decisions, patterns, and corrections. Combines multiple knowledge sources to suggest best approaches for a given situation.',
+    inputSchema: {
+      type: 'object' as const,
+      properties: {
+        query: {
+          type: 'string',
+          description: 'What you need recommendations for (e.g., "how to implement caching", "error handling approach")'
+        },
+        project_name: {
+          type: 'string',
+          description: 'Filter by project (optional)'
+        },
+        limit: {
+          type: 'number',
+          description: 'Maximum recommendations (default 10)',
+          default: 10
+        }
+      },
+      required: ['query']
+    }
+  },
+
+  /**
+   * FIND_CROSS_PROJECT_PATTERNS
+   * Find patterns common across multiple projects
+   */
+  FIND_CROSS_PROJECT_PATTERNS: {
+    name: 'find_cross_project_patterns',
+    description: 'Finds patterns and approaches that appear across multiple projects. Identifies shared technologies, common decisions, and transferable knowledge between projects.',
+    inputSchema: {
+      type: 'object' as const,
+      properties: {
+        min_projects: {
+          type: 'number',
+          description: 'Minimum number of projects a pattern must appear in (default 2)',
+          default: 2
+        },
+        limit: {
+          type: 'number',
+          description: 'Maximum patterns to return (default 20)',
+          default: 20
+        },
+        query: {
+          type: 'string',
+          description: 'Optional query to focus the search (e.g., "authentication", "deployment")'
+        }
+      }
+    }
+  }
+} 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)
+}