@rlabs-inc/memory 0.4.14 → 0.5.0

package/src/server/index.ts

@@ -7,7 +7,7 @@ import { MemoryEngine, createEngine, type EngineConfig } from '../core/engine.ts
 import { Curator, createCurator, type CuratorConfig } from '../core/curator.ts'
 import { EmbeddingGenerator, createEmbeddings } from '../core/embeddings.ts'
 import { Manager, createManager, type ManagerConfig } from '../core/manager.ts'
-import type { CurationTrigger } from '../types/memory.ts'
+import type { CurationTrigger, CurationResult } from '../types/memory.ts'
 import { logger } from '../utils/logger.ts'
 
 /**
@@ -215,29 +215,42 @@ export async function createServer(config: ServerConfig = {}) {
           // Fire and forget - don't block the response
           setImmediate(async () => {
             try {
-              // Try session resume first (v2) - gets full context including tool uses
-              // Falls back to segmented transcript parsing if resume fails
-              let result = await curator.curateWithSessionResume(
-                body.claude_session_id,
-                body.trigger
-              )
+              let result: CurationResult
 
-              // Fallback to transcript-based curation WITH SEGMENTATION if resume returned nothing
-              // This matches the ingest command behavior - breaks large sessions into segments
-              if (result.memories.length === 0) {
-                logger.debug('Session resume returned no memories, falling back to segmented transcript parsing', 'server')
-                result = await curator.curateFromSessionFileWithSegments(
+              // Branch on CLI type - Gemini CLI vs Claude Code
+              if (body.cli_type === 'gemini-cli') {
+                // Use Gemini CLI for curation (no Claude dependency)
+                logger.debug('Using Gemini CLI for curation', 'server')
+                result = await curator.curateWithGeminiCLI(
                   body.claude_session_id,
-                  body.trigger,
-                  body.cwd,
-                  150000, // 150k tokens per segment
-                  (progress) => {
-                    logger.debug(
-                      `Curation segment ${progress.segmentIndex + 1}/${progress.totalSegments}: ${progress.memoriesExtracted} memories (~${Math.round(progress.tokensInSegment / 1000)}k tokens)`,
-                      'server'
-                    )
-                  }
+                  body.trigger
+                )
+              } else {
+                // Default: Use Claude Code (session resume or transcript parsing)
+                // Try session resume first (v2) - gets full context including tool uses
+                // Falls back to segmented transcript parsing if resume fails
+                result = await curator.curateWithSessionResume(
+                  body.claude_session_id,
+                  body.trigger
                 )
+
+                // Fallback to transcript-based curation WITH SEGMENTATION if resume returned nothing
+                // This matches the ingest command behavior - breaks large sessions into segments
+                if (result.memories.length === 0) {
+                  logger.debug('Session resume returned no memories, falling back to segmented transcript parsing', 'server')
+                  result = await curator.curateFromSessionFileWithSegments(
+                    body.claude_session_id,
+                    body.trigger,
+                    body.cwd,
+                    150000, // 150k tokens per segment
+                    (progress) => {
+                      logger.debug(
+                        `Curation segment ${progress.segmentIndex + 1}/${progress.totalSegments}: ${progress.memoriesExtracted} memories (~${Math.round(progress.tokensInSegment / 1000)}k tokens)`,
+                        'server'
+                      )
+                    }
+                  )
+                }
               }
 
               if (result.memories.length > 0) {
@@ -255,19 +268,34 @@ export async function createServer(config: ServerConfig = {}) {
                 const sessionNumber = await engine.getSessionNumber(body.project_id, body.project_path)
                 // Get resolved storage paths from engine config (runtime values, not hardcoded)
                 const storagePaths = engine.getStoragePaths(body.project_id, body.project_path)
+                // Remember cli_type for manager
+                const cliType = body.cli_type
 
                 setImmediate(async () => {
                   try {
                     logger.logManagementStart(result.memories.length)
                     const startTime = Date.now()
 
-                    // Use SDK mode - more reliable than CLI which can go off-rails
-                    const managementResult = await manager.manageWithSDK(
-                      body.project_id,
-                      sessionNumber,
-                      result,
-                      storagePaths
-                    )
+                    // Use appropriate mode based on CLI type
+                    let managementResult
+                    if (cliType === 'gemini-cli') {
+                      // Use Gemini CLI for management (no Claude dependency)
+                      logger.debug('Using Gemini CLI for management', 'server')
+                      managementResult = await manager.manageWithGeminiCLI(
+                        body.project_id,
+                        sessionNumber,
+                        result,
+                        storagePaths
+                      )
+                    } else {
+                      // Use Claude Agent SDK mode - more reliable than CLI
+                      managementResult = await manager.manageWithSDK(
+                        body.project_id,
+                        sessionNumber,
+                        result,
+                        storagePaths
+                      )
+                    }
 
                     logger.logManagementComplete({
                       success: managementResult.success,
@@ -387,6 +415,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 },