claude-brain 0.30.2 → 0.30.3

package/src/routing/handlers/mutation-handler.ts

@@ -0,0 +1,241 @@
+/**
+ * Mutation Handler
+ * Task 3.1: Mutation intents — handleUpdateMemory, handleDeleteMemory
+ */
+
+import type { HandlerContext, BrainExtractedEntities, BrainResponse } from './types'
+import { DEFAULT_PROJECT, UPDATE_MIN_SIMILARITY, DELETE_MIN_SIMILARITY } from './types'
+import { servicesNotReady, storeAsNew, hasDescriptiveContent } from './shared'
+import { getMemoryService, isServicesInitialized } from '@/server/services'
+
+/** Shape of raw search results from MemoryManager.searchRaw() */
+interface RawSearchResult {
+  id?: string
+  content?: string
+  similarity?: number
+  memory?: { id?: string; content?: string }
+  decision?: { id?: string; decision?: string }
+}
+
+/**
+ * Phase 19 D4: Update with higher similarity threshold
+ */
+export async function handleUpdateMemory(
+  ctx: HandlerContext,
+  message: string,
+  project: string | undefined,
+  entities: BrainExtractedEntities
+): Promise<BrainResponse> {
+  const effectiveProject = project || ctx.lastStoredProject || DEFAULT_PROJECT
+
+  if (!isServicesInitialized()) {
+    return servicesNotReady()
+  }
+
+  const memory = getMemoryService()
+  const topic = entities.topic || message
+  const hasSpecific = hasDescriptiveContent(message)
+
+  if (hasSpecific) {
+    try {
+      const results = await memory.searchRaw(topic, {
+        project: effectiveProject,
+        limit: 1,
+        minSimilarity: UPDATE_MIN_SIMILARITY
+      }) as RawSearchResult[]
+
+      const first = results[0]
+      const matchId = first?.memory?.id || first?.decision?.id || first?.id
+      const matchSimilarity = first?.similarity || 0
+
+      if (results.length > 0 && matchId && matchSimilarity >= UPDATE_MIN_SIMILARITY) {
+        const oldId = matchId
+        const newId = await memory.updateDecision(
+          oldId,
+          effectiveProject,
+          `Updated: ${topic.slice(0, 200)}`,
+          message,
+          entities.reasoning || 'Updated via brain tool',
+          { tags: entities.technologies.length > 0 ? entities.technologies : ['updated'] }
+        )
+
+        ctx.setLastStored(newId, effectiveProject)
+
+        // Invalidate cache
+        ctx.searchEngine.invalidateCache(effectiveProject)
+
+        const oldContent = first?.decision?.decision || first?.memory?.content?.slice(0, 100) || first?.content?.slice(0, 100) || ''
+        return {
+          action: 'stored',
+          summary: `Updated decision`,
+          content: `Replaced: "${oldContent.slice(0, 80)}"\n\nWith:\n**New content:** ${message}`,
+          relevantItems: 1
+        }
+      } else if (results.length > 0 && matchSimilarity < UPDATE_MIN_SIMILARITY) {
+        // D4: No confident match — store as new instead of updating wrong memory
+        return storeAsNew(ctx, memory, effectiveProject, message, topic, entities, 'No confident match to update (similarity too low)')
+      }
+    } catch {
+      // Search failed, fall through
+    }
+  }
+
+  // Generic update — use lastStoredId
+  if (ctx.lastStoredId) {
+    const newId = await memory.updateDecision(
+      ctx.lastStoredId,
+      effectiveProject,
+      `Updated: ${topic.slice(0, 200)}`,
+      message,
+      entities.reasoning || 'Updated via brain tool',
+      { tags: entities.technologies.length > 0 ? entities.technologies : ['updated'] }
+    )
+
+    ctx.setLastStored(newId, effectiveProject)
+    ctx.searchEngine.invalidateCache(effectiveProject)
+
+    return {
+      action: 'stored',
+      summary: `Updated decision`,
+      content: `Previous decision replaced with:\n\n**Project:** ${effectiveProject}\n**New content:** ${message}`,
+      relevantItems: 1
+    }
+  }
+
+  // Fallback: store as new decision
+  return storeAsNew(ctx, memory, effectiveProject, message, topic, entities, 'No matching decision found to update')
+}
+
+/**
+ * Phase 19 D4: Delete with higher similarity threshold
+ */
+export async function handleDeleteMemory(
+  ctx: HandlerContext,
+  message: string,
+  project: string | undefined,
+  entities: BrainExtractedEntities
+): Promise<BrainResponse> {
+  const effectiveProject = project || ctx.lastStoredProject || DEFAULT_PROJECT
+
+  if (!isServicesInitialized()) {
+    return servicesNotReady()
+  }
+
+  const memory = getMemoryService()
+  const topic = entities.topic || message
+  const hasSpecific = hasDescriptiveContent(message)
+  const lower = message.toLowerCase()
+
+  // BUG-006 T6: Bulk delete — "delete all memories for project X"
+  if (lower.includes('delete all') || lower.includes('remove all') || lower.includes('clear all')) {
+    const bulkProject = entities.project || project || ctx.lastStoredProject
+    if (bulkProject) {
+      try {
+        const decisions = await memory.chroma.store.getDecisionsByProject(bulkProject)
+        if (decisions.length === 0) {
+          return {
+            action: 'none',
+            summary: 'No memories found',
+            content: `No memories found for project "${bulkProject}".`,
+            relevantItems: 0
+          }
+        }
+        for (const d of decisions) {
+          await memory.deleteDecision(d.id)
+        }
+        ctx.searchEngine.invalidateCache(bulkProject)
+        return {
+          action: 'stored',
+          summary: `Bulk deleted ${decisions.length} memories`,
+          content: `Deleted all ${decisions.length} memories for project "${bulkProject}".`,
+          relevantItems: 0
+        }
+      } catch {
+        // Bulk delete failed, fall through to single-item delete
+      }
+    }
+  }
+
+  if (hasSpecific) {
+    try {
+      const results = await memory.searchRaw(topic, {
+        project: effectiveProject,
+        limit: 3,
+        minSimilarity: DELETE_MIN_SIMILARITY
+      }) as RawSearchResult[]
+
+      const first = results[0]
+      const matchId = first?.memory?.id || first?.decision?.id || first?.id
+      const matchSimilarity = first?.similarity || 0
+
+      if (results.length > 0 && matchId && matchSimilarity >= DELETE_MIN_SIMILARITY) {
+        const targetId = matchId
+        const content = first?.decision?.decision || first?.memory?.content?.slice(0, 100) || first?.content?.slice(0, 100) || ''
+
+        await memory.deleteDecision(targetId)
+        if (ctx.lastStoredId === targetId) ctx.setLastStored('', '')
+
+        // Invalidate cache
+        ctx.searchEngine.invalidateCache(effectiveProject)
+
+        return {
+          action: 'stored',
+          summary: `Deleted memory`,
+          content: `Deleted: "${content.slice(0, 100)}" (ID: ${targetId})`,
+          relevantItems: 0
+        }
+      } else if (results.length > 0 && matchSimilarity < DELETE_MIN_SIMILARITY) {
+        // D4: No confident match — try direct FTS5 content search as fallback
+        const memory = getMemoryService()
+        if (memory.fts5) {
+          const ftsResults = memory.fts5.search(topic, effectiveProject, 3)
+          if (ftsResults.length > 0) {
+            const ftsTarget = ftsResults[0]!
+            await memory.deleteDecision(ftsTarget.id)
+            if (ctx.lastStoredId === ftsTarget.id) ctx.setLastStored('', '')
+            ctx.searchEngine.invalidateCache(effectiveProject)
+            return {
+              action: 'stored',
+              summary: `Deleted memory`,
+              content: `Deleted: "${ftsTarget.content.slice(0, 100)}" (ID: ${ftsTarget.id})`,
+              relevantItems: 0
+            }
+          }
+        }
+        return {
+          action: 'none',
+          summary: 'No confident match to delete',
+          content: `Found a possible match but similarity (${Math.round(matchSimilarity * 100)}%) is too low for safe deletion. Try being more specific about what to delete.`,
+          relevantItems: 0
+        }
+      }
+    } catch {
+      // Search failed, fall through
+    }
+  }
+
+  // Generic request — use lastStoredId
+  if (ctx.lastStoredId) {
+    try {
+      await memory.deleteDecision(ctx.lastStoredId)
+      const deletedId = ctx.lastStoredId
+      ctx.setLastStored('', '')
+      ctx.searchEngine.invalidateCache(effectiveProject)
+      return {
+        action: 'stored',
+        summary: `Deleted most recent memory`,
+        content: `Deleted memory (ID: ${deletedId})`,
+        relevantItems: 0
+      }
+    } catch {
+      // Deletion failed
+    }
+  }
+
+  return {
+    action: 'none',
+    summary: 'No matching memory found to delete',
+    content: 'Could not find a memory matching your request. Try being more specific about what to delete.',
+    relevantItems: 0
+  }
+}