claude-brain 0.14.2 → 0.14.4

package/src/orchestrator/decision-logger.ts

@@ -1,228 +1,228 @@
-/**
- * DecisionLogger - Automatically capture and store project decisions
- */
-
-import type { Logger } from 'pino'
-import type { MemoryManager } from '@/memory'
-import type { VaultWriter } from '@/vault'
-import { randomUUID } from 'crypto'
-
-export interface DecisionEntry {
-  id: string
-  project: string
-  title: string
-  context: string
-  decision: string
-  reasoning: string
-  alternatives?: string
-  impact?: string
-  outcome?: string
-  tags?: string[]
-  timestamp: Date
-}
-
-export class DecisionLogger {
-  private logger: Logger
-  private memory: MemoryManager
-  private vaultWriter: VaultWriter
-
-  constructor(
-    logger: Logger,
-    memory: MemoryManager,
-    vaultWriter: VaultWriter
-  ) {
-    this.logger = logger.child({ component: 'decision-logger' })
-    this.memory = memory
-    this.vaultWriter = vaultWriter
-  }
-
-  /**
-   * Log a decision to both vault and memory
-   */
-  async logDecision(
-    decision: Omit<DecisionEntry, 'id' | 'timestamp'>
-  ): Promise<DecisionEntry> {
-    const fullDecision: DecisionEntry = {
-      ...decision,
-      id: randomUUID(),
-      timestamp: new Date()
-    }
-
-    try {
-      this.logger.info(
-        { decision: decision.title, project: decision.project },
-        'Logging decision'
-      )
-
-      // Store in memory system
-      await this.memory.rememberDecision(
-        fullDecision.project,
-        fullDecision.context,
-        fullDecision.decision,
-        fullDecision.reasoning,
-        {
-          alternatives: fullDecision.alternatives,
-          tags: fullDecision.tags
-        }
-      )
-
-      // Append to vault decisions file
-      await this.appendToVault(fullDecision)
-
-      this.logger.info(
-        { decisionId: fullDecision.id, project: fullDecision.project },
-        'Decision logged successfully'
-      )
-
-      return fullDecision
-    } catch (error) {
-      this.logger.error(
-        { error, decision: decision.title },
-        'Failed to log decision'
-      )
-      throw error
-    }
-  }
-
-  /**
-   * Append decision to vault decisions file
-   */
-  private async appendToVault(decision: DecisionEntry): Promise<void> {
-    const filePath = `Projects/${decision.project}/decisions.md`
-
-    const entry = this.formatDecisionEntry(decision)
-
-    await this.vaultWriter.appendContent(filePath, entry)
-  }
-
-  /**
-   * Format decision as markdown
-   */
-  private formatDecisionEntry(decision: DecisionEntry): string {
-    const date = decision.timestamp.toISOString().split('T')[0]
-
-    let entry = `### Decision: ${decision.title}\n\n`
-    entry += `**Date:** ${date}\n\n`
-    entry += `**Context:** ${decision.context}\n\n`
-    entry += `**Decision:** ${decision.decision}\n\n`
-    entry += `**Reasoning:** ${decision.reasoning}\n\n`
-
-    if (decision.alternatives) {
-      entry += `**Alternatives Considered:** ${decision.alternatives}\n\n`
-    }
-
-    if (decision.impact) {
-      entry += `**Expected Impact:** ${decision.impact}\n\n`
-    }
-
-    if (decision.outcome) {
-      entry += `**Outcome:** ${decision.outcome}\n\n`
-    }
-
-    if (decision.tags) {
-      const tags = Array.isArray(decision.tags) 
-        ? decision.tags.join(', ')
-        : decision.tags
-      entry += `**Tags:** ${tags}\n\n`
-    }
-
-    return entry + '---\n\n'
-  }
-
-  /**
-   * Detect decision patterns in text
-   */
-  static detectDecision(text: string): boolean {
-    const decisionKeywords = [
-      'decided to',
-      'decision:',
-      'chose to',
-      'selected',
-      'went with',
-      'opted for',
-      'concluded that',
-      'we will use',
-      'adopting',
-      'implementing'
-    ]
-
-    const lowerText = text.toLowerCase()
-    return decisionKeywords.some(keyword => lowerText.includes(keyword))
-  }
-
-  /**
-   * Extract decision from natural language
-   */
-  static extractDecisionFromText(text: string): Partial<DecisionEntry> | null {
-    // Try to match common decision patterns
-    const patterns = [
-      /decided to (.+?)(?:\.|$)/i,
-      /chose to (.+?)(?:\.|$)/i,
-      /going with (.+?)(?:\.|$)/i,
-      /we will use (.+?)(?:\.|$)/i,
-      /adopting (.+?)(?:\.|$)/i
-    ]
-
-    let decision: string | null = null
-    for (const pattern of patterns) {
-      const match = pattern.exec(text)
-      if (match?.[1]) {
-        decision = match[1].trim()
-        break
-      }
-    }
-
-    if (!decision) {
-      return null
-    }
-
-    // Try to extract reasoning
-    const reasoningPatterns = [
-      /because (.+?)(?:\.|$)/i,
-      /since (.+?)(?:\.|$)/i,
-      /due to (.+?)(?:\.|$)/i,
-      /as (.+?)(?:\.|$)/i
-    ]
-
-    let reasoning: string | undefined
-    for (const pattern of reasoningPatterns) {
-      const match = pattern.exec(text)
-      if (match?.[1]) {
-        reasoning = match[1].trim()
-        break
-      }
-    }
-
-    return {
-      decision,
-      reasoning
-    }
-  }
-
-  /**
-   * Create a decision entry from minimal input
-   */
-  static createDecisionEntry(
-    project: string,
-    title: string,
-    decision: string,
-    reasoning: string,
-    options?: {
-      context?: string
-      alternatives?: string
-      impact?: string
-      tags?: string[]
-    }
-  ): Omit<DecisionEntry, 'id' | 'timestamp'> {
-    return {
-      project,
-      title,
-      context: options?.context || `Decision about ${title}`,
-      decision,
-      reasoning,
-      alternatives: options?.alternatives,
-      impact: options?.impact,
-      tags: options?.tags
-    }
-  }
-}
+/**
+ * DecisionLogger - Automatically capture and store project decisions
+ */
+
+import type { Logger } from 'pino'
+import type { MemoryManager } from '@/memory'
+import type { VaultWriter } from '@/vault'
+import { randomUUID } from 'crypto'
+
+export interface DecisionEntry {
+  id: string
+  project: string
+  title: string
+  context: string
+  decision: string
+  reasoning: string
+  alternatives?: string
+  impact?: string
+  outcome?: string
+  tags?: string[]
+  timestamp: Date
+}
+
+export class DecisionLogger {
+  private logger: Logger
+  private memory: MemoryManager
+  private vaultWriter: VaultWriter
+
+  constructor(
+    logger: Logger,
+    memory: MemoryManager,
+    vaultWriter: VaultWriter
+  ) {
+    this.logger = logger.child({ component: 'decision-logger' })
+    this.memory = memory
+    this.vaultWriter = vaultWriter
+  }
+
+  /**
+   * Log a decision to both vault and memory
+   */
+  async logDecision(
+    decision: Omit<DecisionEntry, 'id' | 'timestamp'>
+  ): Promise<DecisionEntry> {
+    const fullDecision: DecisionEntry = {
+      ...decision,
+      id: randomUUID(),
+      timestamp: new Date()
+    }
+
+    try {
+      this.logger.info(
+        { decision: decision.title, project: decision.project },
+        'Logging decision'
+      )
+
+      // Store in memory system
+      await this.memory.rememberDecision(
+        fullDecision.project,
+        fullDecision.context,
+        fullDecision.decision,
+        fullDecision.reasoning,
+        {
+          alternatives: fullDecision.alternatives,
+          tags: fullDecision.tags
+        }
+      )
+
+      // Append to vault decisions file
+      await this.appendToVault(fullDecision)
+
+      this.logger.info(
+        { decisionId: fullDecision.id, project: fullDecision.project },
+        'Decision logged successfully'
+      )
+
+      return fullDecision
+    } catch (error) {
+      this.logger.error(
+        { error, decision: decision.title },
+        'Failed to log decision'
+      )
+      throw error
+    }
+  }
+
+  /**
+   * Append decision to vault decisions file
+   */
+  private async appendToVault(decision: DecisionEntry): Promise<void> {
+    const filePath = `Projects/${decision.project}/decisions.md`
+
+    const entry = this.formatDecisionEntry(decision)
+
+    await this.vaultWriter.appendContent(filePath, entry)
+  }
+
+  /**
+   * Format decision as markdown
+   */
+  private formatDecisionEntry(decision: DecisionEntry): string {
+    const date = decision.timestamp.toISOString().split('T')[0]
+
+    let entry = `### Decision: ${decision.title}\n\n`
+    entry += `**Date:** ${date}\n\n`
+    entry += `**Context:** ${decision.context}\n\n`
+    entry += `**Decision:** ${decision.decision}\n\n`
+    entry += `**Reasoning:** ${decision.reasoning}\n\n`
+
+    if (decision.alternatives) {
+      entry += `**Alternatives Considered:** ${decision.alternatives}\n\n`
+    }
+
+    if (decision.impact) {
+      entry += `**Expected Impact:** ${decision.impact}\n\n`
+    }
+
+    if (decision.outcome) {
+      entry += `**Outcome:** ${decision.outcome}\n\n`
+    }
+
+    if (decision.tags) {
+      const tags = Array.isArray(decision.tags) 
+        ? decision.tags.join(', ')
+        : decision.tags
+      entry += `**Tags:** ${tags}\n\n`
+    }
+
+    return entry + '---\n\n'
+  }
+
+  /**
+   * Detect decision patterns in text
+   */
+  static detectDecision(text: string): boolean {
+    const decisionKeywords = [
+      'decided to',
+      'decision:',
+      'chose to',
+      'selected',
+      'went with',
+      'opted for',
+      'concluded that',
+      'we will use',
+      'adopting',
+      'implementing'
+    ]
+
+    const lowerText = text.toLowerCase()
+    return decisionKeywords.some(keyword => lowerText.includes(keyword))
+  }
+
+  /**
+   * Extract decision from natural language
+   */
+  static extractDecisionFromText(text: string): Partial<DecisionEntry> | null {
+    // Try to match common decision patterns
+    const patterns = [
+      /decided to (.+?)(?:\.|$)/i,
+      /chose to (.+?)(?:\.|$)/i,
+      /going with (.+?)(?:\.|$)/i,
+      /we will use (.+?)(?:\.|$)/i,
+      /adopting (.+?)(?:\.|$)/i
+    ]
+
+    let decision: string | null = null
+    for (const pattern of patterns) {
+      const match = pattern.exec(text)
+      if (match?.[1]) {
+        decision = match[1].trim()
+        break
+      }
+    }
+
+    if (!decision) {
+      return null
+    }
+
+    // Try to extract reasoning
+    const reasoningPatterns = [
+      /because (.+?)(?:\.|$)/i,
+      /since (.+?)(?:\.|$)/i,
+      /due to (.+?)(?:\.|$)/i,
+      /as (.+?)(?:\.|$)/i
+    ]
+
+    let reasoning: string | undefined
+    for (const pattern of reasoningPatterns) {
+      const match = pattern.exec(text)
+      if (match?.[1]) {
+        reasoning = match[1].trim()
+        break
+      }
+    }
+
+    return {
+      decision,
+      reasoning
+    }
+  }
+
+  /**
+   * Create a decision entry from minimal input
+   */
+  static createDecisionEntry(
+    project: string,
+    title: string,
+    decision: string,
+    reasoning: string,
+    options?: {
+      context?: string
+      alternatives?: string
+      impact?: string
+      tags?: string[]
+    }
+  ): Omit<DecisionEntry, 'id' | 'timestamp'> {
+    return {
+      project,
+      title,
+      context: options?.context || `Decision about ${title}`,
+      decision,
+      reasoning,
+      alternatives: options?.alternatives,
+      impact: options?.impact,
+      tags: options?.tags
+    }
+  }
+}