@lotargo/memory_plugin 1.2.902 → 1.3.1

package/mcp-server/cli.js

@@ -6,6 +6,7 @@ import { hybridQuery } from "./retrieval/retriever.js";
 import { getDatabase } from "./db/database.js";
 import { deleteDocument } from "./ingest/pipeline.js";
 import { readMemoryRaw, readMemory, writeMemory, GLOBAL_KEY, projectName, projectKey, listProjectStores, migrateLegacyStore, memoryFileName } from "./memory.js";
+import { parseFactEntry, factText, withMeta, displayFact, nextFactId, isKeepFact, isSuperseded, formatFactEntry, metaBadges } from "./fact_format.js";
 import { getCorpusCacheSize, clearCorpusCache } from "./benchmarks/fetch_real_corpus.js";
 import { SMOKE_DOC_IDS } from "./benchmarks/quality_evaluator.js";
 import { getModelStorageInfo, deleteModelCache, listAllCachedModels } from "./ml/model_manager.js";
@@ -628,6 +629,16 @@ function waitForEnter() {
   });
 }
 
+function promptText(question) {
+  return new Promise((resolve) => {
+    const rl = readline.createInterface({ input: process.stdin, output: process.stdout });
+    rl.question(`\n  ${question}\n  > `, (answer) => {
+      rl.close();
+      resolve(answer.trim());
+    });
+  });
+}
+
 export async function runCli() {
   const cliArgs = process.argv.slice(2);
   if (cliArgs.includes("--enable-prompt") || cliArgs.includes("enable-prompt")) {
@@ -1035,11 +1046,15 @@ export async function runCli() {
               }
 
               const file = memoryFileName(key);
-              const factItems = factList.map((fact, idx) => ({
-                label: `${idx + 1}. ${fact}`,
-                value: idx,
-                info: `Select to delete this fact from ${file}`,
-              }));
+              const factItems = factList.map((fact, idx) => {
+                const badges = metaBadges(fact);
+                return {
+                  label: `${idx + 1}. ${factText(fact)}`,
+                  value: idx,
+                  badge: badges.length ? badges.join(" ") : undefined,
+                  info: `Select to manage this fact from ${file}`,
+                };
+              });
               factItems.push({ label: "< Back", value: "back" });
 
               const factRes = await selectSimpleMenu({
@@ -1053,22 +1068,58 @@ export async function runCli() {
               }
 
               const selectedIdx = factRes.value;
-              const selectedFact = factList[selectedIdx];
+              const selectedEntry = rawEntries[selectedIdx];
+              const selDisplay = displayFact(selectedEntry);
+              const selBadges = metaBadges(selectedEntry);
+
+              const actionItems = [
+                { label: "[UPDATE] Edit fact text", value: "update", info: "Rewrite the fact, keeping its date and metadata" },
+              ];
+              if (isKeepFact(selectedEntry)) {
+                actionItems.push({ label: "[UNPROTECT] Remove keep protection", value: "unprotect", info: "Allow forget to delete it without force" });
+              } else {
+                actionItems.push({ label: "[PROTECT] Mark as important (keep)", value: "protect", info: "forget will skip it unless force=true" });
+              }
+              actionItems.push({ label: "[DELETE] Delete this fact from store", value: "delete", info: "Remove fact permanently" });
+              actionItems.push({ label: "< Cancel / Back", value: "cancel" });
 
               const actionRes = await selectSimpleMenu({
-                title: `FACT ACTION`,
-                subtitle: `Fact: "${selectedFact}"`,
-                items: [
-                  { label: "[DELETE] Delete this fact from store", value: "delete", info: "Remove fact permanently" },
-                  { label: "< Cancel / Back", value: "cancel" },
-                ],
+                title: "FACT ACTION",
+                subtitle: `Fact: "${selDisplay}"${selBadges.length ? " [" + selBadges.join("] [") + "]" : ""}`,
+                items: actionItems,
               });
 
               if (actionRes.action === "back" || actionRes.value === "cancel") {
                 return;
               }
 
-              if (actionRes.action === "select" && actionRes.value === "delete") {
+              if (actionRes.action === "select" && actionRes.value === "update") {
+                const p = parseFactEntry(selectedEntry);
+                const newText = await promptText(`New text for fact #${selectedIdx + 1}:`);
+                if (!newText) continue;
+                const newLine = formatFactEntry({ date: p.date, time: p.time, text: newText, meta: p.meta });
+                const updated = [...rawEntries];
+                updated[selectedIdx] = newLine;
+                await writeMemory(key, updated);
+                let links = 0;
+                try {
+                  const db = getDatabase();
+                  links = db
+                    .prepare("UPDATE knowledge_links SET fact_text = ? WHERE fact_key = ? AND fact_text = ?")
+                    .run(newText, key, factText(selectedEntry)).changes;
+                } catch (e) {}
+                console.clear();
+                console.log(`\n  [OK] Fact updated successfully${links ? `, ${links} doc link(s) updated` : ""}.\n`);
+                await waitForEnter();
+              } else if (actionRes.action === "select" && (actionRes.value === "protect" || actionRes.value === "unprotect")) {
+                const updated = [...rawEntries];
+                updated[selectedIdx] =
+                  actionRes.value === "protect" ? withMeta(selectedEntry, { keep: "1" }) : withMeta(selectedEntry, { keep: null });
+                await writeMemory(key, updated);
+                console.clear();
+                console.log(`\n  [OK] Fact ${actionRes.value === "protect" ? "protected" : "unprotected"} successfully.\n`);
+                await waitForEnter();
+              } else if (actionRes.action === "select" && actionRes.value === "delete") {
                 const updated = [...rawEntries];
                 updated.splice(selectedIdx, 1);
                 await writeMemory(key, updated);

package/mcp-server/config/config_manager.js

@@ -1,6 +1,6 @@
 import fs from "fs";
 import path from "path";
-import { MEMORY_DIR, ensureDir } from "../memory.js";
+import { MEMORY_DIR, ensureDirSync } from "../memory.js";
 
 const CONFIG_FILE = path.join(MEMORY_DIR, "config.json");
 
@@ -23,7 +23,7 @@ export function getConfig() {
     return cachedConfig;
   }
 
-  ensureDir();
+  ensureDirSync();
 
   if (fs.existsSync(CONFIG_FILE)) {
     try {
@@ -42,7 +42,7 @@ export function getConfig() {
 }
 
 export function saveConfig(newConfig) {
-  ensureDir();
+  ensureDirSync();
   cachedConfig = Object.freeze({ ...DEFAULT_CONFIG, ...newConfig });
   try {
     fs.writeFileSync(CONFIG_FILE, JSON.stringify(cachedConfig, null, 2), "utf-8");

package/mcp-server/fact_format.js

@@ -0,0 +1,177 @@
+// Shared fact-line format + metadata parsing for the Notebook Layer 1 store.
+//
+// A fact line looks like:
+//   - [2026-08-02 06:08] text here <!-- id:8f3a2c, ttl:90d, keep:1, supersedes:a1b2c3, tags:pref,arch -->
+// The trailing HTML comment carries optional metadata. It is invisible in
+// Markdown, so the store stays a single plain Markdown file. Older lines
+// without a comment parse to empty metadata and stay fully compatible.
+//
+// Metadata keys:
+//   id           short random id (e.g. "8f3a2c")
+//   ttl          time-to-live, e.g. "90d", "2w", "24h", "12m" (m=month ~30d)
+//   keep         "1" = protected fact: forget refuses to delete without force
+//   supersedes   id (or number/text) this fact replaces
+//   supersededBy id of the fact that replaced this one
+//   tags         comma-separated free-form tags for recall filtering
+
+const META_KEYS = ["id", "ttl", "keep", "supersedes", "supersededBy", "tags"];
+
+const ENTRY_RE = /^- \[(\d{4}-\d{2}-\d{2})\s+(\d{2}:\d{2})\]\s+(.*)$/;
+
+// Parse a raw entry line into { line, date, time, text, meta }.
+// Returns null if the line is not a fact entry.
+export function parseFactEntry(line) {
+  const m = ENTRY_RE.exec(line);
+  if (!m) return null;
+  const [, date, time, rest] = m;
+  let text = rest;
+  const meta = {};
+  const cm = /^(.*?)\s*<!--\s*(.*?)\s*-->$/.exec(rest);
+  if (cm) {
+    // Values may themselves contain commas (e.g. "tags:pref,arch"), so scan
+    // for known "key:" tokens instead of splitting the comment on commas.
+    const raw = cm[2];
+    const keyRe = new RegExp(`(${META_KEYS.join("|")})\\s*:`, "g");
+    const found = [];
+    let fm;
+    while ((fm = keyRe.exec(raw))) {
+      found.push({ key: fm[1], valStart: fm.index + fm[0].length, tokenStart: fm.index });
+    }
+    for (let i = 0; i < found.length; i++) {
+      const valEnd = i + 1 < found.length ? found[i + 1].tokenStart : raw.length;
+      const v = raw.slice(found[i].valStart, valEnd).replace(/[,\s]+$/, "").trim();
+      if (v !== "") {
+        meta[found[i].key] = v;
+      }
+    }
+    if (Object.keys(meta).length) text = cm[1];
+  }
+  return { line, date, time, text, meta };
+}
+
+// Display text of a fact line (metadata comment stripped).
+export function factText(line) {
+  const p = parseFactEntry(line);
+  return p ? p.text : line;
+}
+
+// Metadata object of a fact line (empty if none / unparsable).
+export function factMeta(line) {
+  const p = parseFactEntry(line);
+  return p ? p.meta : {};
+}
+
+// Format a fact line from parts. `meta` entries with falsy values are omitted.
+export function formatFactEntry({ date, time, text, meta = {} }) {
+  let out = `- [${date} ${time}] ${text}`;
+  const pairs = [];
+  for (const k of META_KEYS) {
+    if (meta[k]) pairs.push(`${k}:${meta[k]}`);
+  }
+  if (pairs.length) out += ` <!-- ${pairs.join(", ")} -->`;
+  return out;
+}
+
+// Return a new line with `patch` applied to the metadata. Patch values that are
+// null/undefined/"" remove the corresponding key. Non-fact lines are returned
+// unchanged.
+export function withMeta(line, patch) {
+  const p = parseFactEntry(line);
+  if (!p) return line;
+  const meta = { ...p.meta };
+  for (const k of Object.keys(patch)) {
+    const v = patch[k];
+    if (v === null || v === undefined || v === "") delete meta[k];
+    else meta[k] = String(v);
+  }
+  return formatFactEntry({ date: p.date, time: p.time, text: p.text, meta });
+}
+
+// Generate a short random id that is unique within the given entries.
+export function nextFactId(entries) {
+  let id;
+  do {
+    id = Math.random().toString(36).slice(2, 8);
+  } while (entries.some((e) => factMeta(e).id === id));
+  return id;
+}
+
+const TTL_UNITS = { h: 3600e3, d: 86400e3, w: 7 * 86400e3, m: 30 * 86400e3 };
+
+// Parse "90d" | "2w" | "24h" | "12m" (m = ~30 days) into milliseconds. Null if invalid.
+export function ttlMs(ttl) {
+  const m = /^(\d+)\s*([hdwm])?$/.exec(String(ttl || "").trim());
+  if (!m) return null;
+  const n = parseInt(m[1], 10);
+  const u = m[2] || "d";
+  return n * (TTL_UNITS[u] || TTL_UNITS.d);
+}
+
+// True if the fact line has a ttl and it has elapsed relative to `now` (ms).
+export function isExpiredLine(line, now = Date.now()) {
+  const p = parseFactEntry(line);
+  if (!p || !p.meta.ttl) return false;
+  const ms = ttlMs(p.meta.ttl);
+  if (!ms) return false;
+  const ts = new Date(`${p.date}T${p.time}:00`).getTime();
+  if (Number.isNaN(ts)) return false;
+  return now > ts + ms;
+}
+
+// True if the fact is protected from deletion (keep:1).
+export function isKeepFact(line) {
+  return factMeta(line).keep === "1";
+}
+
+// True if the fact has been superseded by another fact.
+export function isSuperseded(line) {
+  return Boolean(factMeta(line).supersededBy);
+}
+
+// Keyword match: space-separated terms, all must be present (case-insensitive).
+// Also matches against the fact's id and tags.
+export function matchesQuery(factLine, query) {
+  const q = String(query || "").trim();
+  if (!q) return true;
+  const p = parseFactEntry(factLine);
+  if (!p) return false;
+  const terms = q.toLowerCase().split(/\s+/).filter(Boolean);
+  const haystack = `${p.text} ${p.meta.id || ""} ${p.meta.tags || ""} ${p.date}`.toLowerCase();
+  return terms.every((t) => haystack.includes(t));
+}
+
+// Tag filter: comma-separated requested tags; match if ANY fact tag equals or
+// contains a requested tag (case-insensitive).
+export function matchesTags(factLine, tagsStr) {
+  const want = String(tagsStr || "").split(",").map((t) => t.trim().toLowerCase()).filter(Boolean);
+  if (!want.length) return true;
+  const have = (factMeta(factLine).tags || "").split(",").map((t) => t.trim().toLowerCase()).filter(Boolean);
+  if (!have.length) return false;
+  return want.some((w) => have.some((h) => h === w || h.includes(w) || w.includes(h)));
+}
+
+// Date-range filter. `since`/`until` are "YYYY-MM-DD" (inclusive).
+export function inDateRange(factLine, since, until) {
+  const p = parseFactEntry(factLine);
+  if (!p) return false;
+  if (since && p.date < since) return false;
+  if (until && p.date > until) return false;
+  return true;
+}
+
+// Human-readable badges for a fact line, e.g. ["EXPIRED", "KEEP", "SUPERSEDED"].
+export function metaBadges(factLine, now = Date.now()) {
+  const badges = [];
+  if (isExpiredLine(factLine, now)) badges.push("EXPIRED");
+  if (isKeepFact(factLine)) badges.push("KEEP");
+  if (isSuperseded(factLine)) badges.push("SUPERSEDED");
+  return badges;
+}
+
+// Display text of a fact line with badges appended, e.g.
+//   "user prefers TS  [EXPIRED] [KEEP]"
+export function displayFact(factLine, now = Date.now()) {
+  const text = factText(factLine);
+  const badges = metaBadges(factLine, now);
+  return badges.length ? `${text}  [${badges.join("] [")}]` : text;
+}