claude-brain 0.14.2 → 0.14.4

package/src/packs/manager.ts

@@ -1,204 +1,204 @@
-/**
- * Phase 18: Pack Manager
- * Handles discovery, loading, and manifest tracking for knowledge packs
- */
-
-import fs from 'fs/promises'
-import path from 'path'
-import type { Logger } from 'pino'
-import type { PacksConfig } from '@/config/schema'
-import { KnowledgePackSchema, type KnowledgePack, type PackManifest } from './types'
-
-/** Maps tech stack names to relevant pack IDs */
-const STACK_MAP: Record<string, string[]> = {
-  // Languages
-  typescript: ['core/typescript'],
-  javascript: ['core/javascript'],
-
-  // Frontend frameworks
-  react: ['frontend/react'],
-  vue: ['frontend/react'], // reuse performance patterns; will add vue pack later
-  angular: ['frontend/react'],
-  svelte: ['frontend/react'],
-  'next.js': ['frontend/react'],
-  nuxt: ['frontend/react'],
-  remix: ['frontend/react'],
-  gatsby: ['frontend/react'],
-
-  // Backend
-  node: ['backend/node'],
-  express: ['backend/node'],
-  fastify: ['backend/node'],
-  hono: ['backend/node'],
-  elysia: ['backend/node'],
-  nestjs: ['backend/node'],
-  bun: ['backend/node'],
-
-  // Meta
-  jest: ['meta/testing'],
-  vitest: ['meta/testing'],
-  mocha: ['meta/testing'],
-  'bun:test': ['meta/testing'],
-  testing: ['meta/testing']
-}
-
-export class PackManager {
-  private logger: Logger
-  private config: PacksConfig
-  private packageRoot: string
-  private dataDir: string
-
-  constructor(logger: Logger, config: PacksConfig, packageRoot: string, dataDir: string) {
-    this.logger = logger.child({ component: 'pack-manager' })
-    this.config = config
-    this.packageRoot = packageRoot
-    this.dataDir = dataDir
-  }
-
-  /** Find pack IDs relevant to a given tech stack */
-  findRelevantPacks(techStack: string[]): string[] {
-    const packIds = new Set<string>()
-
-    // Always include core and meta packs when configured
-    if (this.config.alwaysLoadCore) {
-      packIds.add('core/typescript')
-      packIds.add('core/javascript')
-    }
-    if (this.config.alwaysLoadMeta) {
-      packIds.add('meta/testing')
-    }
-
-    // Add tech-stack specific packs
-    for (const tech of techStack) {
-      const normalizedTech = tech.toLowerCase()
-      const mapped = STACK_MAP[normalizedTech]
-      if (mapped) {
-        for (const packId of mapped) {
-          packIds.add(packId)
-        }
-      }
-    }
-
-    return Array.from(packIds)
-  }
-
-  /** Load and validate a pack from the packs directory */
-  async loadPack(packId: string): Promise<KnowledgePack> {
-    const packPath = path.join(this.packageRoot, this.config.packsDir, `${packId}.json`)
-
-    try {
-      const content = await fs.readFile(packPath, 'utf-8')
-      const raw = JSON.parse(content)
-      const pack = KnowledgePackSchema.parse(raw)
-      this.logger.debug({ packId, entries: pack.entries.length }, 'Pack loaded and validated')
-      return pack
-    } catch (error) {
-      this.logger.error({ error, packId, packPath }, 'Failed to load pack')
-      throw new Error(`Failed to load pack "${packId}": ${error instanceof Error ? error.message : String(error)}`)
-    }
-  }
-
-  /** Get the manifest for a project (tracks which packs are loaded) */
-  async getManifest(project: string): Promise<PackManifest> {
-    const manifestPath = this.getManifestPath(project)
-
-    try {
-      const content = await fs.readFile(manifestPath, 'utf-8')
-      return JSON.parse(content) as PackManifest
-    } catch {
-      // No manifest yet — return empty
-      return {
-        project,
-        packs: [],
-        lastUpdated: new Date().toISOString()
-      }
-    }
-  }
-
-  /** Save manifest after loading packs */
-  async saveManifest(manifest: PackManifest): Promise<void> {
-    const manifestPath = this.getManifestPath(manifest.project)
-    const manifestDir = path.dirname(manifestPath)
-
-    await fs.mkdir(manifestDir, { recursive: true })
-    manifest.lastUpdated = new Date().toISOString()
-    await fs.writeFile(manifestPath, JSON.stringify(manifest, null, 2), 'utf-8')
-
-    this.logger.debug({ project: manifest.project, packs: manifest.packs.length }, 'Manifest saved')
-  }
-
-  /** Delete manifest for a project (used by reload) */
-  async deleteManifest(project: string): Promise<void> {
-    const manifestPath = this.getManifestPath(project)
-    try {
-      await fs.unlink(manifestPath)
-    } catch {
-      // File didn't exist, that's fine
-    }
-  }
-
-  /** Check if a pack version is already loaded */
-  isPackLoaded(manifest: PackManifest, packId: string, version: string): boolean {
-    return manifest.packs.some(p => p.packId === packId && p.version === version)
-  }
-
-  /** List all available packs in the packs directory */
-  async listAvailablePacks(): Promise<Array<{ id: string; name: string; description: string; entries: number; version: string }>> {
-    const packsDir = path.join(this.packageRoot, this.config.packsDir)
-    const packs: Array<{ id: string; name: string; description: string; entries: number; version: string }> = []
-
-    try {
-      await this.scanPacksDir(packsDir, '', packs)
-    } catch (error) {
-      this.logger.warn({ error, packsDir }, 'Failed to scan packs directory')
-    }
-
-    return packs
-  }
-
-  private async scanPacksDir(
-    dir: string,
-    prefix: string,
-    result: Array<{ id: string; name: string; description: string; entries: number; version: string }>
-  ): Promise<void> {
-    let entries: import('fs').Dirent[]
-    try {
-      entries = await fs.readdir(dir, { withFileTypes: true })
-    } catch {
-      return
-    }
-
-    for (const entry of entries) {
-      if (entry.isDirectory()) {
-        await this.scanPacksDir(
-          path.join(dir, entry.name),
-          prefix ? `${prefix}/${entry.name}` : entry.name,
-          result
-        )
-      } else if (entry.name.endsWith('.json')) {
-        const packId = prefix
-          ? `${prefix}/${entry.name.replace('.json', '')}`
-          : entry.name.replace('.json', '')
-
-        try {
-          const content = await fs.readFile(path.join(dir, entry.name), 'utf-8')
-          const raw = JSON.parse(content)
-          const pack = KnowledgePackSchema.parse(raw)
-          result.push({
-            id: packId,
-            name: pack.name,
-            description: pack.description,
-            entries: pack.entries.length,
-            version: pack.version
-          })
-        } catch (error) {
-          this.logger.warn({ error, packId }, 'Skipping invalid pack file')
-        }
-      }
-    }
-  }
-
-  private getManifestPath(project: string): string {
-    return path.join(this.dataDir, 'pack-manifests', `${project}.json`)
-  }
-}
+/**
+ * Phase 18: Pack Manager
+ * Handles discovery, loading, and manifest tracking for knowledge packs
+ */
+
+import fs from 'fs/promises'
+import path from 'path'
+import type { Logger } from 'pino'
+import type { PacksConfig } from '@/config/schema'
+import { KnowledgePackSchema, type KnowledgePack, type PackManifest } from './types'
+
+/** Maps tech stack names to relevant pack IDs */
+const STACK_MAP: Record<string, string[]> = {
+  // Languages
+  typescript: ['core/typescript'],
+  javascript: ['core/javascript'],
+
+  // Frontend frameworks
+  react: ['frontend/react'],
+  vue: ['frontend/react'], // reuse performance patterns; will add vue pack later
+  angular: ['frontend/react'],
+  svelte: ['frontend/react'],
+  'next.js': ['frontend/react'],
+  nuxt: ['frontend/react'],
+  remix: ['frontend/react'],
+  gatsby: ['frontend/react'],
+
+  // Backend
+  node: ['backend/node'],
+  express: ['backend/node'],
+  fastify: ['backend/node'],
+  hono: ['backend/node'],
+  elysia: ['backend/node'],
+  nestjs: ['backend/node'],
+  bun: ['backend/node'],
+
+  // Meta
+  jest: ['meta/testing'],
+  vitest: ['meta/testing'],
+  mocha: ['meta/testing'],
+  'bun:test': ['meta/testing'],
+  testing: ['meta/testing']
+}
+
+export class PackManager {
+  private logger: Logger
+  private config: PacksConfig
+  private packageRoot: string
+  private dataDir: string
+
+  constructor(logger: Logger, config: PacksConfig, packageRoot: string, dataDir: string) {
+    this.logger = logger.child({ component: 'pack-manager' })
+    this.config = config
+    this.packageRoot = packageRoot
+    this.dataDir = dataDir
+  }
+
+  /** Find pack IDs relevant to a given tech stack */
+  findRelevantPacks(techStack: string[]): string[] {
+    const packIds = new Set<string>()
+
+    // Always include core and meta packs when configured
+    if (this.config.alwaysLoadCore) {
+      packIds.add('core/typescript')
+      packIds.add('core/javascript')
+    }
+    if (this.config.alwaysLoadMeta) {
+      packIds.add('meta/testing')
+    }
+
+    // Add tech-stack specific packs
+    for (const tech of techStack) {
+      const normalizedTech = tech.toLowerCase()
+      const mapped = STACK_MAP[normalizedTech]
+      if (mapped) {
+        for (const packId of mapped) {
+          packIds.add(packId)
+        }
+      }
+    }
+
+    return Array.from(packIds)
+  }
+
+  /** Load and validate a pack from the packs directory */
+  async loadPack(packId: string): Promise<KnowledgePack> {
+    const packPath = path.join(this.packageRoot, this.config.packsDir, `${packId}.json`)
+
+    try {
+      const content = await fs.readFile(packPath, 'utf-8')
+      const raw = JSON.parse(content)
+      const pack = KnowledgePackSchema.parse(raw)
+      this.logger.debug({ packId, entries: pack.entries.length }, 'Pack loaded and validated')
+      return pack
+    } catch (error) {
+      this.logger.error({ error, packId, packPath }, 'Failed to load pack')
+      throw new Error(`Failed to load pack "${packId}": ${error instanceof Error ? error.message : String(error)}`)
+    }
+  }
+
+  /** Get the manifest for a project (tracks which packs are loaded) */
+  async getManifest(project: string): Promise<PackManifest> {
+    const manifestPath = this.getManifestPath(project)
+
+    try {
+      const content = await fs.readFile(manifestPath, 'utf-8')
+      return JSON.parse(content) as PackManifest
+    } catch {
+      // No manifest yet — return empty
+      return {
+        project,
+        packs: [],
+        lastUpdated: new Date().toISOString()
+      }
+    }
+  }
+
+  /** Save manifest after loading packs */
+  async saveManifest(manifest: PackManifest): Promise<void> {
+    const manifestPath = this.getManifestPath(manifest.project)
+    const manifestDir = path.dirname(manifestPath)
+
+    await fs.mkdir(manifestDir, { recursive: true })
+    manifest.lastUpdated = new Date().toISOString()
+    await fs.writeFile(manifestPath, JSON.stringify(manifest, null, 2), 'utf-8')
+
+    this.logger.debug({ project: manifest.project, packs: manifest.packs.length }, 'Manifest saved')
+  }
+
+  /** Delete manifest for a project (used by reload) */
+  async deleteManifest(project: string): Promise<void> {
+    const manifestPath = this.getManifestPath(project)
+    try {
+      await fs.unlink(manifestPath)
+    } catch {
+      // File didn't exist, that's fine
+    }
+  }
+
+  /** Check if a pack version is already loaded */
+  isPackLoaded(manifest: PackManifest, packId: string, version: string): boolean {
+    return manifest.packs.some(p => p.packId === packId && p.version === version)
+  }
+
+  /** List all available packs in the packs directory */
+  async listAvailablePacks(): Promise<Array<{ id: string; name: string; description: string; entries: number; version: string }>> {
+    const packsDir = path.join(this.packageRoot, this.config.packsDir)
+    const packs: Array<{ id: string; name: string; description: string; entries: number; version: string }> = []
+
+    try {
+      await this.scanPacksDir(packsDir, '', packs)
+    } catch (error) {
+      this.logger.warn({ error, packsDir }, 'Failed to scan packs directory')
+    }
+
+    return packs
+  }
+
+  private async scanPacksDir(
+    dir: string,
+    prefix: string,
+    result: Array<{ id: string; name: string; description: string; entries: number; version: string }>
+  ): Promise<void> {
+    let entries: import('fs').Dirent[]
+    try {
+      entries = await fs.readdir(dir, { withFileTypes: true })
+    } catch {
+      return
+    }
+
+    for (const entry of entries) {
+      if (entry.isDirectory()) {
+        await this.scanPacksDir(
+          path.join(dir, entry.name),
+          prefix ? `${prefix}/${entry.name}` : entry.name,
+          result
+        )
+      } else if (entry.name.endsWith('.json')) {
+        const packId = prefix
+          ? `${prefix}/${entry.name.replace('.json', '')}`
+          : entry.name.replace('.json', '')
+
+        try {
+          const content = await fs.readFile(path.join(dir, entry.name), 'utf-8')
+          const raw = JSON.parse(content)
+          const pack = KnowledgePackSchema.parse(raw)
+          result.push({
+            id: packId,
+            name: pack.name,
+            description: pack.description,
+            entries: pack.entries.length,
+            version: pack.version
+          })
+        } catch (error) {
+          this.logger.warn({ error, packId }, 'Skipping invalid pack file')
+        }
+      }
+    }
+  }
+
+  private getManifestPath(project: string): string {
+    return path.join(this.dataDir, 'pack-manifests', `${project}.json`)
+  }
+}

