claude-brain 0.14.2 → 0.14.4

package/src/orchestrator/types.ts

@@ -1,98 +1,98 @@
-/**
- * Orchestration Engine Types
- * Event-driven coordination system for Claude Brain
- */
-
-// File events - triggered by vault watcher
-// Task events - triggered by task extraction
-// Decision events - triggered by decision detection
-// Project events - triggered by project changes
-// System events - triggered by system state changes
-export type EventType =
-  // File events
-  | 'file:created'
-  | 'file:modified'
-  | 'file:deleted'
-  // Task events
-  | 'task:created'
-  | 'task:updated'
-  | 'task:completed'
-  | 'task:blocked'
-  // Decision events
-  | 'decision:made'
-  | 'decision:updated'
-  // Project events
-  | 'project:created'
-  | 'project:updated'
-  | 'project:archived'
-  // System events
-  | 'system:ready'
-  | 'system:error'
-  | 'system:shutdown'
-
-export type EventPriority = 'low' | 'normal' | 'high' | 'urgent'
-
-export interface Event {
-  id: string
-  type: EventType
-  priority: EventPriority
-  timestamp: Date
-  payload: Record<string, unknown>
-  source: string
-}
-
-export interface EventHandler {
-  name: string
-  types: EventType[]
-  priority: EventPriority
-  handle: (event: Event) => Promise<void>
-}
-
-export interface EventQueueItem {
-  event: Event
-  retries: number
-  maxRetries: number
-  scheduledFor?: Date
-}
-
-export interface EventBusStats {
-  totalEvents: number
-  registeredHandlers: number
-  eventsByType: Record<string, number>
-  oldestEvent?: Date
-  newestEvent?: Date
-}
-
-export interface QueueStatus {
-  size: number
-  processing: boolean
-  events: Array<{
-    id: string
-    type: EventType
-    priority: EventPriority
-    retries: number
-    scheduledFor?: Date
-  }>
-}
-
-export interface Operation {
-  id: string
-  type: string
-  status: 'pending' | 'running' | 'completed' | 'failed'
-  startTime?: Date
-  endTime?: Date
-  result?: unknown
-  error?: unknown
-}
-
-export interface CoordinatorStats {
-  totalOperations: number
-  queueSize: number
-  operationsByStatus: Record<string, number>
-  maxConcurrent: number
-}
-
-export interface OrchestratorStats {
-  eventBus: EventBusStats
-  coordinator: CoordinatorStats
-}
+/**
+ * Orchestration Engine Types
+ * Event-driven coordination system for Claude Brain
+ */
+
+// File events - triggered by vault watcher
+// Task events - triggered by task extraction
+// Decision events - triggered by decision detection
+// Project events - triggered by project changes
+// System events - triggered by system state changes
+export type EventType =
+  // File events
+  | 'file:created'
+  | 'file:modified'
+  | 'file:deleted'
+  // Task events
+  | 'task:created'
+  | 'task:updated'
+  | 'task:completed'
+  | 'task:blocked'
+  // Decision events
+  | 'decision:made'
+  | 'decision:updated'
+  // Project events
+  | 'project:created'
+  | 'project:updated'
+  | 'project:archived'
+  // System events
+  | 'system:ready'
+  | 'system:error'
+  | 'system:shutdown'
+
+export type EventPriority = 'low' | 'normal' | 'high' | 'urgent'
+
+export interface Event {
+  id: string
+  type: EventType
+  priority: EventPriority
+  timestamp: Date
+  payload: Record<string, unknown>
+  source: string
+}
+
+export interface EventHandler {
+  name: string
+  types: EventType[]
+  priority: EventPriority
+  handle: (event: Event) => Promise<void>
+}
+
+export interface EventQueueItem {
+  event: Event
+  retries: number
+  maxRetries: number
+  scheduledFor?: Date
+}
+
+export interface EventBusStats {
+  totalEvents: number
+  registeredHandlers: number
+  eventsByType: Record<string, number>
+  oldestEvent?: Date
+  newestEvent?: Date
+}
+
+export interface QueueStatus {
+  size: number
+  processing: boolean
+  events: Array<{
+    id: string
+    type: EventType
+    priority: EventPriority
+    retries: number
+    scheduledFor?: Date
+  }>
+}
+
+export interface Operation {
+  id: string
+  type: string
+  status: 'pending' | 'running' | 'completed' | 'failed'
+  startTime?: Date
+  endTime?: Date
+  result?: unknown
+  error?: unknown
+}
+
+export interface CoordinatorStats {
+  totalOperations: number
+  queueSize: number
+  operationsByStatus: Record<string, number>
+  maxConcurrent: number
+}
+
+export interface OrchestratorStats {
+  eventBus: EventBusStats
+  coordinator: CoordinatorStats
+}

package/src/packs/index.ts

