claude-brain 0.22.4 → 0.24.0

package/VERSION

@@ -1 +1 @@
-0.22.4
+0.24.0

package/package.json

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

package/scripts/postinstall.mjs

@@ -314,6 +314,80 @@ function installClaudeMd() {
   return true
 }
 
+// ── Step 6: Install auto-start in shell profile ──────────
+
+const AUTO_START_MARKER = '# >>> claude-brain auto-start >>>'
+const AUTO_END_MARKER = '# <<< claude-brain auto-start <<<'
+
+function getShellProfile() {
+  const home = homedir()
+  const os = process.platform
+
+  if (os === 'win32') {
+    const userProfile = process.env.USERPROFILE
+    if (userProfile) {
+      return join(userProfile, 'Documents', 'PowerShell', 'Microsoft.PowerShell_profile.ps1')
+    }
+    return null
+  }
+
+  // macOS defaults to zsh, Linux to bash
+  return os === 'darwin' ? join(home, '.zshrc') : join(home, '.bashrc')
+}
+
+function buildAutoStartSnippet(profilePath) {
+  if (profilePath && profilePath.endsWith('.ps1')) {
+    return [
+      AUTO_START_MARKER,
+      'if (Get-Command claude-brain -ErrorAction SilentlyContinue) {',
+      '  $listening = Get-NetTCPConnection -LocalPort 3000 -ErrorAction SilentlyContinue',
+      '  if (-not $listening) {',
+      '    Start-Process -NoNewWindow -FilePath "claude-brain" -ArgumentList "serve" -WindowStyle Hidden',
+      '  }',
+      '}',
+      AUTO_END_MARKER,
+    ].join('\n')
+  }
+  return [
+    AUTO_START_MARKER,
+    '# Auto-start claude-brain server if not already running',
+    '(command -v claude-brain >/dev/null 2>&1 && ! lsof -ti :3000 >/dev/null 2>&1) && {',
+    '  nohup claude-brain serve >/dev/null 2>&1 &',
+    '  disown 2>/dev/null',
+    '}',
+    AUTO_END_MARKER,
+  ].join('\n')
+}
+
+function installShellAutoStart() {
+  const profilePath = getShellProfile()
+  if (!profilePath) {
+    log('No supported shell profile found, skipping auto-start')
+    return false
+  }
+
+  // Check if already installed
+  if (existsSync(profilePath)) {
+    const content = readFileSync(profilePath, 'utf-8')
+    if (content.includes(AUTO_START_MARKER)) {
+      log('Auto-start already installed')
+      return true
+    }
+  }
+
+  // Ensure parent directory exists
+  const dir = join(profilePath, '..')
+  mkdirSync(dir, { recursive: true })
+
+  const existing = existsSync(profilePath) ? readFileSync(profilePath, 'utf-8') : ''
+  const separator = existing.length > 0 && !existing.endsWith('\n') ? '\n\n' : '\n'
+  const snippet = buildAutoStartSnippet(profilePath)
+  writeFileSync(profilePath, existing + separator + snippet + '\n', 'utf-8')
+
+  log(`Auto-start installed in ${profilePath}`)
+  return true
+}
+
 // ── Main ─────────────────────────────────────────────────
 
 async function main() {
@@ -332,6 +406,7 @@ async function main() {
     hooks: false,
     hookFiles: false,
     claudemd: false,
+    autostart: false,
   }
 
   // Step 1: Create data directory
@@ -349,15 +424,17 @@ async function main() {
   // Step 5: Install CLAUDE.md
   try { results.claudemd = installClaudeMd() } catch (e) { log(`CLAUDE.md install failed: ${e.message}`) }
 
+  // Step 6: Install auto-start in shell profile
+  try { results.autostart = installShellAutoStart() } catch (e) { log(`Auto-start install failed: ${e.message}`) }
+
   // Print success summary
   console.error('')
   console.error(`${PREFIX} ────────────────────────────────────────`)
   console.error(`${PREFIX}`)
   console.error(`${PREFIX}  Claude Brain installed successfully!`)
   console.error(`${PREFIX}`)
-  console.error(`${PREFIX}  Next steps:`)
-  console.error(`${PREFIX}    1. Start the server:  claude-brain start`)
-  console.error(`${PREFIX}    2. Restart Claude Code to activate hooks`)
+  console.error(`${PREFIX}  Server will auto-start on next terminal session.`)
+  console.error(`${PREFIX}  Auto-updates check every 24h in the background.`)
   console.error(`${PREFIX}`)
   console.error(`${PREFIX}  Data:   ${HOME}/data/`)
   console.error(`${PREFIX}  Config: ${HOME}/config.yml`)
@@ -365,6 +442,7 @@ async function main() {
   console.error(`${PREFIX}`)
   console.error(`${PREFIX}  No setup wizard needed — everything works out of the box.`)
   console.error(`${PREFIX}  ChromaDB is optional (disabled by default, SQLite FTS5 is used).`)
+  console.error(`${PREFIX}  To disable auto-start: claude-brain autostart uninstall`)
   console.error(`${PREFIX} ────────────────────────────────────────`)
   console.error('')
 }

package/src/cli/auto-start.ts

@@ -0,0 +1,266 @@
+/**
+ * Auto-start integration for claude-brain server.
+ * Installs/uninstalls a shell profile snippet so the server
+ * auto-starts on every new terminal session.
+ *
+ * Pure Node.js — no Bun-specific APIs.
+ */
+
+import { existsSync, readFileSync, writeFileSync, mkdirSync } from 'node:fs'
+import { join, dirname } from 'node:path'
+import { homedir, platform } from 'node:os'
+
+const START_MARKER = '# >>> claude-brain auto-start >>>'
+const END_MARKER = '# <<< claude-brain auto-start <<<'
+
+const PREFIX = '[claude-brain]'
+
+function log(msg: string) {
+  console.error(`${PREFIX} ${msg}`)
+}
+
+export interface AutoStartResult {
+  success: boolean
+  message: string
+  profilePath: string
+}
+
+/**
+ * Build the Unix/macOS/Linux shell snippet.
+ * Uses `lsof` to check if the port is already in use before starting.
+ */
+function buildUnixSnippet(port: number): string {
+  return [
+    START_MARKER,
+    '# Auto-start claude-brain server if not already running',
+    `(command -v claude-brain >/dev/null 2>&1 && ! lsof -ti :${port} >/dev/null 2>&1) && {`,
+    '  nohup claude-brain serve >/dev/null 2>&1 &',
+    '  disown 2>/dev/null',
+    '}',
+    END_MARKER,
+  ].join('\n')
+}
+
+/**
+ * Build the Fish shell snippet.
+ * Fish uses different syntax than bash/zsh.
+ */
+function buildFishSnippet(port: number): string {
+  return [
+    START_MARKER,
+    '# Auto-start claude-brain server if not already running',
+    `if command -v claude-brain >/dev/null 2>&1; and not lsof -ti :${port} >/dev/null 2>&1`,
+    '  nohup claude-brain serve >/dev/null 2>&1 &',
+    'end',
+    END_MARKER,
+  ].join('\n')
+}
+
+/**
+ * Build the PowerShell snippet for Windows.
+ */
+function buildPowerShellSnippet(port: number): string {
+  return [
+    START_MARKER,
+    'if (Get-Command claude-brain -ErrorAction SilentlyContinue) {',
+    `  $port = ${port}`,
+    '  $listening = Get-NetTCPConnection -LocalPort $port -ErrorAction SilentlyContinue',
+    '  if (-not $listening) {',
+    '    Start-Process -NoNewWindow -FilePath "claude-brain" -ArgumentList "serve" -WindowStyle Hidden',
+    '  }',
+    '}',
+    END_MARKER,
+  ].join('\n')
+}
+
+/**
+ * Detect available shell profile files based on platform.
+ * Returns paths that exist or are the primary target for the detected shell.
+ */
+export function getShellProfiles(): string[] {
+  const home = homedir()
+  const os = platform()
+  const profiles: string[] = []
+
+  if (os === 'win32') {
+    // PowerShell profile
+    const psProfile = process.env.USERPROFILE
+      ? join(
+          process.env.USERPROFILE,
+          'Documents',
+          'PowerShell',
+          'Microsoft.PowerShell_profile.ps1'
+        )
+      : null
+    // Also check WindowsPowerShell variant
+    const psProfileLegacy = process.env.USERPROFILE
+      ? join(
+          process.env.USERPROFILE,
+          'Documents',
+          'WindowsPowerShell',
+          'Microsoft.PowerShell_profile.ps1'
+        )
+      : null
+
+    if (psProfile) profiles.push(psProfile)
+    if (psProfileLegacy && psProfileLegacy !== psProfile) profiles.push(psProfileLegacy)
+    return profiles
+  }
+
+  // Unix/macOS/Linux
+  if (os === 'darwin') {
+    // macOS defaults to zsh
+    profiles.push(join(home, '.zshrc'))
+    profiles.push(join(home, '.zprofile'))
+  } else {
+    // Linux defaults to bash
+    profiles.push(join(home, '.bashrc'))
+    profiles.push(join(home, '.bash_profile'))
+  }
+
+  // Fish (cross-platform Unix)
+  const fishConfig = join(home, '.config', 'fish', 'config.fish')
+  if (existsSync(fishConfig)) {
+    profiles.push(fishConfig)
+  }
+
+  return profiles
+}
+
+/**
+ * Check if the auto-start snippet is already in any profile file.
+ */
+function profileContainsSnippet(profilePath: string): boolean {
+  if (!existsSync(profilePath)) return false
+  const content = readFileSync(profilePath, 'utf-8')
+  return content.includes(START_MARKER)
+}
+
+/**
+ * Get the appropriate snippet for a given profile path.
+ */
+function getSnippetForProfile(profilePath: string, port: number): string {
+  if (profilePath.endsWith('.ps1')) {
+    return buildPowerShellSnippet(port)
+  }
+  if (profilePath.includes('fish')) {
+    return buildFishSnippet(port)
+  }
+  return buildUnixSnippet(port)
+}
+
+/**
+ * Install auto-start snippet into the primary shell profile.
+ * Idempotent — skips if already installed.
+ */
+export function installAutoStart(port: number = 3000): AutoStartResult {
+  const profiles = getShellProfiles()
+
+  if (profiles.length === 0) {
+    return {
+      success: false,
+      message: 'No supported shell profile found',
+      profilePath: '',
+    }
+  }
+
+  // Use the first (primary) profile
+  const profilePath = profiles[0]
+
+  // Already installed?
+  if (profileContainsSnippet(profilePath)) {
+    log(`Auto-start already installed in ${profilePath}`)
+    return {
+      success: true,
+      message: 'Auto-start already installed',
+      profilePath,
+    }
+  }
+
+  // Ensure parent directory exists
+  const dir = dirname(profilePath)
+  if (!existsSync(dir)) {
+    mkdirSync(dir, { recursive: true })
+  }
+
+  // Read existing content or start fresh
+  const existing = existsSync(profilePath) ? readFileSync(profilePath, 'utf-8') : ''
+
+  // Append snippet with a blank line separator
+  const separator = existing.length > 0 && !existing.endsWith('\n') ? '\n\n' : '\n'
+  const snippet = getSnippetForProfile(profilePath, port)
+  writeFileSync(profilePath, existing + separator + snippet + '\n', 'utf-8')
+
+  log(`Auto-start installed in ${profilePath}`)
+  return {
+    success: true,
+    message: `Auto-start installed in ${profilePath}`,
+    profilePath,
+  }
+}
+
+/**
+ * Remove auto-start snippet from all known shell profiles.
+ * Removes everything between and including the marker comments.
+ */
+export function uninstallAutoStart(): AutoStartResult {
+  const profiles = getShellProfiles()
+  let removedFrom = ''
+
+  for (const profilePath of profiles) {
+    if (!existsSync(profilePath)) continue
+
+    const content = readFileSync(profilePath, 'utf-8')
+    if (!content.includes(START_MARKER)) continue
+
+    // Remove the snippet block (markers + everything between)
+    const startIdx = content.indexOf(START_MARKER)
+    const endIdx = content.indexOf(END_MARKER)
+
+    if (startIdx === -1 || endIdx === -1) continue
+
+    const endOfMarker = endIdx + END_MARKER.length
+    // Also remove trailing newline after end marker
+    const endWithNewline =
+      endOfMarker < content.length && content[endOfMarker] === '\n'
+        ? endOfMarker + 1
+        : endOfMarker
+
+    // Remove leading blank line if the snippet was appended with separator
+    let start = startIdx
+    if (start > 0 && content[start - 1] === '\n') {
+      start--
+      if (start > 0 && content[start - 1] === '\n') {
+        start--
+      }
+    }
+
+    const cleaned = content.slice(0, start) + content.slice(endWithNewline)
+    writeFileSync(profilePath, cleaned, 'utf-8')
+    removedFrom = profilePath
+    log(`Auto-start removed from ${profilePath}`)
+  }
+
+  if (!removedFrom) {
+    log('Auto-start was not installed in any profile')
+    return {
+      success: true,
+      message: 'Auto-start was not installed in any profile',
+      profilePath: '',
+    }
+  }
+
+  return {
+    success: true,
+    message: `Auto-start removed from ${removedFrom}`,
+    profilePath: removedFrom,
+  }
+}
+
+/**
+ * Check if auto-start is installed in any known shell profile.
+ */
+export function isAutoStartInstalled(): boolean {
+  const profiles = getShellProfiles()
+  return profiles.some((p) => profileContainsSnippet(p))
+}

package/src/cli/bin.ts

@@ -34,6 +34,7 @@ function printHelp() {
     ['uninstall', 'Remove MCP server from Claude Code'],
     ['update', 'Update package and refresh CLAUDE.md'],
     ['refresh', 'Kill all, update to latest, and setup everything'],
+    ['autostart', 'Manage auto-start on terminal open (install/uninstall/status)'],
     ['chroma', 'Manage ChromaDB server (start/stop/status)'],
     ['hooks', 'Manage passive learning hooks (install/uninstall/status)'],
     ['git-hook', 'Manage git post-commit hook (install/uninstall/status)'],
@@ -142,6 +143,12 @@ async function main() {
       break
     }
 
+    case 'autostart': {
+      const { runAutoStart } = await import('./commands/autostart')
+      await runAutoStart()
+      break
+    }
+
     case 'chroma': {
       const { runChroma } = await import('./commands/chroma')
       await runChroma()

package/src/cli/commands/autostart.ts

@@ -0,0 +1,90 @@
+/**
+ * claude-brain autostart — Manage auto-start on terminal open.
+ *
+ * Usage:
+ *   claude-brain autostart install    Install auto-start snippet in shell profile
+ *   claude-brain autostart uninstall  Remove auto-start snippet from shell profiles
+ *   claude-brain autostart status     Check if auto-start is installed
+ */
+
+import {
+  heading, successText, warningText, dimText, box,
+} from '@/cli/ui/index.js'
+import {
+  installAutoStart, uninstallAutoStart, isAutoStartInstalled, getShellProfiles,
+} from '@/cli/auto-start'
+
+export async function runAutoStart(): Promise<void> {
+  const subcommand = process.argv[3] || 'status'
+
+  switch (subcommand) {
+    case 'install': {
+      console.log()
+      console.log(heading('Auto-Start — Install'))
+      console.log()
+
+      const result = installAutoStart()
+      if (result.success) {
+        console.log(successText(`  ${result.message}`))
+        if (result.profilePath) {
+          console.log(dimText(`  Profile: ${result.profilePath}`))
+          console.log()
+          console.log(dimText('  Open a new terminal to activate.'))
+        }
+      } else {
+        console.log(warningText(`  ${result.message}`))
+      }
+      console.log()
+      break
+    }
+
+    case 'uninstall': {
+      console.log()
+      console.log(heading('Auto-Start — Uninstall'))
+      console.log()
+
+      const result = uninstallAutoStart()
+      console.log(successText(`  ${result.message}`))
+      console.log()
+      break
+    }
+
+    case 'status': {
+      console.log()
+      console.log(heading('Auto-Start — Status'))
+      console.log()
+
+      const installed = isAutoStartInstalled()
+      const profiles = getShellProfiles()
+
+      if (installed) {
+        console.log(successText('  Auto-start is installed'))
+      } else {
+        console.log(warningText('  Auto-start is not installed'))
+      }
+
+      console.log(dimText(`  Shell profiles checked: ${profiles.join(', ') || 'none found'}`))
+      console.log()
+
+      if (!installed) {
+        console.log(box([
+          dimText('Install with:'),
+          `  claude-brain autostart install`,
+        ].join('\n'), 'Tip'))
+        console.log()
+      }
+      break
+    }
+
+    default: {
+      console.log()
+      console.log(warningText(`Unknown subcommand: ${subcommand}`))
+      console.log()
+      console.log(dimText('Usage:'))
+      console.log(dimText('  claude-brain autostart install    Install auto-start'))
+      console.log(dimText('  claude-brain autostart uninstall  Remove auto-start'))
+      console.log(dimText('  claude-brain autostart status     Check status'))
+      console.log()
+    }
+  }
+}

package/src/cli/commands/install-mcp.ts

@@ -41,7 +41,7 @@ export async function runInstall() {
     } else {
       try {
         await withSpinner('Registering with Claude Code', async () => {
-          execSync('claude mcp add claude-brain -- claude-brain serve', {
+          execSync('claude mcp add claude-brain -s user -- claude-brain serve', {
             encoding: 'utf-8',
             stdio: ['pipe', 'pipe', 'pipe']
           })
@@ -59,7 +59,7 @@ export async function runInstall() {
             errorText('Failed to register automatically.'),
             '',
             dimText('Run manually:'),
-            `  ${theme.bold('claude mcp add claude-brain -- claude-brain serve')}`,
+            `  ${theme.bold('claude mcp add claude-brain -s user -- claude-brain serve')}`,
           ].join('\n'), 'Error'))
         }
       }
@@ -71,10 +71,10 @@ export async function runInstall() {
     console.log(box([
       `${theme.primary('Option 1:')} Install globally, then register`,
       `  ${theme.bold('bun install -g claude-brain')}`,
-      `  ${theme.bold('claude mcp add claude-brain -- claude-brain serve')}`,
+      `  ${theme.bold('claude mcp add claude-brain -s user -- claude-brain serve')}`,
       '',
       `${theme.primary('Option 2:')} Use bunx ${dimText('(zero-install)')}`,
-      `  ${theme.bold('claude mcp add claude-brain -- bunx claude-brain@latest')}`,
+      `  ${theme.bold('claude mcp add claude-brain -s user -- bunx claude-brain@latest')}`,
       '',
       `${theme.primary('Option 3:')} Add to Claude Code config manually`,
       dimText('  Add to your Claude Code MCP settings:'),

package/src/cli/commands/refresh.ts

@@ -128,7 +128,7 @@ function isMcpConfigured(): boolean {
 
 function registerMcp(): boolean {
   try {
-    execSync('claude mcp add claude-brain -- claude-brain serve', {
+    execSync('claude mcp add claude-brain -s user -- claude-brain serve', {
       encoding: 'utf-8', stdio: ['pipe', 'pipe', 'pipe'], timeout: 10_000,
     })
     return true

package/src/cli/commands/serve.ts

@@ -5,6 +5,7 @@ import { ClaudeBrainMCPServer } from '@/server'
 import { initializeServices, shutdownServices, getVaultService, getMemoryService } from '@/server/services'
 import { createOrchestrator, type Orchestrator } from '@/orchestrator'
 import { ensureHomeDirectory } from '@/cli/auto-setup'
+import { ServerPidManager } from '@/server/pid-manager'
 
 const BANNER = `
 ╔═══════════════════════════════════════════════════════╗
@@ -17,6 +18,18 @@ export async function runServe() {
   // Auto-initialize home directory on first run
   ensureHomeDirectory()
 
+  // Singleton check: prevent multiple server instances
+  const pidManager = new ServerPidManager()
+  const existingPid = pidManager.getRunningPid()
+  if (existingPid) {
+    console.error(`[claude-brain] Server already running (PID: ${existingPid}). Exiting.`)
+    process.exit(0)
+  }
+
+  // Write PID file and register cleanup handlers
+  pidManager.writePidFile()
+  pidManager.registerCleanupHandlers()
+
   // Auto-install Claude Code hooks (idempotent, non-fatal)
   try {
     const { installHooks } = await import('@/hooks/installer')
@@ -118,6 +131,11 @@ export async function runServe() {
     await shutdownServices()
   })
 
+  // Clean up PID file during graceful shutdown
+  cleanup.register(async () => {
+    pidManager.cleanup()
+  })
+
   // Start HTTP API server alongside MCP server
   const { HttpApiServer } = await import('@/server/http-api')
   const httpServer = new HttpApiServer(config, logger)
@@ -190,6 +208,44 @@ export async function runServe() {
     }
   }
 
+  // Phase 31: Auto-update checker
+  let autoUpdater: InstanceType<typeof import('@/server/auto-updater').AutoUpdater> | null = null
+  if (config.autoUpdate?.enabled !== false) {
+    try {
+      const { AutoUpdater } = await import('@/server/auto-updater')
+      autoUpdater = new AutoUpdater(
+        {
+          enabled: config.autoUpdate?.enabled ?? true,
+          checkIntervalHours: config.autoUpdate?.checkIntervalHours ?? 24,
+          autoRestart: config.autoUpdate?.autoRestart ?? true,
+        },
+        mainLogger
+      )
+
+      // Check for updates on startup (non-blocking)
+      autoUpdater.check().then(result => {
+        if (result.updateAvailable && result.latestVersion) {
+          mainLogger.info(
+            { current: result.currentVersion, latest: result.latestVersion },
+            'Update available! Run: claude-brain update'
+          )
+        }
+      }).catch(() => {})
+
+      // Schedule periodic checks
+      autoUpdater.schedulePeriodicCheck()
+
+      cleanup.register(async () => {
+        autoUpdater?.stopPeriodicCheck()
+        mainLogger.info('Auto-updater stopped')
+      })
+
+      mainLogger.info('Auto-updater initialized')
+    } catch (error) {
+      mainLogger.warn({ error }, 'Failed to initialize auto-updater')
+    }
+  }
+
   // Start HTTP server after MCP server is ready
   setTimeout(async () => {
     try {

package/src/cli/commands/uninstall-mcp.ts

@@ -14,12 +14,12 @@ export async function runUninstall() {
   try {
     await withSpinner('Removing Claude Brain from Claude Code', async () => {
       try {
-        execSync('claude mcp remove claude-brain', {
+        execSync('claude mcp remove claude-brain -s user', {
           encoding: 'utf-8',
           stdio: ['pipe', 'pipe', 'pipe'],
         })
       } catch {
-        // Falls back to scoped removal when registered in multiple scopes
+        // Falls back to local scope removal in case it was registered there
         execSync('claude mcp remove claude-brain -s local', {
           encoding: 'utf-8',
           stdio: ['pipe', 'pipe', 'pipe'],

package/src/config/schema.ts

@@ -346,6 +346,16 @@ export const ConfigSchema = z.object({
     enabled: z.boolean().default(true),
   }).default({} as any),
 
+  /** Phase 31: Auto-update configuration */
+  autoUpdate: z.object({
+    /** Enable automatic update checks */
+    enabled: z.boolean().default(true),
+    /** Hours between update checks */
+    checkIntervalHours: z.number().int().min(1).max(168).default(24),
+    /** Automatically restart server after update */
+    autoRestart: z.boolean().default(true),
+  }).default({} as any),
+
   /** Phase 30: Optional LLM compression for observations */
   compression: z.object({
     /** Enable LLM-based compression of long observations */

package/src/hooks/passive-classifier.ts

@@ -211,7 +211,7 @@ export class PassiveClassifier {
         const packages = match[1]?.trim()
         if (packages) {
           return {
-            type: 'decision',
+            type: 'progress',
             confidence: 0.85,
             content: `Installed package(s): ${packages}`,
             project: this.extractProjectFromCwd(input.cwd),