@pyxmate/memory 1.23.0 → 1.23.1

package/dist/cli/pyx-mem.mjs

@@ -2223,7 +2223,7 @@ function createProxyServer(client, version, uploadLocalFile) {
   return server;
 }
 async function runMcpProxyServer(opts) {
-  const version = opts.version ?? (true ? "1.23.0" : "0.0.0-dev");
+  const version = opts.version ?? (true ? "1.23.1" : "0.0.0-dev");
   const read = await opts.readCredentials();
   if (!read.ok) {
     throw new Error(
@@ -2269,7 +2269,7 @@ async function runMcpProxyServer(opts) {
 
 // src/cli/commands/mcp-install.ts
 import { spawnSync as nodeSpawnSync } from "child_process";
-import { existsSync as existsSync3, readFileSync as readFileSync3 } from "fs";
+import { existsSync as existsSync3 } from "fs";
 import { homedir as homedir2 } from "os";
 import { join as join2 } from "path";
 
@@ -2389,7 +2389,20 @@ function indent(text) {
 }
 
 // src/cli/commands/memory-rules-merge.ts
-import { existsSync as existsSync2, mkdirSync as mkdirSync2, readFileSync as readFileSync2, renameSync as renameSync2, statSync, writeFileSync as writeFileSync2 } from "fs";
+import { randomUUID as randomUUID4 } from "crypto";
+import {
+  chmodSync,
+  existsSync as existsSync2,
+  linkSync,
+  lstatSync,
+  mkdirSync as mkdirSync2,
+  readFileSync as readFileSync2,
+  realpathSync,
+  renameSync as renameSync2,
+  rmSync,
+  statSync,
+  writeFileSync as writeFileSync2
+} from "fs";
 import { dirname as dirname3 } from "path";
 var RULES_BEGIN_MARKER = "<!-- pyx-memory:begin (managed by `pyx-mem mcp install`; edit outside these markers) -->";
 var RULES_END_MARKER = "<!-- pyx-memory:end -->";
@@ -2397,6 +2410,15 @@ var BEGIN_MARKER_PREFIX = "<!-- pyx-memory:begin";
 var PM_HEADING_RE = /^ {0,3}##[ \t]+Persistent Memory[ \t]*$/;
 var H1_OR_H2_RE = /^ {0,3}#{1,2}[ \t]+\S/;
 var FENCE_RE = /^ {0,3}(`{3,}|~{3,})/;
+var CLOSING_FENCE_RE = /^ {0,3}(`{3,}|~{3,})[ \t]*$/;
+var BEGIN_MARKER_RE = /^ {0,3}<!-- pyx-memory:begin(?:[ \t][^>]*)?-->[ \t]*$/;
+var END_MARKER_RE = /^ {0,3}<!-- pyx-memory:end -->[ \t]*$/;
+function isBeginMarker(line) {
+  return BEGIN_MARKER_RE.test(line);
+}
+function isEndMarker(line) {
+  return END_MARKER_RE.test(line);
+}
 function fenceMask(lines) {
   const mask = new Array(lines.length).fill(false);
   let openIdx = -1;
@@ -2411,7 +2433,7 @@ function fenceMask(lines) {
       openLen = fence.length;
       continue;
     }
-    if (fence.charAt(0) === delim && fence.length >= openLen) {
+    if (CLOSING_FENCE_RE.test(lines[i] ?? "") && fence.charAt(0) === delim && fence.length >= openLen) {
       for (let j = openIdx; j <= i; j++) mask[j] = true;
       openIdx = -1;
       delim = "";
@@ -2432,36 +2454,29 @@ function findCompleteManagedRange(lines, mask) {
   for (let i = 0; i < lines.length; i++) {
     const line = lines[i];
     if (line === void 0 || mask[i]) continue;
-    const t = line.trim();
-    if (begin === -1) {
-      if (t.startsWith(BEGIN_MARKER_PREFIX)) begin = i;
-    } else if (t === RULES_END_MARKER) {
-      return [begin, i + 1];
-    }
+    if (isBeginMarker(line)) begin = i;
+    else if (begin !== -1 && isEndMarker(line)) return [begin, i + 1];
   }
   return null;
 }
-function findOrphanBeginLine(lines, mask) {
+function findBeginLines(lines, mask) {
+  const found = [];
   for (let i = 0; i < lines.length; i++) {
     const line = lines[i];
-    if (line !== void 0 && !mask[i] && line.trim().startsWith(BEGIN_MARKER_PREFIX)) return i;
+    if (line !== void 0 && !mask[i] && isBeginMarker(line)) found.push(i);
   }
-  return -1;
+  return found;
 }
 function findLegacyPyxRange(lines, mask) {
   for (let i = 0; i < lines.length; i++) {
     const line = lines[i];
     if (line === void 0 || mask[i] || !PM_HEADING_RE.test(line)) continue;
     const end = nextH1OrH2(lines, mask, i + 1);
-    if (lines.slice(i, end).join("\n").toLowerCase().includes("pyx-memory")) return [i, end];
+    const own = lines.slice(i, end).filter((l, k) => !mask[i + k] && !isBeginMarker(l) && !isEndMarker(l));
+    if (own.join("\n").toLowerCase().includes("pyx-memory")) return [i, end];
   }
   return null;
 }
-function hasPyxMemoryRules(content) {
-  const lines = content.replace(/\r\n/g, "\n").split("\n");
-  const mask = fenceMask(lines);
-  return findCompleteManagedRange(lines, mask) !== null || findOrphanBeginLine(lines, mask) !== -1 || findLegacyPyxRange(lines, mask) !== null;
-}
 function spliceBlock(lines, from, toExclusive, blockLines) {
   const before = lines.slice(0, from);
   const after = lines.slice(toExclusive);
@@ -2478,7 +2493,13 @@ function joinWithTrailingNewline(lines, eol) {
   const body = lines.join(eol);
   return body.endsWith(eol) ? body : `${body}${eol}`;
 }
+var BOM = "\uFEFF";
 function mergeMemoryRules(existing, section) {
+  const bom = existing.startsWith(BOM) ? BOM : "";
+  const merged = mergeBody(existing.slice(bom.length), section);
+  return { ...merged, content: bom + merged.content };
+}
+function mergeBody(existing, section) {
   if (section.includes(BEGIN_MARKER_PREFIX) || section.includes(RULES_END_MARKER)) {
     throw new Error("pyx-memory rules section must not contain the managed markers.");
   }
@@ -2495,9 +2516,9 @@ function mergeMemoryRules(existing, section) {
     const next2 = spliceBlock(lines, complete[0], complete[1], blockLines);
     return { content: joinWithTrailingNewline(next2, eol), action: "updated" };
   }
-  const orphan = findOrphanBeginLine(lines, mask);
-  if (orphan !== -1) {
-    lines = [...lines.slice(0, orphan), ...lines.slice(orphan + 1)];
+  const orphans = new Set(findBeginLines(lines, mask));
+  if (orphans.size > 0) {
+    lines = lines.filter((_, i) => !orphans.has(i));
     mask = fenceMask(lines);
   }
   const legacy = findLegacyPyxRange(lines, mask);
@@ -2508,12 +2529,53 @@ function mergeMemoryRules(existing, section) {
   const next = spliceBlock(lines, lines.length, lines.length, blockLines);
   return { content: joinWithTrailingNewline(next, eol), action: "appended" };
 }
+function refreshMemoryRules(file, section) {
+  const bom = file.startsWith(BOM) ? BOM : "";
+  const refreshed = refreshBody(file.slice(bom.length), section);
+  return refreshed === null ? null : bom + refreshed;
+}
+function refreshBody(existing, section) {
+  const lines = existing.replace(/\r\n/g, "\n").split("\n");
+  const complete = findCompleteManagedRange(lines, fenceMask(lines));
+  if (!complete) return null;
+  const [first, last] = [complete[0], complete[1] - 1];
+  const starts = [0];
+  for (let i = 0; i < existing.length; i++) if (existing[i] === "\n") starts.push(i + 1);
+  const from = starts[first] ?? 0;
+  const lastStart = starts[last] ?? 0;
+  const to = lastStart + (lines[last] ?? "").length;
+  const eol = existing.slice(from).match(/\r?\n/)?.[0] ?? "\n";
+  const block = [RULES_BEGIN_MARKER, ...section.split(/\r?\n/), RULES_END_MARKER].join(eol);
+  return existing.slice(0, from) + block + existing.slice(to);
+}
+function changedDuringWrite(filePath) {
+  return new Error(`${filePath} changed while updating the pyx-memory rules; retry.`);
+}
+function readUtf8Strict(path) {
+  try {
+    return new TextDecoder("utf-8", { fatal: true, ignoreBOM: true }).decode(readFileSync2(path));
+  } catch (err) {
+    if (err instanceof TypeError) {
+      throw new Error(`${path} is not valid UTF-8; the pyx-memory rules were not changed.`);
+    }
+    throw err;
+  }
+}
 function writeMemoryRulesFile(opts) {
   const { filePath, section } = opts;
   const fileExists = existsSync2(filePath);
-  const existing = fileExists ? readFileSync2(filePath, "utf8") : "";
-  const { content, action } = mergeMemoryRules(existing, section);
-  if (content === existing) {
+  if (!fileExists && lstatSync(filePath, { throwIfNoEntry: false })?.isSymbolicLink()) {
+    throw new Error(`${filePath} is a broken link; fix or remove it, then retry.`);
+  }
+  const target = fileExists ? realpathSync(filePath) : filePath;
+  const existing = fileExists ? readUtf8Strict(target) : "";
+  let merged = null;
+  if (!opts.refreshOnly) merged = mergeMemoryRules(existing, section);
+  else {
+    const content = refreshMemoryRules(existing, section);
+    if (content !== null) merged = { content, action: "updated" };
+  }
+  if (merged === null || merged.content === existing) {
     return {
       action: "unchanged",
       filePath,
@@ -2521,15 +2583,32 @@ function writeMemoryRulesFile(opts) {
 `
     };
   }
-  const parent = dirname3(filePath);
+  const parent = dirname3(target);
   if (!existsSync2(parent)) mkdirSync2(parent, { recursive: true });
-  const mode = fileExists ? statSync(filePath).mode & 511 : 420;
-  const tmpPath = `${filePath}.tmp`;
-  writeFileSync2(tmpPath, content, { mode });
-  renameSync2(tmpPath, filePath);
-  const verb = action === "created" ? "Wrote" : action === "appended" ? "Added" : "Updated";
+  const mode = fileExists ? statSync(target).mode & 511 : 420;
+  const tmpPath = `${target}.${process.pid}.${randomUUID4()}.tmp`;
+  try {
+    writeFileSync2(tmpPath, merged.content, { mode });
+    chmodSync(tmpPath, mode);
+    if (fileExists) {
+      if (readUtf8Strict(target) !== existing) throw changedDuringWrite(filePath);
+      renameSync2(tmpPath, target);
+    } else {
+      try {
+        linkSync(tmpPath, target);
+      } catch (err) {
+        if (err.code === "EEXIST") throw changedDuringWrite(filePath);
+        throw err;
+      }
+      rmSync(tmpPath);
+    }
+  } catch (err) {
+    rmSync(tmpPath, { force: true });
+    throw err;
+  }
+  const verb = merged.action === "created" ? "Wrote" : merged.action === "appended" ? "Added" : "Updated";
   return {
-    action,
+    action: merged.action,
     filePath,
     message: `${verb} the pyx-memory rules in ${filePath}.
 `
@@ -2894,8 +2973,7 @@ function reconcileMemoryRules(opts = {}) {
     const filePath = rulesFilePath(target, opts);
     try {
       if (!existsSync3(filePath)) continue;
-      if (!hasPyxMemoryRules(readFileSync3(filePath, "utf8"))) continue;
-      const result = writeMemoryRulesFile({ filePath, section });
+      const result = writeMemoryRulesFile({ filePath, section, refreshOnly: true });
       if (result.action !== "unchanged") {
         process.stderr.write(
           `pyx-memory: refreshed the "## Persistent Memory" rules in ${filePath}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@pyxmate/memory",
-  "version": "1.23.0",
+  "version": "1.23.1",
   "type": "module",
   "description": "SDK for pyx-memory — Memory as a Service for AI agents",
   "license": "MIT",