@rlabs-inc/memory 0.1.0 → 0.2.1

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

package/src/core/store.ts

@@ -1,9 +1,9 @@
 // ============================================================================
-// MEMORY STORE - FatherStateDB-powered storage
+// MEMORY STORE - fsDB-powered storage
 // Per-project database management with reactive parallel arrays
 // ============================================================================
 
-import { createDatabase, type Database } from 'fatherstatedb'
+import { createDatabase, type Database, type PersistentCollection } from '@rlabs-inc/fsdb'
 import { homedir } from 'os'
 import { join } from 'path'
 import type {
@@ -42,21 +42,22 @@ export interface StoreConfig {
 }
 
 /**
- * Project database collection
+ * Project database with collections
  */
-interface ProjectDatabases {
-  memories: Database<typeof memorySchema>
-  summaries: Database<typeof sessionSummarySchema>
-  snapshots: Database<typeof projectSnapshotSchema>
-  sessions: Database<typeof sessionSchema>
+interface ProjectDB {
+  db: Database
+  memories: PersistentCollection<typeof memorySchema>
+  summaries: PersistentCollection<typeof sessionSummarySchema>
+  snapshots: PersistentCollection<typeof projectSnapshotSchema>
+  sessions: PersistentCollection<typeof sessionSchema>
 }
 
 /**
- * MemoryStore - Manages per-project FatherStateDB instances
+ * MemoryStore - Manages per-project fsDB instances
  */
 export class MemoryStore {
   private _config: Required<StoreConfig>
-  private _projects = new Map<string, ProjectDatabases>()
+  private _projects = new Map<string, ProjectDB>()
 
   constructor(config: StoreConfig = {}) {
     this._config = {
@@ -66,9 +67,9 @@ export class MemoryStore {
   }
 
   /**
-   * Get or create databases for a project
+   * Get or create database for a project
    */
-  async getProject(projectId: string): Promise<ProjectDatabases> {
+  async getProject(projectId: string): Promise<ProjectDB> {
     if (this._projects.has(projectId)) {
       console.log(`🔄 [DEBUG] Returning cached databases for ${projectId}`)
       return this._projects.get(projectId)!
@@ -78,40 +79,51 @@ export class MemoryStore {
     const projectPath = join(this._config.basePath, projectId)
     console.log(`   Path: ${projectPath}`)
 
-    // Create all databases for this project
-    const [memories, summaries, snapshots, sessions] = await Promise.all([
-      createDatabase({
-        path: join(projectPath, 'memories'),
-        schema: memorySchema,
-        contentColumn: 'content',
-        autoSave: true,
-        watchFiles: this._config.watchFiles,
-      }),
-      createDatabase({
-        path: join(projectPath, 'summaries'),
-        schema: sessionSummarySchema,
-        contentColumn: 'summary',
-        autoSave: true,
-        watchFiles: this._config.watchFiles,
-      }),
-      createDatabase({
-        path: join(projectPath, 'snapshots'),
-        schema: projectSnapshotSchema,
-        autoSave: true,
-        watchFiles: this._config.watchFiles,
-      }),
-      createDatabase({
-        path: join(projectPath, 'sessions'),
-        schema: sessionSchema,
-        autoSave: true,
-        watchFiles: this._config.watchFiles,
-      }),
+    // Create the database for this project
+    const db = createDatabase({
+      name: projectId,
+      basePath: projectPath,
+    })
+
+    // Create all collections for this project
+    const memories = db.collection('memories', {
+      schema: memorySchema,
+      contentColumn: 'content',
+      autoSave: true,
+      watchFiles: this._config.watchFiles,
+    })
+
+    const summaries = db.collection('summaries', {
+      schema: sessionSummarySchema,
+      contentColumn: 'summary',
+      autoSave: true,
+      watchFiles: this._config.watchFiles,
+    })
+
+    const snapshots = db.collection('snapshots', {
+      schema: projectSnapshotSchema,
+      autoSave: true,
+      watchFiles: this._config.watchFiles,
+    })
+
+    const sessions = db.collection('sessions', {
+      schema: sessionSchema,
+      autoSave: true,
+      watchFiles: this._config.watchFiles,
+    })
+
+    // Load existing data
+    await Promise.all([
+      memories.load(),
+      summaries.load(),
+      snapshots.load(),
+      sessions.load(),
     ])
 
-    const dbs: ProjectDatabases = { memories, summaries, snapshots, sessions }
-    this._projects.set(projectId, dbs)
+    const projectDB: ProjectDB = { db, memories, summaries, snapshots, sessions }
+    this._projects.set(projectId, projectDB)
 
-    return dbs
+    return projectDB
   }
 
   // ================================================================
@@ -129,7 +141,7 @@ export class MemoryStore {
   ): Promise<string> {
     const { memories } = await this.getProject(projectId)
 
-    const id = await memories.insert({
+    const id = memories.insert({
       content: memory.content,
       reasoning: memory.reasoning,
       importance_weight: memory.importance_weight,
@@ -147,7 +159,7 @@ export class MemoryStore {
       project_id: projectId,
       embedding: embedding
         ? (embedding instanceof Float32Array ? embedding : new Float32Array(embedding))
-        : undefined,
+        : null,
     })
 
     return id
@@ -165,10 +177,10 @@ export class MemoryStore {
       reasoning: record.reasoning,
       importance_weight: record.importance_weight,
       confidence_score: record.confidence_score,
-      context_type: record.context_type,
-      temporal_relevance: record.temporal_relevance,
-      knowledge_domain: record.knowledge_domain,
-      emotional_resonance: record.emotional_resonance,
+      context_type: record.context_type as StoredMemory['context_type'],
+      temporal_relevance: record.temporal_relevance as StoredMemory['temporal_relevance'],
+      knowledge_domain: record.knowledge_domain as StoredMemory['knowledge_domain'],
+      emotional_resonance: record.emotional_resonance as StoredMemory['emotional_resonance'],
       action_required: record.action_required,
       problem_solution_pair: record.problem_solution_pair,
       semantic_tags: record.semantic_tags,
@@ -176,7 +188,7 @@ export class MemoryStore {
       question_types: record.question_types,
       session_id: record.session_id,
       project_id: record.project_id,
-      embedding: record.embedding,
+      embedding: record.embedding ?? undefined,
       created_at: record.created,
       updated_at: record.updated,
       stale: record.stale,
@@ -196,18 +208,19 @@ export class MemoryStore {
 
     const results = memories.search('embedding', queryEmbedding, {
       topK,
-      filter: filter ? (record) => {
-        // Convert record to StoredMemory format for filter
+      filter: filter ? (record, _idx) => {
+        // Filter receives raw schema record - we need to adapt it
+        // Note: filter doesn't have access to id/created/updated (those are in RecordWithMeta)
         const mem: StoredMemory = {
-          id: record.id,
+          id: '', // Not available in filter
           content: record.content,
           reasoning: record.reasoning,
           importance_weight: record.importance_weight,
           confidence_score: record.confidence_score,
-          context_type: record.context_type,
-          temporal_relevance: record.temporal_relevance,
-          knowledge_domain: record.knowledge_domain,
-          emotional_resonance: record.emotional_resonance,
+          context_type: record.context_type as StoredMemory['context_type'],
+          temporal_relevance: record.temporal_relevance as StoredMemory['temporal_relevance'],
+          knowledge_domain: record.knowledge_domain as StoredMemory['knowledge_domain'],
+          emotional_resonance: record.emotional_resonance as StoredMemory['emotional_resonance'],
           action_required: record.action_required,
           problem_solution_pair: record.problem_solution_pair,
           semantic_tags: record.semantic_tags,
@@ -222,27 +235,27 @@ export class MemoryStore {
       } : undefined,
     })
 
-    return results.map(record => ({
-      id: record.id,
-      content: record.content,
-      reasoning: record.reasoning,
-      importance_weight: record.importance_weight,
-      confidence_score: record.confidence_score,
-      context_type: record.context_type,
-      temporal_relevance: record.temporal_relevance,
-      knowledge_domain: record.knowledge_domain,
-      emotional_resonance: record.emotional_resonance,
-      action_required: record.action_required,
-      problem_solution_pair: record.problem_solution_pair,
-      semantic_tags: record.semantic_tags,
-      trigger_phrases: record.trigger_phrases,
-      question_types: record.question_types,
-      session_id: record.session_id,
-      project_id: record.project_id,
-      embedding: record.embedding,
-      created_at: record.created,
-      updated_at: record.updated,
-      stale: record.stale,
+    return results.map(result => ({
+      id: result.record.id,
+      content: result.record.content,
+      reasoning: result.record.reasoning,
+      importance_weight: result.record.importance_weight,
+      confidence_score: result.record.confidence_score,
+      context_type: result.record.context_type as StoredMemory['context_type'],
+      temporal_relevance: result.record.temporal_relevance as StoredMemory['temporal_relevance'],
+      knowledge_domain: result.record.knowledge_domain as StoredMemory['knowledge_domain'],
+      emotional_resonance: result.record.emotional_resonance as StoredMemory['emotional_resonance'],
+      action_required: result.record.action_required,
+      problem_solution_pair: result.record.problem_solution_pair,
+      semantic_tags: result.record.semantic_tags,
+      trigger_phrases: result.record.trigger_phrases,
+      question_types: result.record.question_types,
+      session_id: result.record.session_id,
+      project_id: result.record.project_id,
+      embedding: result.record.embedding ?? undefined,
+      created_at: result.record.created,
+      updated_at: result.record.updated,
+      stale: result.stale,
     }))
   }
 
@@ -254,9 +267,10 @@ export class MemoryStore {
     memoryId: string,
     embedding: Float32Array | number[],
     content: string
-  ): Promise<boolean> {
+  ): Promise<void> {
     const { memories } = await this.getProject(projectId)
-    return memories.setEmbedding(memoryId, 'embedding', embedding, content)
+    const vec = embedding instanceof Float32Array ? embedding : new Float32Array(embedding)
+    memories.setEmbedding(memoryId, 'embedding', vec, content)
   }
 
   /**
@@ -264,7 +278,7 @@ export class MemoryStore {
    */
   async getStaleMemoryIds(projectId: string): Promise<string[]> {
     const { memories } = await this.getProject(projectId)
-    return memories.getStaleIds()
+    return memories.all().filter(r => r.stale).map(r => r.id)
   }
 
   // ================================================================
@@ -293,7 +307,7 @@ export class MemoryStore {
     const allSessions = sessions.all()
     const firstSessionCompleted = allSessions.some(s => s.first_session_completed)
 
-    await sessions.insert({
+    sessions.insert({
       id: sessionId,
       project_id: projectId,
       message_count: 0,
@@ -321,7 +335,7 @@ export class MemoryStore {
     }
 
     const newCount = session.message_count + 1
-    await sessions.update(sessionId, {
+    sessions.update(sessionId, {
       message_count: newCount,
       last_active: Date.now(),
     })
@@ -334,7 +348,7 @@ export class MemoryStore {
    */
   async markFirstSessionCompleted(projectId: string, sessionId: string): Promise<void> {
     const { sessions } = await this.getProject(projectId)
-    await sessions.update(sessionId, { first_session_completed: true })
+    sessions.update(sessionId, { first_session_completed: true })
   }
 
   // ================================================================
@@ -356,7 +370,7 @@ export class MemoryStore {
     console.log(`   Summary length: ${summary.length} chars`)
     console.log(`   Summaries count before: ${summaries.all().length}`)
 
-    const id = await summaries.insert({
+    const id = summaries.insert({
       session_id: sessionId,
       project_id: projectId,
       summary,
@@ -385,9 +399,9 @@ export class MemoryStore {
     }
 
     // Sort by created timestamp (most recent first)
-    all.sort((a, b) => b.created - a.created)
+    const sorted = [...all].sort((a, b) => b.created - a.created)
 
-    const latest = all[0]!
+    const latest = sorted[0]!
     console.log(`   Latest summary: ${latest.summary.slice(0, 50)}...`)
 
     return {
@@ -434,9 +448,9 @@ export class MemoryStore {
     if (!all.length) return null
 
     // Sort by created timestamp (most recent first)
-    all.sort((a, b) => b.created - a.created)
+    const sorted = [...all].sort((a, b) => b.created - a.created)
 
-    const latest = all[0]!
+    const latest = sorted[0]!
     return {
       id: latest.id,
       session_id: latest.session_id,
@@ -466,19 +480,19 @@ export class MemoryStore {
 
     const allMemories = memories.all()
     const allSessions = sessions.all()
-    const staleIds = memories.getStaleIds()
+    const staleCount = allMemories.filter(r => r.stale).length
 
     // Find latest session
     let latestSession: string | null = null
     if (allSessions.length) {
-      allSessions.sort((a, b) => b.last_active - a.last_active)
-      latestSession = allSessions[0]!.id
+      const sorted = [...allSessions].sort((a, b) => b.last_active - a.last_active)
+      latestSession = sorted[0]!.id
     }
 
     return {
       totalMemories: allMemories.length,
       totalSessions: allSessions.length,
-      staleMemories: staleIds.length,
+      staleMemories: staleCount,
       latestSession,
     }
   }
@@ -487,11 +501,8 @@ export class MemoryStore {
    * Close all project databases
    */
   close(): void {
-    for (const dbs of this._projects.values()) {
-      dbs.memories.close()
-      dbs.summaries.close()
-      dbs.snapshots.close()
-      dbs.sessions.close()
+    for (const projectDB of this._projects.values()) {
+      projectDB.db.close()
     }
     this._projects.clear()
   }

package/src/server/index.ts

@@ -12,21 +12,8 @@ import { logger } from '../utils/logger.ts'
  * Server configuration
  */
 export interface ServerConfig extends EngineConfig {
-  /**
-   * Port to listen on
-   * Default: 8765 (same as Python)
-   */
   port?: number
-
-  /**
-   * Host to bind to
-   * Default: 'localhost'
-   */
   host?: string
-
-  /**
-   * Curator configuration
-   */
   curator?: CuratorConfig
 }
 
@@ -61,7 +48,6 @@ interface CheckpointRequest {
 
 /**
  * Create and start the memory server
- * Uses Bun.serve() for high performance
  */
 export function createServer(config: ServerConfig = {}) {
   const {
@@ -102,7 +88,9 @@ export function createServer(config: ServerConfig = {}) {
 
         // Get memory context for a message
         if (path === '/memory/context' && req.method === 'POST') {
-          const body: ContextRequest = await req.json()
+          const body = await req.json() as ContextRequest
+
+          logger.request('POST', '/memory/context', body.project_id)
 
           const result = await engine.getContext({
             sessionId: body.session_id,
@@ -126,20 +114,13 @@ export function createServer(config: ServerConfig = {}) {
             )
           }
 
-          // Debug: show what's actually being returned
-          console.log(`\n📤 [DEBUG] Response to hook:`)
-          console.log(`   memories_count: ${result.memories.length}`)
-          console.log(`   has_primer: ${!!result.primer}`)
-          console.log(`   formatted length: ${result.formatted.length} chars`)
-          if (result.formatted) {
-            console.log(`   formatted preview:\n${result.formatted.slice(0, 300)}...`)
-          } else {
-            console.log(`   ⚠️ formatted is EMPTY!`)
-          }
-
           return Response.json({
             success: true,
-            context: result.formatted,
+            session_id: body.session_id,
+            message_count: 0,
+            context_text: result.formatted,
+            has_memories: result.memories.length > 0,
+            curator_enabled: true,
             memories_count: result.memories.length,
             has_primer: !!result.primer,
           }, { headers: corsHeaders })
@@ -147,7 +128,7 @@ export function createServer(config: ServerConfig = {}) {
 
         // Process/track a message exchange
         if (path === '/memory/process' && req.method === 'POST') {
-          const body: ProcessRequest = await req.json()
+          const body = await req.json() as ProcessRequest
 
           const messageCount = await engine.trackMessage(
             body.project_id,
@@ -155,7 +136,7 @@ export function createServer(config: ServerConfig = {}) {
             body.project_path
           )
 
-          logger.session(`Message #${messageCount} tracked for ${body.project_id}/${body.session_id.slice(0, 8)}...`)
+          logger.session(`Message #${messageCount} tracked [${body.project_id}]`)
 
           return Response.json({
             success: true,
@@ -165,15 +146,13 @@ export function createServer(config: ServerConfig = {}) {
 
         // Checkpoint - trigger curation
         if (path === '/memory/checkpoint' && req.method === 'POST') {
-          const body: CheckpointRequest = await req.json()
+          const body = await req.json() as CheckpointRequest
 
-          logger.memory(`Curation triggered for ${body.project_id} (${body.trigger})`)
+          logger.logCurationStart(body.claude_session_id, body.trigger)
 
           // Fire and forget - don't block the response
           setImmediate(async () => {
             try {
-              logger.info(`Resuming session ${body.claude_session_id.slice(0, 8)}... for curation`)
-
               const result = await curator.curateWithCLI(
                 body.claude_session_id,
                 body.trigger,
@@ -188,14 +167,10 @@ export function createServer(config: ServerConfig = {}) {
                   body.project_path
                 )
 
+                logger.logCurationComplete(result.memories.length, result.session_summary)
                 logger.logCuratedMemories(result.memories)
-                logger.success(`Stored ${result.memories.length} memories for ${body.project_id}`)
-
-                if (result.session_summary) {
-                  logger.info(`Summary: ${result.session_summary.slice(0, 100)}...`)
-                }
               } else {
-                logger.warn(`No memories extracted for ${body.project_id}`)
+                logger.logCurationComplete(0)
               }
             } catch (error) {
               logger.error(`Curation failed: ${error}`)
@@ -227,7 +202,7 @@ export function createServer(config: ServerConfig = {}) {
           { status: 404, headers: corsHeaders }
         )
       } catch (error) {
-        console.error('Server error:', error)
+        logger.error(`Server error: ${error}`)
         return Response.json(
           { error: String(error) },
           { status: 500, headers: corsHeaders }

package/src/types/schema.ts

@@ -3,7 +3,7 @@
 // Maps CuratedMemory to reactive parallel arrays
 // ============================================================================
 
-import type { SchemaDefinition } from 'fatherstatedb'
+import type { SchemaDefinition } from '@rlabs-inc/fsdb'
 
 /**
  * Memory storage schema