claude-brain 0.30.2 → 0.30.3

package/src/memory/patterns.ts

@@ -1,438 +1,438 @@
-/**
- * Pattern Recognition System
- * Phase 12: Advanced Memory & Intelligent Automation
- *
- * Detects recurring patterns across projects and decisions
- */
-
-import type { Logger } from 'pino'
-import type { MemoryManager } from './index'
-import type { Decision as _Decision, MemorySearchResult as _MemorySearchResult } from './types'
-
-export interface Pattern {
-  id: string
-  type: 'solution' | 'anti-pattern' | 'best-practice' | 'common-issue'
-  description: string
-  occurrences: number
-  projects: string[]
-  examples: string[]
-  confidence: number
-  firstSeen: Date
-  lastSeen: Date
-}
-
-interface DecisionWithProject {
-  decision: string
-  reasoning?: string
-  project: string
-  timestamp: Date
-  tags?: string[]
-}
-
-export class PatternRecognizer {
-  private logger: Logger
-  private memory: MemoryManager
-  private patterns: Map<string, Pattern> = new Map()
-
-  /** SLM Upgrade: Optional inference router for model-based pattern classification */
-  private inferenceRouter: any = null
-
-  constructor(logger: Logger, memory: MemoryManager) {
-    this.logger = logger.child({ component: 'pattern-recognizer' })
-    this.memory = memory
-  }
-
-  /** SLM Upgrade: Set optional inference router */
-  setInferenceRouter(router: any): void {
-    this.inferenceRouter = router
-  }
-
-  /**
-   * Analyze all decisions to find patterns
-   */
-  async analyzePatterns(): Promise<Pattern[]> {
-    this.logger.info('Analyzing patterns across all projects')
-
-    try {
-      // Get all decisions from all projects
-      const allDecisions = await this.getAllDecisions()
-
-      if (allDecisions.length < 3) {
-        this.logger.info('Not enough decisions for pattern analysis')
-        return []
-      }
-
-      // Group by similarity
-      const clusters = await this.clusterDecisions(allDecisions)
-
-      // Extract patterns from clusters
-      const patterns = await this.extractPatterns(clusters)
-
-      // Store patterns
-      for (const pattern of patterns) {
-        this.patterns.set(pattern.id, pattern)
-      }
-
-      this.logger.info(
-        { patternCount: patterns.length },
-        'Pattern analysis complete'
-      )
-
-      return patterns
-    } catch (error) {
-      this.logger.error({ error }, 'Failed to analyze patterns')
-      return []
-    }
-  }
-
-  /**
-   * Get all decisions from all projects
-   */
-  private async getAllDecisions(): Promise<DecisionWithProject[]> {
-    const projects = this.memory.store.getProjects()
-    const allDecisions: DecisionWithProject[] = []
-
-    for (const project of projects) {
-      const decisions = this.memory.store.getProjectDecisions(project)
-
-      for (const decision of decisions) {
-        // Get associated memory for timestamp
-        const memory = this.memory.store.getMemory(decision.memoryId)
-
-        allDecisions.push({
-          decision: decision.decision,
-          reasoning: decision.reasoning,
-          project,
-          timestamp: memory?.createdAt || new Date(),
-          tags: decision.tags
-        })
-      }
-    }
-
-    return allDecisions
-  }
-
-  /**
-   * Cluster similar decisions together
-   */
-  private async clusterDecisions(decisions: DecisionWithProject[]): Promise<DecisionWithProject[][]> {
-    const clusters: DecisionWithProject[][] = []
-    const processed = new Set<number>()
-
-    for (let i = 0; i < decisions.length; i++) {
-      if (processed.has(i)) continue
-
-      const decision = decisions[i]
-      if (!decision) continue
-      const cluster: DecisionWithProject[] = [decision]
-      processed.add(i)
-
-      // Find similar decisions using semantic search
-      try {
-        const similar = await this.memory.searchRaw(
-          decision.decision,
-          {
-            limit: 10,
-            minSimilarity: 0.75
-          }
-        )
-
-        // Map similar results back to our decision array
-        for (const result of similar) {
-          if (result.decision) {
-            // Find matching decision in our array
-            for (let j = 0; j < decisions.length; j++) {
-              const candidate = decisions[j]
-              if (!processed.has(j) && candidate &&
-                  candidate.decision === result.decision.decision) {
-                cluster.push(candidate)
-                processed.add(j)
-              }
-            }
-          }
-        }
-      } catch (error) {
-        this.logger.warn({ error }, 'Error finding similar decisions')
-      }
-
-      // Only add cluster if it has enough items
-      if (cluster.length >= 3) {
-        clusters.push(cluster)
-      }
-    }
-
-    return clusters
-  }
-
-  /**
-   * Extract patterns from decision clusters
-   */
-  private async extractPatterns(clusters: DecisionWithProject[][]): Promise<Pattern[]> {
-    const patterns: Pattern[] = []
-
-    for (const cluster of clusters) {
-      const pattern = await this.analyzeCluster(cluster)
-
-      if (pattern) {
-        patterns.push(pattern)
-        // SLM Phase 1A: Log classification for training data
-        this._logPatternTraining(pattern.description, pattern.type)
-      }
-    }
-
-    return patterns
-  }
-
-  /**
-   * Analyze a cluster to find the common pattern
-   */
-  private async analyzeCluster(cluster: DecisionWithProject[]): Promise<Pattern | null> {
-    if (cluster.length < 3) return null
-
-    // Extract common keywords
-    const keywords = this.extractCommonKeywords(cluster)
-
-    if (keywords.length === 0) return null
-
-    // Determine pattern type — SLM model first, regex fallback
-    let type: Pattern['type']
-    if (this.inferenceRouter) {
-      try {
-        // Use representative text from cluster for model classification
-        const representative = cluster.slice(0, 3)
-          .map(d => d.decision + (d.reasoning ? ` ${d.reasoning}` : ''))
-          .join('. ')
-        type = await this.inferenceRouter.classifyPatternType(representative)
-      } catch {
-        type = this.determinePatternType(cluster)
-      }
-    } else {
-      type = this.determinePatternType(cluster)
-    }
-
-    // Create pattern description
-    const description = this.generatePatternDescription(keywords, type)
-
-    // Get unique projects
-    const projects = [...new Set(cluster.map(d => d.project))]
-
-    // Get timestamps
-    const timestamps = cluster.map(d => d.timestamp.getTime())
-
-    return {
-      id: this.generatePatternId(description),
-      type,
-      description,
-      occurrences: cluster.length,
-      projects,
-      examples: cluster.slice(0, 3).map(d => d.decision),
-      confidence: this.calculateConfidence(cluster),
-      firstSeen: new Date(Math.min(...timestamps)),
-      lastSeen: new Date(Math.max(...timestamps))
-    }
-  }
-
-  /**
-   * Extract common keywords from decisions
-   */
-  private extractCommonKeywords(decisions: DecisionWithProject[]): string[] {
-    const wordFreq: Map<string, number> = new Map()
-
-    // Stop words to filter out
-    const stopWords = new Set([
-      'the', 'a', 'an', 'and', 'or', 'but', 'in', 'on', 'at', 'to', 'for',
-      'of', 'with', 'by', 'from', 'as', 'is', 'was', 'are', 'were', 'been',
-      'be', 'have', 'has', 'had', 'do', 'does', 'did', 'will', 'would',
-      'could', 'should', 'may', 'might', 'must', 'shall', 'can', 'need',
-      'this', 'that', 'these', 'those', 'it', 'its', 'we', 'our', 'you',
-      'your', 'they', 'their', 'use', 'using', 'because', 'since'
-    ])
-
-    for (const decision of decisions) {
-      const words = decision.decision
-        .toLowerCase()
-        .split(/\W+/)
-        .filter(w => w.length > 4 && !stopWords.has(w))
-
-      for (const word of words) {
-        wordFreq.set(word, (wordFreq.get(word) || 0) + 1)
-      }
-    }
-
-    // Return top keywords that appear in multiple decisions
-    return Array.from(wordFreq.entries())
-      .filter(([_, count]) => count >= 2)
-      .sort((a, b) => b[1] - a[1])
-      .slice(0, 5)
-      .map(([word]) => word)
-  }
-
-  /**
-   * Determine pattern type from cluster
-   */
-  private determinePatternType(cluster: DecisionWithProject[]): Pattern['type'] {
-    // Check for anti-pattern indicators
-    const hasNegative = cluster.some(d => {
-      const text = (d.reasoning || '').toLowerCase()
-      return text.includes('avoid') ||
-             text.includes("don't") ||
-             text.includes('problem') ||
-             text.includes('mistake') ||
-             text.includes('bad')
-    })
-
-    if (hasNegative) return 'anti-pattern'
-
-    // Check for best practice indicators
-    const hasBestPractice = cluster.some(d => {
-      const text = (d.reasoning || '').toLowerCase()
-      return text.includes('best practice') ||
-             text.includes('recommended') ||
-             text.includes('standard') ||
-             d.tags?.includes('best-practice')
-    })
-
-    if (hasBestPractice) return 'best-practice'
-
-    // Check for issue indicators
-    const hasIssue = cluster.some(d => {
-      const text = (d.reasoning || '').toLowerCase()
-      return text.includes('issue') ||
-             text.includes('bug') ||
-             text.includes('fix')
-    })
-
-    if (hasIssue) return 'common-issue'
-
-    return 'solution'
-  }
-
-  /**
-   * SLM Phase 1A: Log pattern type classification for training data.
-   * Called from analyzeCluster when a pattern type is determined.
-   */
-  private _logPatternTraining(description: string, patternType: Pattern['type']): void {
-    try {
-      const { logTrainingData } = require('@/training/data-store')
-      logTrainingData({
-        task: 'pattern' as const,
-        input: description,
-        output: JSON.stringify({ label: patternType }),
-      })
-    } catch {
-      // Non-critical
-    }
-  }
-
-  /**
-   * Generate pattern description
-   */
-  private generatePatternDescription(keywords: string[], type: Pattern['type']): string {
-    const keywordPhrase = keywords.join(', ')
-
-    switch (type) {
-      case 'anti-pattern':
-        return `Avoid: ${keywordPhrase} - identified as anti-pattern`
-      case 'best-practice':
-        return `Best practice: ${keywordPhrase}`
-      case 'common-issue':
-        return `Common issue: ${keywordPhrase}`
-      case 'solution':
-      default:
-        return `Common solution: ${keywordPhrase}`
-    }
-  }
-
-  /**
-   * Calculate confidence score for pattern
-   */
-  private calculateConfidence(cluster: DecisionWithProject[]): number {
-    // More occurrences = higher confidence
-    // More projects = higher confidence
-    const projects = new Set(cluster.map(d => d.project))
-
-    const occurrenceScore = Math.min(cluster.length / 10, 1)
-    const projectScore = Math.min(projects.size / 5, 1)
-
-    return (occurrenceScore + projectScore) / 2
-  }
-
-  /**
-   * Generate unique ID for pattern
-   */
-  private generatePatternId(description: string): string {
-    return description
-      .toLowerCase()
-      .replace(/[^a-z0-9]+/g, '-')
-      .slice(0, 50)
-  }
-
-  /**
-   * Get patterns matching query
-   */
-  async getRelevantPatterns(query: string): Promise<Pattern[]> {
-    const allPatterns = Array.from(this.patterns.values())
-
-    if (allPatterns.length === 0) {
-      // Try to analyze patterns first
-      await this.analyzePatterns()
-    }
-
-    // Score patterns by relevance
-    const scored = Array.from(this.patterns.values()).map(pattern => ({
-      pattern,
-      score: this.scorePatternRelevance(pattern, query)
-    }))
-
-    // Return top patterns
-    return scored
-      .filter(p => p.score > 0.3)
-      .sort((a, b) => b.score - a.score)
-      .slice(0, 5)
-      .map(p => p.pattern)
-  }
-
-  /**
-   * Score pattern relevance to query
-   */
-  private scorePatternRelevance(pattern: Pattern, query: string): number {
-    const queryLower = query.toLowerCase()
-    const descLower = pattern.description.toLowerCase()
-
-    // Exact match
-    if (descLower.includes(queryLower)) return 1.0
-
-    // Word overlap
-    const queryWords = queryLower.split(/\W+/).filter(w => w.length > 2)
-    const descWords = descLower.split(/\W+/).filter(w => w.length > 2)
-
-    if (queryWords.length === 0) return 0
-
-    const overlap = queryWords.filter(w => descWords.includes(w)).length
-
-    return overlap / queryWords.length
-  }
-
-  /**
-   * Get all detected patterns
-   */
-  getAllPatterns(): Pattern[] {
-    return Array.from(this.patterns.values())
-  }
-
-  /**
-   * Get patterns by type
-   */
-  getPatternsByType(type: Pattern['type']): Pattern[] {
-    return Array.from(this.patterns.values())
-      .filter(p => p.type === type)
-  }
-
-  /**
-   * Clear all patterns (useful for re-analysis)
-   */
-  clearPatterns(): void {
-    this.patterns.clear()
-    this.logger.info('Patterns cleared')
-  }
-}
+/**
+ * Pattern Recognition System
+ * Phase 12: Advanced Memory & Intelligent Automation
+ *
+ * Detects recurring patterns across projects and decisions
+ */
+
+import type { Logger } from 'pino'
+import type { MemoryManager } from './index'
+import type { Decision as _Decision, MemorySearchResult as _MemorySearchResult } from './types'
+
+export interface Pattern {
+  id: string
+  type: 'solution' | 'anti-pattern' | 'best-practice' | 'common-issue'
+  description: string
+  occurrences: number
+  projects: string[]
+  examples: string[]
+  confidence: number
+  firstSeen: Date
+  lastSeen: Date
+}
+
+interface DecisionWithProject {
+  decision: string
+  reasoning?: string
+  project: string
+  timestamp: Date
+  tags?: string[]
+}
+
+export class PatternRecognizer {
+  private logger: Logger
+  private memory: MemoryManager
+  private patterns: Map<string, Pattern> = new Map()
+
+  /** SLM Upgrade: Optional inference router for model-based pattern classification */
+  private inferenceRouter: import('@/intelligence/inference-router').InferenceRouter | null = null
+
+  constructor(logger: Logger, memory: MemoryManager) {
+    this.logger = logger.child({ component: 'pattern-recognizer' })
+    this.memory = memory
+  }
+
+  /** SLM Upgrade: Set optional inference router */
+  setInferenceRouter(router: import('@/intelligence/inference-router').InferenceRouter): void {
+    this.inferenceRouter = router
+  }
+
+  /**
+   * Analyze all decisions to find patterns
+   */
+  async analyzePatterns(): Promise<Pattern[]> {
+    this.logger.info('Analyzing patterns across all projects')
+
+    try {
+      // Get all decisions from all projects
+      const allDecisions = await this.getAllDecisions()
+
+      if (allDecisions.length < 3) {
+        this.logger.info('Not enough decisions for pattern analysis')
+        return []
+      }
+
+      // Group by similarity
+      const clusters = await this.clusterDecisions(allDecisions)
+
+      // Extract patterns from clusters
+      const patterns = await this.extractPatterns(clusters)
+
+      // Store patterns
+      for (const pattern of patterns) {
+        this.patterns.set(pattern.id, pattern)
+      }
+
+      this.logger.info(
+        { patternCount: patterns.length },
+        'Pattern analysis complete'
+      )
+
+      return patterns
+    } catch (error) {
+      this.logger.error({ error }, 'Failed to analyze patterns')
+      return []
+    }
+  }
+
+  /**
+   * Get all decisions from all projects
+   */
+  private async getAllDecisions(): Promise<DecisionWithProject[]> {
+    const projects = this.memory.store.getProjects()
+    const allDecisions: DecisionWithProject[] = []
+
+    for (const project of projects) {
+      const decisions = this.memory.store.getProjectDecisions(project)
+
+      for (const decision of decisions) {
+        // Get associated memory for timestamp
+        const memory = this.memory.store.getMemory(decision.memoryId)
+
+        allDecisions.push({
+          decision: decision.decision,
+          reasoning: decision.reasoning,
+          project,
+          timestamp: memory?.createdAt || new Date(),
+          tags: decision.tags
+        })
+      }
+    }
+
+    return allDecisions
+  }
+
+  /**
+   * Cluster similar decisions together
+   */
+  private async clusterDecisions(decisions: DecisionWithProject[]): Promise<DecisionWithProject[][]> {
+    const clusters: DecisionWithProject[][] = []
+    const processed = new Set<number>()
+
+    for (let i = 0; i < decisions.length; i++) {
+      if (processed.has(i)) continue
+
+      const decision = decisions[i]
+      if (!decision) continue
+      const cluster: DecisionWithProject[] = [decision]
+      processed.add(i)
+
+      // Find similar decisions using semantic search
+      try {
+        const similar = await this.memory.searchRaw(
+          decision.decision,
+          {
+            limit: 10,
+            minSimilarity: 0.75
+          }
+        )
+
+        // Map similar results back to our decision array
+        for (const result of similar) {
+          if (result.decision) {
+            // Find matching decision in our array
+            for (let j = 0; j < decisions.length; j++) {
+              const candidate = decisions[j]
+              if (!processed.has(j) && candidate &&
+                  candidate.decision === result.decision.decision) {
+                cluster.push(candidate)
+                processed.add(j)
+              }
+            }
+          }
+        }
+      } catch (error) {
+        this.logger.warn({ error }, 'Error finding similar decisions')
+      }
+
+      // Only add cluster if it has enough items
+      if (cluster.length >= 3) {
+        clusters.push(cluster)
+      }
+    }
+
+    return clusters
+  }
+
+  /**
+   * Extract patterns from decision clusters
+   */
+  private async extractPatterns(clusters: DecisionWithProject[][]): Promise<Pattern[]> {
+    const patterns: Pattern[] = []
+
+    for (const cluster of clusters) {
+      const pattern = await this.analyzeCluster(cluster)
+
+      if (pattern) {
+        patterns.push(pattern)
+        // SLM Phase 1A: Log classification for training data
+        this._logPatternTraining(pattern.description, pattern.type)
+      }
+    }
+
+    return patterns
+  }
+
+  /**
+   * Analyze a cluster to find the common pattern
+   */
+  private async analyzeCluster(cluster: DecisionWithProject[]): Promise<Pattern | null> {
+    if (cluster.length < 3) return null
+
+    // Extract common keywords
+    const keywords = this.extractCommonKeywords(cluster)
+
+    if (keywords.length === 0) return null
+
+    // Determine pattern type — SLM model first, regex fallback
+    let type: Pattern['type']
+    if (this.inferenceRouter) {
+      try {
+        // Use representative text from cluster for model classification
+        const representative = cluster.slice(0, 3)
+          .map(d => d.decision + (d.reasoning ? ` ${d.reasoning}` : ''))
+          .join('. ')
+        type = await this.inferenceRouter.classifyPatternType(representative)
+      } catch {
+        type = this.determinePatternType(cluster)
+      }
+    } else {
+      type = this.determinePatternType(cluster)
+    }
+
+    // Create pattern description
+    const description = this.generatePatternDescription(keywords, type)
+
+    // Get unique projects
+    const projects = [...new Set(cluster.map(d => d.project))]
+
+    // Get timestamps
+    const timestamps = cluster.map(d => d.timestamp.getTime())
+
+    return {
+      id: this.generatePatternId(description),
+      type,
+      description,
+      occurrences: cluster.length,
+      projects,
+      examples: cluster.slice(0, 3).map(d => d.decision),
+      confidence: this.calculateConfidence(cluster),
+      firstSeen: new Date(Math.min(...timestamps)),
+      lastSeen: new Date(Math.max(...timestamps))
+    }
+  }
+
+  /**
+   * Extract common keywords from decisions
+   */
+  private extractCommonKeywords(decisions: DecisionWithProject[]): string[] {
+    const wordFreq: Map<string, number> = new Map()
+
+    // Stop words to filter out
+    const stopWords = new Set([
+      'the', 'a', 'an', 'and', 'or', 'but', 'in', 'on', 'at', 'to', 'for',
+      'of', 'with', 'by', 'from', 'as', 'is', 'was', 'are', 'were', 'been',
+      'be', 'have', 'has', 'had', 'do', 'does', 'did', 'will', 'would',
+      'could', 'should', 'may', 'might', 'must', 'shall', 'can', 'need',
+      'this', 'that', 'these', 'those', 'it', 'its', 'we', 'our', 'you',
+      'your', 'they', 'their', 'use', 'using', 'because', 'since'
+    ])
+
+    for (const decision of decisions) {
+      const words = decision.decision
+        .toLowerCase()
+        .split(/\W+/)
+        .filter(w => w.length > 4 && !stopWords.has(w))
+
+      for (const word of words) {
+        wordFreq.set(word, (wordFreq.get(word) || 0) + 1)
+      }
+    }
+
+    // Return top keywords that appear in multiple decisions
+    return Array.from(wordFreq.entries())
+      .filter(([_, count]) => count >= 2)
+      .sort((a, b) => b[1] - a[1])
+      .slice(0, 5)
+      .map(([word]) => word)
+  }
+
+  /**
+   * Determine pattern type from cluster
+   */
+  private determinePatternType(cluster: DecisionWithProject[]): Pattern['type'] {
+    // Check for anti-pattern indicators
+    const hasNegative = cluster.some(d => {
+      const text = (d.reasoning || '').toLowerCase()
+      return text.includes('avoid') ||
+             text.includes("don't") ||
+             text.includes('problem') ||
+             text.includes('mistake') ||
+             text.includes('bad')
+    })
+
+    if (hasNegative) return 'anti-pattern'
+
+    // Check for best practice indicators
+    const hasBestPractice = cluster.some(d => {
+      const text = (d.reasoning || '').toLowerCase()
+      return text.includes('best practice') ||
+             text.includes('recommended') ||
+             text.includes('standard') ||
+             d.tags?.includes('best-practice')
+    })
+
+    if (hasBestPractice) return 'best-practice'
+
+    // Check for issue indicators
+    const hasIssue = cluster.some(d => {
+      const text = (d.reasoning || '').toLowerCase()
+      return text.includes('issue') ||
+             text.includes('bug') ||
+             text.includes('fix')
+    })
+
+    if (hasIssue) return 'common-issue'
+
+    return 'solution'
+  }
+
+  /**
+   * SLM Phase 1A: Log pattern type classification for training data.
+   * Called from analyzeCluster when a pattern type is determined.
+   */
+  private _logPatternTraining(description: string, patternType: Pattern['type']): void {
+    try {
+      const { logTrainingData } = require('@/training/data-store')
+      logTrainingData({
+        task: 'pattern' as const,
+        input: description,
+        output: JSON.stringify({ label: patternType }),
+      })
+    } catch {
+      // Non-critical
+    }
+  }
+
+  /**
+   * Generate pattern description
+   */
+  private generatePatternDescription(keywords: string[], type: Pattern['type']): string {
+    const keywordPhrase = keywords.join(', ')
+
+    switch (type) {
+      case 'anti-pattern':
+        return `Avoid: ${keywordPhrase} - identified as anti-pattern`
+      case 'best-practice':
+        return `Best practice: ${keywordPhrase}`
+      case 'common-issue':
+        return `Common issue: ${keywordPhrase}`
+      case 'solution':
+      default:
+        return `Common solution: ${keywordPhrase}`
+    }
+  }
+
+  /**
+   * Calculate confidence score for pattern
+   */
+  private calculateConfidence(cluster: DecisionWithProject[]): number {
+    // More occurrences = higher confidence
+    // More projects = higher confidence
+    const projects = new Set(cluster.map(d => d.project))
+
+    const occurrenceScore = Math.min(cluster.length / 10, 1)
+    const projectScore = Math.min(projects.size / 5, 1)
+
+    return (occurrenceScore + projectScore) / 2
+  }
+
+  /**
+   * Generate unique ID for pattern
+   */
+  private generatePatternId(description: string): string {
+    return description
+      .toLowerCase()
+      .replace(/[^a-z0-9]+/g, '-')
+      .slice(0, 50)
+  }
+
+  /**
+   * Get patterns matching query
+   */
+  async getRelevantPatterns(query: string): Promise<Pattern[]> {
+    const allPatterns = Array.from(this.patterns.values())
+
+    if (allPatterns.length === 0) {
+      // Try to analyze patterns first
+      await this.analyzePatterns()
+    }
+
+    // Score patterns by relevance
+    const scored = Array.from(this.patterns.values()).map(pattern => ({
+      pattern,
+      score: this.scorePatternRelevance(pattern, query)
+    }))
+
+    // Return top patterns
+    return scored
+      .filter(p => p.score > 0.3)
+      .sort((a, b) => b.score - a.score)
+      .slice(0, 5)
+      .map(p => p.pattern)
+  }
+
+  /**
+   * Score pattern relevance to query
+   */
+  private scorePatternRelevance(pattern: Pattern, query: string): number {
+    const queryLower = query.toLowerCase()
+    const descLower = pattern.description.toLowerCase()
+
+    // Exact match
+    if (descLower.includes(queryLower)) return 1.0
+
+    // Word overlap
+    const queryWords = queryLower.split(/\W+/).filter(w => w.length > 2)
+    const descWords = descLower.split(/\W+/).filter(w => w.length > 2)
+
+    if (queryWords.length === 0) return 0
+
+    const overlap = queryWords.filter(w => descWords.includes(w)).length
+
+    return overlap / queryWords.length
+  }
+
+  /**
+   * Get all detected patterns
+   */
+  getAllPatterns(): Pattern[] {
+    return Array.from(this.patterns.values())
+  }
+
+  /**
+   * Get patterns by type
+   */
+  getPatternsByType(type: Pattern['type']): Pattern[] {
+    return Array.from(this.patterns.values())
+      .filter(p => p.type === type)
+  }
+
+  /**
+   * Clear all patterns (useful for re-analysis)
+   */
+  clearPatterns(): void {
+    this.patterns.clear()
+    this.logger.info('Patterns cleared')
+  }
+}