claude-brain 0.14.2 → 0.14.4

package/src/memory/knowledge-extractor.ts

@@ -1,455 +1,455 @@
-/**
- * Knowledge Extractor
- * Phase 12: Advanced Memory & Intelligent Automation
- *
- * Automatically extracts knowledge from conversations and stores it
- */
-
-import type { Logger } from 'pino'
-import type { MemoryManager } from './index'
-
-export interface ExtractedKnowledge {
-  id: string
-  type: 'fact' | 'preference' | 'constraint' | 'goal' | 'definition'
-  content: string
-  confidence: number
-  source: string
-  project?: string
-  timestamp: Date
-  metadata?: Record<string, unknown>
-}
-
-export interface ExtractionResult {
-  knowledge: ExtractedKnowledge[]
-  stored: number
-  skipped: number
-}
-
-export class KnowledgeExtractor {
-  private logger: Logger
-  private memory: MemoryManager
-
-  // Pattern definitions for different knowledge types
-  private readonly FACT_PATTERNS = [
-    /(\w+(?:\s+\w+)*)\s+is\s+(?:a\s+)?(\w+(?:\s+\w+)*)/gi,
-    /(\w+(?:\s+\w+)*)\s+uses?\s+(\w+(?:\s+\w+)*)/gi,
-    /(\w+(?:\s+\w+)*)\s+requires?\s+(\w+(?:\s+\w+)*)/gi,
-    /(\w+(?:\s+\w+)*)\s+depends?\s+on\s+(\w+(?:\s+\w+)*)/gi,
-    /(\w+(?:\s+\w+)*)\s+contains?\s+(\w+(?:\s+\w+)*)/gi
-  ]
-
-  private readonly PREFERENCE_PATTERNS = [
-    /prefer(?:s)?\s+(?:to\s+)?(?:use\s+)?(\w+(?:\s+\w+)*)/gi,
-    /like(?:s)?\s+(?:to\s+)?(?:use\s+)?(\w+(?:\s+\w+)*)/gi,
-    /always\s+use(?:s)?\s+(\w+(?:\s+\w+)*)/gi,
-    /should\s+use\s+(\w+(?:\s+\w+)*)/gi,
-    /better\s+to\s+use\s+(\w+(?:\s+\w+)*)/gi,
-    /recommend(?:s)?\s+(\w+(?:\s+\w+)*)/gi
-  ]
-
-  private readonly CONSTRAINT_PATTERNS = [
-    /must\s+(?:not\s+)?(\w+(?:\s+\w+)*)/gi,
-    /cannot\s+(\w+(?:\s+\w+)*)/gi,
-    /required\s+to\s+(\w+(?:\s+\w+)*)/gi,
-    /not\s+allowed\s+to\s+(\w+(?:\s+\w+)*)/gi,
-    /never\s+(\w+(?:\s+\w+)*)/gi,
-    /forbidden\s+to\s+(\w+(?:\s+\w+)*)/gi,
-    /(?:it'?s\s+)?mandatory\s+(?:to\s+)?(\w+(?:\s+\w+)*)/gi
-  ]
-
-  private readonly GOAL_PATTERNS = [
-    /(?:want|need)\s+to\s+(\w+(?:\s+\w+)*)/gi,
-    /goal\s+is\s+to\s+(\w+(?:\s+\w+)*)/gi,
-    /aim(?:s)?\s+to\s+(\w+(?:\s+\w+)*)/gi,
-    /objective\s+is\s+to\s+(\w+(?:\s+\w+)*)/gi,
-    /plan(?:ning)?\s+to\s+(\w+(?:\s+\w+)*)/gi,
-    /intend(?:s)?\s+to\s+(\w+(?:\s+\w+)*)/gi
-  ]
-
-  private readonly DEFINITION_PATTERNS = [
-    /(\w+(?:\s+\w+)*)\s+(?:is\s+)?defined\s+as\s+(\w+(?:\s+\w+)*)/gi,
-    /(\w+(?:\s+\w+)*)\s+means\s+(\w+(?:\s+\w+)*)/gi,
-    /(?:by\s+)?(\w+(?:\s+\w+)*)\s+(?:we\s+)?mean\s+(\w+(?:\s+\w+)*)/gi
-  ]
-
-  constructor(logger: Logger, memory: MemoryManager) {
-    this.logger = logger.child({ component: 'knowledge-extractor' })
-    this.memory = memory
-  }
-
-  /**
-   * Extract knowledge from conversation text
-   */
-  async extractFromConversation(
-    text: string,
-    project?: string
-  ): Promise<ExtractionResult> {
-    const knowledge: ExtractedKnowledge[] = []
-
-    // Skip very short text
-    if (text.length < 20) {
-      return { knowledge: [], stored: 0, skipped: 0 }
-    }
-
-    // Extract different types of knowledge
-    knowledge.push(...this.extractFacts(text, project))
-    knowledge.push(...this.extractPreferences(text, project))
-    knowledge.push(...this.extractConstraints(text, project))
-    knowledge.push(...this.extractGoals(text, project))
-    knowledge.push(...this.extractDefinitions(text, project))
-
-    // Deduplicate by content
-    const uniqueKnowledge = this.deduplicateKnowledge(knowledge)
-
-    // Store high-confidence knowledge
-    let stored = 0
-    let skipped = 0
-
-    for (const item of uniqueKnowledge) {
-      if (item.confidence >= 0.6) {
-        const success = await this.storeKnowledge(item)
-        if (success) {
-          stored++
-        } else {
-          skipped++
-        }
-      } else {
-        skipped++
-      }
-    }
-
-    this.logger.info(
-      { extractedCount: uniqueKnowledge.length, stored, skipped },
-      'Knowledge extracted from conversation'
-    )
-
-    return { knowledge: uniqueKnowledge, stored, skipped }
-  }
-
-  /**
-   * Extract factual statements
-   */
-  private extractFacts(text: string, project?: string): ExtractedKnowledge[] {
-    const facts: ExtractedKnowledge[] = []
-
-    for (const pattern of this.FACT_PATTERNS) {
-      // Reset pattern state
-      pattern.lastIndex = 0
-
-      let match
-      while ((match = pattern.exec(text)) !== null) {
-        const content = match[0].trim()
-
-        // Skip very short or very long matches
-        if (content.length < 10 || content.length > 200) continue
-
-        // Skip matches that are too generic
-        if (this.isGenericMatch(content)) continue
-
-        facts.push({
-          id: this.generateId(),
-          type: 'fact',
-          content,
-          confidence: this.calculateConfidence(content, 'fact'),
-          source: 'pattern-match',
-          project,
-          timestamp: new Date()
-        })
-      }
-    }
-
-    return facts
-  }
-
-  /**
-   * Extract user preferences
-   */
-  private extractPreferences(text: string, project?: string): ExtractedKnowledge[] {
-    const preferences: ExtractedKnowledge[] = []
-
-    for (const pattern of this.PREFERENCE_PATTERNS) {
-      pattern.lastIndex = 0
-
-      let match
-      while ((match = pattern.exec(text)) !== null) {
-        const content = match[0].trim()
-
-        if (content.length < 10 || content.length > 200) continue
-        if (this.isGenericMatch(content)) continue
-
-        preferences.push({
-          id: this.generateId(),
-          type: 'preference',
-          content,
-          confidence: this.calculateConfidence(content, 'preference'),
-          source: 'preference-pattern',
-          project,
-          timestamp: new Date()
-        })
-      }
-    }
-
-    return preferences
-  }
-
-  /**
-   * Extract constraints
-   */
-  private extractConstraints(text: string, project?: string): ExtractedKnowledge[] {
-    const constraints: ExtractedKnowledge[] = []
-
-    for (const pattern of this.CONSTRAINT_PATTERNS) {
-      pattern.lastIndex = 0
-
-      let match
-      while ((match = pattern.exec(text)) !== null) {
-        const content = match[0].trim()
-
-        if (content.length < 8 || content.length > 200) continue
-        if (this.isGenericMatch(content)) continue
-
-        constraints.push({
-          id: this.generateId(),
-          type: 'constraint',
-          content,
-          confidence: this.calculateConfidence(content, 'constraint'),
-          source: 'constraint-pattern',
-          project,
-          timestamp: new Date()
-        })
-      }
-    }
-
-    return constraints
-  }
-
-  /**
-   * Extract goals
-   */
-  private extractGoals(text: string, project?: string): ExtractedKnowledge[] {
-    const goals: ExtractedKnowledge[] = []
-
-    for (const pattern of this.GOAL_PATTERNS) {
-      pattern.lastIndex = 0
-
-      let match
-      while ((match = pattern.exec(text)) !== null) {
-        const content = match[0].trim()
-
-        if (content.length < 10 || content.length > 200) continue
-        if (this.isGenericMatch(content)) continue
-
-        goals.push({
-          id: this.generateId(),
-          type: 'goal',
-          content,
-          confidence: this.calculateConfidence(content, 'goal'),
-          source: 'goal-pattern',
-          project,
-          timestamp: new Date()
-        })
-      }
-    }
-
-    return goals
-  }
-
-  /**
-   * Extract definitions
-   */
-  private extractDefinitions(text: string, project?: string): ExtractedKnowledge[] {
-    const definitions: ExtractedKnowledge[] = []
-
-    for (const pattern of this.DEFINITION_PATTERNS) {
-      pattern.lastIndex = 0
-
-      let match
-      while ((match = pattern.exec(text)) !== null) {
-        const content = match[0].trim()
-
-        if (content.length < 10 || content.length > 200) continue
-        if (this.isGenericMatch(content)) continue
-
-        definitions.push({
-          id: this.generateId(),
-          type: 'definition',
-          content,
-          confidence: this.calculateConfidence(content, 'definition'),
-          source: 'definition-pattern',
-          project,
-          timestamp: new Date()
-        })
-      }
-    }
-
-    return definitions
-  }
-
-  /**
-   * Check if match is too generic
-   */
-  private isGenericMatch(content: string): boolean {
-    const genericWords = new Set([
-      'it', 'this', 'that', 'thing', 'stuff', 'something',
-      'anything', 'everything', 'nothing'
-    ])
-
-    const words = content.toLowerCase().split(/\W+/).filter(w => w.length > 0)
-
-    // If most words are generic, skip
-    const genericCount = words.filter(w => genericWords.has(w)).length
-    return genericCount > words.length / 2
-  }
-
-  /**
-   * Calculate confidence score for extracted knowledge
-   */
-  private calculateConfidence(content: string, type: ExtractedKnowledge['type']): number {
-    let confidence = 0.5 // Base confidence
-
-    // Longer content = slightly higher confidence
-    if (content.length > 30) confidence += 0.1
-    if (content.length > 50) confidence += 0.05
-
-    // Type-specific adjustments
-    switch (type) {
-      case 'constraint':
-        // Constraints are usually clear
-        confidence += 0.2
-        break
-      case 'preference':
-        // Preferences have moderate confidence
-        confidence += 0.15
-        break
-      case 'definition':
-        // Definitions are usually precise
-        confidence += 0.2
-        break
-      case 'goal':
-        // Goals are intentional statements
-        confidence += 0.1
-        break
-      case 'fact':
-        // Facts need verification
-        confidence += 0.05
-        break
-    }
-
-    // Check for strong language
-    const strongIndicators = ['always', 'never', 'must', 'required', 'mandatory']
-    const hasStrong = strongIndicators.some(ind =>
-      content.toLowerCase().includes(ind)
-    )
-    if (hasStrong) confidence += 0.1
-
-    return Math.min(confidence, 1.0)
-  }
-
-  /**
-   * Deduplicate knowledge by content similarity
-   */
-  private deduplicateKnowledge(knowledge: ExtractedKnowledge[]): ExtractedKnowledge[] {
-    const seen = new Set<string>()
-    const unique: ExtractedKnowledge[] = []
-
-    for (const item of knowledge) {
-      // Normalize content for comparison
-      const normalized = item.content.toLowerCase().replace(/\s+/g, ' ').trim()
-
-      if (!seen.has(normalized)) {
-        seen.add(normalized)
-        unique.push(item)
-      }
-    }
-
-    return unique
-  }
-
-  /**
-   * Store extracted knowledge
-   */
-  private async storeKnowledge(knowledge: ExtractedKnowledge): Promise<boolean> {
-    try {
-      await this.memory.store.storeMemory({
-        project: knowledge.project || 'global',
-        content: `[${knowledge.type.toUpperCase()}] ${knowledge.content}`,
-        metadata: {
-          type: 'extracted-knowledge',
-          knowledgeType: knowledge.type,
-          confidence: knowledge.confidence,
-          source: knowledge.source
-        }
-      })
-      return true
-    } catch (error) {
-      this.logger.warn(
-        { error, knowledgeId: knowledge.id },
-        'Failed to store extracted knowledge'
-      )
-      return false
-    }
-  }
-
-  /**
-   * Extract knowledge from multiple texts (batch processing)
-   */
-  async extractFromMultiple(
-    texts: Array<{ text: string; project?: string }>
-  ): Promise<ExtractionResult> {
-    const allKnowledge: ExtractedKnowledge[] = []
-    let totalStored = 0
-    let totalSkipped = 0
-
-    for (const { text, project } of texts) {
-      const result = await this.extractFromConversation(text, project)
-      allKnowledge.push(...result.knowledge)
-      totalStored += result.stored
-      totalSkipped += result.skipped
-    }
-
-    return {
-      knowledge: allKnowledge,
-      stored: totalStored,
-      skipped: totalSkipped
-    }
-  }
-
-  /**
-   * Get knowledge by type
-   */
-  async getKnowledgeByType(
-    type: ExtractedKnowledge['type'],
-    project?: string,
-    limit: number = 10
-  ): Promise<ExtractedKnowledge[]> {
-    try {
-      const results = await this.memory.searchRaw(
-        `[${type.toUpperCase()}]`,
-        {
-          project,
-          limit,
-          minSimilarity: 0.3
-        }
-      )
-
-      return results
-        .filter(r => r.memory.metadata?.knowledgeType === type)
-        .map(r => ({
-          id: r.memory.id,
-          type: r.memory.metadata?.knowledgeType as ExtractedKnowledge['type'],
-          content: r.memory.content.replace(/^\[\w+\]\s*/, ''),
-          confidence: r.memory.metadata?.confidence as number || 0,
-          source: r.memory.metadata?.source as string || 'unknown',
-          project: r.memory.project,
-          timestamp: r.memory.createdAt
-        }))
-    } catch (error) {
-      this.logger.error({ error, type, project }, 'Failed to get knowledge by type')
-      return []
-    }
-  }
-
-  private generateId(): string {
-    return `knowledge-${Date.now()}-${Math.random().toString(36).substring(2, 11)}`
-  }
-}
+/**
+ * Knowledge Extractor
+ * Phase 12: Advanced Memory & Intelligent Automation
+ *
+ * Automatically extracts knowledge from conversations and stores it
+ */
+
+import type { Logger } from 'pino'
+import type { MemoryManager } from './index'
+
+export interface ExtractedKnowledge {
+  id: string
+  type: 'fact' | 'preference' | 'constraint' | 'goal' | 'definition'
+  content: string
+  confidence: number
+  source: string
+  project?: string
+  timestamp: Date
+  metadata?: Record<string, unknown>
+}
+
+export interface ExtractionResult {
+  knowledge: ExtractedKnowledge[]
+  stored: number
+  skipped: number
+}
+
+export class KnowledgeExtractor {
+  private logger: Logger
+  private memory: MemoryManager
+
+  // Pattern definitions for different knowledge types
+  private readonly FACT_PATTERNS = [
+    /(\w+(?:\s+\w+)*)\s+is\s+(?:a\s+)?(\w+(?:\s+\w+)*)/gi,
+    /(\w+(?:\s+\w+)*)\s+uses?\s+(\w+(?:\s+\w+)*)/gi,
+    /(\w+(?:\s+\w+)*)\s+requires?\s+(\w+(?:\s+\w+)*)/gi,
+    /(\w+(?:\s+\w+)*)\s+depends?\s+on\s+(\w+(?:\s+\w+)*)/gi,
+    /(\w+(?:\s+\w+)*)\s+contains?\s+(\w+(?:\s+\w+)*)/gi
+  ]
+
+  private readonly PREFERENCE_PATTERNS = [
+    /prefer(?:s)?\s+(?:to\s+)?(?:use\s+)?(\w+(?:\s+\w+)*)/gi,
+    /like(?:s)?\s+(?:to\s+)?(?:use\s+)?(\w+(?:\s+\w+)*)/gi,
+    /always\s+use(?:s)?\s+(\w+(?:\s+\w+)*)/gi,
+    /should\s+use\s+(\w+(?:\s+\w+)*)/gi,
+    /better\s+to\s+use\s+(\w+(?:\s+\w+)*)/gi,
+    /recommend(?:s)?\s+(\w+(?:\s+\w+)*)/gi
+  ]
+
+  private readonly CONSTRAINT_PATTERNS = [
+    /must\s+(?:not\s+)?(\w+(?:\s+\w+)*)/gi,
+    /cannot\s+(\w+(?:\s+\w+)*)/gi,
+    /required\s+to\s+(\w+(?:\s+\w+)*)/gi,
+    /not\s+allowed\s+to\s+(\w+(?:\s+\w+)*)/gi,
+    /never\s+(\w+(?:\s+\w+)*)/gi,
+    /forbidden\s+to\s+(\w+(?:\s+\w+)*)/gi,
+    /(?:it'?s\s+)?mandatory\s+(?:to\s+)?(\w+(?:\s+\w+)*)/gi
+  ]
+
+  private readonly GOAL_PATTERNS = [
+    /(?:want|need)\s+to\s+(\w+(?:\s+\w+)*)/gi,
+    /goal\s+is\s+to\s+(\w+(?:\s+\w+)*)/gi,
+    /aim(?:s)?\s+to\s+(\w+(?:\s+\w+)*)/gi,
+    /objective\s+is\s+to\s+(\w+(?:\s+\w+)*)/gi,
+    /plan(?:ning)?\s+to\s+(\w+(?:\s+\w+)*)/gi,
+    /intend(?:s)?\s+to\s+(\w+(?:\s+\w+)*)/gi
+  ]
+
+  private readonly DEFINITION_PATTERNS = [
+    /(\w+(?:\s+\w+)*)\s+(?:is\s+)?defined\s+as\s+(\w+(?:\s+\w+)*)/gi,
+    /(\w+(?:\s+\w+)*)\s+means\s+(\w+(?:\s+\w+)*)/gi,
+    /(?:by\s+)?(\w+(?:\s+\w+)*)\s+(?:we\s+)?mean\s+(\w+(?:\s+\w+)*)/gi
+  ]
+
+  constructor(logger: Logger, memory: MemoryManager) {
+    this.logger = logger.child({ component: 'knowledge-extractor' })
+    this.memory = memory
+  }
+
+  /**
+   * Extract knowledge from conversation text
+   */
+  async extractFromConversation(
+    text: string,
+    project?: string
+  ): Promise<ExtractionResult> {
+    const knowledge: ExtractedKnowledge[] = []
+
+    // Skip very short text
+    if (text.length < 20) {
+      return { knowledge: [], stored: 0, skipped: 0 }
+    }
+
+    // Extract different types of knowledge
+    knowledge.push(...this.extractFacts(text, project))
+    knowledge.push(...this.extractPreferences(text, project))
+    knowledge.push(...this.extractConstraints(text, project))
+    knowledge.push(...this.extractGoals(text, project))
+    knowledge.push(...this.extractDefinitions(text, project))
+
+    // Deduplicate by content
+    const uniqueKnowledge = this.deduplicateKnowledge(knowledge)
+
+    // Store high-confidence knowledge
+    let stored = 0
+    let skipped = 0
+
+    for (const item of uniqueKnowledge) {
+      if (item.confidence >= 0.6) {
+        const success = await this.storeKnowledge(item)
+        if (success) {
+          stored++
+        } else {
+          skipped++
+        }
+      } else {
+        skipped++
+      }
+    }
+
+    this.logger.info(
+      { extractedCount: uniqueKnowledge.length, stored, skipped },
+      'Knowledge extracted from conversation'
+    )
+
+    return { knowledge: uniqueKnowledge, stored, skipped }
+  }
+
+  /**
+   * Extract factual statements
+   */
+  private extractFacts(text: string, project?: string): ExtractedKnowledge[] {
+    const facts: ExtractedKnowledge[] = []
+
+    for (const pattern of this.FACT_PATTERNS) {
+      // Reset pattern state
+      pattern.lastIndex = 0
+
+      let match
+      while ((match = pattern.exec(text)) !== null) {
+        const content = match[0].trim()
+
+        // Skip very short or very long matches
+        if (content.length < 10 || content.length > 200) continue
+
+        // Skip matches that are too generic
+        if (this.isGenericMatch(content)) continue
+
+        facts.push({
+          id: this.generateId(),
+          type: 'fact',
+          content,
+          confidence: this.calculateConfidence(content, 'fact'),
+          source: 'pattern-match',
+          project,
+          timestamp: new Date()
+        })
+      }
+    }
+
+    return facts
+  }
+
+  /**
+   * Extract user preferences
+   */
+  private extractPreferences(text: string, project?: string): ExtractedKnowledge[] {
+    const preferences: ExtractedKnowledge[] = []
+
+    for (const pattern of this.PREFERENCE_PATTERNS) {
+      pattern.lastIndex = 0
+
+      let match
+      while ((match = pattern.exec(text)) !== null) {
+        const content = match[0].trim()
+
+        if (content.length < 10 || content.length > 200) continue
+        if (this.isGenericMatch(content)) continue
+
+        preferences.push({
+          id: this.generateId(),
+          type: 'preference',
+          content,
+          confidence: this.calculateConfidence(content, 'preference'),
+          source: 'preference-pattern',
+          project,
+          timestamp: new Date()
+        })
+      }
+    }
+
+    return preferences
+  }
+
+  /**
+   * Extract constraints
+   */
+  private extractConstraints(text: string, project?: string): ExtractedKnowledge[] {
+    const constraints: ExtractedKnowledge[] = []
+
+    for (const pattern of this.CONSTRAINT_PATTERNS) {
+      pattern.lastIndex = 0
+
+      let match
+      while ((match = pattern.exec(text)) !== null) {
+        const content = match[0].trim()
+
+        if (content.length < 8 || content.length > 200) continue
+        if (this.isGenericMatch(content)) continue
+
+        constraints.push({
+          id: this.generateId(),
+          type: 'constraint',
+          content,
+          confidence: this.calculateConfidence(content, 'constraint'),
+          source: 'constraint-pattern',
+          project,
+          timestamp: new Date()
+        })
+      }
+    }
+
+    return constraints
+  }
+
+  /**
+   * Extract goals
+   */
+  private extractGoals(text: string, project?: string): ExtractedKnowledge[] {
+    const goals: ExtractedKnowledge[] = []
+
+    for (const pattern of this.GOAL_PATTERNS) {
+      pattern.lastIndex = 0
+
+      let match
+      while ((match = pattern.exec(text)) !== null) {
+        const content = match[0].trim()
+
+        if (content.length < 10 || content.length > 200) continue
+        if (this.isGenericMatch(content)) continue
+
+        goals.push({
+          id: this.generateId(),
+          type: 'goal',
+          content,
+          confidence: this.calculateConfidence(content, 'goal'),
+          source: 'goal-pattern',
+          project,
+          timestamp: new Date()
+        })
+      }
+    }
+
+    return goals
+  }
+
+  /**
+   * Extract definitions
+   */
+  private extractDefinitions(text: string, project?: string): ExtractedKnowledge[] {
+    const definitions: ExtractedKnowledge[] = []
+
+    for (const pattern of this.DEFINITION_PATTERNS) {
+      pattern.lastIndex = 0
+
+      let match
+      while ((match = pattern.exec(text)) !== null) {
+        const content = match[0].trim()
+
+        if (content.length < 10 || content.length > 200) continue
+        if (this.isGenericMatch(content)) continue
+
+        definitions.push({
+          id: this.generateId(),
+          type: 'definition',
+          content,
+          confidence: this.calculateConfidence(content, 'definition'),
+          source: 'definition-pattern',
+          project,
+          timestamp: new Date()
+        })
+      }
+    }
+
+    return definitions
+  }
+
+  /**
+   * Check if match is too generic
+   */
+  private isGenericMatch(content: string): boolean {
+    const genericWords = new Set([
+      'it', 'this', 'that', 'thing', 'stuff', 'something',
+      'anything', 'everything', 'nothing'
+    ])
+
+    const words = content.toLowerCase().split(/\W+/).filter(w => w.length > 0)
+
+    // If most words are generic, skip
+    const genericCount = words.filter(w => genericWords.has(w)).length
+    return genericCount > words.length / 2
+  }
+
+  /**
+   * Calculate confidence score for extracted knowledge
+   */
+  private calculateConfidence(content: string, type: ExtractedKnowledge['type']): number {
+    let confidence = 0.5 // Base confidence
+
+    // Longer content = slightly higher confidence
+    if (content.length > 30) confidence += 0.1
+    if (content.length > 50) confidence += 0.05
+
+    // Type-specific adjustments
+    switch (type) {
+      case 'constraint':
+        // Constraints are usually clear
+        confidence += 0.2
+        break
+      case 'preference':
+        // Preferences have moderate confidence
+        confidence += 0.15
+        break
+      case 'definition':
+        // Definitions are usually precise
+        confidence += 0.2
+        break
+      case 'goal':
+        // Goals are intentional statements
+        confidence += 0.1
+        break
+      case 'fact':
+        // Facts need verification
+        confidence += 0.05
+        break
+    }
+
+    // Check for strong language
+    const strongIndicators = ['always', 'never', 'must', 'required', 'mandatory']
+    const hasStrong = strongIndicators.some(ind =>
+      content.toLowerCase().includes(ind)
+    )
+    if (hasStrong) confidence += 0.1
+
+    return Math.min(confidence, 1.0)
+  }
+
+  /**
+   * Deduplicate knowledge by content similarity
+   */
+  private deduplicateKnowledge(knowledge: ExtractedKnowledge[]): ExtractedKnowledge[] {
+    const seen = new Set<string>()
+    const unique: ExtractedKnowledge[] = []
+
+    for (const item of knowledge) {
+      // Normalize content for comparison
+      const normalized = item.content.toLowerCase().replace(/\s+/g, ' ').trim()
+
+      if (!seen.has(normalized)) {
+        seen.add(normalized)
+        unique.push(item)
+      }
+    }
+
+    return unique
+  }
+
+  /**
+   * Store extracted knowledge
+   */
+  private async storeKnowledge(knowledge: ExtractedKnowledge): Promise<boolean> {
+    try {
+      await this.memory.store.storeMemory({
+        project: knowledge.project || 'global',
+        content: `[${knowledge.type.toUpperCase()}] ${knowledge.content}`,
+        metadata: {
+          type: 'extracted-knowledge',
+          knowledgeType: knowledge.type,
+          confidence: knowledge.confidence,
+          source: knowledge.source
+        }
+      })
+      return true
+    } catch (error) {
+      this.logger.warn(
+        { error, knowledgeId: knowledge.id },
+        'Failed to store extracted knowledge'
+      )
+      return false
+    }
+  }
+
+  /**
+   * Extract knowledge from multiple texts (batch processing)
+   */
+  async extractFromMultiple(
+    texts: Array<{ text: string; project?: string }>
+  ): Promise<ExtractionResult> {
+    const allKnowledge: ExtractedKnowledge[] = []
+    let totalStored = 0
+    let totalSkipped = 0
+
+    for (const { text, project } of texts) {
+      const result = await this.extractFromConversation(text, project)
+      allKnowledge.push(...result.knowledge)
+      totalStored += result.stored
+      totalSkipped += result.skipped
+    }
+
+    return {
+      knowledge: allKnowledge,
+      stored: totalStored,
+      skipped: totalSkipped
+    }
+  }
+
+  /**
+   * Get knowledge by type
+   */
+  async getKnowledgeByType(
+    type: ExtractedKnowledge['type'],
+    project?: string,
+    limit: number = 10
+  ): Promise<ExtractedKnowledge[]> {
+    try {
+      const results = await this.memory.searchRaw(
+        `[${type.toUpperCase()}]`,
+        {
+          project,
+          limit,
+          minSimilarity: 0.3
+        }
+      )
+
+      return results
+        .filter(r => r.memory.metadata?.knowledgeType === type)
+        .map(r => ({
+          id: r.memory.id,
+          type: r.memory.metadata?.knowledgeType as ExtractedKnowledge['type'],
+          content: r.memory.content.replace(/^\[\w+\]\s*/, ''),
+          confidence: r.memory.metadata?.confidence as number || 0,
+          source: r.memory.metadata?.source as string || 'unknown',
+          project: r.memory.project,
+          timestamp: r.memory.createdAt
+        }))
+    } catch (error) {
+      this.logger.error({ error, type, project }, 'Failed to get knowledge by type')
+      return []
+    }
+  }
+
+  private generateId(): string {
+    return `knowledge-${Date.now()}-${Math.random().toString(36).substring(2, 11)}`
+  }
+}