claude-brain 0.30.2 → 0.30.3

package/src/retrieval/query/intent-classifier.ts

@@ -1,252 +1,252 @@
-/**
- * Query Intent Classifier
- * Rule-based intent detection for query understanding
- */
-
-import type { QueryIntent } from '../types'
-
-/** Intent types and their indicators */
-const INTENT_PATTERNS: Record<string, { keywords: string[]; patterns: RegExp[] }> = {
-  factual: {
-    keywords: ['what', 'where', 'when', 'who', 'which', 'define', 'explain', 'describe'],
-    patterns: [
-      /^what\s+(is|are|was|were)\b/i,
-      /^how\s+does\b/i,
-      /^where\s+(is|are|can)\b/i,
-      /^when\s+(did|does|is|was)\b/i,
-      /^who\s+(is|are|was|were)\b/i
-    ]
-  },
-  decision: {
-    keywords: ['decide', 'chose', 'chosen', 'selected', 'picked', 'why did', 'reason', 'rationale'],
-    patterns: [
-      /why\s+(did|do|does|should)\s+(we|i|you)\s+(use|choose|pick|select)/i,
-      /what\s+(was|is)\s+the\s+(decision|choice|rationale)/i,
-      /why\s+(was|is|are)\s+\w+\s+(used|chosen|selected)/i,
-      /(decision|choice)\s+(for|about|regarding)/i
-    ]
-  },
-  pattern: {
-    keywords: ['pattern', 'best practice', 'approach', 'method', 'way to', 'how to', 'technique'],
-    patterns: [
-      /how\s+(do|should|can)\s+(we|i|you)\s+(implement|build|create|handle)/i,
-      /what('s|\s+is)\s+the\s+(best|recommended|correct)\s+(way|approach|method)/i,
-      /(pattern|practice)\s+for/i,
-      /how\s+to\s+\w+/i
-    ]
-  },
-  comparison: {
-    keywords: ['vs', 'versus', 'compare', 'comparison', 'difference', 'between', 'better', 'worse', 'prefer'],
-    patterns: [
-      /\w+\s+vs\.?\s+\w+/i,
-      /\w+\s+versus\s+\w+/i,
-      /(compare|comparison)\s+(between|of)/i,
-      /difference\s+between/i,
-      /which\s+(is|one)\s+(better|preferred|recommended)/i,
-      /should\s+(i|we)\s+use\s+\w+\s+or\s+\w+/i
-    ]
-  },
-  temporal: {
-    keywords: ['recent', 'latest', 'last', 'today', 'yesterday', 'week', 'month', 'ago', 'since', 'before', 'after'],
-    patterns: [
-      /(last|past)\s+(week|month|year|day)/i,
-      /\d+\s+(days?|weeks?|months?|years?)\s+ago/i,
-      /(recently|lately|today|yesterday)/i,
-      /since\s+\w+/i,
-      /before\s+\w+/i,
-      /after\s+\w+/i
-    ]
-  },
-  exploratory: {
-    keywords: ['any', 'all', 'list', 'show', 'find', 'search', 'look for', 'examples', 'related'],
-    patterns: [
-      /^(show|list|find|get)\s+(me\s+)?(all|any)/i,
-      /what\s+(are\s+)?(the\s+)?\w+\s+related\s+to/i,
-      /any\s+\w+\s+(about|related|for)/i,
-      /examples?\s+of/i
-    ]
-  }
-}
-
-/** Confidence thresholds */
-const HIGH_CONFIDENCE = 0.9
-const MEDIUM_CONFIDENCE = 0.7
-const LOW_CONFIDENCE = 0.5
-
-/**
- * Classify the intent of a query
- */
-export function classifyIntent(query: string): QueryIntent {
-  const startTime = Date.now()
-  const normalizedQuery = query.toLowerCase().trim()
-
-  // Track matches for each intent
-  const scores: Record<string, { score: number; matches: string[] }> = {}
-
-  for (const [intent, { keywords, patterns }] of Object.entries(INTENT_PATTERNS)) {
-    scores[intent] = { score: 0, matches: [] }
-
-    // Check keyword matches
-    for (const keyword of keywords) {
-      if (normalizedQuery.includes(keyword)) {
-        scores[intent].score += 0.3
-        scores[intent].matches.push(keyword)
-      }
-    }
-
-    // Check pattern matches (higher weight)
-    for (const pattern of patterns) {
-      if (pattern.test(normalizedQuery)) {
-        scores[intent].score += 0.5
-        scores[intent].matches.push(pattern.source)
-      }
-    }
-  }
-
-  // Find best matching intent
-  let bestIntent: string = 'exploratory' // Default
-  let bestScore = 0
-
-  for (const [intent, { score }] of Object.entries(scores)) {
-    if (score > bestScore) {
-      bestScore = score
-      bestIntent = intent
-    }
-  }
-
-  // Calculate confidence
-  let confidence: number
-  if (bestScore >= 0.8) {
-    confidence = HIGH_CONFIDENCE
-  } else if (bestScore >= 0.5) {
-    confidence = MEDIUM_CONFIDENCE
-  } else if (bestScore > 0) {
-    confidence = LOW_CONFIDENCE
-  } else {
-    confidence = 0.3 // Default low confidence for exploratory
-  }
-
-  // Extract additional metadata based on intent
-  const metadata: QueryIntent['metadata'] = {}
-
-  if (bestIntent === 'comparison') {
-    metadata.comparisonTerms = extractComparisonTerms(query)
-  }
-
-  const result: QueryIntent = {
-    type: bestIntent as QueryIntent['type'],
-    confidence,
-    metadata
-  }
-
-  // SLM Phase 1A: Log query classification for training data collection
-  try {
-    const { logTrainingData } = require('@/training/data-store')
-    logTrainingData({
-      task: 'query' as const,
-      input: query,
-      output: JSON.stringify({ label: result.type }),
-      metadata: JSON.stringify({ confidence, scores, elapsed_ms: Date.now() - startTime }),
-    })
-  } catch {
-    // Non-critical
-  }
-
-  return result
-}
-
-/**
- * Extract comparison terms from a query
- */
-function extractComparisonTerms(query: string): string[] {
-  const terms: string[] = []
-
-  // Match "X vs Y" patterns
-  const vsMatch = query.match(/(\w+)\s+(?:vs\.?|versus)\s+(\w+)/i)
-  if (vsMatch) {
-    terms.push(vsMatch[1]!, vsMatch[2]!)
-  }
-
-  // Match "X or Y" patterns
-  const orMatch = query.match(/(\w+)\s+or\s+(\w+)/i)
-  if (orMatch && terms.length === 0) {
-    terms.push(orMatch[1]!, orMatch[2]!)
-  }
-
-  // Match "between X and Y" patterns
-  const betweenMatch = query.match(/between\s+(\w+)\s+and\s+(\w+)/i)
-  if (betweenMatch && terms.length === 0) {
-    terms.push(betweenMatch[1]!, betweenMatch[2]!)
-  }
-
-  return terms
-}
-
-/**
- * Check if query has a specific intent
- */
-export function hasIntent(query: string, intentType: QueryIntent['type']): boolean {
-  const intent = classifyIntent(query)
-  return intent.type === intentType && intent.confidence >= MEDIUM_CONFIDENCE
-}
-
-/**
- * Get all detected intents above a confidence threshold
- */
-export function getIntents(query: string, minConfidence: number = LOW_CONFIDENCE): QueryIntent[] {
-  const normalizedQuery = query.toLowerCase().trim()
-  const intents: QueryIntent[] = []
-
-  for (const [intentName, { keywords, patterns }] of Object.entries(INTENT_PATTERNS)) {
-    let score = 0
-
-    for (const keyword of keywords) {
-      if (normalizedQuery.includes(keyword)) {
-        score += 0.3
-      }
-    }
-
-    for (const pattern of patterns) {
-      if (pattern.test(normalizedQuery)) {
-        score += 0.5
-      }
-    }
-
-    let confidence: number
-    if (score >= 0.8) {
-      confidence = HIGH_CONFIDENCE
-    } else if (score >= 0.5) {
-      confidence = MEDIUM_CONFIDENCE
-    } else if (score > 0) {
-      confidence = LOW_CONFIDENCE
-    } else {
-      continue // Skip if no matches
-    }
-
-    if (confidence >= minConfidence) {
-      intents.push({
-        type: intentName as QueryIntent['type'],
-        confidence
-      })
-    }
-  }
-
-  // Sort by confidence descending
-  intents.sort((a, b) => b.confidence - a.confidence)
-
-  return intents
-}
-
-export class IntentClassifier {
-  classify(query: string): QueryIntent {
-    return classifyIntent(query)
-  }
-
-  hasIntent(query: string, intentType: QueryIntent['type']): boolean {
-    return hasIntent(query, intentType)
-  }
-
-  getIntents(query: string, minConfidence?: number): QueryIntent[] {
-    return getIntents(query, minConfidence)
-  }
-}
+/**
+ * Query Intent Classifier
+ * Rule-based intent detection for query understanding
+ */
+
+import type { QueryIntent } from '../types'
+
+/** Intent types and their indicators */
+const INTENT_PATTERNS: Record<string, { keywords: string[]; patterns: RegExp[] }> = {
+  factual: {
+    keywords: ['what', 'where', 'when', 'who', 'which', 'define', 'explain', 'describe'],
+    patterns: [
+      /^what\s+(is|are|was|were)\b/i,
+      /^how\s+does\b/i,
+      /^where\s+(is|are|can)\b/i,
+      /^when\s+(did|does|is|was)\b/i,
+      /^who\s+(is|are|was|were)\b/i
+    ]
+  },
+  decision: {
+    keywords: ['decide', 'chose', 'chosen', 'selected', 'picked', 'why did', 'reason', 'rationale'],
+    patterns: [
+      /why\s+(did|do|does|should)\s+(we|i|you)\s+(use|choose|pick|select)/i,
+      /what\s+(was|is)\s+the\s+(decision|choice|rationale)/i,
+      /why\s+(was|is|are)\s+\w+\s+(used|chosen|selected)/i,
+      /(decision|choice)\s+(for|about|regarding)/i
+    ]
+  },
+  pattern: {
+    keywords: ['pattern', 'best practice', 'approach', 'method', 'way to', 'how to', 'technique'],
+    patterns: [
+      /how\s+(do|should|can)\s+(we|i|you)\s+(implement|build|create|handle)/i,
+      /what('s|\s+is)\s+the\s+(best|recommended|correct)\s+(way|approach|method)/i,
+      /(pattern|practice)\s+for/i,
+      /how\s+to\s+\w+/i
+    ]
+  },
+  comparison: {
+    keywords: ['vs', 'versus', 'compare', 'comparison', 'difference', 'between', 'better', 'worse', 'prefer'],
+    patterns: [
+      /\w+\s+vs\.?\s+\w+/i,
+      /\w+\s+versus\s+\w+/i,
+      /(compare|comparison)\s+(between|of)/i,
+      /difference\s+between/i,
+      /which\s+(is|one)\s+(better|preferred|recommended)/i,
+      /should\s+(i|we)\s+use\s+\w+\s+or\s+\w+/i
+    ]
+  },
+  temporal: {
+    keywords: ['recent', 'latest', 'last', 'today', 'yesterday', 'week', 'month', 'ago', 'since', 'before', 'after'],
+    patterns: [
+      /(last|past)\s+(week|month|year|day)/i,
+      /\d+\s+(days?|weeks?|months?|years?)\s+ago/i,
+      /(recently|lately|today|yesterday)/i,
+      /since\s+\w+/i,
+      /before\s+\w+/i,
+      /after\s+\w+/i
+    ]
+  },
+  exploratory: {
+    keywords: ['any', 'all', 'list', 'show', 'find', 'search', 'look for', 'examples', 'related'],
+    patterns: [
+      /^(show|list|find|get)\s+(me\s+)?(all|any)/i,
+      /what\s+(are\s+)?(the\s+)?\w+\s+related\s+to/i,
+      /any\s+\w+\s+(about|related|for)/i,
+      /examples?\s+of/i
+    ]
+  }
+}
+
+/** Confidence thresholds */
+const HIGH_CONFIDENCE = 0.9
+const MEDIUM_CONFIDENCE = 0.7
+const LOW_CONFIDENCE = 0.5
+
+/**
+ * Classify the intent of a query
+ */
+export function classifyIntent(query: string): QueryIntent {
+  const startTime = Date.now()
+  const normalizedQuery = query.toLowerCase().trim()
+
+  // Track matches for each intent
+  const scores: Record<string, { score: number; matches: string[] }> = {}
+
+  for (const [intent, { keywords, patterns }] of Object.entries(INTENT_PATTERNS)) {
+    scores[intent] = { score: 0, matches: [] }
+
+    // Check keyword matches
+    for (const keyword of keywords) {
+      if (normalizedQuery.includes(keyword)) {
+        scores[intent].score += 0.3
+        scores[intent].matches.push(keyword)
+      }
+    }
+
+    // Check pattern matches (higher weight)
+    for (const pattern of patterns) {
+      if (pattern.test(normalizedQuery)) {
+        scores[intent].score += 0.5
+        scores[intent].matches.push(pattern.source)
+      }
+    }
+  }
+
+  // Find best matching intent
+  let bestIntent: string = 'exploratory' // Default
+  let bestScore = 0
+
+  for (const [intent, { score }] of Object.entries(scores)) {
+    if (score > bestScore) {
+      bestScore = score
+      bestIntent = intent
+    }
+  }
+
+  // Calculate confidence
+  let confidence: number
+  if (bestScore >= 0.8) {
+    confidence = HIGH_CONFIDENCE
+  } else if (bestScore >= 0.5) {
+    confidence = MEDIUM_CONFIDENCE
+  } else if (bestScore > 0) {
+    confidence = LOW_CONFIDENCE
+  } else {
+    confidence = 0.3 // Default low confidence for exploratory
+  }
+
+  // Extract additional metadata based on intent
+  const metadata: QueryIntent['metadata'] = {}
+
+  if (bestIntent === 'comparison') {
+    metadata.comparisonTerms = extractComparisonTerms(query)
+  }
+
+  const result: QueryIntent = {
+    type: bestIntent as QueryIntent['type'],
+    confidence,
+    metadata
+  }
+
+  // SLM Phase 1A: Log query classification for training data collection
+  try {
+    const { logTrainingData } = require('@/training/data-store')
+    logTrainingData({
+      task: 'query' as const,
+      input: query,
+      output: JSON.stringify({ label: result.type }),
+      metadata: JSON.stringify({ confidence, scores, elapsed_ms: Date.now() - startTime }),
+    })
+  } catch {
+    // Non-critical
+  }
+
+  return result
+}
+
+/**
+ * Extract comparison terms from a query
+ */
+function extractComparisonTerms(query: string): string[] {
+  const terms: string[] = []
+
+  // Match "X vs Y" patterns
+  const vsMatch = query.match(/(\w+)\s+(?:vs\.?|versus)\s+(\w+)/i)
+  if (vsMatch) {
+    terms.push(vsMatch[1]!, vsMatch[2]!)
+  }
+
+  // Match "X or Y" patterns
+  const orMatch = query.match(/(\w+)\s+or\s+(\w+)/i)
+  if (orMatch && terms.length === 0) {
+    terms.push(orMatch[1]!, orMatch[2]!)
+  }
+
+  // Match "between X and Y" patterns
+  const betweenMatch = query.match(/between\s+(\w+)\s+and\s+(\w+)/i)
+  if (betweenMatch && terms.length === 0) {
+    terms.push(betweenMatch[1]!, betweenMatch[2]!)
+  }
+
+  return terms
+}
+
+/**
+ * Check if query has a specific intent
+ */
+export function hasIntent(query: string, intentType: QueryIntent['type']): boolean {
+  const intent = classifyIntent(query)
+  return intent.type === intentType && intent.confidence >= MEDIUM_CONFIDENCE
+}
+
+/**
+ * Get all detected intents above a confidence threshold
+ */
+export function getIntents(query: string, minConfidence: number = LOW_CONFIDENCE): QueryIntent[] {
+  const normalizedQuery = query.toLowerCase().trim()
+  const intents: QueryIntent[] = []
+
+  for (const [intentName, { keywords, patterns }] of Object.entries(INTENT_PATTERNS)) {
+    let score = 0
+
+    for (const keyword of keywords) {
+      if (normalizedQuery.includes(keyword)) {
+        score += 0.3
+      }
+    }
+
+    for (const pattern of patterns) {
+      if (pattern.test(normalizedQuery)) {
+        score += 0.5
+      }
+    }
+
+    let confidence: number
+    if (score >= 0.8) {
+      confidence = HIGH_CONFIDENCE
+    } else if (score >= 0.5) {
+      confidence = MEDIUM_CONFIDENCE
+    } else if (score > 0) {
+      confidence = LOW_CONFIDENCE
+    } else {
+      continue // Skip if no matches
+    }
+
+    if (confidence >= minConfidence) {
+      intents.push({
+        type: intentName as QueryIntent['type'],
+        confidence
+      })
+    }
+  }
+
+  // Sort by confidence descending
+  intents.sort((a, b) => b.confidence - a.confidence)
+
+  return intents
+}
+
+export class IntentClassifier {
+  classify(query: string): QueryIntent {
+    return classifyIntent(query)
+  }
+
+  hasIntent(query: string, intentType: QueryIntent['type']): boolean {
+    return hasIntent(query, intentType)
+  }
+
+  getIntents(query: string, minConfidence?: number): QueryIntent[] {
+    return getIntents(query, minConfidence)
+  }
+}