@rlabs-inc/memory 0.4.14 → 0.4.15

package/README.md

@@ -398,6 +398,11 @@ This isn't just about remembering facts. It's about preserving:
 
 ## Changelog
 
+### v0.4.15
+- **Feature**: PATCH `/memory/:id` endpoint for updating memory metadata
+- Supports: `importance_weight`, `exclude_from_retrieval`, `status`, `action_required`, and more
+- Enables dashboards and tools for memory curation (promote/demote/bury)
+
 ### v0.4.14
 - **Feature**: Action items signal (`***`) - add to end of message to retrieve all pending items
 - **Feature**: New `getActionItems()` retrieval function with special formatting

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@rlabs-inc/memory",
-  "version": "0.4.14",
+  "version": "0.4.15",
   "description": "AI Memory System - Consciousness continuity through intelligent memory curation and retrieval",
   "type": "module",
   "main": "dist/index.js",

package/src/core/engine.ts

@@ -404,6 +404,42 @@ export class MemoryEngine {
     return [...projectMemories, ...globalMemories]
   }
 
+  /**
+   * Update a memory's metadata
+   * Used for curation actions: promote/demote, bury, archive
+   */
+  async updateMemory(
+    projectId: string,
+    memoryId: string,
+    updates: {
+      importance_weight?: number
+      confidence_score?: number
+      exclude_from_retrieval?: boolean
+      status?: 'active' | 'pending' | 'superseded' | 'deprecated' | 'archived'
+      action_required?: boolean
+      awaiting_implementation?: boolean
+      awaiting_decision?: boolean
+      semantic_tags?: string[]
+      trigger_phrases?: string[]
+    },
+    projectPath?: string
+  ): Promise<{ success: boolean; updated_fields: string[] }> {
+    const store = await this._getStore(projectId, projectPath)
+    return store.updateMemory(projectId, memoryId, updates)
+  }
+
+  /**
+   * Get a single memory by ID
+   */
+  async getMemory(
+    projectId: string,
+    memoryId: string,
+    projectPath?: string
+  ): Promise<StoredMemory | null> {
+    const store = await this._getStore(projectId, projectPath)
+    return store.getMemory(projectId, memoryId)
+  }
+
   // ================================================================
   // FORMATTING
   // ================================================================

package/src/core/store.ts

@@ -534,6 +534,113 @@ export class MemoryStore {
     return id
   }
 
