claude-brain 0.14.2 → 0.14.4

package/src/intelligence/cross-project/transfer.ts

@@ -1,201 +1,201 @@
-/**
- * Knowledge Transfer
- * Transfer knowledge from one project to another based on similarity
- */
-
-import type { Logger } from 'pino'
-import type { CollectionManager } from '@/memory/chroma/collection-manager'
-import type { EmbeddingProvider } from '@/memory/chroma/embeddings'
-
-export interface TransferableKnowledge {
-  sourceProject: string
-  targetProject: string
-  items: TransferItem[]
-  affinityScore: number
-}
-
-export interface TransferItem {
-  type: 'decision' | 'pattern' | 'correction'
-  id: string
-  content: string
-  relevance: number
-  reasoning: string
-}
-
-export class KnowledgeTransfer {
-  private logger: Logger
-  private collections: CollectionManager
-  private embeddings?: EmbeddingProvider
-
-  constructor(logger: Logger, collections: CollectionManager, embeddings?: EmbeddingProvider) {
-    this.logger = logger.child({ component: 'knowledge-transfer' })
-    this.collections = collections
-    this.embeddings = embeddings
-  }
-
-  /**
-   * Find transferable knowledge from source project to apply to target project
-   */
-  async findTransferable(sourceProject: string, targetProject: string, options: {
-    limit?: number
-    minRelevance?: number
-  } = {}): Promise<TransferableKnowledge> {
-    const { limit = 10, minRelevance = 0.4 } = options
-
-    // Get target project's decisions to understand its context
-    const targetContext = await this.getProjectContext(targetProject)
-
-    if (!targetContext) {
-      return {
-        sourceProject,
-        targetProject,
-        items: [],
-        affinityScore: 0
-      }
-    }
-
-    // Search source project for relevant knowledge
-    const items: TransferItem[] = []
-
-    // Decisions
-    const decisions = await this.searchSourceProject(
-      sourceProject,
-      targetContext,
-      'decisions',
-      limit,
-      minRelevance
-    )
-    items.push(...decisions)
-
-    // Patterns
-    const patterns = await this.searchSourceProject(
-      sourceProject,
-      targetContext,
-      'patterns',
-      limit,
-      minRelevance
-    )
-    items.push(...patterns)
-
-    // Corrections
-    const corrections = await this.searchSourceProject(
-      sourceProject,
-      targetContext,
-      'corrections',
-      limit,
-      minRelevance
-    )
-    items.push(...corrections)
-
-    // Sort by relevance
-    items.sort((a, b) => b.relevance - a.relevance)
-
-    // Calculate affinity
-    const affinityScore = items.length > 0
-      ? items.reduce((sum, i) => sum + i.relevance, 0) / items.length
-      : 0
-
-    return {
-      sourceProject,
-      targetProject,
-      items: items.slice(0, limit),
-      affinityScore
-    }
-  }
-
-  private async getProjectContext(project: string): Promise<string | null> {
-    try {
-      const collection = await this.collections.getDecisions()
-
-      const results = await collection.get({
-        where: { project: { $eq: project } },
-        include: ['documents'],
-        limit: 20
-      })
-
-      if (results.ids.length === 0) return null
-
-      // Combine recent decisions into a context string
-      return results.documents!
-        .slice(0, 10)
-        .map(d => d as string)
-        .join(' ')
-    } catch (error) {
-      this.logger.debug({ error, project }, 'Failed to get project context')
-      return null
-    }
-  }
-
-  private async searchSourceProject(
-    sourceProject: string,
-    targetContext: string,
-    collectionType: 'decisions' | 'patterns' | 'corrections',
-    limit: number,
-    minRelevance: number
-  ): Promise<TransferItem[]> {
-    try {
-      let collection
-      let type: 'decision' | 'pattern' | 'correction'
-
-      switch (collectionType) {
-        case 'decisions':
-          collection = await this.collections.getDecisions()
-          type = 'decision'
-          break
-        case 'patterns':
-          collection = await this.collections.getPatterns()
-          type = 'pattern'
-          break
-        case 'corrections':
-          collection = await this.collections.getCorrections()
-          type = 'correction'
-          break
-      }
-
-      const where: any = { project: { $eq: sourceProject } }
-
-      let results: any
-
-      if (this.embeddings) {
-        // Use truncated target context for embedding
-        const queryText = targetContext.slice(0, 500)
-        const embedding = await this.embeddings.generate(queryText)
-        results = await collection.query({
-          queryEmbeddings: [embedding],
-          nResults: limit,
-          where,
-          include: ['documents', 'metadatas', 'distances']
-        })
-      } else {
-        results = await collection.query({
-          queryTexts: [targetContext.slice(0, 500)],
-          nResults: limit,
-          where,
-          include: ['documents', 'metadatas', 'distances']
-        })
-      }
-
-      if (!results.ids || !results.ids[0]) return []
-
-      const items: TransferItem[] = []
-
-      for (let i = 0; i < results.ids[0].length; i++) {
-        const similarity = 1 - (results.distances?.[0]?.[i] || 0)
-        if (similarity < minRelevance) continue
-
-        items.push({
-          type,
-          id: results.ids[0][i],
-          content: results.documents?.[0]?.[i] || '',
-          relevance: similarity,
-          reasoning: `Relevant ${type} from ${sourceProject} (${Math.round(similarity * 100)}% match)`
-        })
-      }
-
-      return items
-    } catch (error) {
-      this.logger.debug({ error, sourceProject, collectionType }, 'Failed to search source project')
-      return []
-    }
-  }
-}
+/**
+ * Knowledge Transfer
+ * Transfer knowledge from one project to another based on similarity
+ */
+
+import type { Logger } from 'pino'
+import type { CollectionManager } from '@/memory/chroma/collection-manager'
+import type { EmbeddingProvider } from '@/memory/chroma/embeddings'
+
+export interface TransferableKnowledge {
+  sourceProject: string
+  targetProject: string
+  items: TransferItem[]
+  affinityScore: number
+}
+
+export interface TransferItem {
+  type: 'decision' | 'pattern' | 'correction'
+  id: string
+  content: string
+  relevance: number
+  reasoning: string
+}
+
+export class KnowledgeTransfer {
+  private logger: Logger
+  private collections: CollectionManager
+  private embeddings?: EmbeddingProvider
+
+  constructor(logger: Logger, collections: CollectionManager, embeddings?: EmbeddingProvider) {
+    this.logger = logger.child({ component: 'knowledge-transfer' })
+    this.collections = collections
+    this.embeddings = embeddings
+  }
+
+  /**
+   * Find transferable knowledge from source project to apply to target project
+   */
+  async findTransferable(sourceProject: string, targetProject: string, options: {
+    limit?: number
+    minRelevance?: number
+  } = {}): Promise<TransferableKnowledge> {
+    const { limit = 10, minRelevance = 0.4 } = options
+
+    // Get target project's decisions to understand its context
+    const targetContext = await this.getProjectContext(targetProject)
+
+    if (!targetContext) {
+      return {
+        sourceProject,
+        targetProject,
+        items: [],
+        affinityScore: 0
+      }
+    }
+
+    // Search source project for relevant knowledge
+    const items: TransferItem[] = []
+
+    // Decisions
+    const decisions = await this.searchSourceProject(
+      sourceProject,
+      targetContext,
+      'decisions',
+      limit,
+      minRelevance
+    )
+    items.push(...decisions)
+
+    // Patterns
+    const patterns = await this.searchSourceProject(
+      sourceProject,
+      targetContext,
+      'patterns',
+      limit,
+      minRelevance
+    )
+    items.push(...patterns)
+
+    // Corrections
+    const corrections = await this.searchSourceProject(
+      sourceProject,
+      targetContext,
+      'corrections',
+      limit,
+      minRelevance
+    )
+    items.push(...corrections)
+
+    // Sort by relevance
+    items.sort((a, b) => b.relevance - a.relevance)
+
+    // Calculate affinity
+    const affinityScore = items.length > 0
+      ? items.reduce((sum, i) => sum + i.relevance, 0) / items.length
+      : 0
+
+    return {
+      sourceProject,
+      targetProject,
+      items: items.slice(0, limit),
+      affinityScore
+    }
+  }
+
+  private async getProjectContext(project: string): Promise<string | null> {
+    try {
+      const collection = await this.collections.getDecisions()
+
+      const results = await collection.get({
+        where: { project: { $eq: project } },
+        include: ['documents'],
+        limit: 20
+      })
+
+      if (results.ids.length === 0) return null
+
+      // Combine recent decisions into a context string
+      return results.documents!
+        .slice(0, 10)
+        .map(d => d as string)
+        .join(' ')
+    } catch (error) {
+      this.logger.debug({ error, project }, 'Failed to get project context')
+      return null
+    }
+  }
+
+  private async searchSourceProject(
+    sourceProject: string,
+    targetContext: string,
+    collectionType: 'decisions' | 'patterns' | 'corrections',
+    limit: number,
+    minRelevance: number
+  ): Promise<TransferItem[]> {
+    try {
+      let collection
+      let type: 'decision' | 'pattern' | 'correction'
+
+      switch (collectionType) {
+        case 'decisions':
+          collection = await this.collections.getDecisions()
+          type = 'decision'
+          break
+        case 'patterns':
+          collection = await this.collections.getPatterns()
+          type = 'pattern'
+          break
+        case 'corrections':
+          collection = await this.collections.getCorrections()
+          type = 'correction'
+          break
+      }
+
+      const where: any = { project: { $eq: sourceProject } }
+
+      let results: any
+
+      if (this.embeddings) {
+        // Use truncated target context for embedding
+        const queryText = targetContext.slice(0, 500)
+        const embedding = await this.embeddings.generate(queryText)
+        results = await collection.query({
+          queryEmbeddings: [embedding],
+          nResults: limit,
+          where,
+          include: ['documents', 'metadatas', 'distances']
+        })
+      } else {
+        results = await collection.query({
+          queryTexts: [targetContext.slice(0, 500)],
+          nResults: limit,
+          where,
+          include: ['documents', 'metadatas', 'distances']
+        })
+      }
+
+      if (!results.ids || !results.ids[0]) return []
+
+      const items: TransferItem[] = []
+
+      for (let i = 0; i < results.ids[0].length; i++) {
+        const similarity = 1 - (results.distances?.[0]?.[i] || 0)
+        if (similarity < minRelevance) continue
+
+        items.push({
+          type,
+          id: results.ids[0][i],
+          content: results.documents?.[0]?.[i] || '',
+          relevance: similarity,
+          reasoning: `Relevant ${type} from ${sourceProject} (${Math.round(similarity * 100)}% match)`
+        })
+      }
+
+      return items
+    } catch (error) {
+      this.logger.debug({ error, sourceProject, collectionType }, 'Failed to search source project')
+      return []
+    }
+  }
+}

