claude-brain 0.30.2 → 0.30.3

package/src/intelligence/model-manager.ts

@@ -1,245 +1,263 @@
-/**
- * Model Manager — SLM Upgrade Phase 4A
- * Discovers, loads, and caches ONNX models from ~/.claude-brain/models/
- * Lazy loading: models load on first use, not at startup.
- */
-
-import { existsSync, readFileSync } from 'node:fs'
-import { join } from 'node:path'
-import type { Logger } from 'pino'
-import { getHomePaths } from '@/config/home'
-
-export type ModelTask = 'intent' | 'entity' | 'query' | 'knowledge' | 'compress' | 'pattern'
-
-export interface ModelManifestEntry {
-  version: string
-  file: string
-  sha256?: string
-  params?: string
-  accuracy?: number
-  labels?: string[]
-  maxSeqLen?: number
-}
-
-export interface ModelManifest {
-  models: Partial<Record<ModelTask, ModelManifestEntry>>
-}
-
-export interface LoadedModel {
-  session: any  // onnxruntime.InferenceSession
-  manifest: ModelManifestEntry
-  loadedAt: number
-}
-
-export class ModelManager {
-  private modelsDir: string
-  private manifest: ModelManifest | null = null
-  private loadedModels = new Map<ModelTask, LoadedModel>()
-  private onnxRuntime: any = null
-  private onnxAvailable: boolean | null = null
-  private logger: Logger
-
-  constructor(logger: Logger, modelsDir?: string) {
-    this.logger = logger.child({ component: 'model-manager' })
-    this.modelsDir = modelsDir || getHomePaths().models
-  }
-
-  /**
-   * Check if ONNX Runtime is available (installed as optional dep)
-   * Tries onnxruntime-node first (faster native), falls back to onnxruntime-web (WASM)
-   */
-  private async checkOnnxRuntime(): Promise<boolean> {
-    if (this.onnxAvailable !== null) return this.onnxAvailable
-    // Try native node bindings first
-    try {
-      this.onnxRuntime = await import('onnxruntime-node')
-      this.onnxAvailable = true
-      this.logger.debug('ONNX Runtime (native) available')
-      return true
-    } catch {
-      // Native not available, try WASM fallback
-    }
-    try {
-      this.onnxRuntime = await import('onnxruntime-web')
-      this.onnxAvailable = true
-      this.logger.debug('ONNX Runtime (WASM) available')
-    } catch {
-      this.onnxAvailable = false
-      this.logger.debug('ONNX Runtime not installed — models will not load')
-    }
-    return this.onnxAvailable
-  }
-
-  /**
-   * Load the manifest.json from the models directory
-   */
-  private loadManifest(): ModelManifest | null {
-    if (this.manifest) return this.manifest
-    const manifestPath = join(this.modelsDir, 'manifest.json')
-    if (!existsSync(manifestPath)) {
-      this.logger.debug({ modelsDir: this.modelsDir }, 'No manifest.json found')
-      return null
-    }
-    try {
-      const raw = readFileSync(manifestPath, 'utf-8')
-      this.manifest = JSON.parse(raw) as ModelManifest
-      return this.manifest
-    } catch (error) {
-      this.logger.warn({ error }, 'Failed to parse manifest.json')
-      return null
-    }
-  }
-
-  /**
-   * Check if a model file exists for a given task (without loading it)
-   */
-  hasModel(task: ModelTask): boolean {
-    const manifest = this.loadManifest()
-    if (!manifest?.models[task]) return false
-    const entry = manifest.models[task]!
-    return existsSync(join(this.modelsDir, entry.file))
-  }
-
-  /**
-   * Get manifest entry for a task
-   */
-  getManifestEntry(task: ModelTask): ModelManifestEntry | null {
-    const manifest = this.loadManifest()
-    return manifest?.models[task] ?? null
-  }
-
-  /**
-   * Lazy-load a model on first use. Returns null if unavailable.
-   */
-  async loadModel(task: ModelTask): Promise<LoadedModel | null> {
-    // Return cached model
-    if (this.loadedModels.has(task)) return this.loadedModels.get(task)!
-
-    // Check prerequisites
-    if (!(await this.checkOnnxRuntime())) return null
-    const manifest = this.loadManifest()
-    if (!manifest?.models[task]) return null
-
-    const entry = manifest.models[task]!
-    const modelPath = join(this.modelsDir, entry.file)
-    if (!existsSync(modelPath)) {
-      this.logger.debug({ task, file: entry.file }, 'Model file not found')
-      return null
-    }
-
-    try {
-      const startMs = Date.now()
-      const session = await this.onnxRuntime.InferenceSession.create(modelPath)
-      const loaded: LoadedModel = {
-        session,
-        manifest: entry,
-        loadedAt: Date.now(),
-      }
-      this.loadedModels.set(task, loaded)
-      this.logger.info({ task, file: entry.file, loadMs: Date.now() - startMs }, 'Model loaded')
-      return loaded
-    } catch (err) {
-      const error = err instanceof Error ? { message: err.message, stack: err.stack } : err
-      this.logger.warn({ error, task, file: entry.file }, 'Failed to load model')
-      return null
-    }
-  }
-
-  /**
-   * Run inference on a loaded model. Returns raw output tensor data.
-   * Callers (InferenceRouter) handle task-specific pre/post processing.
-   * Automatically detects which inputs the model accepts (input_ids, attention_mask).
-   */
-  async infer(task: ModelTask, inputIds: number[], attentionMask?: number[]): Promise<Float32Array | null> {
-    const model = await this.loadModel(task)
-    if (!model) return null
-
-    try {
-      const OrtTensor = this.onnxRuntime.Tensor
-      const inputTensor = new OrtTensor('int64', BigInt64Array.from(inputIds.map(BigInt)), [1, inputIds.length])
-      const feeds: Record<string, any> = { input_ids: inputTensor }
-
-      // Only pass attention_mask if the model actually accepts it
-      const modelInputNames = model.session.inputNames ?? []
-      if (attentionMask && modelInputNames.includes('attention_mask')) {
-        const maskTensor = new OrtTensor('int64', BigInt64Array.from(attentionMask.map(BigInt)), [1, attentionMask.length])
-        feeds.attention_mask = maskTensor
-      }
-
-      const results = await model.session.run(feeds)
-
-      // Most classification models output 'logits'
-      const outputKey = Object.keys(results)[0]
-      if (!outputKey) return null
-      return results[outputKey].data as Float32Array
-    } catch (err) {
-      const error = err instanceof Error ? { message: err.message, stack: err.stack } : err
-      this.logger.warn({ error, task }, 'Inference failed')
-      return null
-    }
-  }
-
-  /**
-   * Public accessor for the models directory path
-   */
-  getModelsDir(): string {
-    return this.modelsDir
-  }
-
-  /**
-   * Public check for ONNX Runtime availability
-   */
-  async isOnnxAvailable(): Promise<boolean> {
-    return this.checkOnnxRuntime()
-  }
-
-  /**
-   * Get status of all models (for CLI and health checks)
-   */
-  getStatus(): Record<ModelTask, { available: boolean; loaded: boolean; version?: string; accuracy?: number }> {
-    const tasks: ModelTask[] = ['intent', 'entity', 'query', 'knowledge', 'compress', 'pattern']
-    const status = {} as Record<ModelTask, { available: boolean; loaded: boolean; version?: string; accuracy?: number }>
-
-    for (const task of tasks) {
-      const entry = this.getManifestEntry(task)
-      status[task] = {
-        available: this.hasModel(task),
-        loaded: this.loadedModels.has(task),
-        version: entry?.version,
-        accuracy: entry?.accuracy,
-      }
-    }
-    return status
-  }
-
-  /**
-   * Unload a single model, releasing its ONNX session to free native memory.
-   */
-  async unloadModel(task: ModelTask): Promise<void> {
-    const loaded = this.loadedModels.get(task)
-    if (!loaded) return
-
-    try {
-      await loaded.session?.release?.()
-    } catch (err) {
-      this.logger.warn({ error: err, task }, 'Failed to release ONNX session')
-    }
-    this.loadedModels.delete(task)
-    this.logger.debug({ task }, 'Model unloaded')
-  }
-
-  /**
-   * Unload all models, releasing ONNX sessions to free native memory.
-   */
-  async unloadAll(): Promise<void> {
-    for (const [task, loaded] of this.loadedModels) {
-      try {
-        await loaded.session?.release?.()
-      } catch (err) {
-        this.logger.warn({ error: err, task }, 'Failed to release ONNX session during unloadAll')
-      }
-    }
-    this.loadedModels.clear()
-    this.logger.debug('All models unloaded')
-  }
-}
+/**
+ * Model Manager — SLM Upgrade Phase 4A
+ * Discovers, loads, and caches ONNX models from ~/.claude-brain/models/
+ * Lazy loading: models load on first use, not at startup.
+ */
+
+import { existsSync, readFileSync } from 'node:fs'
+import { join } from 'node:path'
+import type { Logger } from 'pino'
+import { getHomePaths } from '@/config/home'
+
+/** Minimal shape for dynamically imported onnxruntime-node/web */
+interface OnnxRuntime {
+  InferenceSession: {
+    create(path: string): Promise<OnnxSession>
+  }
+  Tensor: new (type: string, data: BigInt64Array, dims: number[]) => unknown
+}
+
+interface OnnxSession {
+  inputNames?: string[]
+  run(feeds: Record<string, unknown>): Promise<Record<string, { data: Float32Array }>>
+  release?(): Promise<void>
+}
+
+export type ModelTask = 'intent' | 'entity' | 'query' | 'knowledge' | 'compress' | 'pattern'
+
+export interface ModelManifestEntry {
+  version: string
+  file: string
+  sha256?: string
+  params?: string
+  accuracy?: number
+  labels?: string[]
+  maxSeqLen?: number
+}
+
+export interface ModelManifest {
+  models: Partial<Record<ModelTask, ModelManifestEntry>>
+}
+
+export interface LoadedModel {
+  session: OnnxSession
+  manifest: ModelManifestEntry
+  loadedAt: number
+}
+
+export class ModelManager {
+  private modelsDir: string
+  private manifest: ModelManifest | null = null
+  private loadedModels = new Map<ModelTask, LoadedModel>()
+  private onnxRuntime: unknown = null
+  private onnxAvailable: boolean | null = null
+  private logger: Logger
+
+  constructor(logger: Logger, modelsDir?: string) {
+    this.logger = logger.child({ component: 'model-manager' })
+    this.modelsDir = modelsDir || getHomePaths().models
+  }
+
+  /**
+   * Check if ONNX Runtime is available (installed as optional dep)
+   * Tries onnxruntime-node first (faster native), falls back to onnxruntime-web (WASM)
+   */
+  private async checkOnnxRuntime(): Promise<boolean> {
+    if (this.onnxAvailable !== null) return this.onnxAvailable
+    // Try native node bindings first
+    try {
+      this.onnxRuntime = await import('onnxruntime-node')
+      this.onnxAvailable = true
+      this.logger.debug('ONNX Runtime (native) available')
+      return true
+    } catch {
+      // Native not available, try WASM fallback
+    }
+    try {
+      this.onnxRuntime = await import('onnxruntime-web')
+      this.onnxAvailable = true
+      this.logger.debug('ONNX Runtime (WASM) available')
+    } catch {
+      this.onnxAvailable = false
+      this.logger.debug('ONNX Runtime not installed — models will not load')
+    }
+    return this.onnxAvailable
+  }
+
+  /**
+   * Load the manifest.json from the models directory
+   */
+  private loadManifest(): ModelManifest | null {
+    if (this.manifest) return this.manifest
+    const manifestPath = join(this.modelsDir, 'manifest.json')
+    if (!existsSync(manifestPath)) {
+      this.logger.debug({ modelsDir: this.modelsDir }, 'No manifest.json found')
+      return null
+    }
+    try {
+      const raw = readFileSync(manifestPath, 'utf-8')
+      this.manifest = JSON.parse(raw) as ModelManifest
+      return this.manifest
+    } catch (error) {
+      this.logger.warn({ error }, 'Failed to parse manifest.json')
+      return null
+    }
+  }
+
+  /**
+   * Check if a model file exists for a given task (without loading it)
+   */
+  hasModel(task: ModelTask): boolean {
+    const manifest = this.loadManifest()
+    if (!manifest?.models[task]) return false
+    const entry = manifest.models[task]!
+    return existsSync(join(this.modelsDir, entry.file))
+  }
+
+  /**
+   * Get manifest entry for a task
+   */
+  getManifestEntry(task: ModelTask): ModelManifestEntry | null {
+    const manifest = this.loadManifest()
+    return manifest?.models[task] ?? null
+  }
+
+  /**
+   * Lazy-load a model on first use. Returns null if unavailable.
+   */
+  async loadModel(task: ModelTask): Promise<LoadedModel | null> {
+    // Return cached model
+    if (this.loadedModels.has(task)) return this.loadedModels.get(task)!
+
+    // Check prerequisites
+    if (!(await this.checkOnnxRuntime())) return null
+    const manifest = this.loadManifest()
+    if (!manifest?.models[task]) return null
+
+    const entry = manifest.models[task]!
+    const modelPath = join(this.modelsDir, entry.file)
+    if (!existsSync(modelPath)) {
+      this.logger.debug({ task, file: entry.file }, 'Model file not found')
+      return null
+    }
+
+    try {
+      const startMs = Date.now()
+      const ort = this.onnxRuntime as OnnxRuntime
+      const session = await ort.InferenceSession.create(modelPath)
+      const loaded: LoadedModel = {
+        session,
+        manifest: entry,
+        loadedAt: Date.now(),
+      }
+      this.loadedModels.set(task, loaded)
+      this.logger.info({ task, file: entry.file, loadMs: Date.now() - startMs }, 'Model loaded')
+      return loaded
+    } catch (err) {
+      const error = err instanceof Error ? { message: err.message, stack: err.stack } : err
+      this.logger.warn({ error, task, file: entry.file }, 'Failed to load model')
+      return null
+    }
+  }
+
+  /**
+   * Run inference on a loaded model. Returns raw output tensor data.
+   * Callers (InferenceRouter) handle task-specific pre/post processing.
+   * Automatically detects which inputs the model accepts (input_ids, attention_mask).
+   */
+  async infer(task: ModelTask, inputIds: number[], attentionMask?: number[]): Promise<Float32Array | null> {
+    const model = await this.loadModel(task)
+    if (!model) return null
+
+    try {
+      const ort = this.onnxRuntime as OnnxRuntime
+      const OrtTensor = ort.Tensor
+      const inputTensor = new OrtTensor('int64', BigInt64Array.from(inputIds.map(BigInt)), [1, inputIds.length])
+      const feeds: Record<string, unknown> = { input_ids: inputTensor }
+
+      // Only pass attention_mask if the model actually accepts it
+      const modelInputNames = model.session.inputNames ?? []
+      if (attentionMask && modelInputNames.includes('attention_mask')) {
+        const maskTensor = new OrtTensor('int64', BigInt64Array.from(attentionMask.map(BigInt)), [1, attentionMask.length])
+        feeds.attention_mask = maskTensor
+      }
+
+      const results = await model.session.run(feeds)
+
+      // Most classification models output 'logits'
+      const outputKey = Object.keys(results)[0]
+      if (!outputKey) return null
+      const output = results[outputKey]
+      if (!output) return null
+      return output.data as Float32Array
+    } catch (err) {
+      const error = err instanceof Error ? { message: err.message, stack: err.stack } : err
+      this.logger.warn({ error, task }, 'Inference failed')
+      return null
+    }
+  }
+
+  /**
+   * Public accessor for the models directory path
+   */
+  getModelsDir(): string {
+    return this.modelsDir
+  }
+
+  /**
+   * Public check for ONNX Runtime availability
+   */
+  async isOnnxAvailable(): Promise<boolean> {
+    return this.checkOnnxRuntime()
+  }
+
+  /**
+   * Get status of all models (for CLI and health checks)
+   */
+  getStatus(): Record<ModelTask, { available: boolean; loaded: boolean; version?: string; accuracy?: number }> {
+    const tasks: ModelTask[] = ['intent', 'entity', 'query', 'knowledge', 'compress', 'pattern']
+    const status = {} as Record<ModelTask, { available: boolean; loaded: boolean; version?: string; accuracy?: number }>
+
+    for (const task of tasks) {
+      const entry = this.getManifestEntry(task)
+      status[task] = {
+        available: this.hasModel(task),
+        loaded: this.loadedModels.has(task),
+        version: entry?.version,
+        accuracy: entry?.accuracy,
+      }
+    }
+    return status
+  }
+
+  /**
+   * Unload a single model, releasing its ONNX session to free native memory.
+   */
+  async unloadModel(task: ModelTask): Promise<void> {
+    const loaded = this.loadedModels.get(task)
+    if (!loaded) return
+
+    try {
+      await loaded.session?.release?.()
+    } catch (err) {
+      this.logger.warn({ error: err, task }, 'Failed to release ONNX session')
+    }
+    this.loadedModels.delete(task)
+    this.logger.debug({ task }, 'Model unloaded')
+  }
+
+  /**
+   * Unload all models, releasing ONNX sessions to free native memory.
+   */
+  async unloadAll(): Promise<void> {
+    for (const [task, loaded] of this.loadedModels) {
+      try {
+        await loaded.session?.release?.()
+      } catch (err) {
+        this.logger.warn({ error: err, task }, 'Failed to release ONNX session during unloadAll')
+      }
+    }
+    this.loadedModels.clear()
+    this.logger.debug('All models unloaded')
+  }
+}

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'