claude-brain 0.14.2 → 0.14.4

package/src/orchestrator/handlers/decision-handler.ts

@@ -1,204 +1,204 @@
-/**
- * DecisionDetectionHandler - Auto-detects and stores decisions from decisions.md files
- */
-
-import type { Logger } from 'pino'
-import type { Event, EventType, EventPriority } from '../types'
-import type { VaultReader } from '@/vault'
-import type { MemoryManager } from '@/memory'
-import { BaseHandler } from './base-handler'
-import type { EventBus } from '../event-emitter'
-
-export interface ExtractedDecision {
-  context: string
-  decision: string
-  reasoning: string
-  alternatives?: string
-  tags?: string[]
-}
-
-export class DecisionDetectionHandler extends BaseHandler {
-  name = 'decision-detection-handler'
-  types: EventType[] = ['file:modified']
-  priority: EventPriority = 'high'
-
-  private vaultReader: VaultReader
-  private memory: MemoryManager
-  private lastProcessed: Map<string, Date>
-  private eventBus: EventBus | null = null
-  private debounceMs: number
-
-  constructor(
-    logger: Logger,
-    vaultReader: VaultReader,
-    memory: MemoryManager,
-    debounceMs: number = 5000
-  ) {
-    super(logger)
-    this.initLogger(logger)
-    this.vaultReader = vaultReader
-    this.memory = memory
-    this.lastProcessed = new Map()
-    this.debounceMs = debounceMs
-  }
-
-  /**
-   * Set the event bus for emitting decision events
-   */
-  setEventBus(eventBus: EventBus): void {
-    this.eventBus = eventBus
-  }
-
-  async handle(event: Event): Promise<void> {
-    this.logHandling(event)
-
-    const filePath = event.payload.path as string
-
-    // Only process decisions.md files
-    if (!this.shouldHandleFile(filePath, ['decisions.md'])) {
-      return
-    }
-
-    try {
-      // Check if we've processed recently (debounce)
-      const lastTime = this.lastProcessed.get(filePath)
-      if (lastTime && Date.now() - lastTime.getTime() < this.debounceMs) {
-        this.logger.debug({ filePath }, 'Debounced, skipping')
-        return
-      }
-
-      const file = await this.vaultReader.readMarkdownFile(filePath, false)
-      const project = file.frontmatter.project as string | undefined
-
-      if (!project) {
-        this.logger.warn({ filePath }, 'No project in frontmatter, skipping')
-        return
-      }
-
-      // Extract new decisions from content
-      const decisions = this.extractDecisions(file.content)
-
-      if (decisions.length === 0) {
-        return
-      }
-
-      let storedCount = 0
-      for (const decision of decisions) {
-        try {
-          // Check for duplicates before storing
-          const existing = await this.memory.searchRaw(decision.decision, {
-            project,
-            limit: 1,
-            minSimilarity: 0.9
-          })
-
-          if (existing.length > 0 && existing[0].similarity >= 0.9) {
-            this.logger.debug(
-              { existingId: existing[0].memory?.id, similarity: existing[0].similarity },
-              'Skipping duplicate decision'
-            )
-            continue
-          }
-
-          // Store in memory system
-          await this.memory.rememberDecision(
-            project,
-            decision.context,
-            decision.decision,
-            decision.reasoning,
-            {
-              alternatives: decision.alternatives,
-              tags: decision.tags
-            }
-          )
-
-          storedCount++
-
-          this.logger.info(
-            { project, decision: decision.decision.slice(0, 50) },
-            'Decision auto-stored in memory'
-          )
-
-          // Emit decision event if event bus is available
-          if (this.eventBus) {
-            this.eventBus.emitEvent(
-              'decision:made',
-              {
-                decision,
-                filePath,
-                project
-              },
-              this.name
-            )
-          }
-        } catch (error) {
-          this.logger.error(
-            { error, decision: decision.decision.slice(0, 50) },
-            'Failed to store decision'
-          )
-        }
-      }
-
-      this.lastProcessed.set(filePath, new Date())
-      this.logSuccess(event, { decisionsStored: storedCount })
-    } catch (error) {
-      this.logError(event, error)
-    }
-  }
-
-  /**
-   * Extract decisions from markdown content
-   */
-  private extractDecisions(content: string): ExtractedDecision[] {
-    const decisions: ExtractedDecision[] = []
-
-    // Look for decision entries in format:
-    // ### Decision: [title]
-    // **Context:** [context]
-    // **Decision:** [decision]
-    // **Reasoning:** [reasoning]
-    const decisionRegex = /###\s+Decision[:\s]+(.+?)(?:\n|$)/gi
-
-    let match
-    while ((match = decisionRegex.exec(content)) !== null) {
-      const sectionStart = match.index
-      const nextSection = content.indexOf('###', sectionStart + 1)
-      const sectionEnd = nextSection === -1 ? content.length : nextSection
-      const section = content.slice(sectionStart, sectionEnd)
-
-      // Extract fields
-      const contextMatch = /\*\*Context:\*\*\s*(.+?)(?:\n\n|\n\*\*|$)/is.exec(section)
-      const decisionMatch = /\*\*Decision:\*\*\s*(.+?)(?:\n\n|\n\*\*|$)/is.exec(section)
-      const reasoningMatch = /\*\*Reasoning:\*\*\s*(.+?)(?:\n\n|\n\*\*|$)/is.exec(section)
-      const alternativesMatch = /\*\*Alternatives(?:\s+Considered)?:\*\*\s*(.+?)(?:\n\n|\n\*\*|$)/is.exec(section)
-      const tagsMatch = /\*\*Tags:\*\*\s*(.+?)(?:\n|$)/i.exec(section)
-
-      if (contextMatch?.[1] && decisionMatch?.[1] && reasoningMatch?.[1]) {
-        decisions.push({
-          context: contextMatch[1].trim(),
-          decision: decisionMatch[1].trim(),
-          reasoning: reasoningMatch[1].trim(),
-          alternatives: alternativesMatch?.[1]?.trim(),
-          tags: tagsMatch?.[1]?.split(',').map(t => t.trim())
-        })
-      }
-    }
-
-    return decisions
-  }
-
-  /**
-   * Get last processed time for a file
-   */
-  getLastProcessedTime(filePath: string): Date | undefined {
-    return this.lastProcessed.get(filePath)
-  }
-
-  /**
-   * Clear processing history
-   */
-  clearProcessingHistory(): void {
-    this.lastProcessed.clear()
-    this.logger.debug('Processing history cleared')
-  }
-}
+/**
+ * DecisionDetectionHandler - Auto-detects and stores decisions from decisions.md files
+ */
+
+import type { Logger } from 'pino'
+import type { Event, EventType, EventPriority } from '../types'
+import type { VaultReader } from '@/vault'
+import type { MemoryManager } from '@/memory'
+import { BaseHandler } from './base-handler'
+import type { EventBus } from '../event-emitter'
+
+export interface ExtractedDecision {
+  context: string
+  decision: string
+  reasoning: string
+  alternatives?: string
+  tags?: string[]
+}
+
+export class DecisionDetectionHandler extends BaseHandler {
+  name = 'decision-detection-handler'
+  types: EventType[] = ['file:modified']
+  priority: EventPriority = 'high'
+
+  private vaultReader: VaultReader
+  private memory: MemoryManager
+  private lastProcessed: Map<string, Date>
+  private eventBus: EventBus | null = null
+  private debounceMs: number
+
+  constructor(
+    logger: Logger,
+    vaultReader: VaultReader,
+    memory: MemoryManager,
+    debounceMs: number = 5000
+  ) {
+    super(logger)
+    this.initLogger(logger)
+    this.vaultReader = vaultReader
+    this.memory = memory
+    this.lastProcessed = new Map()
+    this.debounceMs = debounceMs
+  }
+
+  /**
+   * Set the event bus for emitting decision events
+   */
+  setEventBus(eventBus: EventBus): void {
+    this.eventBus = eventBus
+  }
+
+  async handle(event: Event): Promise<void> {
+    this.logHandling(event)
+
+    const filePath = event.payload.path as string
+
+    // Only process decisions.md files
+    if (!this.shouldHandleFile(filePath, ['decisions.md'])) {
+      return
+    }
+
+    try {
+      // Check if we've processed recently (debounce)
+      const lastTime = this.lastProcessed.get(filePath)
+      if (lastTime && Date.now() - lastTime.getTime() < this.debounceMs) {
+        this.logger.debug({ filePath }, 'Debounced, skipping')
+        return
+      }
+
+      const file = await this.vaultReader.readMarkdownFile(filePath, false)
+      const project = file.frontmatter.project as string | undefined
+
+      if (!project) {
+        this.logger.warn({ filePath }, 'No project in frontmatter, skipping')
+        return
+      }
+
+      // Extract new decisions from content
+      const decisions = this.extractDecisions(file.content)
+
+      if (decisions.length === 0) {
+        return
+      }
+
+      let storedCount = 0
+      for (const decision of decisions) {
+        try {
+          // Check for duplicates before storing
+          const existing = await this.memory.searchRaw(decision.decision, {
+            project,
+            limit: 1,
+            minSimilarity: 0.9
+          })
+
+          if (existing.length > 0 && existing[0].similarity >= 0.9) {
+            this.logger.debug(
+              { existingId: existing[0].memory?.id, similarity: existing[0].similarity },
+              'Skipping duplicate decision'
+            )
+            continue
+          }
+
+          // Store in memory system
+          await this.memory.rememberDecision(
+            project,
+            decision.context,
+            decision.decision,
+            decision.reasoning,
+            {
+              alternatives: decision.alternatives,
+              tags: decision.tags
+            }
+          )
+
+          storedCount++
+
+          this.logger.info(
+            { project, decision: decision.decision.slice(0, 50) },
+            'Decision auto-stored in memory'
+          )
+
+          // Emit decision event if event bus is available
+          if (this.eventBus) {
+            this.eventBus.emitEvent(
+              'decision:made',
+              {
+                decision,
+                filePath,
+                project
+              },
+              this.name
+            )
+          }
+        } catch (error) {
+          this.logger.error(
+            { error, decision: decision.decision.slice(0, 50) },
+            'Failed to store decision'
+          )
+        }
+      }
+
+      this.lastProcessed.set(filePath, new Date())
+      this.logSuccess(event, { decisionsStored: storedCount })
+    } catch (error) {
+      this.logError(event, error)
+    }
+  }
+
+  /**
+   * Extract decisions from markdown content
+   */
+  private extractDecisions(content: string): ExtractedDecision[] {
+    const decisions: ExtractedDecision[] = []
+
+    // Look for decision entries in format:
+    // ### Decision: [title]
+    // **Context:** [context]
+    // **Decision:** [decision]
+    // **Reasoning:** [reasoning]
+    const decisionRegex = /###\s+Decision[:\s]+(.+?)(?:\n|$)/gi
+
+    let match
+    while ((match = decisionRegex.exec(content)) !== null) {
+      const sectionStart = match.index
+      const nextSection = content.indexOf('###', sectionStart + 1)
+      const sectionEnd = nextSection === -1 ? content.length : nextSection
+      const section = content.slice(sectionStart, sectionEnd)
+
+      // Extract fields
+      const contextMatch = /\*\*Context:\*\*\s*(.+?)(?:\n\n|\n\*\*|$)/is.exec(section)
+      const decisionMatch = /\*\*Decision:\*\*\s*(.+?)(?:\n\n|\n\*\*|$)/is.exec(section)
+      const reasoningMatch = /\*\*Reasoning:\*\*\s*(.+?)(?:\n\n|\n\*\*|$)/is.exec(section)
+      const alternativesMatch = /\*\*Alternatives(?:\s+Considered)?:\*\*\s*(.+?)(?:\n\n|\n\*\*|$)/is.exec(section)
+      const tagsMatch = /\*\*Tags:\*\*\s*(.+?)(?:\n|$)/i.exec(section)
+
+      if (contextMatch?.[1] && decisionMatch?.[1] && reasoningMatch?.[1]) {
+        decisions.push({
+          context: contextMatch[1].trim(),
+          decision: decisionMatch[1].trim(),
+          reasoning: reasoningMatch[1].trim(),
+          alternatives: alternativesMatch?.[1]?.trim(),
+          tags: tagsMatch?.[1]?.split(',').map(t => t.trim())
+        })
+      }
+    }
+
+    return decisions
+  }
+
+  /**
+   * Get last processed time for a file
+   */
+  getLastProcessedTime(filePath: string): Date | undefined {
+    return this.lastProcessed.get(filePath)
+  }
+
+  /**
+   * Clear processing history
+   */
+  clearProcessingHistory(): void {
+    this.lastProcessed.clear()
+    this.logger.debug('Processing history cleared')
+  }
+}

package/src/orchestrator/handlers/index.ts

@@ -1,10 +1,10 @@
-/**
- * Event Handlers Index
- * Export all event handlers for orchestration
- */
-
-export { BaseHandler } from './base-handler'
-export { TaskHandler, type DetectedTask } from './task-handler'
-export { StatusChangeHandler, type StatusChange } from './status-handler'
-export { DecisionDetectionHandler, type ExtractedDecision } from './decision-handler'
-export { ContextUpdateHandler } from './context-handler'
+/**
+ * Event Handlers Index
+ * Export all event handlers for orchestration
+ */
+
+export { BaseHandler } from './base-handler'
+export { TaskHandler, type DetectedTask } from './task-handler'
+export { StatusChangeHandler, type StatusChange } from './status-handler'
+export { DecisionDetectionHandler, type ExtractedDecision } from './decision-handler'
+export { ContextUpdateHandler } from './context-handler'