@rlabs-inc/memory 0.1.0 → 0.2.0

package/src/cli/commands/install.ts

@@ -0,0 +1,153 @@
+// ============================================================================
+// INSTALL COMMAND - Set up Claude Code hooks
+// ============================================================================
+
+import { homedir } from 'os'
+import { join, dirname } from 'path'
+import { existsSync, mkdirSync } from 'fs'
+import { c, symbols, fmt } from '../colors.ts'
+
+interface InstallOptions {
+  verbose?: boolean
+  force?: boolean
+}
+
+export async function install(options: InstallOptions) {
+  console.log()
+  console.log(c.header(`${symbols.brain} Memory - Install Hooks`))
+  console.log()
+
+  const claudeDir = join(homedir(), '.claude')
+  const settingsPath = join(claudeDir, 'settings.json')
+
+  // Find the hooks directory (relative to this CLI)
+  const cliPath = import.meta.dir
+  const packageRoot = join(cliPath, '..', '..', '..')
+  const hooksDir = join(packageRoot, 'hooks')
+
+  console.log(`  ${fmt.kv('Claude config', claudeDir)}`)
+  console.log(`  ${fmt.kv('Hooks source', hooksDir)}`)
+  console.log()
+
+  // Check if hooks directory exists
+  if (!existsSync(hooksDir)) {
+    console.log(c.error(`  ${symbols.cross} Hooks directory not found at ${hooksDir}`))
+    console.log(c.muted(`  Make sure the memory package is properly installed`))
+    process.exit(1)
+  }
+
+  // Ensure .claude directory exists
+  if (!existsSync(claudeDir)) {
+    mkdirSync(claudeDir, { recursive: true })
+    console.log(`  ${c.success(symbols.tick)} Created ${claudeDir}`)
+  }
+
+  // Read existing settings or create new
+  let settings: any = {}
+  if (existsSync(settingsPath)) {
+    try {
+      const content = await Bun.file(settingsPath).text()
+      settings = JSON.parse(content)
+      console.log(`  ${c.success(symbols.tick)} Found existing settings.json`)
+    } catch {
+      console.log(`  ${c.warn(symbols.warning)} Could not parse settings.json, creating backup`)
+      const backupPath = `${settingsPath}.backup.${Date.now()}`
+      await Bun.write(backupPath, await Bun.file(settingsPath).text())
+    }
+  }
+
+  // Build hooks configuration
+  const sessionStartHook = join(hooksDir, 'session-start.ts')
+  const userPromptHook = join(hooksDir, 'user-prompt.ts')
+  const curationHook = join(hooksDir, 'curation.ts')
+
+  const hooksConfig = {
+    SessionStart: [
+      {
+        matcher: 'startup|resume',
+        hooks: [
+          {
+            type: 'command',
+            command: `bun "${sessionStartHook}"`,
+            timeout: 10
+          }
+        ]
+      }
+    ],
+    UserPromptSubmit: [
+      {
+        hooks: [
+          {
+            type: 'command',
+            command: `bun "${userPromptHook}"`,
+            timeout: 10
+          }
+        ]
+      }
+    ],
+    PreCompact: [
+      {
+        matcher: 'auto|manual',
+        hooks: [
+          {
+            type: 'command',
+            command: `bun "${curationHook}"`,
+            timeout: 120
+          }
+        ]
+      }
+    ],
+    SessionEnd: [
+      {
+        hooks: [
+          {
+            type: 'command',
+            command: `bun "${curationHook}"`,
+            timeout: 120
+          }
+        ]
+      }
+    ]
+  }
+
+  // Check for existing hooks
+  if (settings.hooks && !options.force) {
+    const existingHooks = Object.keys(settings.hooks)
+    if (existingHooks.length > 0) {
+      console.log()
+      console.log(c.warn(`  ${symbols.warning} Existing hooks found: ${existingHooks.join(', ')}`))
+      console.log(c.muted(`  Use --force to overwrite, or manually merge in settings.json`))
+      console.log()
+
+      // Show what would be added
+      console.log(c.bold('  Hooks to add:'))
+      console.log(c.muted('  ' + JSON.stringify(hooksConfig, null, 2).split('\n').join('\n  ')))
+      console.log()
+      process.exit(1)
+    }
+  }
+
+  // Merge hooks
+  settings.hooks = {
+    ...settings.hooks,
+    ...hooksConfig
+  }
+
+  // Write settings
+  try {
+    await Bun.write(settingsPath, JSON.stringify(settings, null, 2))
+    console.log(`  ${c.success(symbols.tick)} Updated ${settingsPath}`)
+  } catch (error: any) {
+    console.log(c.error(`  ${symbols.cross} Failed to write settings: ${error.message}`))
+    process.exit(1)
+  }
+
+  console.log()
+  console.log(c.success(`${symbols.sparkles} Hooks installed successfully!`))
+  console.log()
+  console.log(c.bold('Next steps:'))
+  console.log(`  1. Start the memory server: ${c.command('memory serve')}`)
+  console.log(`  2. Open Claude Code in any project`)
+  console.log(`  3. Memories will be automatically injected`)
+  console.log()
+}

