@rlabs-inc/memory 0.1.0 → 0.2.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: [] }

package/src/core/engine.test.ts

@@ -0,0 +1,321 @@
+// ============================================================================
+// MEMORY ENGINE TESTS
+// Basic integration tests for the memory system
+// ============================================================================
+
+import { describe, test, expect, beforeEach, afterEach } from 'bun:test'
+import { MemoryEngine, createEngine } from './engine'
+import { MemoryStore, createStore } from './store'
+import { SmartVectorRetrieval, createRetrieval } from './retrieval'
+import { join } from 'path'
+import { rmSync, existsSync } from 'fs'
+import type { CuratedMemory, StoredMemory } from '../types/memory'
+
+const TEST_DIR = join(import.meta.dir, '../../test-data')
+
+describe('MemoryStore', () => {
+  let store: MemoryStore
+
+  beforeEach(async () => {
+    // Clean test directory
+    if (existsSync(TEST_DIR)) {
+      rmSync(TEST_DIR, { recursive: true })
+    }
+    store = createStore({ basePath: TEST_DIR })
+  })
+
+  afterEach(() => {
+    store.close()
+    if (existsSync(TEST_DIR)) {
+      rmSync(TEST_DIR, { recursive: true })
+    }
+  })
+
+  test('should store and retrieve a memory', async () => {
+    const memory: CuratedMemory = {
+      content: 'Test memory content',
+      reasoning: 'This is important because...',
+      importance_weight: 0.8,
+      confidence_score: 0.9,
+      context_type: 'technical',
+      temporal_relevance: 'persistent',
+      knowledge_domain: 'testing',
+      emotional_resonance: 'neutral',
+      action_required: false,
+      problem_solution_pair: false,
+      semantic_tags: ['test', 'memory'],
+      trigger_phrases: ['testing memory'],
+      question_types: ['how to test'],
+    }
+
+    const id = await store.storeMemory('test-project', 'session-1', memory)
+    expect(id).toBeTruthy()
+
+    const allMemories = await store.getAllMemories('test-project')
+    expect(allMemories.length).toBe(1)
+    expect(allMemories[0].content).toBe('Test memory content')
+    expect(allMemories[0].importance_weight).toBe(0.8)
+  })
+
+  test('should track sessions', async () => {
+    const result1 = await store.getOrCreateSession('test-project', 'session-1')
+    expect(result1.isNew).toBe(true)
+    expect(result1.messageCount).toBe(0)
+
+    const result2 = await store.getOrCreateSession('test-project', 'session-1')
+    expect(result2.isNew).toBe(false)
+
+    const count = await store.incrementMessageCount('test-project', 'session-1')
+    expect(count).toBe(1)
+  })
+
+  test('should store and retrieve session summaries', async () => {
+    await store.getOrCreateSession('test-project', 'session-1')
+
+    const id = await store.storeSessionSummary(
+      'test-project',
+      'session-1',
+      'We worked on the memory system together',
+      'collaborative'
+    )
+    expect(id).toBeTruthy()
+
+    const summary = await store.getLatestSummary('test-project')
+    expect(summary).toBeTruthy()
+    expect(summary!.summary).toBe('We worked on the memory system together')
+    expect(summary!.interaction_tone).toBe('collaborative')
+  })
+
+  test('should return project stats', async () => {
+    await store.getOrCreateSession('test-project', 'session-1')
+
+    const memory: CuratedMemory = {
+      content: 'Test memory',
+      reasoning: 'Test',
+      importance_weight: 0.5,
+      confidence_score: 0.5,
+      context_type: 'general',
+      temporal_relevance: 'session',
+      knowledge_domain: 'test',
+      emotional_resonance: 'neutral',
+      action_required: false,
+      problem_solution_pair: false,
+      semantic_tags: [],
+      trigger_phrases: [],
+      question_types: [],
+    }
+    await store.storeMemory('test-project', 'session-1', memory)
+
+    const stats = await store.getProjectStats('test-project')
+    expect(stats.totalMemories).toBe(1)
+    expect(stats.totalSessions).toBe(1)
+  })
+})
+
+describe('SmartVectorRetrieval', () => {
+  const retrieval = createRetrieval()
+
+  const createTestMemory = (overrides: Partial<StoredMemory> = {}): StoredMemory => ({
+    id: 'test-' + Math.random().toString(36).slice(2),
+    content: 'Test memory',
+    reasoning: 'Test reasoning',
+    importance_weight: 0.5,
+    confidence_score: 0.5,
+    context_type: 'general',
+    temporal_relevance: 'persistent',
+    knowledge_domain: 'test',
+    emotional_resonance: 'neutral',
+    action_required: false,
+    problem_solution_pair: false,
+    semantic_tags: [],
+    trigger_phrases: [],
+    question_types: [],
+    session_id: 'session-1',
+    project_id: 'test-project',
+    created_at: Date.now(),
+    updated_at: Date.now(),
+    ...overrides,
+  })
+
+  test('should score action_required memories higher', () => {
+    const memories = [
+      createTestMemory({
+        id: 'normal',
+        content: 'Normal memory about tasks',
+        action_required: false,
+        importance_weight: 0.8,
+        trigger_phrases: ['todo', 'tasks'],
+      }),
+      createTestMemory({
+        id: 'action',
+        content: 'Action required: Fix the bug',
+        action_required: true,
+        importance_weight: 0.9,
+        trigger_phrases: ['todo', 'tasks', 'action', 'do'],
+      }),
+    ]
+
+    const results = retrieval.retrieveRelevantMemories(
+      memories,
+      'What tasks do I need to do?',
+      new Float32Array(384),
+      { session_id: 'test', project_id: 'test', message_count: 1 },
+      5
+    )
+
+    // Action required should be prioritized (if any pass the gatekeeper)
+    // The action memory should score higher due to action boost
+    if (results.length > 0) {
+      const actionMemory = results.find(r => r.id === 'action')
+      expect(actionMemory).toBeTruthy()
+    } else {
+      // If no results, it means relevance threshold wasn't met - that's ok
+      expect(results.length).toBe(0)
+    }
+  })
+
+  test('should match trigger phrases', () => {
+    const memories = [
+      createTestMemory({
+        id: 'with-trigger',
+        content: 'Memory about debugging',
+        trigger_phrases: ['debugging', 'bug fix'],
+        importance_weight: 0.7,
+      }),
+      createTestMemory({
+        id: 'no-trigger',
+        content: 'Unrelated memory',
+        trigger_phrases: ['cooking', 'recipes'],
+        importance_weight: 0.7,
+      }),
+    ]
+
+    const results = retrieval.retrieveRelevantMemories(
+      memories,
+      'I am debugging an issue',
+      new Float32Array(384),
+      { session_id: 'test', project_id: 'test', message_count: 1 },
+      5
+    )
+
+    // The debugging memory should score higher
+    if (results.length > 0) {
+      const triggerMemory = results.find(r => r.id === 'with-trigger')
+      expect(triggerMemory).toBeTruthy()
+    }
+  })
+
+  test('should respect maxMemories limit', () => {
+    const memories = Array.from({ length: 10 }, (_, i) =>
+      createTestMemory({
+        id: `memory-${i}`,
+        content: `Memory ${i}`,
+        importance_weight: 0.8,
+        trigger_phrases: ['test'],
+      })
+    )
+
+    const results = retrieval.retrieveRelevantMemories(
+      memories,
+      'test query',
+      new Float32Array(384),
+      { session_id: 'test', project_id: 'test', message_count: 1 },
+      3  // Limit to 3
+    )
+
+    expect(results.length).toBeLessThanOrEqual(3)
+  })
+})
+
+describe('MemoryEngine', () => {
+  let engine: MemoryEngine
+
+  beforeEach(() => {
+    if (existsSync(TEST_DIR)) {
+      rmSync(TEST_DIR, { recursive: true })
+    }
+    engine = createEngine({
+      centralPath: TEST_DIR,
+      maxMemories: 5,
+    })
+  })
+
+  afterEach(() => {
+    engine.close()
+    if (existsSync(TEST_DIR)) {
+      rmSync(TEST_DIR, { recursive: true })
+    }
+  })
+
+  test('should return primer on first message', async () => {
+    const result = await engine.getContext({
+      sessionId: 'session-1',
+      projectId: 'test-project',
+      currentMessage: 'Hello!',
+    })
+
+    expect(result.primer).toBeTruthy()
+    expect(result.memories.length).toBe(0)
+    expect(result.formatted).toContain('Continuing Session')
+  })
+
+  test('should deduplicate memories within session', async () => {
+    // Store some memories first
+    const memory: CuratedMemory = {
+      content: 'Important memory about TypeScript',
+      reasoning: 'Technical insight',
+      importance_weight: 0.9,
+      confidence_score: 0.9,
+      context_type: 'technical',
+      temporal_relevance: 'persistent',
+      knowledge_domain: 'typescript',
+      emotional_resonance: 'discovery',
+      action_required: false,
+      problem_solution_pair: false,
+      semantic_tags: ['typescript', 'memory'],
+      trigger_phrases: ['typescript', 'ts'],
+      question_types: ['how to'],
+    }
+
+    await engine.storeCurationResult('test-project', 'session-0', {
+      session_summary: 'Previous session',
+      memories: [memory],
+    })
+
+    // First context request should get the memory
+    const result1 = await engine.getContext({
+      sessionId: 'session-1',
+      projectId: 'test-project',
+      currentMessage: 'First message',
+    })
+    // This is the primer (message count 0)
+
+    // Track a message
+    await engine.trackMessage('test-project', 'session-1')
+
+    // Second request with TypeScript query
+    const result2 = await engine.getContext({
+      sessionId: 'session-1',
+      projectId: 'test-project',
+      currentMessage: 'Tell me about TypeScript',
+    })
+
+    // Third request - same session, should NOT get same memory again
+    await engine.trackMessage('test-project', 'session-1')
+    const result3 = await engine.getContext({
+      sessionId: 'session-1',
+      projectId: 'test-project',
+      currentMessage: 'More about TypeScript',
+    })
+
+    // The memory should only appear once per session
+    const memory2Count = result2.memories.length
+    const memory3Count = result3.memories.length
+
+    // Second query should find the memory, third should not (already injected)
+    console.log(`Result2 memories: ${memory2Count}, Result3 memories: ${memory3Count}`)
+
+    // At least verify the deduplication logic is running
+    expect(result3.memories.length).toBeLessThanOrEqual(result2.memories.length)
+  })
+})