package/src/packs/ranker.ts

@@ -1,78 +1,78 @@
-/**
- * Phase 18: Knowledge Ranker
- * Post-processing layer for search results that boosts personal entries
- * over community (pack) entries
- */
-
-import type { PacksConfig } from '@/config/schema'
-
-export interface RankedResult {
-  id: string
-  content: string
-  metadata: Record<string, any>
-  similarity: number
-  adjustedScore: number
-  badge: 'personal' | 'community'
-}
-
-export class KnowledgeRanker {
-  private personalBoost: number
-  private projectBoost: number
-
-  constructor(config: PacksConfig) {
-    this.personalBoost = config.personalBoost
-    this.projectBoost = config.projectBoost
-  }
-
-  /** Adjust similarity scores based on entry source */
-  rank(
-    results: Array<{ id: string; content: string; metadata: Record<string, any>; similarity: number }>,
-    currentProject?: string
-  ): RankedResult[] {
-    const ranked = results.map(result => {
-      const isCommunity = this.isCommunityEntry(result.metadata)
-      let adjustedScore = result.similarity
-
-      if (!isCommunity) {
-        // Personal entries get a boost
-        adjustedScore *= this.personalBoost
-
-        // Project-specific entries get an additional boost
-        if (currentProject && result.metadata.project === currentProject) {
-          adjustedScore *= this.projectBoost
-        }
-      }
-      // Community entries: no boost (effectively ranked lower)
-
-      // Cap at 1.0
-      adjustedScore = Math.min(adjustedScore, 1.0)
-
-      return {
-        id: result.id,
-        content: result.content,
-        metadata: result.metadata,
-        similarity: result.similarity,
-        adjustedScore,
-        badge: isCommunity ? 'community' as const : 'personal' as const
-      }
-    })
-
-    // Sort by adjusted score descending
-    return ranked.sort((a, b) => b.adjustedScore - a.adjustedScore)
-  }
-
-  /** Detect if a search result is from a community pack */
-  isCommunityEntry(metadata: Record<string, any>): boolean {
-    // Check source field
-    if (typeof metadata.source === 'string' && metadata.source.startsWith('pack:')) {
-      return true
-    }
-
-    // Check context field for community marker
-    if (typeof metadata.context === 'string' && metadata.context.includes('[community:pack:')) {
-      return true
-    }
-
-    return false
-  }
-}
+/**
+ * Phase 18: Knowledge Ranker
+ * Post-processing layer for search results that boosts personal entries
+ * over community (pack) entries
+ */
+
+import type { PacksConfig } from '@/config/schema'
+
+export interface RankedResult {
+  id: string
+  content: string
+  metadata: Record<string, any>
+  similarity: number
+  adjustedScore: number
+  badge: 'personal' | 'community'
+}
+
+export class KnowledgeRanker {
+  private personalBoost: number
+  private projectBoost: number
+
+  constructor(config: PacksConfig) {
+    this.personalBoost = config.personalBoost
+    this.projectBoost = config.projectBoost
+  }
+
+  /** Adjust similarity scores based on entry source */
+  rank(
+    results: Array<{ id: string; content: string; metadata: Record<string, any>; similarity: number }>,
+    currentProject?: string
+  ): RankedResult[] {
+    const ranked = results.map(result => {
+      const isCommunity = this.isCommunityEntry(result.metadata)
+      let adjustedScore = result.similarity
+
+      if (!isCommunity) {
+        // Personal entries get a boost
+        adjustedScore *= this.personalBoost
+
+        // Project-specific entries get an additional boost
+        if (currentProject && result.metadata.project === currentProject) {
+          adjustedScore *= this.projectBoost
+        }
+      }
+      // Community entries: no boost (effectively ranked lower)
+
+      // Cap at 1.0
+      adjustedScore = Math.min(adjustedScore, 1.0)
+
+      return {
+        id: result.id,
+        content: result.content,
+        metadata: result.metadata,
+        similarity: result.similarity,
+        adjustedScore,
+        badge: isCommunity ? 'community' as const : 'personal' as const
+      }
+    })
+
+    // Sort by adjusted score descending
+    return ranked.sort((a, b) => b.adjustedScore - a.adjustedScore)
+  }
+
+  /** Detect if a search result is from a community pack */
+  isCommunityEntry(metadata: Record<string, any>): boolean {
+    // Check source field
+    if (typeof metadata.source === 'string' && metadata.source.startsWith('pack:')) {
+      return true
+    }
+
+    // Check context field for community marker
+    if (typeof metadata.context === 'string' && metadata.context.includes('[community:pack:')) {
+      return true
+    }
+
+    return false
+  }
+}