@lotargo/memory_plugin 1.3.2 → 1.4.5

package/mcp-server/index.js

@@ -1,4 +1,4 @@
-#!/usr/bin/env node
+#!/usr/bin/env node
 import { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
 import { StdioServerTransport } from "@modelcontextprotocol/sdk/server/stdio.js";
 import * as z from "zod/v4";
@@ -39,7 +39,7 @@ if (cliArgs.includes("setup") || cliArgs.includes("install") || cliArgs.includes
   process.exit(0);
 }
 
-if (cliArgs.includes("cli") || cliArgs.includes("config") || cliArgs.includes("--cli") || cliArgs.includes("-c")) {
+if (cliArgs.includes("cli") || cliArgs.includes("config") || cliArgs.includes("--cli") || cliArgs.includes("-c") || cliArgs.includes("login") || cliArgs.includes("logout")) {
   const { runCli } = await import("./cli.js");
   await runCli();
   process.exit(0);
@@ -175,10 +175,10 @@ server.registerTool(
     const { getLinksForFact } = await import("./graph/knowledge_linker.js");
     const results = [];
 
-    const formatFactWithLinks = (factLine, key) => {
+    const formatFactWithLinks = async (factLine, key) => {
       let line = displayFact(factLine);
       try {
-        const links = getLinksForFact(key, factText(factLine));
+        const links = await getLinksForFact(key, factText(factLine));
         if (links && links.length > 0) {
           const docStr = links
             .map((l) => {
@@ -192,14 +192,16 @@ server.registerTool(
       return line;
     };
 
-    const collect = (entries, key) => {
+    const collect = async (entries, key) => {
       const matched = entries.filter(
         (e) => matchesQuery(e, query) && matchesTags(e, tags) && inDateRange(e, since, until)
       );
       if (!matched.length) return;
       if (results.length) results.push("");
       results.push(`--- ${key === GLOBAL_KEY ? "Global" : `Project: ${key === target ? label : key}`} ---`);
-      matched.forEach((e, i) => results.push(`${i + 1}. ${formatFactWithLinks(e, key)}`));
+      for (let i = 0; i < matched.length; i++) {
+        results.push(`${i + 1}. ${await formatFactWithLinks(matched[i], key)}`);
+      }
       results.push(`Store file: ${storeFilePath(key)}`);
     };
 
@@ -225,11 +227,11 @@ server.registerTool(
     const label = project ? target : projectName();
     if (scope !== "project") {
       const global = await readMemory(GLOBAL_KEY);
-      collect(global, GLOBAL_KEY);
+      await collect(global, GLOBAL_KEY);
     }
     if (scope !== "global") {
       const local = await readMemory(target);
-      collect(local, target);
+      await collect(local, target);
     }
     const filtered = Boolean(query || tags || since || until);
     const text = results.length
@@ -315,8 +317,8 @@ server.registerTool(
     let linksUpdated = 0;
     try {
       const { getDatabase } = await import("./db/database.js");
-      const db = getDatabase();
-      const res = db
+      const db = await getDatabase();
+      const res = await db
         .prepare(
           "UPDATE knowledge_links SET fact_text = ? WHERE fact_key = ? AND fact_text = ?"
         )
@@ -353,12 +355,17 @@ server.registerTool(
     let rag = {};
     try {
       const { getDatabase } = await import("./db/database.js");
-      const db = getDatabase();
-      rag.documents = db.prepare("SELECT COUNT(*) AS c FROM documents").get().c;
-      rag.sections = db.prepare("SELECT COUNT(*) AS c FROM sections").get().c;
-      rag.chunks = db.prepare("SELECT COUNT(*) AS c FROM micro_chunks").get().c;
-      rag.edges = db.prepare("SELECT COUNT(*) AS c FROM graph_edges").get().c;
-      rag.links = db.prepare("SELECT COUNT(*) AS c FROM knowledge_links").get().c;
+      const db = await getDatabase();
+      const docCountRow = await db.prepare("SELECT COUNT(*) AS c FROM documents").get();
+      rag.documents = docCountRow ? docCountRow.c : 0;
+      const secCountRow = await db.prepare("SELECT COUNT(*) AS c FROM sections").get();
+      rag.sections = secCountRow ? secCountRow.c : 0;
+      const chunkCountRow = await db.prepare("SELECT COUNT(*) AS c FROM micro_chunks").get();
+      rag.chunks = chunkCountRow ? chunkCountRow.c : 0;
+      const edgeCountRow = await db.prepare("SELECT COUNT(*) AS c FROM graph_edges").get();
+      rag.edges = edgeCountRow ? edgeCountRow.c : 0;
+      const linkCountRow = await db.prepare("SELECT COUNT(*) AS c FROM knowledge_links").get();
+      rag.links = linkCountRow ? linkCountRow.c : 0;
     } catch (e) {
       rag.error = e.message;
     }
@@ -561,13 +568,17 @@ server.registerTool(
   },
   async ({ action, docId, snapshotPath }) => {
     const { getDatabase } = await import("./db/database.js");
-    const db = getDatabase();
+    const db = await getDatabase();
 
     if (action === "stats") {
-      const docCount = db.prepare("SELECT COUNT(*) as cnt FROM documents").get().cnt;
-      const secCount = db.prepare("SELECT COUNT(*) as cnt FROM sections").get().cnt;
-      const chunkCount = db.prepare("SELECT COUNT(*) as cnt FROM micro_chunks").get().cnt;
-      const edgeCount = db.prepare("SELECT COUNT(*) as cnt FROM graph_edges").get().cnt;
+      const docCountRow = await db.prepare("SELECT COUNT(*) as cnt FROM documents").get();
+      const docCount = docCountRow ? docCountRow.cnt : 0;
+      const secCountRow = await db.prepare("SELECT COUNT(*) as cnt FROM sections").get();
+      const secCount = secCountRow ? secCountRow.cnt : 0;
+      const chunkCountRow = await db.prepare("SELECT COUNT(*) as cnt FROM micro_chunks").get();
+      const chunkCount = chunkCountRow ? chunkCountRow.cnt : 0;
+      const edgeCountRow = await db.prepare("SELECT COUNT(*) as cnt FROM graph_edges").get();
+      const edgeCount = edgeCountRow ? edgeCountRow.cnt : 0;
       return {
         content: [
           {
@@ -588,7 +599,7 @@ server.registerTool(
     }
 
     if (action === "list") {
-      const docs = db
+      const docs = await db
         .prepare("SELECT id, title, path, blob_hash, created_at FROM documents ORDER BY created_at DESC")
         .all();
       return {
@@ -598,7 +609,7 @@ server.registerTool(
 
     if (action === "read_document") {
       if (!docId) throw new Error("docId parameter is required for read_document action");
-      const doc = db
+      const doc = await db
         .prepare("SELECT id, title, path, blob_hash, created_at FROM documents WHERE id = ? OR path = ? OR title = ?")
         .get(docId, docId, docId);
       if (!doc) {

package/mcp-server/ingest/exporter.js

@@ -12,9 +12,9 @@ export function ensureExportsDir() {
   return EXPORTS_DIR;
 }
 
-export function exportDocumentData(docIdOrPath, customDb = null) {
-  const db = customDb || getDatabase();
-  const doc = db.prepare("SELECT * FROM documents WHERE id = ? OR path = ?").get(docIdOrPath, docIdOrPath);
+export async function exportDocumentData(docIdOrPath, customDb = null) {
+  const db = customDb || await getDatabase();
+  const doc = await db.prepare("SELECT * FROM documents WHERE id = ? OR path = ?").get(docIdOrPath, docIdOrPath);
   if (!doc) {
     throw new Error(`Document not found for ID or path: ${docIdOrPath}`);
   }
@@ -33,10 +33,10 @@ export function exportDocumentData(docIdOrPath, customDb = null) {
     metadata = doc.metadata_json;
   }
 
-  const sections = db.prepare("SELECT id, heading, breadcrumbs, content, token_count FROM sections WHERE doc_id = ?").all(doc.id);
-  const mediumChunks = db.prepare("SELECT id, section_id, content, block_type, token_count, created_at FROM medium_chunks WHERE doc_id = ?").all(doc.id);
-  const microChunks = db.prepare("SELECT id, medium_id, section_id, content, token_count FROM micro_chunks WHERE doc_id = ?").all(doc.id);
-  const graphEdges = db.prepare("SELECT source_id, target_id, relation_type, metadata_json FROM graph_edges WHERE source_id = ? OR target_id = ?").all(doc.id, doc.id);
+  const sections = await db.prepare("SELECT id, heading, breadcrumbs, content, token_count FROM sections WHERE doc_id = ?").all(doc.id);
+  const mediumChunks = await db.prepare("SELECT id, section_id, content, block_type, token_count, created_at FROM medium_chunks WHERE doc_id = ?").all(doc.id);
+  const microChunks = await db.prepare("SELECT id, medium_id, section_id, content, token_count FROM micro_chunks WHERE doc_id = ?").all(doc.id);
+  const graphEdges = await db.prepare("SELECT source_id, target_id, relation_type, metadata_json FROM graph_edges WHERE source_id = ? OR target_id = ?").all(doc.id, doc.id);
 
   return {
     document: {
@@ -63,15 +63,15 @@ export function exportDocumentData(docIdOrPath, customDb = null) {
   };
 }
 
-export function exportDocumentToJsonString(docIdOrPath, customDb = null) {
-  const data = exportDocumentData(docIdOrPath, customDb);
+export async function exportDocumentToJsonString(docIdOrPath, customDb = null) {
+  const data = await exportDocumentData(docIdOrPath, customDb);
   return JSON.stringify(data, null, 2);
 }
 
-export function exportDocumentToFile(docIdOrPath, outputPath = null, customDb = null) {
+export async function exportDocumentToFile(docIdOrPath, outputPath = null, customDb = null) {
   const targetDir = ensureExportsDir();
-  const db = customDb || getDatabase();
-  const data = exportDocumentData(docIdOrPath, db);
+  const db = customDb || await getDatabase();
+  const data = await exportDocumentData(docIdOrPath, db);
   const jsonStr = JSON.stringify(data, null, 2);
 
   const finalPath = outputPath || join(targetDir, `doc_export_${data.document.id}.json`);

package/mcp-server/ingest/normalizer.js

@@ -1,4 +1,7 @@
 import { basename, extname } from "node:path";
+import { PDFParse } from "pdf-parse";
+import mammoth from "mammoth";
+import xlsx from "xlsx";
 
 export function cleanHtml(html) {
   if (!html) return "";
@@ -98,7 +101,60 @@ export function stripMarkdownBadgesAndNoise(text) {
   return cleaned;
 }
 
-export function normalizeContent({ content, type = "text", path = null, title = null }) {
+export function parseSpreadsheet(content, fileName, isCsv = false) {
+  const options = isCsv && (typeof content === "string") ? { type: "string" } : { type: "buffer" };
+  const workbook = xlsx.read(content, options);
+  let markdownParts = [];
+
+  for (const sheetName of workbook.SheetNames) {
+    const sheet = workbook.Sheets[sheetName];
+    // Convert to JSON 2D array
+    const rows = xlsx.utils.sheet_to_json(sheet, { header: 1 });
+    if (rows.length === 0) continue;
+
+    markdownParts.push(`## Sheet: ${sheetName}\n`);
+
+    // Create Markdown Table representation
+    const normalizedRows = rows.map(r => (Array.isArray(r) ? r : []).map(cell => (cell === undefined || cell === null) ? "" : String(cell)));
+    const maxCols = Math.max(...normalizedRows.map(r => r.length), 0);
+    if (maxCols === 0) continue;
+
+    // Pad all rows to maxCols
+    for (const r of normalizedRows) {
+      while (r.length < maxCols) r.push("");
+    }
+
+    // Header
+    const headers = normalizedRows[0];
+    markdownParts.push(`| ${headers.join(" | ")} |`);
+    markdownParts.push(`| ${headers.map(() => "---").join(" | ")} |`);
+
+    // Data rows
+    for (let i = 1; i < normalizedRows.length; i++) {
+      markdownParts.push(`| ${normalizedRows[i].join(" | ")} |`);
+    }
+
+    markdownParts.push("\n### Searchable Records\n");
+    // Row-by-row key-value representation for chunking/semantic search
+    for (let i = 1; i < normalizedRows.length; i++) {
+      const row = normalizedRows[i];
+      // Skip completely empty rows
+      if (row.every(cell => cell.trim() === "")) continue;
+
+      markdownParts.push(`Record ${i} from sheet ${sheetName}:`);
+      for (let j = 0; j < maxCols; j++) {
+        const headerName = headers[j]?.trim() || `Column_${j + 1}`;
+        const val = row[j]?.trim() || "";
+        markdownParts.push(`- ${headerName}: ${val}`);
+      }
+      markdownParts.push("");
+    }
+  }
+
+  return markdownParts.join("\n");
+}
+
+export async function normalizeContent({ content, type = "text", path = null, title = null }) {
   let markdown = "";
   let docTitle = title;
   const fileName = path ? basename(path) : "document";
@@ -112,6 +168,18 @@ export function normalizeContent({ content, type = "text", path = null, title =
       ".js": "javascript",
       ".ts": "typescript",
       ".py": "python",
+      ".go": "go",
+      ".rs": "rust",
+      ".cpp": "cpp",
+      ".h": "cpp",
+      ".hpp": "cpp",
+      ".cc": "cpp",
+      ".cxx": "cpp",
+      ".java": "java",
+      ".kt": "kotlin",
+      ".cs": "csharp",
+      ".php": "php",
+      ".rb": "ruby",
       ".json": "json",
       ".yaml": "yaml",
       ".yml": "yaml",
@@ -119,15 +187,44 @@ export function normalizeContent({ content, type = "text", path = null, title =
       ".html": "html",
     };
 
-    if (codeLangs[ext]) {
-      markdown = `# ${fileName}\n\n\`\`\`${codeLangs[ext]}\n${content.trim()}\n\`\`\``;
+    if (ext === ".pdf") {
+      try {
+        const pdfBuffer = Buffer.isBuffer(content) ? content : Buffer.from(content);
+        const parser = new PDFParse({ data: pdfBuffer });
+        const result = await parser.getText();
+        markdown = result.text || "";
+        docTitle = title || fileName;
+      } catch (err) {
+        throw new Error(`Failed to parse PDF file '${fileName}': ${err.message}`);
+      }
+    } else if (ext === ".docx") {
+      try {
+        const docxBuffer = Buffer.isBuffer(content) ? content : Buffer.from(content);
+        const result = await mammoth.convertToMarkdown({ buffer: docxBuffer });
+        markdown = result.value || "";
+        docTitle = title || fileName;
+      } catch (err) {
+        throw new Error(`Failed to parse DOCX file '${fileName}': ${err.message}`);
+      }
+    } else if (ext === ".xlsx" || ext === ".xls" || ext === ".csv") {
+      try {
+        markdown = parseSpreadsheet(content, fileName, ext === ".csv");
+        docTitle = title || fileName;
+      } catch (err) {
+        throw new Error(`Failed to parse spreadsheet file '${fileName}': ${err.message}`);
+      }
+    } else if (codeLangs[ext]) {
+      const textContent = Buffer.isBuffer(content) ? content.toString("utf8") : String(content);
+      markdown = `# ${fileName}\n\n\`\`\`${codeLangs[ext]}\n${textContent.trim()}\n\`\`\``;
       docTitle = title || fileName;
     } else {
-      markdown = content.trim();
+      const textContent = Buffer.isBuffer(content) ? content.toString("utf8") : String(content);
+      markdown = textContent.trim();
       docTitle = title || extractTitle(markdown, fileName);
     }
   } else {
-    markdown = typeof content === "string" ? content.trim() : String(content);
+    const textContent = Buffer.isBuffer(content) ? content.toString("utf8") : String(content);
+    markdown = textContent.trim();
     docTitle = title || extractTitle(markdown, "Direct Note");
   }
 

package/mcp-server/ingest/pipeline.js

@@ -1,5 +1,6 @@
 import { randomUUID } from "node:crypto";
 import { readFile } from "node:fs/promises";
+import { extname } from "node:path";
 import { getDatabase, BLOBS_DIR } from "../db/database.js";
 import { saveBlob, deleteBlob } from "../storage/blob_store.js";
 import { normalizeContent, fetchUrlContent } from "./normalizer.js";
@@ -17,7 +18,7 @@ export async function ingestDocument({
   customBlobDir = BLOBS_DIR,
   generateEmbeddings = true,
 }) {
-  const db = customDb || getDatabase();
+  const db = customDb || await getDatabase();
 
   let effectiveType = type;
   let effectivePath = path;
@@ -33,12 +34,14 @@ export async function ingestDocument({
     const filePath = effectivePath || content;
     const needsRead = !content || content === filePath;
     if (needsRead && filePath) {
-      content = await readFile(filePath, "utf-8");
+      const ext = extname(filePath).toLowerCase();
+      const isBinary = [".pdf", ".docx", ".xlsx", ".xls"].includes(ext);
+      content = await readFile(filePath, isBinary ? null : "utf-8");
       effectivePath = filePath;
     }
   }
 
-  const { markdown, title: docTitle, metadata } = normalizeContent({ content, type: effectiveType, path: effectivePath, title: effectiveTitle });
+  const { markdown, title: docTitle, metadata } = await normalizeContent({ content, type: effectiveType, path: effectivePath, title: effectiveTitle });
   if (type === "url") metadata.source_type = "url";
 
   const blobRes = await saveBlob(markdown, customBlobDir);
@@ -78,21 +81,21 @@ export async function ingestDocument({
     }
   }
 
-  db.exec("BEGIN IMMEDIATE;");
+  await db.exec("BEGIN IMMEDIATE;");
   try {
-    const existingDoc = db.prepare("SELECT id FROM documents WHERE path = ?").get(docPath);
+    const existingDoc = await db.prepare("SELECT id FROM documents WHERE path = ?").get(docPath);
     if (existingDoc) {
-      const microChunks = db.prepare("SELECT id FROM micro_chunks WHERE doc_id = ?").all(existingDoc.id);
+      const microChunks = await db.prepare("SELECT id FROM micro_chunks WHERE doc_id = ?").all(existingDoc.id);
       for (const mc of microChunks) {
         try {
-          db.prepare("DELETE FROM micro_chunks_fts WHERE id = ?").run(mc.id);
+          await db.prepare("DELETE FROM micro_chunks_fts WHERE id = ?").run(mc.id);
         } catch {}
       }
-      db.prepare("DELETE FROM graph_edges WHERE source_id = ? OR target_id = ?").run(existingDoc.id, existingDoc.id);
-      db.prepare("DELETE FROM documents WHERE id = ?").run(existingDoc.id);
+      await db.prepare("DELETE FROM graph_edges WHERE source_id = ? OR target_id = ?").run(existingDoc.id, existingDoc.id);
+      await db.prepare("DELETE FROM documents WHERE id = ?").run(existingDoc.id);
     }
 
-    db.prepare(`
+    await db.prepare(`
       INSERT INTO documents (id, path, blob_hash, title, checksum, toc_json, metadata_json, created_at, updated_at)
       VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?);
     `).run(
@@ -112,7 +115,7 @@ export async function ingestDocument({
       VALUES (?, ?, ?, ?, ?, ?);
     `);
     for (const sec of hierarchy.sections) {
-      insertSectionStmt.run(sec.id, sec.doc_id, sec.heading, sec.breadcrumbs, sec.content, sec.token_count);
+      await insertSectionStmt.run(sec.id, sec.doc_id, sec.heading, sec.breadcrumbs, sec.content, sec.token_count);
     }
 
     if (hierarchy.mediumChunks && hierarchy.mediumChunks.length > 0) {
@@ -121,7 +124,7 @@ export async function ingestDocument({
         VALUES (?, ?, ?, ?, ?, ?, ?);
       `);
       for (const med of hierarchy.mediumChunks) {
-        insertMediumStmt.run(med.id, med.section_id, med.doc_id, med.content, med.block_type, med.token_count, now);
+        await insertMediumStmt.run(med.id, med.section_id, med.doc_id, med.content, med.block_type, med.token_count, now);
       }
     }
 
@@ -135,19 +138,30 @@ export async function ingestDocument({
     `);
 
     for (const micro of hierarchy.microChunks) {
-      insertMicroStmt.run(micro.id, micro.section_id, micro.doc_id, micro.content, micro.vector, micro.token_count, micro.medium_id || null);
-      insertFtsStmt.run(micro.id, micro.content, micro.breadcrumbs);
+      await insertMicroStmt.run(micro.id, micro.section_id, micro.doc_id, micro.content, micro.vector, micro.token_count, micro.medium_id || null);
+      await insertFtsStmt.run(micro.id, micro.content, micro.breadcrumbs);
     }
 
     const edges = buildGraphEdges(docId, hierarchy);
-    saveGraphEdges(db, edges);
+    await saveGraphEdges(db, edges);
 
-    db.exec("COMMIT;");
+    await db.exec("COMMIT;");
   } catch (err) {
-    db.exec("ROLLBACK;");
+    await db.exec("ROLLBACK;");
     throw new Error(`Ingestion transaction failed: ${err.message}`);
   }
 
+  if (getConfig().mode === "hybrid-sync") {
+    try {
+      const { exportDocumentData } = await import("./exporter.js");
+      const { enqueueSyncTask } = await import("../db/sync_queue.js");
+      const exportedData = await exportDocumentData(docId, db);
+      await enqueueSyncTask("ingest_document", docId, exportedData);
+    } catch (err) {
+      console.error("Failed to queue document ingest sync task:", err.message);
+    }
+  }
+
   return {
     docId,
     doc_id: docId,
@@ -164,54 +178,64 @@ export async function ingestDocument({
 }
 
 export async function deleteDocument(docIdOrPath, customDb = null, customBlobDir = BLOBS_DIR) {
-  const db = customDb || getDatabase();
-  const doc = db.prepare("SELECT * FROM documents WHERE id = ? OR path = ?").get(docIdOrPath, docIdOrPath);
+  const db = customDb || await getDatabase();
+  const doc = await db.prepare("SELECT * FROM documents WHERE id = ? OR path = ?").get(docIdOrPath, docIdOrPath);
   if (!doc) {
     return { deleted: false, reason: "Document not found" };
   }
 
-  const microChunks = db.prepare("SELECT id FROM micro_chunks WHERE doc_id = ?").all(doc.id);
+  const microChunks = await db.prepare("SELECT id FROM micro_chunks WHERE doc_id = ?").all(doc.id);
 
   // Collect every id owned by this document so we can purge dangling graph edges
   // (graph_edges has no FK constraints, so section/chunk/doc references would otherwise leak).
   const ownedIds = [doc.id];
   for (const table of ["sections", "medium_chunks", "micro_chunks"]) {
-    const rows = db.prepare(`SELECT id FROM ${table} WHERE doc_id = ?`).all(doc.id);
+    const rows = await db.prepare(`SELECT id FROM ${table} WHERE doc_id = ?`).all(doc.id);
     for (const r of rows) ownedIds.push(r.id);
   }
 
-  db.exec("BEGIN IMMEDIATE;");
+  await db.exec("BEGIN IMMEDIATE;");
   try {
     for (const mc of microChunks) {
       try {
-        db.prepare("DELETE FROM micro_chunks_fts WHERE id = ?").run(mc.id);
+        await db.prepare("DELETE FROM micro_chunks_fts WHERE id = ?").run(mc.id);
       } catch {}
     }
 
     // Auto-clean Agent knowledge graph links pointing at this document.
-    db.prepare("DELETE FROM knowledge_links WHERE doc_id = ?").run(doc.id);
+    await db.prepare("DELETE FROM knowledge_links WHERE doc_id = ?").run(doc.id);
 
     for (const id of ownedIds) {
       // GLOB: '*' suffix is exact (unlike LIKE, '_' stays literal in ids like doc_xxx).
-      db.prepare(
+      await db.prepare(
         "DELETE FROM graph_edges WHERE source_id = ? OR target_id = ? OR source_id GLOB ? OR target_id GLOB ?"
       ).run(id, id, `${id}*`, `${id}*`);
     }
 
-    db.prepare("DELETE FROM documents WHERE id = ?").run(doc.id);
+    await db.prepare("DELETE FROM documents WHERE id = ?").run(doc.id);
 
-    db.exec("COMMIT;");
+    await db.exec("COMMIT;");
   } catch (err) {
-    db.exec("ROLLBACK;");
+    await db.exec("ROLLBACK;");
     throw err;
   }
 
   if (doc.blob_hash) {
-    const refCount = db.prepare("SELECT COUNT(*) as cnt FROM documents WHERE blob_hash = ?").get(doc.blob_hash).cnt;
+    const refCountRow = await db.prepare("SELECT COUNT(*) as cnt FROM documents WHERE blob_hash = ?").get(doc.blob_hash);
+    const refCount = refCountRow ? refCountRow.cnt : 0;
     if (refCount === 0) {
       await deleteBlob(doc.blob_hash, customBlobDir);
     }
   }
 
+  if (getConfig().mode === "hybrid-sync") {
+    try {
+      const { enqueueSyncTask } = await import("../db/sync_queue.js");
+      await enqueueSyncTask("delete_document", docIdOrPath);
+    } catch (err) {
+      console.error("Failed to queue document delete sync task:", err.message);
+    }
+  }
+
   return { deleted: true, docId: doc.id, title: doc.title, linksCleaned: true };
 }

package/mcp-server/memory.js

@@ -125,6 +125,22 @@ async function maybeMigrateLegacy(key) {
 }
 
 export async function readMemory(key) {
+  const { getConfig } = await import("./config/config_manager.js");
+  const config = getConfig();
+  if (config.mode === "only-cloud") {
+    try {
+      const { getDatabase } = await import("./db/database.js");
+      const db = await getDatabase();
+      const row = await db.prepare("SELECT content FROM notebooks WHERE key = ?;").get(key);
+      if (row && row.content) {
+        return row.content.split("\n").filter((l) => l.startsWith("- ["));
+      }
+    } catch (err) {
+      console.error("Failed to read memory from cloud database:", err.message);
+    }
+    return [];
+  }
+
   const fp = memoryPath(key);
   if (existsSync(fp)) {
     const content = await readFile(fp, "utf-8");
@@ -149,10 +165,67 @@ export async function writeMemory(key, entries) {
     }
   }
   const content = lines.join("\n") + "\n" + (entries.length ? entries.join("\n") + "\n" : "");
+
+  const { getConfig } = await import("./config/config_manager.js");
+  const config = getConfig();
+  if (config.mode === "only-cloud") {
+    try {
+      const { getDatabase } = await import("./db/database.js");
+      const db = await getDatabase();
+      await db.prepare(`
+        INSERT INTO notebooks (key, content, updated_at)
+        VALUES (?, ?, ?)
+        ON CONFLICT(key) DO UPDATE SET content = excluded.content, updated_at = excluded.updated_at;
+      `).run(key, content, Date.now());
+    } catch (err) {
+      console.error("Failed to write memory to cloud database:", err.message);
+    }
+    return;
+  }
+
   await writeFile(memoryPath(key), content);
+
+  if (config.mode === "hybrid-sync") {
+    try {
+      const { enqueueSyncTask } = await import("./db/sync_queue.js");
+      await enqueueSyncTask("write_memory", key, content);
+    } catch (err) {
+      console.error("Failed to queue memory sync task:", err.message);
+    }
+  }
 }
 
 export async function listProjectStores() {
+  const { getConfig } = await import("./config/config_manager.js");
+  const config = getConfig();
+  if (config.mode === "only-cloud") {
+    try {
+      const { getDatabase } = await import("./db/database.js");
+      const db = await getDatabase();
+      const rows = await db.prepare("SELECT key, content FROM notebooks WHERE key != ?;").all(GLOBAL_KEY);
+      const stores = [];
+      for (const row of rows) {
+        const key = row.key;
+        const content = row.content;
+        const facts = content.split("\n").filter((l) => l.startsWith("- ["));
+        const meta = parseMeta(content);
+        stores.push({
+          key,
+          path: meta.path || (key.includes("/") || key.includes(":") ? key : null),
+          basename: basename(meta.path || key) || key,
+          file: `${slugify(key)}.md`,
+          count: facts.length,
+          legacy: !meta.path,
+        });
+      }
+      stores.sort((a, b) => a.basename.localeCompare(b.basename));
+      return stores;
+    } catch (err) {
+      console.error("Failed to list memory stores from cloud database:", err.message);
+    }
+    return [];
+  }
+
   const stores = [];
   const files = await readdir(MEMORY_DIR).catch(() => []);
   for (const f of files) {