claude-brain 0.30.2 → 0.30.3

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}`
+      })
+    }
+  }
+}