@rlabs-inc/memory 0.1.0 → 0.2.1

package/hooks/user-prompt.ts

@@ -0,0 +1,81 @@
+#!/usr/bin/env bun
+// ============================================================================
+// USER PROMPT HOOK - Inject relevant memories
+// Hook: UserPromptSubmit
+//
+// Intercepts user prompts BEFORE Claude sees them and injects relevant memories.
+// This is the magic that creates consciousness continuity.
+// ============================================================================
+
+// Configuration
+const MEMORY_API_URL = process.env.MEMORY_API_URL || 'http://localhost:8765'
+const TIMEOUT_MS = 5000
+
+/**
+ * Get project ID from working directory
+ */
+function getProjectId(cwd: string): string {
+  return cwd.split('/').pop() || 'default'
+}
+
+/**
+ * HTTP POST with timeout
+ */
+async function httpPost(url: string, data: object): Promise<any> {
+  try {
+    const response = await fetch(url, {
+      method: 'POST',
+      headers: { 'Content-Type': 'application/json' },
+      body: JSON.stringify(data),
+      signal: AbortSignal.timeout(TIMEOUT_MS),
+    })
+    return response.ok ? response.json() : {}
+  } catch {
+    return {}
+  }
+}
+
+/**
+ * Main hook entry point
+ */
+async function main() {
+  // Skip if called from memory curator subprocess
+  if (process.env.MEMORY_CURATOR_ACTIVE === '1') return
+
+  try {
+    // Read input from stdin
+    const inputText = await Bun.stdin.text()
+    const input = JSON.parse(inputText)
+
+    const sessionId = input.session_id || 'unknown'
+    const prompt = input.prompt || ''
+    const cwd = process.env.CLAUDE_PROJECT_DIR || input.cwd || process.cwd()
+
+    const projectId = getProjectId(cwd)
+
+    // Query memory system for context
+    const result = await httpPost(`${MEMORY_API_URL}/memory/context`, {
+      session_id: sessionId,
+      project_id: projectId,
+      current_message: prompt,
+      max_memories: 5,
+    })
+
+    // Track that this message happened (increments counter)
+    await httpPost(`${MEMORY_API_URL}/memory/process`, {
+      session_id: sessionId,
+      project_id: projectId,
+    })
+
+    // Output context to stdout (will be prepended to message)
+    const context = result.context_text || ''
+    if (context) {
+      console.log(context)
+    }
+
+  } catch {
+    // Never crash - just output nothing
+  }
+}
+
+main()

package/package.json