@@ -1,9 +1,9 @@
-/**
- * Phase 18: Knowledge Packs
- * Pre-seeded knowledge for zero cold-start experience
- */
-
-export * from './types'
-export { PackManager } from './manager'
-export { PackLoader } from './loader'
-export { KnowledgeRanker, type RankedResult } from './ranker'
+/**
+ * Phase 18: Knowledge Packs
+ * Pre-seeded knowledge for zero cold-start experience
+ */
+
+export * from './types'
+export { PackManager } from './manager'
+export { PackLoader } from './loader'
+export { KnowledgeRanker, type RankedResult } from './ranker'

package/src/packs/loader.ts

@@ -1,134 +1,134 @@
-/**
- * Phase 18: Pack Loader
- * Orchestrates loading pack entries into the memory system
- */
-
-import type { Logger } from 'pino'
-import type { MemoryManager } from '@/memory/index'
-import type { PackManager } from './manager'
-import type { PacksConfig } from '@/config/schema'
-import { ENTRY_TYPE_TO_PATTERN_TYPE, type PackEntry, type PackLoadResult } from './types'
-
-export class PackLoader {
-  private logger: Logger
-  private memory: MemoryManager
-  private packManager: PackManager
-  private config: PacksConfig
-
-  constructor(logger: Logger, memory: MemoryManager, packManager: PackManager, config: PacksConfig) {
-    this.logger = logger.child({ component: 'pack-loader' })
-    this.memory = memory
-    this.packManager = packManager
-    this.config = config
-  }
-
-  /** Main entry point: load all relevant packs for a project */
-  async loadPacksForProject(project: string, techStack: string[]): Promise<PackLoadResult> {
-    const result: PackLoadResult = {
-      packsLoaded: 0,
-      entriesLoaded: 0,
-      packDetails: [],
-      skipped: []
-    }
-
-    const relevantPackIds = this.packManager.findRelevantPacks(techStack)
-    this.logger.info({ project, techStack, relevantPackIds }, 'Loading packs for project')
-
-    const manifest = await this.packManager.getManifest(project)
-
-    for (const packId of relevantPackIds) {
-      try {
-        const pack = await this.packManager.loadPack(packId)
-
-        // Idempotency check
-        if (this.packManager.isPackLoaded(manifest, packId, pack.version)) {
-          result.skipped.push({ packId, reason: `Already loaded (v${pack.version})` })
-          this.logger.debug({ packId, version: pack.version }, 'Pack already loaded, skipping')
-          continue
-        }
-
-        // Load each entry
-        let entriesLoaded = 0
-        for (const entry of pack.entries) {
-          try {
-            await this.storeEntry(project, packId, entry)
-            entriesLoaded++
-          } catch (error) {
-            this.logger.warn({ error, packId, entry: entry.title }, 'Failed to store pack entry')
-          }
-        }
-
-        // Update manifest
-        manifest.packs.push({
-          packId,
-          version: pack.version,
-          entriesLoaded,
-          loadedAt: new Date().toISOString()
-        })
-
-        result.packsLoaded++
-        result.entriesLoaded += entriesLoaded
-        result.packDetails.push({
-          packId,
-          name: pack.name,
-          entriesLoaded
-        })
-
-        this.logger.info({ packId, entriesLoaded }, 'Pack loaded successfully')
-      } catch (error) {
-        result.skipped.push({
-          packId,
-          reason: `Load failed: ${error instanceof Error ? error.message : String(error)}`
-        })
-        this.logger.warn({ error, packId }, 'Failed to load pack')
-      }
-    }
-
-    // Save updated manifest
-    await this.packManager.saveManifest(manifest)
-
-    this.logger.info({
-      project,
-      packsLoaded: result.packsLoaded,
-      entriesLoaded: result.entriesLoaded,
-      skipped: result.skipped.length
-    }, 'Pack loading complete')
-
-    return result
-  }
-
-  /** Route a single pack entry to the appropriate storage method */
-  private async storeEntry(project: string, packId: string, entry: PackEntry): Promise<void> {
-    const dampenedConfidence = entry.confidence * this.config.communityConfidenceMultiplier
-
-    if (entry.type === 'decision-template') {
-      // Decision templates go to rememberDecision
-      await this.memory.rememberDecision(
-        project,
-        `[community:pack:${packId}] ${entry.category}`,
-        `${entry.title}: ${entry.content}`,
-        `Pre-seeded from knowledge pack: ${packId}`,
-        {
-          tags: ['pack', `pack:${packId}`, ...entry.tags]
-        }
-      )
-    } else {
-      // All other types go to storePattern
-      const patternType = ENTRY_TYPE_TO_PATTERN_TYPE[entry.type]
-      if (!patternType) {
-        this.logger.warn({ type: entry.type, packId }, 'Unknown entry type, skipping')
-        return
-      }
-
-      await this.memory.storePattern({
-        project,
-        pattern_type: patternType,
-        description: `${entry.title}: ${entry.content}`,
-        example: entry.example,
-        confidence: dampenedConfidence,
-        context: `[community:pack:${packId}] ${entry.category}`,
-        source: `pack:${packId}`
-      })
-    }
-  }
-}
+/**
+ * Phase 18: Pack Loader
+ * Orchestrates loading pack entries into the memory system
+ */
+
+import type { Logger } from 'pino'
+import type { MemoryManager } from '@/memory/index'
+import type { PackManager } from './manager'
+import type { PacksConfig } from '@/config/schema'
+import { ENTRY_TYPE_TO_PATTERN_TYPE, type PackEntry, type PackLoadResult } from './types'
+
+export class PackLoader {
+  private logger: Logger
+  private memory: MemoryManager
+  private packManager: PackManager
+  private config: PacksConfig
+
+  constructor(logger: Logger, memory: MemoryManager, packManager: PackManager, config: PacksConfig) {
+    this.logger = logger.child({ component: 'pack-loader' })
+    this.memory = memory
+    this.packManager = packManager
+    this.config = config
+  }
+
+  /** Main entry point: load all relevant packs for a project */
+  async loadPacksForProject(project: string, techStack: string[]): Promise<PackLoadResult> {
+    const result: PackLoadResult = {
+      packsLoaded: 0,
+      entriesLoaded: 0,
+      packDetails: [],
+      skipped: []
+    }
+
+    const relevantPackIds = this.packManager.findRelevantPacks(techStack)
+    this.logger.info({ project, techStack, relevantPackIds }, 'Loading packs for project')
+
+    const manifest = await this.packManager.getManifest(project)
+
+    for (const packId of relevantPackIds) {
+      try {
+        const pack = await this.packManager.loadPack(packId)
+
+        // Idempotency check
+        if (this.packManager.isPackLoaded(manifest, packId, pack.version)) {
+          result.skipped.push({ packId, reason: `Already loaded (v${pack.version})` })
+          this.logger.debug({ packId, version: pack.version }, 'Pack already loaded, skipping')
+          continue
+        }
+
+        // Load each entry
+        let entriesLoaded = 0
+        for (const entry of pack.entries) {
+          try {
+            await this.storeEntry(project, packId, entry)
+            entriesLoaded++
+          } catch (error) {
+            this.logger.warn({ error, packId, entry: entry.title }, 'Failed to store pack entry')
+          }
+        }
+
+        // Update manifest
+        manifest.packs.push({
+          packId,
+          version: pack.version,
+          entriesLoaded,
+          loadedAt: new Date().toISOString()
+        })
+
+        result.packsLoaded++
+        result.entriesLoaded += entriesLoaded
+        result.packDetails.push({
+          packId,
+          name: pack.name,
+          entriesLoaded
+        })
+
+        this.logger.info({ packId, entriesLoaded }, 'Pack loaded successfully')
+      } catch (error) {
+        result.skipped.push({
+          packId,
+          reason: `Load failed: ${error instanceof Error ? error.message : String(error)}`
+        })
+        this.logger.warn({ error, packId }, 'Failed to load pack')
+      }
+    }
+
+    // Save updated manifest
+    await this.packManager.saveManifest(manifest)
+
+    this.logger.info({
+      project,
+      packsLoaded: result.packsLoaded,
+      entriesLoaded: result.entriesLoaded,
+      skipped: result.skipped.length
+    }, 'Pack loading complete')
+
+    return result
+  }
+
+  /** Route a single pack entry to the appropriate storage method */
+  private async storeEntry(project: string, packId: string, entry: PackEntry): Promise<void> {
+    const dampenedConfidence = entry.confidence * this.config.communityConfidenceMultiplier
+
+    if (entry.type === 'decision-template') {
+      // Decision templates go to rememberDecision
+      await this.memory.rememberDecision(
+        project,
+        `[community:pack:${packId}] ${entry.category}`,
+        `${entry.title}: ${entry.content}`,
+        `Pre-seeded from knowledge pack: ${packId}`,
+        {
+          tags: ['pack', `pack:${packId}`, ...entry.tags]
+        }
+      )
+    } else {
+      // All other types go to storePattern
+      const patternType = ENTRY_TYPE_TO_PATTERN_TYPE[entry.type]
+      if (!patternType) {
+        this.logger.warn({ type: entry.type, packId }, 'Unknown entry type, skipping')
+        return
+      }
+
+      await this.memory.storePattern({
+        project,
+        pattern_type: patternType,
+        description: `${entry.title}: ${entry.content}`,
+        example: entry.example,
+        confidence: dampenedConfidence,
+        context: `[community:pack:${packId}] ${entry.category}`,
+        source: `pack:${packId}`
+      })
+    }
+  }
+}