package/src/cli/commands/serve.ts

@@ -0,0 +1,76 @@
+// ============================================================================
+// SERVE COMMAND - Start the memory server
+// ============================================================================
+
+import { c, symbols, fmt, box } from '../colors.ts'
+import { createServer } from '../../server/index.ts'
+
+interface ServeOptions {
+  port?: string
+  verbose?: boolean
+  quiet?: boolean
+}
+
+export async function serve(options: ServeOptions) {
+  const port = parseInt(options.port || process.env.MEMORY_PORT || '8765')
+  const host = process.env.MEMORY_HOST || 'localhost'
+  const storageMode = (process.env.MEMORY_STORAGE_MODE || 'central') as 'central' | 'local'
+  const apiKey = process.env.ANTHROPIC_API_KEY
+
+  if (!options.quiet) {
+    console.log()
+    console.log(c.header(`${symbols.brain} Memory Server`))
+    console.log()
+  }
+
+  try {
+    const { server } = createServer({
+      port,
+      host,
+      storageMode,
+      curator: { apiKey },
+    })
+
+    if (!options.quiet) {
+      const url = `http://${host}:${port}`
+
+      console.log(`  ${c.success(symbols.tick)} Server running at ${c.cyan(url)}`)
+      console.log()
+      console.log(`  ${fmt.kv('Storage', storageMode)}`)
+      console.log(`  ${fmt.kv('Curation', apiKey ? c.success('enabled') : c.warn('disabled'))}`)
+      console.log()
+      console.log(c.muted(`  Press Ctrl+C to stop`))
+      console.log()
+
+      if (options.verbose) {
+        console.log(c.muted('─'.repeat(50)))
+        console.log()
+      }
+    }
+
+    // Keep process alive
+    process.on('SIGINT', () => {
+      if (!options.quiet) {
+        console.log()
+        console.log(`  ${symbols.info} Shutting down...`)
+      }
+      server.stop()
+      process.exit(0)
+    })
+
+    process.on('SIGTERM', () => {
+      server.stop()
+      process.exit(0)
+    })
+
+  } catch (error: any) {
+    if (error.code === 'EADDRINUSE') {
+      console.error(c.error(`${symbols.cross} Port ${port} is already in use`))
+      console.log(c.muted(`  Try a different port with --port <number>`))
+      console.log(c.muted(`  Or check if another memory server is running`))
+    } else {
+      console.error(c.error(`${symbols.cross} Failed to start server: ${error.message}`))
+    }
+    process.exit(1)
+  }
+}

package/src/cli/commands/stats.ts

@@ -0,0 +1,64 @@
+// ============================================================================
+// STATS COMMAND - Show memory statistics
+// ============================================================================
+
+import { c, symbols, fmt } from '../colors.ts'
+
+interface StatsOptions {
+  project?: string
+  verbose?: boolean
+}
+
+const MEMORY_API_URL = process.env.MEMORY_API_URL || 'http://localhost:8765'
+
+export async function stats(options: StatsOptions) {
+  console.log()
+  console.log(c.header(`${symbols.brain} Memory Statistics`))
+  console.log()
+
+  try {
+    // Check if server is running
+    const healthResponse = await fetch(`${MEMORY_API_URL}/health`).catch(() => null)
+
+    if (!healthResponse?.ok) {
+      console.log(`  ${c.error(symbols.cross)} Memory server is not running`)
+      console.log()
+      console.log(c.muted(`  Start it with: memory serve`))
+      console.log()
+      process.exit(1)
+    }
+
+    const health = await healthResponse.json()
+    console.log(`  ${c.success(symbols.tick)} Server: ${c.cyan(MEMORY_API_URL)}`)
+    console.log(`  ${fmt.kv('Engine', health.engine || 'unknown')}`)
+    console.log()
+
+    // Get project stats if project specified
+    if (options.project) {
+      const statsUrl = `${MEMORY_API_URL}/memory/stats?project_id=${encodeURIComponent(options.project)}`
+      const statsResponse = await fetch(statsUrl)
+
+      if (statsResponse.ok) {
+        const projectStats = await statsResponse.json()
+        console.log(fmt.section(`Project: ${options.project}`))
+        console.log()
+        console.log(`  ${fmt.kv('Total Memories', projectStats.totalMemories || 0)}`)
+        console.log(`  ${fmt.kv('Total Sessions', projectStats.totalSessions || 0)}`)
+        console.log(`  ${fmt.kv('Stale Memories', projectStats.staleMemories || 0)}`)
+        if (projectStats.latestSession) {
+          console.log(`  ${fmt.kv('Latest Session', projectStats.latestSession.slice(0, 8) + '...')}`)
+        }
+      } else {
+        console.log(c.warn(`  ${symbols.warning} Could not fetch stats for project: ${options.project}`))
+      }
+    } else {
+      console.log(c.muted(`  Use --project <name> to see project-specific stats`))
+    }
+
+    console.log()
+
+  } catch (error: any) {
+    console.error(c.error(`${symbols.cross} Error: ${error.message}`))
+    process.exit(1)
+  }
+}

