Add memory management include and delete actions

Author: zhmzm

packages/server/src/index.ts

@@ -7,7 +7,14 @@ import { dirname, join } from 'path'
 import { fileURLToPath } from 'url'
 import { learnFromDeletions, learnFromTrajectoryRevisions, getLearnedPreferences, clearPreferences, deletePreference } from './preference.js'
 import { createSession, getSession, listSessions, completeSession, setSessionRewriting, updateSessionPayload } from './store.js'
-import { buildMemoryCatalog, buildMemoryReviewPayload, readMemoryFileContent } from './memory.js'
+import {
+  buildMemoryCatalog,
+  buildMemoryReviewPayload,
+  deleteMemoryFile,
+  includeMemoryFileInContext,
+  readMemoryFileContent,
+  removeMemoryFileFromContext,
+} from './memory.js'
 
 const app = express()
 const DEFAULT_PORT = 38173
@@ -252,6 +259,33 @@ app.get('/api/memory/file', (req, res) => {
   res.json(file)
 })
 
+app.post('/api/memory/include', (req, res) => {
+  const projectRoot = join(__dirname, '../../..')
+  const filePath = typeof req.body?.path === 'string' ? req.body.path : ''
+  if (!filePath) return res.status(400).json({ error: 'Missing path in request body' })
+  const result = includeMemoryFileInContext({ projectRoot, filePath })
+  if (!result.ok) return res.status(404).json({ error: 'File not found in memory catalog' })
+  res.json(result)
+})
+
+app.post('/api/memory/exclude', (req, res) => {
+  const projectRoot = join(__dirname, '../../..')
+  const filePath = typeof req.body?.path === 'string' ? req.body.path : ''
+  if (!filePath) return res.status(400).json({ error: 'Missing path in request body' })
+  const result = removeMemoryFileFromContext({ projectRoot, filePath })
+  if (!result.ok) return res.status(404).json({ error: 'File not found in memory catalog' })
+  res.json(result)
+})
+
+app.delete('/api/memory/file', (req, res) => {
+  const projectRoot = join(__dirname, '../../..')
+  const filePath = typeof req.query.path === 'string' ? req.query.path : ''
+  if (!filePath) return res.status(400).json({ error: 'Missing path query' })
+  const result = deleteMemoryFile({ projectRoot, filePath })
+  if (!result.ok) return res.status(400).json({ error: result.reason || 'Failed to delete file' })
+  res.json(result)
+})
+
 app.post('/api/memory/review/create', async (req, res) => {
   const { sessionKey, noOpen, openHome, currentContextFiles, generatedContent } = req.body ?? {}
   const projectRoot = join(__dirname, '../../..')

packages/server/src/memory.ts

@@ -51,6 +51,8 @@ export interface MemoryCatalogPayload {
   defaultIncludedFileIds: string[]
 }
 
+const MEMORY_INCLUDE_STATE_PATH = path.join(os.homedir(), '.openclaw', 'agentclick-memory-includes.json')
+
 function walkMarkdownFiles(baseDir: string, options?: { maxFiles?: number }): string[] {
   const maxFiles = options?.maxFiles ?? 200
   const output: string[] = []
@@ -91,6 +93,23 @@ function safeRead(filePath: string, maxChars = 12000): string {
   }
 }
 
+function readIncludedMemoryPaths(): string[] {
+  try {
+    if (!fs.existsSync(MEMORY_INCLUDE_STATE_PATH)) return []
+    const raw = fs.readFileSync(MEMORY_INCLUDE_STATE_PATH, 'utf-8')
+    const parsed = JSON.parse(raw) as { includedPaths?: string[] }
+    return (parsed.includedPaths ?? []).filter(Boolean)
+  } catch {
+    return []
+  }
+}
+
+function writeIncludedMemoryPaths(paths: string[]): void {
+  const dir = path.dirname(MEMORY_INCLUDE_STATE_PATH)
+  if (!fs.existsSync(dir)) fs.mkdirSync(dir, { recursive: true })
+  fs.writeFileSync(MEMORY_INCLUDE_STATE_PATH, JSON.stringify({ includedPaths: paths }, null, 2), 'utf-8')
+}
+
 function parseSections(markdown: string): Array<{ id: string; title: string }> {
   const out: Array<{ id: string; title: string }> = []
   const lines = markdown.split('\n')
@@ -134,7 +153,11 @@ export function buildMemoryCatalog(input: {
   currentContextFiles?: string[]
 }): MemoryCatalogPayload {
   const projectRoot = input.projectRoot
-  const currentContextSet = new Set((input.currentContextFiles ?? []).map(p => path.resolve(projectRoot, p)))
+  const persistedIncludes = readIncludedMemoryPaths().map(p => path.resolve(p))
+  const currentContextSet = new Set([
+    ...persistedIncludes,
+    ...(input.currentContextFiles ?? []).map(p => path.resolve(projectRoot, p)),
+  ])
   const relatedMarkdown = walkMarkdownFiles(projectRoot, { maxFiles: 220 })
   const projectMemoryFiles = relatedMarkdown.filter(p => path.basename(p).toLowerCase().includes('memory'))
   const agentCacheFiles = collectAgentCacheMemoryFiles()
@@ -239,6 +262,43 @@ export function readMemoryFileContent(input: {
   }
 }
 
+export function includeMemoryFileInContext(input: { projectRoot: string; filePath: string }): { ok: boolean; includedPaths: string[] } {
+  const catalog = buildMemoryCatalog({ projectRoot: input.projectRoot })
+  const target = catalog.files.find(f => path.resolve(f.path) === path.resolve(input.filePath))
+  if (!target) return { ok: false, includedPaths: readIncludedMemoryPaths() }
+  const current = new Set(readIncludedMemoryPaths().map(p => path.resolve(p)))
+  current.add(path.resolve(target.path))
+  const next = Array.from(current.values()).sort()
+  writeIncludedMemoryPaths(next)
+  return { ok: true, includedPaths: next }
+}
+
+export function removeMemoryFileFromContext(input: { projectRoot: string; filePath: string }): { ok: boolean; includedPaths: string[] } {
+  const catalog = buildMemoryCatalog({ projectRoot: input.projectRoot })
+  const target = catalog.files.find(f => path.resolve(f.path) === path.resolve(input.filePath))
+  if (!target) return { ok: false, includedPaths: readIncludedMemoryPaths() }
+  const current = new Set(readIncludedMemoryPaths().map(p => path.resolve(p)))
+  current.delete(path.resolve(target.path))
+  const next = Array.from(current.values()).sort()
+  writeIncludedMemoryPaths(next)
+  return { ok: true, includedPaths: next }
+}
+
+export function deleteMemoryFile(input: { projectRoot: string; filePath: string }): { ok: boolean; deletedPath?: string; reason?: string } {
+  const catalog = buildMemoryCatalog({ projectRoot: input.projectRoot })
+  const target = catalog.files.find(f => path.resolve(f.path) === path.resolve(input.filePath))
+  if (!target) return { ok: false, reason: 'File not found in memory catalog' }
+  try {
+    fs.unlinkSync(target.path)
+  } catch (err) {
+    return { ok: false, reason: err instanceof Error ? err.message : String(err) }
+  }
+  const current = new Set(readIncludedMemoryPaths().map(p => path.resolve(p)))
+  current.delete(path.resolve(target.path))
+  writeIncludedMemoryPaths(Array.from(current.values()).sort())
+  return { ok: true, deletedPath: target.path }
+}
+
 export function buildMemoryReviewPayload(input: {
   projectRoot: string
   currentContextFiles?: string[]

packages/web/src/pages/MemoryManagementPage.tsx

@@ -6,6 +6,7 @@ interface MemoryFile {
   relativePath: string
   categories: string[]
   preview: string
+  inCurrentContent: boolean
 }
 
 interface MemoryGroup {
@@ -98,19 +99,26 @@ export default function MemoryManagementPage() {
   const [collapsedGroups, setCollapsedGroups] = useState<Set<string>>(new Set())
   const [loading, setLoading] = useState(true)
   const [fileLoading, setFileLoading] = useState(false)
+  const [actionLoading, setActionLoading] = useState(false)
   const [error, setError] = useState('')
 
+  const loadCatalog = async () => {
+    setLoading(true)
+    try {
+      const response = await fetch('/api/memory/files')
+      if (!response.ok) throw new Error(`HTTP ${response.status}`)
+      const data = await response.json() as CatalogResponse
+      setCatalog(data)
+      setError('')
+    } catch {
+      setError('Failed to load memory catalog')
+    } finally {
+      setLoading(false)
+    }
+  }
+
   useEffect(() => {
-    fetch('/api/memory/files')
-      .then(r => r.json())
-      .then((data: CatalogResponse) => {
-        setCatalog(data)
-        setLoading(false)
-      })
-      .catch(() => {
-        setError('Failed to load memory catalog')
-        setLoading(false)
-      })
+    loadCatalog()
   }, [])
 
   const fileMap = useMemo(() => {
@@ -144,6 +152,49 @@ export default function MemoryManagementPage() {
     })
   }
 
+  const selectedFile = useMemo(() => {
+    if (!selectedPath) return null
+    return catalog?.files.find(file => file.path === selectedPath) ?? null
+  }, [catalog, selectedPath])
+
+  const setInContext = async (targetPath: string, include: boolean) => {
+    setActionLoading(true)
+    try {
+      const response = await fetch(include ? '/api/memory/include' : '/api/memory/exclude', {
+        method: 'POST',
+        headers: { 'Content-Type': 'application/json' },
+        body: JSON.stringify({ path: targetPath }),
+      })
+      if (!response.ok) throw new Error(`HTTP ${response.status}`)
+      await loadCatalog()
+      setError('')
+    } catch {
+      setError(include ? 'Failed to include file in current content' : 'Failed to exclude file from current content')
+    } finally {
+      setActionLoading(false)
+    }
+  }
+
+  const handleDelete = async (targetPath: string) => {
+    const confirmed = window.confirm('Delete this memory file permanently?')
+    if (!confirmed) return
+    setActionLoading(true)
+    try {
+      const response = await fetch(`/api/memory/file?path=${encodeURIComponent(targetPath)}`, { method: 'DELETE' })
+      if (!response.ok) throw new Error(`HTTP ${response.status}`)
+      if (selectedPath === targetPath) {
+        setSelectedPath('')
+        setSelectedContent(null)
+      }
+      await loadCatalog()
+      setError('')
+    } catch {
+      setError('Failed to delete memory file')
+    } finally {
+      setActionLoading(false)
+    }
+  }
+
   return (
     <div className="min-h-screen bg-gray-50 dark:bg-zinc-950">
       <div className="max-w-7xl mx-auto py-8 px-4">
@@ -212,6 +263,32 @@ export default function MemoryManagementPage() {
                 <>
                   <p className="text-xs text-zinc-400 dark:text-slate-500 uppercase mb-1">Full File</p>
                   <h2 className="text-sm font-mono text-zinc-800 dark:text-slate-200 break-all">{selectedContent.path}</h2>
+                  <div className="mt-3 flex flex-wrap gap-2">
+                    {selectedFile?.inCurrentContent ? (
+                      <button
+                        onClick={() => setInContext(selectedContent.path, false)}
+                        disabled={actionLoading}
+                        className="px-2.5 py-1.5 text-xs rounded border border-amber-300 text-amber-700 bg-amber-50 hover:bg-amber-100 disabled:opacity-60 disabled:cursor-not-allowed"
+                      >
+                        Remove From Context
+                      </button>
+                    ) : (
+                      <button
+                        onClick={() => setInContext(selectedContent.path, true)}
+                        disabled={actionLoading}
+                        className="px-2.5 py-1.5 text-xs rounded border border-emerald-300 text-emerald-700 bg-emerald-50 hover:bg-emerald-100 disabled:opacity-60 disabled:cursor-not-allowed"
+                      >
+                        Include In Context
+                      </button>
+                    )}
+                    <button
+                      onClick={() => handleDelete(selectedContent.path)}
+                      disabled={actionLoading}
+                      className="px-2.5 py-1.5 text-xs rounded border border-red-300 text-red-700 bg-red-50 hover:bg-red-100 disabled:opacity-60 disabled:cursor-not-allowed"
+                    >
+                      Delete File
+                    </button>
+                  </div>
                   <div className="mt-3 max-h-[70vh] overflow-y-auto pr-1">
                     {renderMarkdownFriendly(selectedContent.content)}
                   </div>
@@ -224,4 +301,3 @@ export default function MemoryManagementPage() {
     </div>
   )
 }
-