@pyxmate/memory 1.23.0 → 1.23.2

package/README.md

@@ -34,10 +34,15 @@ pyx-mem mcp install claude-code --scope user
 
 Restart Claude Code. The MCP tools are auto-discovered via MCP Tool Search:
 `search_memories`, `store_memory`, `get_memory`, `list_memories`,
-`delete_memory`, `ingest_memory_file`, `summarize_memory_entity`, `status`,
+`delete_memory`, `summarize_memory_entity`, `status`,
 `get_user_profile`, `upsert_user_profile`, `record_correction`, and
 `fetch_applicable_corrections`.
 
+`ingest_memory_file` is currently supported only through `pyx-mem mcp` connected
+to an upload-enabled self-hosted server (`DATA_PLANE_OPERATION_AUTHORITY_MODE=off`).
+Run `pyx-mem login --endpoint <your-server-url>` first; file ingest is
+unavailable at `https://memory.api.pyxmate.com`.
+
 **That's the whole setup.** Graph is a relational retrieval dimension, not a
 search-score boost. When content names people, organizations, tools, places,
 events, or key concepts, pass both `entities` and `relationships` when you can

package/dist/cli/pyx-mem.mjs

@@ -907,7 +907,19 @@ function createHttpClient(credentials, fetchImpl = fetch) {
     if (res.status === 401 || res.status === 403) {
       return { ok: false, status: res.status, result: mcpAuthFailed(res.status) };
     }
-    const text = await res.text().catch(() => "");
+    let text;
+    try {
+      text = await res.text();
+    } catch (err) {
+      const reason = err instanceof Error ? err.message : String(err);
+      return {
+        ok: false,
+        status: res.status,
+        result: mcpEnvelopeError(
+          `Failed to read pyx-memory response (HTTP ${res.status}): ${reason}`
+        )
+      };
+    }
     return parseHttpResponse(res, text);
   }
   return {
@@ -933,6 +945,9 @@ function parseHttpResponse(res, text) {
   if (res.status >= 500) {
     return { ok: false, status: res.status, result: mcpServerError(res.status, text) };
   }
+  if (res.ok && res.headers.get("content-type")?.includes("application/x-ndjson")) {
+    return parseNdjsonOutcome(res.status, text);
+  }
   const parsed = parseJsonText(text);
   if (!parsed.ok) {
     if (!res.ok) {
@@ -954,6 +969,31 @@ function parseHttpResponse(res, text) {
   }
   return { ok: true, status: res.status, data: parsed.value };
 }
+function parseNdjsonOutcome(status, text) {
+  for (const line of text.split("\n")) {
+    if (!line.trim()) continue;
+    let frame;
+    try {
+      frame = JSON.parse(line);
+    } catch (err) {
+      const reason = err instanceof Error ? err.message : String(err);
+      return {
+        ok: false,
+        status,
+        result: mcpEnvelopeError(`pyx-memory sent an invalid NDJSON line: ${reason}`)
+      };
+    }
+    if (frame?.type === "result") return { ok: true, status, data: frame };
+    if (frame?.type === "error") {
+      return { ok: false, status, result: mcpEnvelopeError(JSON.stringify(frame)) };
+    }
+  }
+  return {
+    ok: false,
+    status,
+    result: mcpEnvelopeError("File ingest stream ended without a server result")
+  };
+}
 function parseJsonText(text) {
   if (text.length === 0) return { ok: true, value: void 0 };
   try {
@@ -2175,27 +2215,29 @@ function createProxyServer(client, version, uploadLocalFile) {
   });
   const localUploads = /* @__PURE__ */ new Map();
   let listedOnce = false;
-  const refreshFromList = (result) => {
-    const tools = result.tools;
-    if (Array.isArray(tools)) {
-      listedOnce = true;
-      for (const tool of tools) {
-        const descriptor = uploadLocalFile ? extractLocalUpload(tool._meta) : void 0;
-        if (descriptor) localUploads.set(tool.name, descriptor);
-        else localUploads.delete(tool.name);
-      }
+  let listingsStarted = 0;
+  let listingApplied = 0;
+  const listAndRefresh = async (params) => {
+    const listing = ++listingsStarted;
+    const result = await client.listTools(params);
+    const { tools, nextCursor } = result;
+    if (!Array.isArray(tools) || listing < listingApplied) return result;
+    listingApplied = listing;
+    listedOnce = true;
+    if (params?.cursor === void 0 && nextCursor === void 0) localUploads.clear();
+    for (const tool of tools) {
+      const descriptor = uploadLocalFile ? extractLocalUpload(tool._meta) : void 0;
+      if (descriptor) localUploads.set(tool.name, descriptor);
+      else localUploads.delete(tool.name);
     }
     return result;
   };
   if (caps?.tools) {
-    server.setRequestHandler(
-      ListToolsRequestSchema,
-      async (req) => refreshFromList(await client.listTools(req.params))
-    );
+    server.setRequestHandler(ListToolsRequestSchema, (req) => listAndRefresh(req.params));
     server.setRequestHandler(CallToolRequestSchema, async (req) => {
       if (uploadLocalFile && !listedOnce) {
         try {
-          refreshFromList(await client.listTools());
+          await listAndRefresh();
         } catch {
         }
       }
@@ -2223,7 +2265,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.2" : "0.0.0-dev");
   const read = await opts.readCredentials();
   if (!read.ok) {
     throw new Error(
@@ -2269,7 +2311,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 +2431,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 +2452,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 +2475,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 +2496,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 +2535,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 +2558,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 +2571,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 +2625,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 +3015,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/dist/index.d.ts

@@ -1650,7 +1650,11 @@ interface EnrichmentPendingV1 {
 interface EnrichmentTextWindowsTruncation {
     /** Total characters seen by the parser, including content beyond the cap. */
     originalChars: number;
-    /** Sum of emitted window lengths. <= originalChars. */
+    /**
+     * Sum of emitted window lengths. Overlapping regions between adjacent
+     * windows are counted once per window, so this can exceed originalChars
+     * once windowCount >= 2; bounded by windowCount * originalChars.
+     */
     includedChars: number;
     windowCount: number;
     truncated: boolean;

package/package.json

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