package/src/cli/index.ts

@@ -0,0 +1,128 @@
+#!/usr/bin/env bun
+// ============================================================================
+// MEMORY CLI - Beautiful command-line interface
+// ============================================================================
+
+import { parseArgs } from 'util'
+import { c, symbols, fmt } from './colors.ts'
+
+const VERSION = '0.1.0'
+
+/**
+ * Show help message
+ */
+function showHelp() {
+  console.log(`
+${c.header(`${symbols.brain} Memory`)} ${c.muted(`v${VERSION}`)}
+${c.muted('Consciousness continuity for Claude')}
+
+${c.bold('Usage:')}
+${fmt.cmd('memory <command> [options]')}
+
+${c.bold('Commands:')}
+  ${c.command('serve')}      Start the memory server ${c.muted('(default)')}
+  ${c.command('stats')}      Show memory statistics
+  ${c.command('install')}    Set up Claude Code hooks
+  ${c.command('doctor')}     Check system health
+  ${c.command('help')}       Show this help message
+
+${c.bold('Options:')}
+  ${c.cyan('-p, --port')} <port>    Server port ${c.muted('(default: 8765)')}
+  ${c.cyan('-v, --verbose')}        Verbose output
+  ${c.cyan('-q, --quiet')}          Minimal output
+  ${c.cyan('--version')}            Show version
+
+${c.bold('Examples:')}
+${fmt.cmd('memory')}                    ${c.muted('# Start server on default port')}
+${fmt.cmd('memory serve --port 9000')}  ${c.muted('# Start on custom port')}
+${fmt.cmd('memory stats')}              ${c.muted('# Show memory statistics')}
+${fmt.cmd('memory install')}            ${c.muted('# Set up hooks for Claude Code')}
+
+${c.muted('Documentation: https://github.com/RLabs-Inc/memory')}
+`)
+}
+
+/**
+ * Show version
+ */
+function showVersion() {
+  console.log(`${symbols.brain} memory v${VERSION}`)
+}
+
+/**
+ * Main entry point
+ */
+async function main() {
+  const { values, positionals } = parseArgs({
+    args: Bun.argv.slice(2),
+    options: {
+      port: { type: 'string', short: 'p', default: '8765' },
+      verbose: { type: 'boolean', short: 'v', default: false },
+      quiet: { type: 'boolean', short: 'q', default: false },
+      help: { type: 'boolean', short: 'h', default: false },
+      version: { type: 'boolean', default: false },
+    },
+    allowPositionals: true,
+    strict: false,  // Allow unknown options for subcommands
+  })
+
+  // Handle global flags
+  if (values.version) {
+    showVersion()
+    process.exit(0)
+  }
+
+  const command = positionals[0] || 'serve'
+
+  if (values.help && command === 'serve') {
+    showHelp()
+    process.exit(0)
+  }
+
+  // Route to commands
+  switch (command) {
+    case 'serve':
+    case 'start':
+    case 'run': {
+      const { serve } = await import('./commands/serve.ts')
+      await serve(values)
+      break
+    }
+
+    case 'stats':
+    case 'status': {
+      const { stats } = await import('./commands/stats.ts')
+      await stats(values)
+      break
+    }
+
+    case 'install':
+    case 'setup': {
+      const { install } = await import('./commands/install.ts')
+      await install(values)
+      break
+    }
+
+    case 'doctor':
+    case 'check': {
+      const { doctor } = await import('./commands/doctor.ts')
+      await doctor(values)
+      break
+    }
+
+    case 'help':
+      showHelp()
+      break
+
+    default:
+      console.error(c.error(`Unknown command: ${command}`))
+      console.log(c.muted(`Run 'memory help' for usage information`))
+      process.exit(1)
+  }
+}
+
+// Run
+main().catch(err => {
+  console.error(c.error(`Error: ${err.message}`))
+  process.exit(1)
+})

package/src/core/curator.ts

@@ -70,8 +70,6 @@ export class Curator {
       cliType: config.cliType ?? 'claude-code',
     }
 