package/src/intelligence/index.ts

@@ -1,24 +1,24 @@
-/**
- * Intelligence Module
- * Phase 22: Consolidates advanced intelligence features under one namespace.
- *
- * Features are lazy-loaded to avoid startup cost when not needed.
- * Gate on config.intelligence?.enabled for opt-in activation.
- */
-
-import type { Config } from '@/config'
-
-export async function loadIntelligence(config: Config) {
-  if (!(config as any).intelligence?.enabled) return null
-  return {
-    prediction: await import('./prediction'),
-    reasoning: await import('./reasoning'),
-    temporal: await import('./temporal'),
-    optimization: await import('./optimization'),
-    crossProject: await import('./cross-project')
-  }
-}
-
-// Re-export submodule paths for direct imports
-export * from './optimization/semantic-cache'
-export * from './optimization/precompute'
+/**
+ * Intelligence Module
+ * Phase 22: Consolidates advanced intelligence features under one namespace.
+ *
+ * Features are lazy-loaded to avoid startup cost when not needed.
+ * Gate on config.intelligence?.enabled for opt-in activation.
+ */
+
+import type { Config } from '@/config'
+
+export async function loadIntelligence(config: Config) {
+  if (!(config as any).intelligence?.enabled) return null
+  return {
+    prediction: await import('./prediction'),
+    reasoning: await import('./reasoning'),
+    temporal: await import('./temporal'),
+    optimization: await import('./optimization'),
+    crossProject: await import('./cross-project')
+  }
+}
+
+// Re-export submodule paths for direct imports
+export * from './optimization/semantic-cache'
+export * from './optimization/precompute'

package/src/intelligence/optimization/index.ts

@@ -1,10 +1,10 @@
-/**
- * Optimization Module
- * Phase 15.5 - Semantic caching and precomputation
- */
-
-export { SemanticCache } from './semantic-cache'
-export type { CachedResult, CacheStats } from './semantic-cache'
-
-export { PrecomputeEngine } from './precompute'
-export type { PrecomputedStats, ProjectStats } from './precompute'
+/**
+ * Optimization Module
+ * Phase 15.5 - Semantic caching and precomputation
+ */
+
+export { SemanticCache } from './semantic-cache'
+export type { CachedResult, CacheStats } from './semantic-cache'
+
+export { PrecomputeEngine } from './precompute'
+export type { PrecomputedStats, ProjectStats } from './precompute'