claude-brain 0.5.1 → 0.9.0

package/src/routing/entity-extractor.ts

@@ -0,0 +1,410 @@
+/**
+ * Brain Entity Extractor
+ * Phase 16: Extracts structured data from natural language messages
+ * for the unified brain() tool routing
+ */
+
+import { getVaultService, isServicesInitialized } from '@/server/services'
+
+// Reuse phrase lists from decision detector
+const DECISION_PHRASES = [
+  'i recommend',
+  'you should use',
+  'the best approach',
+  'i suggest',
+  'better to use',
+  'prefer using',
+  'go with',
+  'choose',
+  'instead of',
+  'the right choice',
+  'decided to',
+  "let's use",
+  'we will use',
+  'the solution is',
+  'implement using',
+  'going with',
+  'switching to',
+  'adopting',
+  'we chose',
+  'the plan is to'
+]
+
+const REASONING_PHRASES = [
+  'because',
+  'since',
+  'due to',
+  'as it',
+  'which provides',
+  'this allows',
+  'this ensures',
+  'given that',
+  'considering',
+  'the reason is',
+  'this way'
+]
+
+const ALTERNATIVE_PHRASES = [
+  'instead of',
+  'rather than',
+  'over',
+  ' vs ',
+  'compared to',
+  'unlike',
+  'as opposed to'
+]
+
+// Compact tech dictionary for entity extraction (most common technologies)
+// Full dictionary is in knowledge/entity-extractor.ts — we use a subset for speed
+const COMMON_TECH: Set<string> = new Set([
+  'typescript', 'javascript', 'python', 'rust', 'go', 'java', 'ruby', 'php', 'swift', 'kotlin',
+  'react', 'vue', 'angular', 'svelte', 'nextjs', 'nuxt', 'remix', 'astro', 'solid',
+  'express', 'fastify', 'hono', 'nestjs', 'django', 'flask', 'fastapi', 'rails', 'spring',
+  'mongodb', 'redis', 'postgresql', 'postgres', 'mysql', 'sqlite', 'dynamodb', 'firebase', 'supabase',
+  'prisma', 'drizzle', 'typeorm', 'sequelize', 'chromadb', 'pinecone',
+  'docker', 'kubernetes', 'aws', 'gcp', 'azure', 'vercel', 'netlify',
+  'webpack', 'vite', 'esbuild', 'bun', 'deno', 'node', 'npm', 'yarn', 'pnpm',
+  'jest', 'vitest', 'cypress', 'playwright',
+  'tailwind', 'bootstrap', 'zod', 'trpc', 'graphql', 'rest',
+  'jwt', 'oauth', 'openai', 'anthropic', 'langchain',
+  'git', 'github', 'gitlab', 'eslint', 'prettier',
+  'zustand', 'redux', 'pinia', 'mobx', 'jotai', 'recoil',
+  'storybook', 'turborepo', 'nx',
+  'microservices', 'serverless', 'monolith', 'ssr', 'ssg', 'spa', 'pwa', 'mcp', 'rag'
+])
+
+// Aliases for common tech names
+const TECH_ALIASES: Record<string, string> = {
+  'ts': 'typescript', 'js': 'javascript', 'py': 'python',
+  'react.js': 'react', 'reactjs': 'react', 'vue.js': 'vue', 'vuejs': 'vue',
+  'next.js': 'nextjs', 'nuxt.js': 'nuxt', 'nest.js': 'nestjs',
+  'express.js': 'express', 'node.js': 'node', 'nodejs': 'node',
+  'mongo': 'mongodb', 'pg': 'postgresql', 'k8s': 'kubernetes',
+  'tailwindcss': 'tailwind', 'tailwind-css': 'tailwind',
+  'gql': 'graphql', 'golang': 'go',
+}
+
+export interface BrainExtractedEntities {
+  project?: string
+  technologies: string[]
+  decision?: string
+  reasoning?: string
+  alternatives?: string
+  topic?: string
+  completedTask?: string
+  nextSteps?: string
+  original?: string
+  correction?: string
+  patternType?: 'solution' | 'anti-pattern' | 'best-practice' | 'common-issue'
+}
+
+export class BrainEntityExtractor {
+  /**
+   * Extract all entities from a natural language message
+   */
+  async extract(message: string, knownProject?: string): Promise<BrainExtractedEntities> {
+    const entities: BrainExtractedEntities = {
+      technologies: []
+    }
+
+    // Use provided project or try to detect from message
+    entities.project = knownProject || await this.extractProject(message)
+    entities.technologies = this.extractTechnologies(message)
+    entities.topic = this.extractTopic(message)
+
+    // Extract decision components if present
+    const decisionParts = this.extractDecision(message)
+    if (decisionParts) {
+      entities.decision = decisionParts.decision
+      entities.reasoning = decisionParts.reasoning
+      entities.alternatives = decisionParts.alternatives
+    }
+
+    // Extract progress components
+    const progress = this.extractProgress(message)
+    if (progress) {
+      entities.completedTask = progress.completedTask
+      entities.nextSteps = progress.nextSteps
+    }
+
+    // Extract correction components
+    const correction = this.extractCorrection(message)
+    if (correction) {
+      entities.original = correction.original
+      entities.correction = correction.correction
+    }
+
+    // Extract pattern type
+    entities.patternType = this.extractPatternType(message)
+
+    return entities
+  }
+
+  /**
+   * Extract project name from message
+   */
+  private async extractProject(message: string): Promise<string | undefined> {
+    const lower = message.toLowerCase()
+
+    // Pattern: "in project X", "for project X", "on project X"
+    const projectPatterns = [
+      /(?:in|for|on)\s+(?:the\s+)?project\s+["']?([a-z0-9][a-z0-9-]*[a-z0-9])["']?/i,
+      /project\s*:\s*["']?([a-z0-9][a-z0-9-]*[a-z0-9])["']?/i,
+      /(?:in|for|on)\s+["']?([a-z0-9][a-z0-9-]*[a-z0-9])["']?\s+project/i,
+      // "working on X", "starting X", "resuming X"
+      /(?:working\s+on|starting|resuming|picking\s+up)\s+(?:the\s+)?["']?([a-z0-9][a-z0-9-]*[a-z0-9])["']?/i,
+    ]
+
+    for (const pattern of projectPatterns) {
+      const match = message.match(pattern)
+      if (match && match[1]) {
+        const candidate = match[1].toLowerCase()
+        // Filter out common false positives
+        if (!COMMON_TECH.has(candidate) && candidate.length > 1 && candidate.length < 50) {
+          return candidate
+        }
+      }
+    }
+
+    // Try to match against known projects via vault service
+    if (isServicesInitialized()) {
+      try {
+        const vault = getVaultService()
+        const projects = await vault.listProjects()
+        for (const project of projects) {
+          if (lower.includes(project.toLowerCase())) {
+            return project
+          }
+        }
+      } catch {
+        // Vault service not available, skip project matching
+      }
+    }
+
+    return undefined
+  }
+
+  /**
+   * Extract technology mentions
+   */
+  private extractTechnologies(message: string): string[] {
+    const lower = message.toLowerCase()
+    const words = lower.split(/[\s,;:()[\]{}"'`|/\\]+/)
+    const found = new Set<string>()
+
+    for (const word of words) {
+      const cleaned = word.replace(/^[^a-z0-9]+|[^a-z0-9]+$/g, '')
+      if (cleaned.length < 2) continue
+
+      // Direct match
+      if (COMMON_TECH.has(cleaned)) {
+        found.add(cleaned)
+        continue
+      }
+
+      // Alias match
+      const alias = TECH_ALIASES[cleaned]
+      if (alias) {
+        found.add(alias)
+      }
+    }
+
+    // Check multi-word aliases
+    for (const [alias, normalized] of Object.entries(TECH_ALIASES)) {
+      if (alias.includes('.') || alias.includes('-')) {
+        if (lower.includes(alias)) {
+          found.add(normalized)
+        }
+      }
+    }
+
+    return Array.from(found)
+  }
+
+  /**
+   * Extract decision, reasoning, and alternatives
+   */
+  private extractDecision(message: string): { decision?: string; reasoning?: string; alternatives?: string } | null {
+    const lower = message.toLowerCase()
+
+    const hasDecision = DECISION_PHRASES.some(p => lower.includes(p))
+    if (!hasDecision) return null
+
+    // Find the decision phrase and extract text after it
+    let decision: string | undefined
+    for (const phrase of DECISION_PHRASES) {
+      const index = lower.indexOf(phrase)
+      if (index !== -1) {
+        const afterPhrase = message.substring(index + phrase.length).trim()
+        // Take until reasoning or sentence end
+        const endIndex = this.findClauseEnd(afterPhrase, REASONING_PHRASES)
+        decision = afterPhrase.substring(0, endIndex).trim()
+        if (decision.length > 5) break
+      }
+    }
+
+    // Extract reasoning
+    let reasoning: string | undefined
+    for (const phrase of REASONING_PHRASES) {
+      const index = lower.indexOf(phrase)
+      if (index !== -1) {
+        const afterPhrase = message.substring(index).trim()
+        const endIndex = Math.min(afterPhrase.length, 300)
+        const sentenceEnd = afterPhrase.search(/\n\n/)
+        reasoning = afterPhrase.substring(0, sentenceEnd !== -1 ? sentenceEnd : endIndex).trim()
+        if (reasoning.length > 10) break
+      }
+    }
+
+    // Extract alternatives
+    let alternatives: string | undefined
+    for (const phrase of ALTERNATIVE_PHRASES) {
+      const index = lower.indexOf(phrase)
+      if (index !== -1) {
+        const afterPhrase = message.substring(index + phrase.length).trim()
+        const endMatch = afterPhrase.match(/[.!?\n]/)
+        const endIndex = endMatch ? endMatch.index! + 1 : Math.min(afterPhrase.length, 150)
+        alternatives = afterPhrase.substring(0, endIndex).trim()
+        if (alternatives.length > 3) break
+      }
+    }
+
+    if (!decision && !reasoning) return null
+
+    return { decision, reasoning, alternatives }
+  }
+
+  /**
+   * Extract progress info: completed task and next steps
+   */
+  private extractProgress(message: string): { completedTask?: string; nextSteps?: string } | null {
+    const completedPatterns = [
+      /(?:finished|completed|done with|implemented|built|created|added|fixed|resolved|shipped)\s+(.+?)(?:\.|,\s*next|$)/i,
+    ]
+
+    const nextPatterns = [
+      /(?:next\s+(?:is|step|up|i'll|we'll|will\s+be)?|then\s+(?:i'll|we'll|will)|moving\s+(?:on\s+)?to)\s+(.+?)(?:\.|$)/i,
+    ]
+
+    let completedTask: string | undefined
+    let nextSteps: string | undefined
+
+    for (const pattern of completedPatterns) {
+      const match = message.match(pattern)
+      if (match && match[1] && match[1].length > 3) {
+        completedTask = match[1].trim()
+        break
+      }
+    }
+
+    for (const pattern of nextPatterns) {
+      const match = message.match(pattern)
+      if (match && match[1] && match[1].length > 3) {
+        nextSteps = match[1].trim()
+        break
+      }
+    }
+
+    if (!completedTask) return null
+    return { completedTask, nextSteps }
+  }
+
+  /**
+   * Extract correction: original mistake and what should have been done
+   */
+  private extractCorrection(message: string): { original?: string; correction?: string } | null {
+    const lower = message.toLowerCase()
+
+    const correctionIndicators = [
+      'the bug was', 'the issue was', 'the problem was', 'mistake was',
+      'should have', 'should not have', "shouldn't have",
+      'lesson learned', "don't use", 'avoid using', 'never use',
+      'the fix is', 'the fix was', 'fixed by', 'solved by'
+    ]
+
+    const hasCorrection = correctionIndicators.some(p => lower.includes(p))
+    if (!hasCorrection) return null
+
+    // Extract the original problem
+    let original: string | undefined
+    const problemPatterns = [
+      /(?:the\s+(?:bug|issue|problem|mistake)\s+was)\s+(.+?)(?:\.|,|;|$)/i,
+      /(?:should\s+(?:have|not\s+have)|shouldn't\s+have)\s+(.+?)(?:\.|,|;|$)/i
+    ]
+
+    for (const pattern of problemPatterns) {
+      const match = message.match(pattern)
+      if (match && match[1] && match[1].length > 3) {
+        original = match[1].trim()
+        break
+      }
+    }
+
+    // Extract the correction
+    let correction: string | undefined
+    const fixPatterns = [
+      /(?:the\s+fix\s+(?:is|was)|fixed\s+by|solved\s+by|instead\s+(?:should|use))\s+(.+?)(?:\.|,|;|$)/i,
+      /(?:don't\s+use|avoid\s+using|never\s+use)\s+(.+?)(?:\.|,|;|$)/i
+    ]
+
+    for (const pattern of fixPatterns) {
+      const match = message.match(pattern)
+      if (match && match[1] && match[1].length > 3) {
+        correction = match[1].trim()
+        break
+      }
+    }
+
+    if (!original && !correction) return null
+    return { original: original || message.slice(0, 200), correction }
+  }
+
+  /**
+   * Extract pattern type from message
+   */
+  private extractPatternType(message: string): BrainExtractedEntities['patternType'] {
+    const lower = message.toLowerCase()
+    if (lower.includes('anti-pattern') || lower.includes('antipattern')) return 'anti-pattern'
+    if (lower.includes('best practice') || lower.includes('best-practice')) return 'best-practice'
+    if (lower.includes('common issue') || lower.includes('common-issue') || lower.includes('common problem')) return 'common-issue'
+    if (lower.includes('pattern') || lower.includes('reusable solution') || lower.includes('reusable approach')) return 'solution'
+    return undefined
+  }
+
+  /**
+   * Extract topic from message (main subject without noise words)
+   */
+  private extractTopic(message: string): string | undefined {
+    // For short messages, the whole thing is the topic
+    if (message.length < 80) {
+      const cleaned = message.replace(/[?.!]+$/, '').trim()
+      if (cleaned.length > 3) return cleaned
+    }
+
+    // For longer messages, extract the first meaningful clause
+    const sentences = message.split(/[.!?\n]+/).filter(s => s.trim().length > 3)
+    const first = sentences[0]
+    if (first) {
+      return first.trim().slice(0, 200)
+    }
+
+    return undefined
+  }
+
+  /**
+   * Find where a clause ends (at a reasoning phrase or sentence boundary)
+   */
+  private findClauseEnd(text: string, stopPhrases: string[]): number {
+    const lower = text.toLowerCase()
+
+    const phraseStart = stopPhrases.reduce((min, phrase) => {
+      const idx = lower.indexOf(phrase)
+      return idx !== -1 ? Math.min(min, idx) : min
+    }, text.length)
+
+    const sentenceEnd = text.search(/[.!?\n]/)
+    const end = sentenceEnd !== -1 ? sentenceEnd : text.length
+
+    return Math.min(phraseStart, end, 200)
+  }
+}

package/src/routing/intent-classifier.ts

@@ -0,0 +1,229 @@
+/**
+ * Brain Intent Classifier
+ * Phase 16: Rule-based intent classification for the unified brain() tool
+ *
+ * Priority-ordered — first confident match wins.
+ * No LLM calls, pure pattern matching.
+ */
+
+export type Intent =
+  | 'session_start'
+  | 'context_needed'
+  | 'decision_made'
+  | 'pattern_found'
+  | 'mistake_learned'
+  | 'progress_update'
+  | 'question'
+  | 'comparison'
+  | 'exploration'
+  | 'no_action'
+
+export interface ClassificationResult {
+  primary: Intent
+  confidence: number
+  secondary: Intent[]
+}
+
+// Decision-indicating phrases (from automation/decision-detector.ts)
+const DECISION_PHRASES = [
+  'i recommend', 'you should use', 'the best approach',
+  'i suggest', 'better to use', 'prefer using',
+  'go with', 'decided to', "let's use", 'we will use',
+  'the solution is', 'implement using', 'going with',
+  'switching to', 'adopting', 'we chose', 'the plan is to'
+]
+
+const REASONING_PHRASES = [
+  'because', 'since', 'due to', 'as it', 'which provides',
+  'this allows', 'this ensures', 'given that', 'considering',
+  'the reason is', 'this way'
+]
+
+// Mistake/correction indicators
+const MISTAKE_PHRASES = [
+  'bug was', 'the issue was', 'the problem was', 'mistake was',
+  'should have', "shouldn't have", 'should not have',
+  'lesson learned', "don't use", 'avoid using', 'never use',
+  'the fix is', 'the fix was', 'fixed by', 'solved by',
+  'was wrong', 'was broken', 'was incorrect'
+]
+
+// Progress indicators
+const PROGRESS_PHRASES = [
+  'finished', 'completed', 'done with', 'implemented',
+  'built', 'created', 'added', 'fixed', 'resolved',
+  'shipped', 'deployed', 'merged', 'released'
+]
+
+// Comparison indicators
+const COMPARISON_PHRASES = [
+  ' vs ', ' versus ', 'or should', 'compared to', 'comparing ',
+  'which is better', 'should i use', 'should we use',
+  'what if we switch', 'what if we change', 'what if we replace',
+  'pros and cons', 'tradeoffs', 'trade-offs'
+]
+
+// Pattern indicators
+const PATTERN_PHRASES = [
+  'pattern:', 'best practice:', 'anti-pattern:', 'reusable solution',
+  'reusable approach', 'common issue:', 'this pattern',
+  'recognized pattern', 'document this pattern'
+]
+
+// Exploration indicators
+const EXPLORATION_PHRASES = [
+  'show me', 'timeline', 'trends', 'evolution of',
+  'history of', 'graph', 'how has', 'what happened',
+  'decisions about', 'when did we', 'list episodes'
+]
+
+// Session start indicators
+const SESSION_START_PHRASES = [
+  'starting work', 'beginning work', 'resuming',
+  'picking up', 'getting started', 'opening',
+  'starting on', 'working on', 'beginning on'
+]
+
+// Question indicators
+const QUESTION_WORDS = [
+  'what', 'how', 'when', 'why', 'where', 'which',
+  'who', 'can', 'does', 'is', 'are', 'should', 'could', 'would'
+]
+
+// No-action indicators
+const NO_ACTION_PHRASES = [
+  'ok', 'okay', 'thanks', 'thank you', 'got it',
+  'sure', 'yes', 'no', 'cool', 'nice', 'great',
+  'understood', 'noted', 'alright', 'right'
+]
+
+export class IntentClassifier {
+  /**
+   * Classify the intent of a message
+   */
+  classify(message: string): ClassificationResult {
+    const lower = message.toLowerCase().trim()
+    const secondary: Intent[] = []
+
+    // Check in priority order — first confident match wins
+
+    // 1. no_action: very short messages, greetings, acknowledgments
+    if (this.isNoAction(lower)) {
+      return { primary: 'no_action', confidence: 0.95, secondary: [] }
+    }
+
+    // 2. decision_made: decision phrases + reasoning
+    if (this.isDecisionMade(lower)) {
+      if (this.hasComparisonSignal(lower)) secondary.push('comparison')
+      return { primary: 'decision_made', confidence: 0.85, secondary }
+    }
+
+    // 3. mistake_learned: correction/bug/lesson indicators
+    if (this.isMistakeLearned(lower)) {
+      return { primary: 'mistake_learned', confidence: 0.85, secondary }
+    }
+
+    // 4. progress_update: completed task indicators (NOT questions)
+    if (this.isProgressUpdate(lower, message)) {
+      if (this.hasSessionSignal(lower)) secondary.push('session_start')
+      return { primary: 'progress_update', confidence: 0.85, secondary }
+    }
+
+    // 5. comparison: vs, which is better, etc.
+    if (this.isComparison(lower)) {
+      if (this.isQuestion(lower, message)) secondary.push('question')
+      return { primary: 'comparison', confidence: 0.85, secondary }
+    }
+
+    // 6. pattern_found: explicit pattern documentation
+    if (this.isPatternFound(lower)) {
+      return { primary: 'pattern_found', confidence: 0.80, secondary }
+    }
+
+    // 7. session_start: starting/resuming work
+    if (this.isSessionStart(lower)) {
+      secondary.push('context_needed')
+      return { primary: 'session_start', confidence: 0.90, secondary }
+    }
+
+    // 8. exploration: timeline, trends, graph, history
+    if (this.isExploration(lower)) {
+      if (this.isQuestion(lower, message)) secondary.push('question')
+      return { primary: 'exploration', confidence: 0.75, secondary }
+    }
+
+    // 9. question: starts with question word or ends with ?
+    if (this.isQuestion(lower, message)) {
+      if (this.hasComparisonSignal(lower)) secondary.push('comparison')
+      if (this.hasExplorationSignal(lower)) secondary.push('exploration')
+      return { primary: 'question', confidence: 0.80, secondary }
+    }
+
+    // 10. Default: context_needed
+    return { primary: 'context_needed', confidence: 0.60, secondary }
+  }
+
+  private isNoAction(lower: string): boolean {
+    if (lower.length > 30) return false
+    const words = lower.split(/\s+/)
+    if (words.length > 5) return false
+    return NO_ACTION_PHRASES.some(p => lower === p || lower === p + '.' || lower === p + '!')
+  }
+
+  private isDecisionMade(lower: string): boolean {
+    const hasDecision = DECISION_PHRASES.some(p => lower.includes(p))
+    if (!hasDecision) return false
+    // Higher confidence if reasoning is also present
+    const hasReasoning = REASONING_PHRASES.some(p => lower.includes(p))
+    return hasReasoning || lower.length > 30
+  }
+
+  private isMistakeLearned(lower: string): boolean {
+    return MISTAKE_PHRASES.some(p => lower.includes(p))
+  }
+
+  private isProgressUpdate(lower: string, original: string): boolean {
+    // Must not be a question
+    if (original.trim().endsWith('?')) return false
+    const firstWord = lower.split(/\s+/)[0] || ''
+    if (QUESTION_WORDS.includes(firstWord)) return false
+
+    return PROGRESS_PHRASES.some(p => lower.includes(p))
+  }
+
+  private isComparison(lower: string): boolean {
+    return COMPARISON_PHRASES.some(p => lower.includes(p))
+  }
+
+  private isPatternFound(lower: string): boolean {
+    const hasPattern = PATTERN_PHRASES.some(p => lower.includes(p))
+    return hasPattern && lower.length > 50
+  }
+
+  private isSessionStart(lower: string): boolean {
+    return SESSION_START_PHRASES.some(p => lower.includes(p))
+  }
+
+  private isExploration(lower: string): boolean {
+    return EXPLORATION_PHRASES.some(p => lower.includes(p))
+  }
+
+  private isQuestion(lower: string, original: string): boolean {
+    if (original.trim().endsWith('?')) return true
+    const firstWord = lower.split(/\s+/)[0] || ''
+    return QUESTION_WORDS.includes(firstWord)
+  }
+
+  // Secondary signal checks
+  private hasComparisonSignal(lower: string): boolean {
+    return COMPARISON_PHRASES.some(p => lower.includes(p))
+  }
+
+  private hasExplorationSignal(lower: string): boolean {
+    return EXPLORATION_PHRASES.some(p => lower.includes(p))
+  }
+
+  private hasSessionSignal(lower: string): boolean {
+    return SESSION_START_PHRASES.some(p => lower.includes(p))
+  }
+}