-    // Log which CLI we're using
-    console.log(`🧠 Curator initialized with CLI: ${cliCommand}`)
   }
 
   /**
@@ -154,8 +152,9 @@ Return ONLY this JSON structure:
     "interaction_tone": "The tone/style of interaction (e.g., professional and focused, warm collaborative friendship, mentor-student dynamic, casual technical discussion, or null if neutral)",
     "project_snapshot": {
         "current_phase": "Current state (if applicable)",
-        "recent_achievements": "What was accomplished (if applicable)",
-        "active_challenges": "What remains (if applicable)"
+        "recent_achievements": ["What was accomplished (if applicable)"],
+        "active_challenges": ["What remains (if applicable)"],
+        "next_steps": ["Planned next actions (if applicable)"]
     },
     "memories": [
         {
@@ -207,8 +206,7 @@ Return ONLY this JSON structure:
         } : undefined,
         memories: this._parseMemories(data.memories ?? []),
       }
-    } catch (error) {
-      console.error('Failed to parse curation response:', error)
+    } catch {
       return {
         session_summary: '',
         memories: [],
@@ -328,14 +326,6 @@ Return ONLY this JSON structure:
       )
     }
 
-    // Log the command we're about to execute
-    console.log(`\n📋 Executing CLI command:`)
-    console.log(`   Command: ${this._config.cliCommand}`)
-    console.log(`   Args: --resume ${sessionId} -p [user_message] --append-system-prompt [curation_instructions] --output-format json --max-turns 1`)
-    console.log(`   CWD: ${cwd || 'not set'}`)
-    console.log(`   User message: "${userMessage.slice(0, 50)}..."`)
-    console.log(`   System prompt length: ${systemPrompt.length} chars`)
-
     // Execute CLI
     const proc = Bun.spawn([this._config.cliCommand, ...args], {
       cwd,
@@ -353,24 +343,7 @@ Return ONLY this JSON structure:
     ])
     const exitCode = await proc.exited
 
-    // Log the results
-    console.log(`\n📤 CLI Response:`)
-    console.log(`   Exit code: ${exitCode}`)
-    console.log(`   Stdout length: ${stdout.length} chars`)
-    console.log(`   Stderr length: ${stderr.length} chars`)
-
-    if (stderr) {
-      console.log(`\n⚠️ Stderr output:`)
-      console.log(stderr.slice(0, 1000))  // First 1000 chars
-    }
-
-    if (stdout) {
-      console.log(`\n📥 Stdout output (first 500 chars):`)
-      console.log(stdout.slice(0, 500))
-    }
-
     if (exitCode !== 0) {
-      console.error(`\n❌ CLI exited with code ${exitCode}`)
       return { session_summary: '', memories: [] }
     }
 
@@ -381,9 +354,6 @@ Return ONLY this JSON structure:
 
       // Check for error response FIRST (like Python does)
       if (cliOutput.type === 'error' || cliOutput.is_error === true) {
-        console.log(`\n❌ CLI returned error:`)
-        console.log(`   Type: ${cliOutput.type}`)
-        console.log(`   Message: ${cliOutput.message || cliOutput.error || 'Unknown error'}`)
         return { session_summary: '', memories: [] }
       }
 
@@ -391,10 +361,7 @@ Return ONLY this JSON structure:
       let aiResponse = ''
       if (typeof cliOutput.result === 'string') {
         aiResponse = cliOutput.result
-        console.log(`\n📦 Extracted result from CLI wrapper (${aiResponse.length} chars)`)
       } else {
-        console.log(`\n⚠️ No result field in CLI output`)
-        console.log(`   Keys: ${Object.keys(cliOutput).join(', ')}`)
         return { session_summary: '', memories: [] }
       }
 
@@ -402,23 +369,15 @@ Return ONLY this JSON structure:
       const codeBlockMatch = aiResponse.match(/```(?:json)?\s*([\s\S]*?)```/)
       if (codeBlockMatch) {
         aiResponse = codeBlockMatch[1]!.trim()
-        console.log(`📝 Extracted JSON from markdown code block`)
       }
 
       // Now find the JSON object (same regex as Python)
       const jsonMatch = aiResponse.match(/\{[\s\S]*\}/)?.[0]
       if (jsonMatch) {
-        console.log(`✅ Found JSON object (${jsonMatch.length} chars)`)
-        const result = this.parseCurationResponse(jsonMatch)
-        console.log(`   Parsed ${result.memories.length} memories`)
-        return result
-      } else {
-        console.log(`\n⚠️ No JSON object found in AI response`)
-        console.log(`   Response preview: ${aiResponse.slice(0, 200)}...`)
+        return this.parseCurationResponse(jsonMatch)
       }
-    } catch (error) {
-      console.error('\n❌ Failed to parse CLI output:', error)
-      console.log(`   Raw stdout (first 500 chars): ${stdout.slice(0, 500)}`)
+    } catch {
+      // Parse error - return empty result
     }
 
     return { session_summary: '', memories: [] }