claude-brain 0.28.1 → 0.28.2

package/VERSION

@@ -1 +1 @@
-0.28.1
+0.28.2

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "claude-brain",
-  "version": "0.28.1",
+  "version": "0.28.2",
   "description": "Local development assistant bridging Obsidian vaults with Claude Code via MCP",
   "type": "module",
   "main": "src/index.ts",

package/scripts/postinstall.mjs

@@ -77,6 +77,7 @@ function setupHomeDirectory() {
     join(HOME, 'vault', 'Projects'),
     join(HOME, 'vault', 'Global'),
     join(HOME, 'hooks'),
+    join(HOME, 'models'),
   ]
 
   for (const dir of dirs) {
@@ -151,6 +152,20 @@ codeIntelligence:
   enabled: true
   autoIndexOnSessionStart: true
 
+# SLM: Local model inference (replaces regex classifiers)
+# Models are optional — install with: claude-brain models download
+slm:
+  enabled: false
+  modelsDir: ~/.claude-brain/models
+  confidenceThreshold: 0.7
+  tasks:
+    intent: regex
+    entity: regex
+    query: regex
+    knowledge: regex
+    compress: api
+    pattern: regex
+
 logLevel: warn
 `
 
@@ -159,6 +174,48 @@ logLevel: warn
   return true
 }
 
+// ── Step 2b: Upgrade existing config.yml (add missing sections) ──
+
+function upgradeExistingConfig() {
+  const configPath = join(HOME, 'config.yml')
+  if (!existsSync(configPath)) {
+    return false
+  }
+
+  let content
+  try {
+    content = readFileSync(configPath, 'utf-8')
+  } catch {
+    return false
+  }
+
+  // Don't touch if user already has an slm: section
+  if (/^slm:/m.test(content)) {
+    log('Config already has SLM section')
+    return true
+  }
+
+  const slmSection = `
+# SLM: Local model inference (replaces regex classifiers)
+# Models are optional — install with: claude-brain models download
+slm:
+  enabled: false
+  modelsDir: ~/.claude-brain/models
+  confidenceThreshold: 0.7
+  tasks:
+    intent: regex
+    entity: regex
+    query: regex
+    knowledge: regex
+    compress: api
+    pattern: regex
+`
+
+  writeFileSync(configPath, content.trimEnd() + '\n' + slmSection, 'utf-8')
+  log('Upgraded config.yml with SLM section')
+  return true
+}
+
 // ── Step 3: Copy hook files ──────────────────────────────
 
 /** Files to copy from package src/hooks/ to ~/.claude-brain/hooks/ */
@@ -432,6 +489,9 @@ async function main() {
   // Step 2: Create default config.yml
   try { results.config = createDefaultConfig() } catch (e) { log(`Config creation failed: ${e.message}`) }
 
+  // Step 2b: Upgrade existing config.yml with new sections (e.g. SLM)
+  try { upgradeExistingConfig() } catch (e) { log(`Config upgrade failed: ${e.message}`) }
+
   // Step 3: Copy hook files
   try { results.hookFiles = copyHookFiles() } catch (e) { log(`Hook file copy failed: ${e.message}`) }
 

package/src/cli/auto-setup.ts

@@ -51,6 +51,7 @@ export function ensureHomeDirectory(): void {
     paths.vault,
     paths.vaultProjects,
     paths.vaultGlobal,
+    paths.models,
   ]
 
   for (const dir of dirs) {

package/src/cli/commands/models.ts

@@ -23,10 +23,20 @@ import { shouldRetrain, retrainTask, retrainAll, type RetrainConfig } from '@/tr
 
 const ALL_TASKS: ModelTask[] = ['intent', 'entity', 'query', 'knowledge', 'compress', 'pattern']
 
+/** Default mode when disabling a task */
+const DISABLE_MODE: Record<ModelTask, string> = {
+  intent: 'regex',
+  entity: 'regex',
+  query: 'regex',
+  knowledge: 'regex',
+  compress: 'api',
+  pattern: 'regex',
+}
+
 export async function runModels() {
   const args = parseArgs(process.argv.slice(3), {
-    subcommand: { type: 'positional', required: false, description: 'Subcommand: list, download, enable, disable, benchmark, stats, retrain' },
-    taskArg: { type: 'positional', required: false, description: 'Task name (for enable/disable/benchmark/retrain)' },
+    subcommand: { type: 'positional', required: false, description: 'Subcommand: list, status, download, enable, disable, benchmark, stats, retrain' },
+    taskArg: { type: 'positional', required: false, description: 'Task name or "all" (for enable/disable/benchmark/retrain)' },
     task: { type: 'string', description: 'Target task (for download --task)' },
     source: { type: 'string', description: 'Source: local (default) or release' },
     force: { type: 'boolean', description: 'Force retrain even if checks say not needed' },
@@ -38,6 +48,8 @@ export async function runModels() {
   switch (subcommand) {
     case 'list':
       return listModels()
+    case 'status':
+      return showStatus()
     case 'download':
       return downloadModels(taskArg || 'all', (args.source as string) || 'local')
     case 'enable':
@@ -135,6 +147,113 @@ function listModels() {
   console.log()
 }
 
+// ─── status ──────────────────────────────────────────────────────
+
+async function showStatus() {
+  console.log()
+  console.log(renderLogo())
+  console.log()
+  console.log(heading('SLM Inference Status'))
+  console.log()
+
+  // Check ONNX runtime availability
+  let onnxAvailable = false
+  let onnxBackend = 'not installed'
+  try {
+    await import('onnxruntime-node')
+    onnxAvailable = true
+    onnxBackend = 'onnxruntime-node (native)'
+  } catch {
+    try {
+      await import('onnxruntime-web')
+      onnxAvailable = true
+      onnxBackend = 'onnxruntime-web (WASM)'
+    } catch {
+      // Neither available
+    }
+  }
+
+  const config = loadConfigFile()
+  const slmEnabled = config.slm?.enabled ?? false
+  const taskConfig = config.slm?.tasks ?? {}
+
+  const paths = getHomePaths()
+  const manifest = loadManifest()
+
+  const headerItems: Array<{ label: string; value: string; status: 'success' | 'warning' | 'error' | 'info' }> = [
+    {
+      label: 'ONNX Runtime',
+      value: onnxBackend,
+      status: onnxAvailable ? 'success' : 'warning',
+    },
+    {
+      label: 'SLM Enabled',
+      value: slmEnabled ? 'yes' : 'no',
+      status: slmEnabled ? 'success' : 'info',
+    },
+    {
+      label: 'Confidence Threshold',
+      value: `${config.slm?.confidenceThreshold ?? 0.7}`,
+      status: 'info',
+    },
+    {
+      label: 'Models Dir',
+      value: paths.models,
+      status: existsSync(paths.models) ? 'success' : 'warning',
+    },
+  ]
+
+  console.log(summaryPanel('Configuration', headerItems))
+  console.log()
+
+  // Per-task status
+  const taskItems: Array<{ label: string; value: string; status: 'success' | 'warning' | 'error' | 'info' }> = []
+
+  for (const task of ALL_TASKS) {
+    const mode = taskConfig[task] || DISABLE_MODE[task]
+    const entry = manifest?.models?.[task]
+    const fileExists = entry ? existsSync(join(paths.models, entry.file)) : false
+
+    let statusStr = `mode: ${mode}`
+    if (entry) {
+      statusStr += fileExists ? ', model: available' : ', model: MISSING'
+    } else {
+      statusStr += ', no manifest entry'
+    }
+
+    const isActive = (mode === 'model' || mode === 'both') && fileExists && onnxAvailable
+    taskItems.push({
+      label: task,
+      value: statusStr,
+      status: isActive ? 'success' : mode === 'model' || mode === 'both' ? 'error' : 'info',
+    })
+  }
+
+  console.log(summaryPanel('Task Routing', taskItems))
+  console.log()
+
+  if (!onnxAvailable) {
+    console.log(warningText('  ONNX Runtime is not installed. Models cannot be loaded.'))
+    console.log(dimText('    Install with: npm install onnxruntime-node'))
+    console.log()
+  }
+
+  if (!slmEnabled && manifest) {
+    console.log(dimText('  SLM is disabled. Enable with: claude-brain models enable all'))
+    console.log()
+  }
+}
+
+function loadManifest(): ModelManifest | null {
+  const manifestPath = join(getHomePaths().models, 'manifest.json')
+  if (!existsSync(manifestPath)) return null
+  try {
+    return JSON.parse(readFileSync(manifestPath, 'utf-8')) as ModelManifest
+  } catch {
+    return null
+  }
+}
+
 // ─── download ─────────────────────────────────────────────────────
 
 function downloadModels(taskFilter: string, source: string) {
@@ -274,15 +393,15 @@ function downloadModels(taskFilter: string, source: string) {
   writeFileSync(manifestPath, JSON.stringify(manifest, null, 2))
 
   // Auto-enable successfully installed models in config
-  const configPath = join(getClaudeBrainHome(), 'config.json')
-  const config = loadConfigFile(configPath)
+  const config = loadConfigFile()
   if (!config.slm) config.slm = {}
   config.slm.enabled = true
   if (!config.slm.tasks) config.slm.tasks = {}
   for (const task of installedTasks) {
     config.slm.tasks[task] = 'model'
   }
-  writeFileSync(configPath, JSON.stringify(config, null, 2))
+  saveConfigFile(config)
+  updateConfigYml(installedTasks, 'model')
 
   console.log(successText(`Installed ${installed} model${installed !== 1 ? 's' : ''} (total: ${formatBytes(totalBytes)})`))
   console.log(successText(`Auto-enabled ${installedTasks.join(', ')} in config`))
@@ -292,64 +411,96 @@ function downloadModels(taskFilter: string, source: string) {
 
 // ─── enable ───────────────────────────────────────────────────────
 
-function enableTask(task: string) {
-  if (!task) {
-    console.log(errorText('Missing task argument'))
-    console.log(dimText(`Usage: claude-brain models enable <task>`))
-    console.log(dimText(`Tasks: ${ALL_TASKS.join(', ')}`))
-    return
-  }
+function enableTask(taskArg: string) {
+  const tasks = resolveTaskArg(taskArg, 'enable')
+  if (!tasks) return
 
-  if (!ALL_TASKS.includes(task as ModelTask)) {
-    console.log(errorText(`Invalid task: ${task}`))
-    console.log(dimText(`Valid tasks: ${ALL_TASKS.join(', ')}`))
-    return
-  }
+  console.log()
+  console.log(heading('Enable SLM Models'))
+  console.log()
 
-  const configPath = join(getClaudeBrainHome(), 'config.json')
-  const config = loadConfigFile(configPath)
+  const config = loadConfigFile()
 
   // Ensure slm section exists
   if (!config.slm) config.slm = {}
   config.slm.enabled = true
   if (!config.slm.tasks) config.slm.tasks = {}
 
-  // compress uses 'api' baseline, others use 'regex'
-  config.slm.tasks[task] = 'model'
+  for (const task of tasks) {
+    config.slm.tasks[task] = 'model'
+  }
 
-  writeFileSync(configPath, JSON.stringify(config, null, 2))
-  console.log(successText(`Enabled model inference for task: ${task}`))
-  console.log(dimText(`Config updated: ${configPath}`))
+  saveConfigFile(config)
+  updateConfigYml(tasks, 'model')
+
+  for (const task of tasks) {
+    console.log(successText(`${task} -> model`))
+  }
+  console.log()
+  console.log(successText('SLM enabled'))
+  console.log(dimText('  Changes take effect on next server restart'))
+  console.log()
 }
 
 // ─── disable ──────────────────────────────────────────────────────
 
-function disableTask(task: string) {
-  if (!task) {
-    console.log(errorText('Missing task argument'))
-    console.log(dimText(`Usage: claude-brain models disable <task>`))
-    console.log(dimText(`Tasks: ${ALL_TASKS.join(', ')}`))
-    return
+function disableTask(taskArg: string) {
+  const tasks = resolveTaskArg(taskArg, 'disable')
+  if (!tasks) return
+
+  console.log()
+  console.log(heading('Disable SLM Models'))
+  console.log()
+
+  const config = loadConfigFile()
+  if (!config.slm) config.slm = {}
+  if (!config.slm.tasks) config.slm.tasks = {}
+
+  for (const task of tasks) {
+    config.slm.tasks[task] = DISABLE_MODE[task]
   }
 
-  if (!ALL_TASKS.includes(task as ModelTask)) {
-    console.log(errorText(`Invalid task: ${task}`))
-    console.log(dimText(`Valid tasks: ${ALL_TASKS.join(', ')}`))
-    return
+  // If all tasks are now regex/api, disable SLM globally
+  const allDisabled = ALL_TASKS.every(t => {
+    const mode = config.slm.tasks[t] || DISABLE_MODE[t]
+    return mode === 'regex' || mode === 'api'
+  })
+  if (allDisabled) {
+    config.slm.enabled = false
   }
 
-  const configPath = join(getClaudeBrainHome(), 'config.json')
-  const config = loadConfigFile(configPath)
+  saveConfigFile(config)
+  updateConfigYml(tasks, 'disable')
 
-  if (!config.slm) config.slm = {}
-  if (!config.slm.tasks) config.slm.tasks = {}
+  for (const task of tasks) {
+    console.log(warningText(`${task} -> ${DISABLE_MODE[task]}`))
+  }
+  console.log()
+  if (allDisabled) {
+    console.log(warningText('All tasks disabled — SLM globally disabled'))
+  }
+  console.log(dimText('  Changes take effect on next server restart'))
+  console.log()
+}
+
+/** Resolve a task argument to a list of tasks, or null if invalid */
+function resolveTaskArg(taskArg: string, verb: string): ModelTask[] | null {
+  if (!taskArg) {
+    console.log(errorText('Missing task argument'))
+    console.log(dimText(`Usage: claude-brain models ${verb} <task|all>`))
+    console.log(dimText(`Tasks: ${ALL_TASKS.join(', ')}, all`))
+    return null
+  }
 
-  // Revert to baseline: compress → 'api', others → 'regex'
-  config.slm.tasks[task] = task === 'compress' ? 'api' : 'regex'
+  if (taskArg === 'all') return [...ALL_TASKS]
 
-  writeFileSync(configPath, JSON.stringify(config, null, 2))
-  console.log(successText(`Disabled model inference for task: ${task}`))
-  console.log(dimText(`Reverted to ${task === 'compress' ? 'api' : 'regex'} mode`))
+  if (!ALL_TASKS.includes(taskArg as ModelTask)) {
+    console.log(errorText(`Invalid task: ${taskArg}`))
+    console.log(dimText(`Valid tasks: ${ALL_TASKS.join(', ')}, all`))
+    return null
+  }
+
+  return [taskArg as ModelTask]
 }
 
 // ─── benchmark ────────────────────────────────────────────────────
@@ -535,9 +686,8 @@ async function retrainModels(taskFilter: string, force: boolean) {
     return
   }
 
-  // Build config from schema defaults + config.json overrides
-  const configPath = join(getClaudeBrainHome(), 'config.json')
-  const userConfig = loadConfigFile(configPath)
+  // Build config from schema defaults + .claudebrainrc.json overrides
+  const userConfig = loadConfigFile()
   const retrainCfg = userConfig?.slm?.retrain ?? {}
 
   const config: RetrainConfig = {
@@ -632,9 +782,10 @@ function printModelsHelp() {
 
   const subcommands = [
     ['list', 'Show installed models and their status'],
+    ['status', 'Show inference routing and ONNX runtime status'],
     ['download', 'Download pre-trained models (--task <task>|all)'],
-    ['enable <task>', 'Enable model inference for a task'],
-    ['disable <task>', 'Disable model inference for a task'],
+    ['enable <task|all>', 'Enable model inference for task(s)'],
+    ['disable <task|all>', 'Disable model inference for task(s)'],
     ['benchmark <task>', 'Run accuracy benchmark on test data'],
     ['stats', 'Show training data statistics'],
     ['retrain [<task>|all]', 'Retrain models from feedback (--force)'],
@@ -653,7 +804,10 @@ function printModelsHelp() {
   console.log()
   console.log(theme.bold('Examples:'))
   console.log(`  ${dimText('claude-brain models list')}`)
+  console.log(`  ${dimText('claude-brain models status')}`)
+  console.log(`  ${dimText('claude-brain models enable all')}`)
   console.log(`  ${dimText('claude-brain models enable intent')}`)
+  console.log(`  ${dimText('claude-brain models disable pattern')}`)
   console.log(`  ${dimText('claude-brain models benchmark intent')}`)
   console.log(`  ${dimText('claude-brain models stats')}`)
   console.log(`  ${dimText('claude-brain models retrain intent')}`)
@@ -663,15 +817,58 @@ function printModelsHelp() {
 
 // ─── helpers ──────────────────────────────────────────────────────
 
-function loadConfigFile(configPath: string): Record<string, any> {
-  if (!existsSync(configPath)) return {}
+const RC_FILE = '.claudebrainrc.json'
+
+function loadConfigFile(): Record<string, any> {
+  const rcPath = join(getClaudeBrainHome(), RC_FILE)
+  if (!existsSync(rcPath)) return {}
   try {
-    return JSON.parse(readFileSync(configPath, 'utf-8'))
+    return JSON.parse(readFileSync(rcPath, 'utf-8'))
   } catch {
     return {}
   }
 }
 
+function saveConfigFile(config: Record<string, any>): void {
+  const rcPath = join(getClaudeBrainHome(), RC_FILE)
+  writeFileSync(rcPath, JSON.stringify(config, null, 2) + '\n', 'utf-8')
+}
+
+/** Best-effort update of config.yml task lines for user visibility */
+function updateConfigYml(tasks: ModelTask[], mode: string): void {
+  const ymlPath = join(getClaudeBrainHome(), 'config.yml')
+  if (!existsSync(ymlPath)) return
+
+  try {
+    let content = readFileSync(ymlPath, 'utf-8')
+
+    // Update each task line (e.g. "    intent: regex" -> "    intent: model")
+    for (const task of tasks) {
+      const newMode = mode === 'disable' ? DISABLE_MODE[task] : mode
+      const regex = new RegExp(`^(\\s*${task}:\\s*)\\S+`, 'm')
+      content = content.replace(regex, `$1${newMode}`)
+    }
+
+    // Update slm.enabled line if present
+    // Use a heuristic: find "enabled:" that appears after "slm:"
+    const slmIdx = content.indexOf('slm:')
+    if (slmIdx !== -1) {
+      const afterSlm = content.slice(slmIdx)
+      const enabledMatch = afterSlm.match(/^(\s+enabled:\s*)\S+/m)
+      if (enabledMatch) {
+        const config = loadConfigFile()
+        const slmEnabled = config.slm?.enabled ?? false
+        const newLine = `${enabledMatch[1]}${slmEnabled}`
+        content = content.slice(0, slmIdx) + afterSlm.replace(enabledMatch[0], newLine)
+      }
+    }
+
+    writeFileSync(ymlPath, content, 'utf-8')
+  } catch {
+    // Non-critical — .claudebrainrc.json is the authoritative config
+  }
+}
+
 function formatBytes(bytes: number): string {
   if (bytes === 0) return '0 B'
   const units = ['B', 'KB', 'MB', 'GB']

package/src/intelligence/model-manager.ts

@@ -179,6 +179,20 @@ export class ModelManager {
     }
   }
 
+  /**
+   * 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)
    */

package/src/server/services.ts

@@ -394,6 +394,41 @@ export async function initializeServices(config: Config, logger: Logger): Promis
       serviceLogger.info('SLM inference wired into PatternRecognizer')
     }
 
+    // SLM startup detection: log model availability and configuration state
+    if (modelManager) {
+      const modelStatus = modelManager.getStatus()
+      const modelsDir = modelManager.getModelsDir()
+      const availableCount = Object.values(modelStatus).filter(s => s.available).length
+      const slmEnabled = config.slm?.enabled ?? false
+
+      if (availableCount > 0 && !slmEnabled) {
+        serviceLogger.info(
+          { count: availableCount, modelsDir },
+          `Found ${availableCount} ONNX models in ${modelsDir}. SLM is disabled. Run "claude-brain models enable all" to activate local inference.`
+        )
+      } else if (availableCount > 0 && slmEnabled) {
+        const tasks = config.slm?.tasks ?? {}
+        const enabledTasks = Object.entries(tasks)
+          .filter(([_, mode]) => mode === 'model' || mode === 'both')
+          .map(([task]) => task)
+        serviceLogger.info(
+          { count: availableCount, enabledTasks },
+          `SLM active: ${enabledTasks.length} tasks using local model inference`
+        )
+
+        // Check onnxruntime availability when SLM is enabled
+        const onnxAvailable = await modelManager.isOnnxAvailable()
+        if (!onnxAvailable) {
+          serviceLogger.warn('SLM enabled but onnxruntime-node not installed. Run: bun add onnxruntime-node')
+        }
+      } else if (availableCount === 0 && slmEnabled) {
+        serviceLogger.warn(
+          { modelsDir },
+          `SLM enabled but no models found in ${modelsDir}. Run "claude-brain models download" to install models.`
+        )
+      }
+    }
+
     // Store services
     services = {
       memory,