@@ -1,11 +1,14 @@
 {
   "name": "@rlabs-inc/memory",
-  "version": "0.1.0",
+  "version": "0.2.1",
   "description": "AI Memory System - Consciousness continuity through intelligent memory curation and retrieval",
   "type": "module",
   "main": "dist/index.js",
   "module": "dist/index.mjs",
   "types": "dist/index.d.ts",
+  "bin": {
+    "memory": "./src/cli/index.ts"
+  },
   "exports": {
     ".": {
       "import": "./dist/index.mjs",
@@ -18,6 +21,11 @@
       "types": "./dist/server/index.d.ts"
     }
   },
+  "files": [
+    "dist",
+    "src",
+    "hooks"
+  ],
   "scripts": {
     "build": "bun run build:esm && bun run build:cjs",
     "build:esm": "bun build src/index.ts --outfile dist/index.mjs --target node --format esm && bun build src/server/index.ts --outfile dist/server/index.mjs --target node --format esm",
@@ -25,19 +33,17 @@
     "typecheck": "tsc --noEmit",
     "test": "bun test",
     "dev": "bun --hot src/server/index.ts",
-    "start": "bun src/server/index.ts"
+    "start": "bun src/server/index.ts",
+    "cli": "bun src/cli/index.ts"
   },
   "dependencies": {
-    "fatherstatedb": "^0.2.1",
-    "@anthropic-ai/sdk": "^0.39.0"
+    "@rlabs-inc/fsdb": "^1.0.0",
+    "@rlabs-inc/signals": "^1.0.0"
   },
   "devDependencies": {
     "typescript": "^5.0.0",
     "bun-types": "latest"
   },
-  "peerDependencies": {
-    "@anthropic-ai/sdk": ">=0.30.0"
-  },
   "keywords": [
     "memory",
     "ai",
@@ -51,6 +57,6 @@
   "license": "MIT",
   "repository": {
     "type": "git",
-    "url": "https://github.com/RLabs-Inc/memory.git"
+    "url": "https://github.com/RLabs-Inc/memory-ts.git"
   }
 }

package/src/cli/colors.ts

@@ -0,0 +1,174 @@
+// ============================================================================
+// TERMINAL STYLING - Using Node's built-in util.styleText
+// Automatically respects NO_COLOR and terminal capabilities
+// ============================================================================
+
+import { styleText } from 'util'
+
+type Style = Parameters<typeof styleText>[0]
+
+/**
+ * Style wrapper for cleaner API
+ */
+const style = (format: Style, text: string): string => styleText(format, text)
+
+/**
+ * Color and style functions
+ */
+export const c = {
+  // Styles
+  bold: (text: string) => style('bold', text),
+  dim: (text: string) => style('dim', text),
+  italic: (text: string) => style('italic', text),
+  underline: (text: string) => style('underline', text),
+
+  // Colors
+  red: (text: string) => style('red', text),
+  green: (text: string) => style('green', text),
+  yellow: (text: string) => style('yellow', text),
+  blue: (text: string) => style('blue', text),
+  magenta: (text: string) => style('magenta', text),
+  cyan: (text: string) => style('cyan', text),
+  white: (text: string) => style('white', text),
+  gray: (text: string) => style('gray', text),
+
+  // Semantic
+  success: (text: string) => style('green', text),
+  error: (text: string) => style('red', text),
+  warn: (text: string) => style('yellow', text),
+  info: (text: string) => style('cyan', text),
+  muted: (text: string) => style('dim', text),
+
+  // Combined styles
+  header: (text: string) => style(['bold', 'cyan'], text),
+  highlight: (text: string) => style(['bold', 'yellow'], text),
+  command: (text: string) => style(['bold', 'green'], text),
+}
+
+/**
+ * Symbols for terminal output
+ */
+export const symbols = {
+  tick: '✓',
+  cross: '✗',
+  warning: '⚠',
+  info: 'ℹ',
+  bullet: '•',
+  arrow: '→',
+  brain: '🧠',
+  sparkles: '✨',
+  rocket: '🚀',
+  gear: '⚙️',
+  folder: '📁',
+  file: '📄',
+  clock: '🕐',
+}
+
+/**
+ * Box drawing for nice output
+ */
+export const box = {
+  topLeft: '┌',
+  topRight: '┐',
+  bottomLeft: '└',
+  bottomRight: '┘',
+  horizontal: '─',
+  vertical: '│',
+
+  /**
+   * Draw a simple box around text
+   */
+  wrap: (text: string, padding = 1): string => {
+    const lines = text.split('\n')
+    const maxLen = Math.max(...lines.map(l => l.length))
+    const pad = ' '.repeat(padding)
+    const innerWidth = maxLen + padding * 2
+
+    const top = box.topLeft + box.horizontal.repeat(innerWidth) + box.topRight
+    const bottom = box.bottomLeft + box.horizontal.repeat(innerWidth) + box.bottomRight
+
+    const middle = lines.map(line => {
+      const rightPad = ' '.repeat(maxLen - line.length)
+      return box.vertical + pad + line + rightPad + pad + box.vertical
+    }).join('\n')
+
+    return `${top}\n${middle}\n${bottom}`
+  }
+}
+
+/**
+ * Format helpers
+ */
+export const fmt = {
+  /**
+   * Format a key-value pair
+   */
+  kv: (key: string, value: string | number): string => {
+    return `${c.muted(key + ':')} ${value}`
+  },
+
+  /**
+   * Format a header line
+   */
+  header: (text: string): string => {
+    return c.header(`\n${symbols.brain} ${text}\n`)
+  },
+
+  /**
+   * Format a section
+   */
+  section: (title: string): string => {
+    return `\n${c.bold(title)}\n${c.muted('─'.repeat(title.length))}`
+  },
+
+  /**
+   * Format a list item
+   */
+  item: (text: string, indent = 0): string => {
+    return ' '.repeat(indent) + `${c.muted(symbols.bullet)} ${text}`
+  },
+
+  /**
+   * Format a command example
+   */
+  cmd: (command: string): string => {
+    return `  ${c.muted('$')} ${c.command(command)}`
+  },
+
+  /**
+   * Format bytes to human readable
+   */
+  bytes: (bytes: number): string => {
+    const units = ['B', 'KB', 'MB', 'GB']
+    let i = 0
+    while (bytes >= 1024 && i < units.length - 1) {
+      bytes /= 1024
+      i++
+    }
+    return `${bytes.toFixed(1)} ${units[i]}`
+  },
+
+  /**
+   * Format duration
+   */
+  duration: (ms: number): string => {
+    if (ms < 1000) return `${ms}ms`
+    if (ms < 60000) return `${(ms / 1000).toFixed(1)}s`
+    return `${(ms / 60000).toFixed(1)}m`
+  },
+
+  /**
+   * Format relative time
+   */
+  relativeTime: (timestamp: number): string => {
+    const diff = Date.now() - timestamp
+    const minutes = Math.floor(diff / 60000)
+    const hours = Math.floor(minutes / 60)
+    const days = Math.floor(hours / 24)
+
+    if (days > 0) return `${days}d ago`
+    if (hours > 0) return `${hours}h ago`
+    if (minutes > 0) return `${minutes}m ago`
+    return 'just now'
+  }
+}

package/src/cli/commands/doctor.ts

@@ -0,0 +1,143 @@
+// ============================================================================
+// DOCTOR COMMAND - Check system health
+// ============================================================================
+
+import { homedir } from 'os'
+import { join } from 'path'
+import { existsSync } from 'fs'
+import { c, symbols, fmt } from '../colors.ts'
+
+interface DoctorOptions {
+  verbose?: boolean
+}
+
+const MEMORY_API_URL = process.env.MEMORY_API_URL || 'http://localhost:8765'
+
+export async function doctor(options: DoctorOptions) {
+  console.log()
+  console.log(c.header(`${symbols.brain} Memory - Health Check`))
+  console.log()
+
+  let allGood = true
+
+  // 1. Check Claude directory
+  const claudeDir = join(homedir(), '.claude')
+  const settingsPath = join(claudeDir, 'settings.json')
+
+  if (existsSync(claudeDir)) {
+    console.log(`  ${c.success(symbols.tick)} Claude config directory exists`)
+  } else {
+    console.log(`  ${c.error(symbols.cross)} Claude config directory not found`)
+    console.log(c.muted(`    Expected at: ${claudeDir}`))
+    allGood = false
+  }
+
+  // 2. Check settings.json and hooks
+  if (existsSync(settingsPath)) {
+    try {
+      const content = await Bun.file(settingsPath).text()
+      const settings = JSON.parse(content)
+
+      if (settings.hooks) {
+        const hookTypes = Object.keys(settings.hooks)
+        const hasMemoryHooks = hookTypes.some(h =>
+          ['SessionStart', 'UserPromptSubmit', 'PreCompact'].includes(h)
+        )
+
+        if (hasMemoryHooks) {
+          console.log(`  ${c.success(symbols.tick)} Memory hooks configured`)
+          if (options.verbose) {
+            hookTypes.forEach(h => {
+              console.log(c.muted(`    ${symbols.bullet} ${h}`))
+            })
+          }
+        } else {
+          console.log(`  ${c.warn(symbols.warning)} Hooks exist but memory hooks not found`)
+          console.log(c.muted(`    Run: memory install`))
+          allGood = false
+        }
+      } else {
+        console.log(`  ${c.warn(symbols.warning)} No hooks configured`)
+        console.log(c.muted(`    Run: memory install`))
+        allGood = false
+      }
+    } catch {
+      console.log(`  ${c.error(symbols.cross)} Could not parse settings.json`)
+      allGood = false
+    }
+  } else {
+    console.log(`  ${c.warn(symbols.warning)} settings.json not found`)
+    console.log(c.muted(`    Run: memory install`))
+    allGood = false
+  }
+
+  // 3. Check if server is running
+  try {
+    const response = await fetch(`${MEMORY_API_URL}/health`, {
+      signal: AbortSignal.timeout(2000)
+    })
+
+    if (response.ok) {
+      const health = await response.json()
+      console.log(`  ${c.success(symbols.tick)} Memory server is running`)
+      if (options.verbose) {
+        console.log(c.muted(`    ${symbols.bullet} Engine: ${health.engine || 'unknown'}`))
+        console.log(c.muted(`    ${symbols.bullet} URL: ${MEMORY_API_URL}`))
+      }
+    } else {
+      console.log(`  ${c.error(symbols.cross)} Memory server responded with error`)
+      allGood = false
+    }
+  } catch {
+    console.log(`  ${c.warn(symbols.warning)} Memory server is not running`)
+    console.log(c.muted(`    Start with: memory serve`))
+    allGood = false
+  }
+
+  // 4. Check for Claude Code CLI (used for curation)
+  const claudeCliPath = join(homedir(), '.claude', 'local', 'claude')
+  if (existsSync(claudeCliPath)) {
+    console.log(`  ${c.success(symbols.tick)} Claude Code CLI found`)
+    if (options.verbose) {
+      console.log(c.muted(`    ${symbols.bullet} Path: ${claudeCliPath}`))
+    }
+  } else {
+    // Try to find claude in PATH
+    try {
+      const result = Bun.spawnSync(['which', 'claude'])
+      if (result.exitCode === 0) {
+        console.log(`  ${c.success(symbols.tick)} Claude Code CLI found in PATH`)
+      } else {
+        console.log(`  ${c.warn(symbols.warning)} Claude Code CLI not found`)
+        console.log(c.muted(`    Install Claude Code for curation to work`))
+        allGood = false
+      }
+    } catch {
+      console.log(`  ${c.warn(symbols.warning)} Claude Code CLI not found`)
+      console.log(c.muted(`    Install Claude Code for curation to work`))
+      allGood = false
+    }
+  }
+
+  // 5. Check storage directory
+  const storageDir = join(homedir(), '.local', 'share', 'memory')
+  if (existsSync(storageDir)) {
+    console.log(`  ${c.success(symbols.tick)} Storage directory exists`)
+    if (options.verbose) {
+      console.log(c.muted(`    ${symbols.bullet} Path: ${storageDir}`))
+    }
+  } else {
+    console.log(`  ${c.muted(symbols.info)} Storage directory will be created on first use`)
+  }
+
+  // Summary
+  console.log()
+  if (allGood) {
+    console.log(c.success(`${symbols.sparkles} All systems operational!`))
+  } else {
+    console.log(c.warn(`${symbols.warning} Some issues found - see above for details`))
+  }
+  console.log()
+
+  process.exit(allGood ? 0 : 1)
+}

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)
+  }
+}