@rlabs-inc/memory 0.1.0 → 0.2.0

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

package/src/core/engine.ts

@@ -69,6 +69,17 @@ export interface ContextRequest {
   projectPath?: string  // Required for 'local' storage mode
 }
 
+/**
+ * Session metadata for deduplication
+ * Tracks which memories have been injected in each session
+ */
+interface SessionMetadata {
+  message_count: number
+  started_at: number
+  project_id: string
+  injected_memories: Set<string>  // Memory IDs already shown in this session
+}
+
 /**
  * Memory Engine - The main orchestrator
  */
@@ -76,6 +87,7 @@ export class MemoryEngine {
   private _config: Required<Omit<EngineConfig, 'embedder'>> & { embedder?: EngineConfig['embedder'] }
   private _stores = new Map<string, MemoryStore>()  // projectPath -> store
   private _retrieval: SmartVectorRetrieval
+  private _sessionMetadata = new Map<string, SessionMetadata>()  // sessionId -> metadata
 
   constructor(config: EngineConfig = {}) {
     this._config = {
@@ -89,6 +101,21 @@ export class MemoryEngine {
     this._retrieval = createRetrieval()
   }
 
+  /**
+   * Get or create session metadata for deduplication
+   */
+  private _getSessionMetadata(sessionId: string, projectId: string): SessionMetadata {
+    if (!this._sessionMetadata.has(sessionId)) {
+      this._sessionMetadata.set(sessionId, {
+        message_count: 0,
+        started_at: Date.now(),
+        project_id: projectId,
+        injected_memories: new Set(),
+      })
+    }
+    return this._sessionMetadata.get(sessionId)!
+  }
+
   /**
    * Get the appropriate store for a project
    */
@@ -97,13 +124,6 @@ export class MemoryEngine {
       ? projectPath
       : projectId
 
-    console.log(`🏪 [DEBUG] _getStore called:`)
-    console.log(`   projectId: ${projectId}`)
-    console.log(`   projectPath: ${projectPath}`)
-    console.log(`   storageMode: ${this._config.storageMode}`)
-    console.log(`   cache key: ${key}`)
-    console.log(`   cached: ${this._stores.has(key)}`)
-
     if (this._stores.has(key)) {
       return this._stores.get(key)!
     }
@@ -166,6 +186,10 @@ export class MemoryEngine {
       return { memories: [], formatted: '' }
     }
 
+    // Get session metadata for deduplication
+    const sessionMeta = this._getSessionMetadata(sessionId, projectId)
+    const injectedIds = sessionMeta.injected_memories
+
     // Get all memories for this project
     const allMemories = await store.getAllMemories(projectId)
 
@@ -173,6 +197,13 @@ export class MemoryEngine {
       return { memories: [], formatted: '' }
     }
 
+    // Filter out already-injected memories (deduplication)
+    const candidateMemories = allMemories.filter(m => !injectedIds.has(m.id))
+
+    if (!candidateMemories.length) {
+      return { memories: [], formatted: '' }
+    }
+
     // Generate embedding for query if embedder is available
     let queryEmbedding: Float32Array | undefined
     if (this._config.embedder) {
@@ -187,14 +218,20 @@ export class MemoryEngine {
     }
 
     // Retrieve relevant memories using 10-dimensional scoring
+    // Use candidateMemories (already filtered for deduplication)
     const relevantMemories = this._retrieval.retrieveRelevantMemories(
-      allMemories,
+      candidateMemories,
       currentMessage,
       queryEmbedding ?? new Float32Array(384),  // Empty embedding if no embedder
       sessionContext,
       maxMemories
     )
 
+    // Update injected memories for deduplication
+    for (const memory of relevantMemories) {
+      injectedIds.add(memory.id)
+    }
+
     return {
       memories: relevantMemories,
       formatted: this._formatMemories(relevantMemories),

package/src/core/retrieval.ts

@@ -5,7 +5,7 @@
 // ============================================================================
 
 import type { StoredMemory, RetrievalResult } from '../types/memory.ts'
-import { cosineSimilarity } from 'fatherstatedb'
+import { cosineSimilarity } from '@rlabs-inc/fsdb'
 
 /**
  * Session context for retrieval