total-recall-brain 3.12.2 → 3.13.1

package/src/server/routes/memory.mjs

@@ -14,12 +14,13 @@ import express from 'express';
 import fs from 'node:fs';
 import path from 'node:path';
 import { createMemoryNode, walkMd } from '../../core/vault.mjs';
-import { writeNodeValidated } from '../../core/validated-write.mjs';
+import { writeNodeValidatedAsync } from '../../core/validated-write.mjs';
 import { getNodes, invalidate } from '../../core/vault-cache.mjs';
 import { requireAuth, requireScope } from '../auth.mjs';
 import { compileSurface } from '../../core/surface.mjs';
 import { buildEmbeddingsIndex, buildSessionEmbeddingsIndex } from '../../core/embeddings.mjs';
 import { detectAndResolve } from '../../core/conflict-detector.mjs';
+import { listQueue, updateQueueItem } from '../../core/research-queue.mjs';
 import {
   BRAIN_DIR,
   VAULT_DIR,
@@ -32,6 +33,7 @@ import {
   serverError,
   sanitizeNode,
   resolveVaultFromQuery,
+  resolveAllVaultsFromQuery,
 } from './_shared.mjs';
 
 const router = express.Router();
@@ -109,10 +111,23 @@ const PASSTHROUGH_FIELDS = [
 
 router.get('/api/memory', requireAuth, requireScope('memory:read'), (req, res) => {
   try {
-    const vaultDir = resolveVaultFromQuery(req);
-    let list = nodes(vaultDir);
+    const vaultDirs = resolveAllVaultsFromQuery(req);
+    let list = [];
 
-    const { q, category, tag, status, limit = '200', offset = '0' } = req.query;
+    // Track unique slugs so we don't count shadowing duplicates twice
+    const seenSlugs = new Set();
+
+    // Iterate backwards so most specific (last in list) is seen first
+    for (let i = vaultDirs.length - 1; i >= 0; i--) {
+      const vaultList = nodes(vaultDirs[i]);
+      for (const n of vaultList) {
+        if (!seenSlugs.has(n.slug)) {
+          seenSlugs.add(n.slug);
+          list.push(n);
+        }
+      }
+    }
+    const { q, category, tag, tags, status, limit = '200', offset = '0' } = req.query;
 
     if (q) {
       const query = String(q).toLowerCase();
@@ -123,7 +138,20 @@ router.get('/api/memory', requireAuth, requireScope('memory:read'), (req, res) =
     }
     if (category) list = list.filter(n => n.category === category);
     if (status) list = list.filter(n => n.status === status);
-    if (tag) list = list.filter(n => (n.tags || []).includes(tag));
+    // Accept tag= or tags= (comma-separated). OpenWiki UI uses tags=openwiki.
+    const tagFilter = tag || tags;
+    if (tagFilter) {
+      const wanted = String(tagFilter)
+        .split(',')
+        .map((t) => t.trim().toLowerCase())
+        .filter(Boolean);
+      if (wanted.length) {
+        list = list.filter((n) => {
+          const nodeTags = (n.tags || []).map((t) => String(t).toLowerCase());
+          return wanted.every((t) => nodeTags.includes(t));
+        });
+      }
+    }
 
     const total = list.length;
     const off   = Math.max(0, parseInt(offset, 10) || 0);
@@ -138,30 +166,87 @@ router.get('/api/memory', requireAuth, requireScope('memory:read'), (req, res) =
 
 router.get('/api/memory/stats', requireAuth, requireScope('memory:read'), (req, res) => {
   try {
-    const vaultDir = resolveVaultFromQuery(req);
-    const list = nodes(vaultDir);
+    const vaultDirs = resolveAllVaultsFromQuery(req);
     const byCategory = {};
-    for (const n of list) {
-      byCategory[n.category] = (byCategory[n.category] || 0) + 1;
+    let total = 0;
+
+    // Track unique slugs so we don't count shadowing duplicates twice
+    const seenSlugs = new Set();
+
+    // Iterate backwards so most specific (last in list) is seen first
+    for (let i = vaultDirs.length - 1; i >= 0; i--) {
+      const list = nodes(vaultDirs[i]);
+      for (const n of list) {
+        if (!seenSlugs.has(n.slug)) {
+          seenSlugs.add(n.slug);
+          byCategory[n.category] = (byCategory[n.category] || 0) + 1;
+          total++;
+        }
+      }
     }
-    res.json({ total: list.length, by_category: byCategory });
+
+    res.json({ total, by_category: byCategory });
   } catch (err) {
     serverError(res, err);
   }
 });
 
+/**
+ * Expand vault search: query brain(s) first, then global, then every registered
+ * project brain. Fixes dashboard 404s when the list came from a project vault
+ * but GET omitted ?brain=.
+ */
+function vaultDirsForSlugLookup(req) {
+  const dirs = [...resolveAllVaultsFromQuery(req)];
+  const seen = new Set(dirs);
+
+  const push = (dir) => {
+    if (dir && !seen.has(dir) && fs.existsSync(dir)) {
+      seen.add(dir);
+      dirs.push(dir);
+    }
+  };
+
+  push(VAULT_DIR);
+
+  try {
+    const home = process.env.HOME || process.env.USERPROFILE || '';
+    const registryPath = path.join(home, '.agent', 'skills', 'total-recall', 'config', 'project-registry.json');
+    if (fs.existsSync(registryPath)) {
+      const registry = JSON.parse(fs.readFileSync(registryPath, 'utf8'));
+      if (Array.isArray(registry)) {
+        for (const project of registry) {
+          if (project?.brainDir) {
+            push(path.join(project.brainDir, 'memory-vault'));
+          }
+        }
+      }
+    }
+  } catch {
+    // non-fatal
+  }
+
+  return dirs;
+}
+
 router.get('/api/memory/:slug', requireAuth, requireScope('memory:read'), (req, res) => {
   try {
-    const vaultDir = resolveVaultFromQuery(req);
-    const node = nodes(vaultDir).find(n => n.slug === req.params.slug);
-    if (!node) return notFound(res, `Memory node not found: ${req.params.slug}`);
-    res.json(sanitizeNode(node));
+    const vaultDirs = vaultDirsForSlugLookup(req);
+
+    for (const vaultDir of vaultDirs) {
+      const node = nodes(vaultDir).find(n => n.slug === req.params.slug);
+      if (node) {
+        return res.json(sanitizeNode(node));
+      }
+    }
+
+    return notFound(res, `Memory node not found: ${req.params.slug}`);
   } catch (err) {
     serverError(res, err);
   }
 });
 
-router.post('/api/memory', requireAuth, requireScope('memory:write'), (req, res) => {
+router.post('/api/memory', requireAuth, requireScope('memory:write'), async (req, res) => {
   try {
     const vaultDir = resolveVaultFromQuery(req);
     const { slug, title, category, content, body, tags } = req.body || {};
@@ -179,7 +264,7 @@ router.post('/api/memory', requireAuth, requireScope('memory:write'), (req, res)
       if (req.body[key] !== undefined) node[key] = req.body[key];
     }
 
-    const vaultResult = writeNodeValidated(node, vaultDir);
+    const vaultResult = await writeNodeValidatedAsync(node, vaultDir);
     if (!vaultResult.success) {
       return res.status(422).json({
         error: 'Validation failed',
@@ -195,7 +280,7 @@ router.post('/api/memory', requireAuth, requireScope('memory:write'), (req, res)
   }
 });
 
-router.put('/api/memory/:slug', requireAuth, requireScope('memory:write'), (req, res) => {
+router.put('/api/memory/:slug', requireAuth, requireScope('memory:write'), async (req, res) => {
   try {
     const vaultDir = resolveVaultFromQuery(req);
     const { title, category, content, body, tags } = req.body || {};
@@ -210,7 +295,7 @@ router.put('/api/memory/:slug', requireAuth, requireScope('memory:write'), (req,
       if (req.body[key] !== undefined) node[key] = req.body[key];
     }
 
-    const vaultResult = writeNodeValidated(node, vaultDir);
+    const vaultResult = await writeNodeValidatedAsync(node, vaultDir);
     if (!vaultResult.success) {
       return res.status(422).json({
         error: 'Validation failed',
@@ -218,18 +303,28 @@ router.put('/api/memory/:slug', requireAuth, requireScope('memory:write'), (req,
         repair: vaultResult.repair,
       });
     }
-    invalidate(vaultDir);
-    triggerMutation(node, vaultDir);
+    invalidate(targetVaultDir);
+    triggerMutation(node, targetVaultDir);
     res.json(sanitizeNode(node));
   } catch (err) {
     serverError(res, err);
   }
 });
 
-router.patch('/api/memory/:slug', requireAuth, requireScope('memory:write'), (req, res) => {
+router.patch('/api/memory/:slug', requireAuth, requireScope('memory:write'), async (req, res) => {
   try {
-    const vaultDir = resolveVaultFromQuery(req);
-    const existing = nodes(vaultDir).find(n => n.slug === req.params.slug);
+    const vaultDirs = resolveAllVaultsFromQuery(req);
+    let existing;
+    let targetVaultDir = vaultDirs[vaultDirs.length - 1]; // Default to most specific
+
+    for (const vaultDir of vaultDirs) {
+      existing = nodes(vaultDir).find(n => n.slug === req.params.slug);
+      if (existing) {
+        targetVaultDir = vaultDir;
+        break;
+      }
+    }
+
     if (!existing) return notFound(res, `Memory node not found: ${req.params.slug}`);
 
     const { title, category, content, body, tags } = req.body || {};
@@ -250,7 +345,7 @@ router.patch('/api/memory/:slug', requireAuth, requireScope('memory:write'), (re
       if (req.body[key] !== undefined) updated[key] = req.body[key];
     }
 
-    const vaultResult = writeNodeValidated(updated, vaultDir);
+    const vaultResult = await writeNodeValidatedAsync(updated, targetVaultDir);
     if (!vaultResult.success) {
       return res.status(422).json({
         error: 'Validation failed',
@@ -258,8 +353,8 @@ router.patch('/api/memory/:slug', requireAuth, requireScope('memory:write'), (re
         repair: vaultResult.repair,
       });
     }
-    invalidate(vaultDir);
-    triggerMutation(updated, vaultDir);
+    invalidate(targetVaultDir);
+    triggerMutation(updated, targetVaultDir);
     res.json(sanitizeNode(updated));
   } catch (err) {
     serverError(res, err);
@@ -268,15 +363,24 @@ router.patch('/api/memory/:slug', requireAuth, requireScope('memory:write'), (re
 
 router.delete('/api/memory/:slug', requireAuth, requireScope('memory:write'), (req, res) => {
   try {
-    const vaultDir = resolveVaultFromQuery(req);
-    const list = nodes(vaultDir);
-    const node = list.find(n => n.slug === req.params.slug);
+    const vaultDirs = resolveAllVaultsFromQuery(req);
+    let node;
+    let targetVaultDir;
+
+    for (const vaultDir of vaultDirs) {
+      node = nodes(vaultDir).find(n => n.slug === req.params.slug);
+      if (node) {
+        targetVaultDir = vaultDir;
+        break;
+      }
+    }
+
     if (!node) return notFound(res, `Memory node not found: ${req.params.slug}`);
 
     if (node._filePath && fs.existsSync(node._filePath)) {
       fs.unlinkSync(node._filePath);
     } else {
-      for (const file of walkMd(vaultDir)) {
+      for (const file of walkMd(targetVaultDir)) {
         const raw = fs.readFileSync(file, 'utf8');
         if (raw.includes(`slug: ${req.params.slug}`)) {
           fs.unlinkSync(file);
@@ -284,8 +388,17 @@ router.delete('/api/memory/:slug', requireAuth, requireScope('memory:write'), (r
         }
       }
     }
-    invalidate(vaultDir);
-    triggerMutation(null, vaultDir);
+    invalidate(targetVaultDir);
+    triggerMutation(null, targetVaultDir);
+
+    // Keep interface and queue in sync: clear this node_slug from any research agenda items
+    const queue = listQueue({});
+    for (const item of queue.items) {
+      if (item.node_slug === req.params.slug) {
+        updateQueueItem(item.id, { node_slug: null });
+      }
+    }
+
     res.json({ deleted: true, slug: req.params.slug });
   } catch (err) {
     serverError(res, err);

package/src/server/routes/research.mjs

@@ -53,3 +53,33 @@ researchRouter.delete('/api/research/:id', requireAuth, requireScope('memory:wri
     serverError(res, err);
   }
 });
+
+// ─── Optional remote vault sync ───────────────────────────────────────────────
+
+researchRouter.post('/api/sync/remote-vault/run', requireAuth, requireScope('memory:write'), async (req, res) => {
+  try {
+    const { runSync } = await import('../../core/remote-vault-sync.mjs');
+    runSync().catch((err) =>
+      logger.error('remote-vault-sync', 'Background sync failed', { error: err.message }),
+    );
+    res.json({ status: 'started' });
+  } catch (err) {
+    serverError(res, err);
+  }
+});
+
+researchRouter.get('/api/sync/remote-vault/status', requireAuth, requireScope('memory:read'), async (req, res) => {
+  try {
+    const fs = await import('node:fs');
+    const path = await import('node:path');
+    const { remoteVaultSync } = await import('../../core/config.mjs');
+    const statusFile = path.join(path.dirname(remoteVaultSync.vaultDir), 'sync-status.json');
+    if (!fs.existsSync(statusFile)) {
+      return res.json({ ok: false, error: 'Never run' });
+    }
+    const status = JSON.parse(fs.readFileSync(statusFile, 'utf8'));
+    res.json(status);
+  } catch (err) {
+    serverError(res, err);
+  }
+});