+  /**
+   * Update a memory's metadata fields
+   * Used for curation actions: promote/demote importance, bury, archive
+   */
+  async updateMemory(
+    projectId: string,
+    memoryId: string,
+    updates: {
+      importance_weight?: number
+      confidence_score?: number
+      exclude_from_retrieval?: boolean
+      status?: 'active' | 'pending' | 'superseded' | 'deprecated' | 'archived'
+      action_required?: boolean
+      awaiting_implementation?: boolean
+      awaiting_decision?: boolean
+      semantic_tags?: string[]
+      trigger_phrases?: string[]
+    }
+  ): Promise<{ success: boolean; updated_fields: string[] }> {
+    const { memories } = await this.getProject(projectId)
+
+    // Check memory exists
+    const existing = memories.get(memoryId)
+    if (!existing) {
+      return { success: false, updated_fields: [] }
+    }
+
+    // Build update object with only provided fields
+    const updateData: Record<string, any> = {}
+    const updatedFields: string[] = []
+
+    if (updates.importance_weight !== undefined) {
+      updateData.importance_weight = Math.max(0, Math.min(1, updates.importance_weight))
+      updatedFields.push('importance_weight')
+    }
+    if (updates.confidence_score !== undefined) {
+      updateData.confidence_score = Math.max(0, Math.min(1, updates.confidence_score))
+      updatedFields.push('confidence_score')
+    }
+    if (updates.exclude_from_retrieval !== undefined) {
+      updateData.exclude_from_retrieval = updates.exclude_from_retrieval
+      updatedFields.push('exclude_from_retrieval')
+    }
+    if (updates.status !== undefined) {
+      updateData.status = updates.status
+      updatedFields.push('status')
+    }
+    if (updates.action_required !== undefined) {
+      updateData.action_required = updates.action_required
+      updatedFields.push('action_required')
+    }
+    if (updates.awaiting_implementation !== undefined) {
+      updateData.awaiting_implementation = updates.awaiting_implementation
+      updatedFields.push('awaiting_implementation')
+    }
+    if (updates.awaiting_decision !== undefined) {
+      updateData.awaiting_decision = updates.awaiting_decision
+      updatedFields.push('awaiting_decision')
+    }
+    if (updates.semantic_tags !== undefined) {
+      updateData.semantic_tags = updates.semantic_tags
+      updatedFields.push('semantic_tags')
+    }
+    if (updates.trigger_phrases !== undefined) {
+      updateData.trigger_phrases = updates.trigger_phrases
+      updatedFields.push('trigger_phrases')
+    }
+
+    if (updatedFields.length === 0) {
+      return { success: true, updated_fields: [] }
+    }
+
+    // Perform update
+    memories.update(memoryId, updateData)
+
+    return { success: true, updated_fields: updatedFields }
+  }
+
+  /**
+   * Get a single memory by ID
+   */
+  async getMemory(projectId: string, memoryId: string): Promise<StoredMemory | null> {
+    const { memories } = await this.getProject(projectId)
+    const record = memories.get(memoryId)
+    if (!record) return null
+
+    return {
+      id: record.id,
+      headline: record.headline ?? '',
+      content: record.content,
+      reasoning: record.reasoning,
+      importance_weight: record.importance_weight,
+      confidence_score: record.confidence_score,
+      context_type: record.context_type as StoredMemory['context_type'],
+      status: record.status as StoredMemory['status'],
+      exclude_from_retrieval: record.exclude_from_retrieval,
+      action_required: record.action_required,
+      awaiting_implementation: record.awaiting_implementation,
+      awaiting_decision: record.awaiting_decision,
+      semantic_tags: record.semantic_tags,
+      trigger_phrases: record.trigger_phrases,
+      project_id: record.project_id,
+      created_at: record.created_at,
+      updated_at: record.updated_at,
+    } as StoredMemory
+  }
+
   /**
    * Get all memories for a project
    */

package/src/server/index.ts

@@ -387,6 +387,52 @@ export async function createServer(config: ServerConfig = {}) {
           })
         }
 
+        // PATCH memory - update metadata for curation (promote/demote/bury)
+        const patchMatch = path.match(/^\/memory\/([a-zA-Z0-9_-]+)$/)
+        if (patchMatch && req.method === 'PATCH') {
+          const memoryId = patchMatch[1]
+          const body = await req.json() as {
+            project_id: string
+            importance_weight?: number
+            confidence_score?: number
+            exclude_from_retrieval?: boolean
+            status?: 'active' | 'pending' | 'superseded' | 'deprecated' | 'archived'
+            action_required?: boolean
+            awaiting_implementation?: boolean
+            awaiting_decision?: boolean
+            semantic_tags?: string[]
+            trigger_phrases?: string[]
+            project_path?: string
+          }
+
+          if (!body.project_id) {
+            return Response.json(
+              { success: false, error: 'project_id is required' },
+              { status: 400, headers: corsHeaders }
+            )
+          }
+
+          logger.request('PATCH', `/memory/${memoryId}`, body.project_id)
+
+          const { project_id, project_path, ...updates } = body
+          const result = await engine.updateMemory(project_id, memoryId, updates, project_path)
+
+          if (!result.success) {
+            return Response.json(
+              { success: false, error: 'Memory not found', memory_id: memoryId },
+              { status: 404, headers: corsHeaders }
+            )
+          }
+
+          logger.info(`Updated memory ${memoryId}: ${result.updated_fields.join(', ')}`)
+
+          return Response.json({
+            success: true,
+            memory_id: memoryId,
+            updated_fields: result.updated_fields,
+          }, { headers: corsHeaders })
+        }
+
         // 404
         return Response.json(
           { error: 'Not found', path },