dotmem 0.0.1 → 0.0.3

package/agent.cjs

@@ -0,0 +1,221 @@
+'use strict';
+
+require('memorio/global');
+
+var __defProp = Object.defineProperty;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __name = (target, value) => __defProp(target, "name", { value, configurable: true });
+var __esm = (fn, res, err) => function __init() {
+  if (err) throw err[0];
+  try {
+    return fn && (res = (0, fn[__getOwnPropNames(fn)[0]])(fn = 0)), res;
+  } catch (e) {
+    throw err = [e], e;
+  }
+};
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+
+// core/global.ts
+var global_exports = {};
+__export(global_exports, {
+  getPlatform: () => getPlatform
+});
+var getPlatform;
+var init_global = __esm({
+  "core/global.ts"() {
+    getPlatform = /* @__PURE__ */ __name(() => {
+      const proc = globalThis.process;
+      if (proc) {
+        return { platform: proc.platform ?? "unknown", arch: proc.arch ?? "unknown" };
+      }
+      const navigatorPlatform = typeof navigator !== "undefined" ? navigator.platform : "unknown";
+      return { platform: navigatorPlatform, arch: "unknown" };
+    }, "getPlatform");
+  }
+});
+
+// core/agent/index.ts
+function isExpired(entry) {
+  if (entry.ttl === null || entry.ttl === void 0) return false;
+  return Date.now() - entry.createdAt > entry.ttl;
+}
+__name(isExpired, "isExpired");
+function normalizeTags(tags) {
+  if (!tags) return [];
+  return Array.isArray(tags) ? tags : [tags];
+}
+__name(normalizeTags, "normalizeTags");
+function namespacedKey(agentTag, key) {
+  return `${agentTag}:${key}`;
+}
+__name(namespacedKey, "namespacedKey");
+function stripKeyPrefix(key) {
+  const idx = key.indexOf(":");
+  if (idx < 0) return key;
+  const rest = key.slice(idx + 1);
+  const idx2 = rest.indexOf(":");
+  if (idx2 < 0) return key;
+  return rest.slice(idx2 + 1);
+}
+__name(stripKeyPrefix, "stripKeyPrefix");
+function createAgentMemory(agentId) {
+  const agentTag = `agent:${agentId}`;
+  async function ensureDotMem() {
+    if (!globalThis.dotmem) {
+      await Promise.resolve().then(() => (init_global(), global_exports));
+    }
+    return globalThis.dotmem.memory;
+  }
+  __name(ensureDotMem, "ensureDotMem");
+  async function ensureTemporal() {
+    if (!globalThis.dotmem) {
+      await Promise.resolve().then(() => (init_global(), global_exports));
+    }
+    return globalThis.dotmem.temporal;
+  }
+  __name(ensureTemporal, "ensureTemporal");
+  return {
+    agentId,
+    /**
+     * Store a memory entry with type, confidence, scope, TTL, and tags.
+     * Keys are automatically namespaced with the agent ID for isolation.
+     */
+    remember: /* @__PURE__ */ __name(async (key, value, options) => {
+      const mem = await ensureDotMem();
+      const userTags = normalizeTags(options?.tags);
+      const allTags = [...userTags, agentTag];
+      const nsKey = namespacedKey(agentTag, key);
+      await mem.remember(nsKey, value, {
+        ...options,
+        tags: allTags,
+        source: options?.source ?? agentId
+      });
+    }, "remember"),
+    /**
+     * Retrieve a memory entry by key with optional filtering.
+     * Returns the full MemoryEntry with metadata (provenance, confidence, timestamp).
+     * Entries with expired TTL are treated as null.
+     */
+    recall: /* @__PURE__ */ __name(async (key, options) => {
+      const mem = await ensureDotMem();
+      const nsKey = namespacedKey(agentTag, key);
+      const entry = await mem._getEntry(nsKey);
+      if (!entry) return null;
+      if (isExpired(entry)) return null;
+      if (entry.status === "obsolete" || entry.status === "superseded") {
+        return options?.includeObsolete ? entry : null;
+      }
+      const cleanEntry = { ...entry, key };
+      return cleanEntry;
+    }, "recall"),
+    /**
+     * Get ranked, semantically relevant memories for context.
+     * Automatically filters to this agent's memories only (via agent tag).
+     *
+     * Tag filtering uses AND semantics: if additional tags are specified,
+     * an entry must have the agent tag AND at least one of the specified tags.
+     */
+    context: /* @__PURE__ */ __name(async (options) => {
+      const mem = await ensureDotMem();
+      const userTags = normalizeTags(options?.tags);
+      const agentTagOnly = await mem.context({
+        ...options,
+        tags: agentTag
+      });
+      let result = agentTagOnly;
+      if (userTags.length > 0) {
+        result = agentTagOnly.filter(
+          (entry) => userTags.some((t) => entry.tags?.includes(t) ?? false)
+        );
+      }
+      return result.map((entry) => ({
+        ...entry,
+        key: stripKeyPrefix(entry.key)
+      }));
+    }, "context"),
+    /**
+     * Access temporal history for a path (mutations over time).
+     */
+    history: /* @__PURE__ */ __name(async (path) => {
+      const t = await ensureTemporal();
+      return t.history(path);
+    }, "history"),
+    /**
+     * Replay the state evolution from a temporal range.
+     */
+    replay: /* @__PURE__ */ __name(async (opts) => {
+      const t = await ensureTemporal();
+      return t.replay({ from: opts.from, to: opts.to });
+    }, "replay"),
+    /**
+     * Create an isolated temporal branch for experimentation.
+     * Useful for "what-if" scenarios without affecting the main timeline.
+     */
+    branch: /* @__PURE__ */ __name(async () => {
+      const t = await ensureTemporal();
+      return t.branch();
+    }, "branch"),
+    /**
+     * Get memory usage statistics.
+     */
+    stats: /* @__PURE__ */ __name(async () => {
+      const mem = await ensureDotMem();
+      return mem.stats();
+    }, "stats"),
+    /**
+     * Update an existing memory entry.
+     */
+    update: /* @__PURE__ */ __name(async (key, value, options) => {
+      const mem = await ensureDotMem();
+      const userTags = normalizeTags(options?.tags);
+      const allTags = [...userTags, agentTag];
+      const nsKey = namespacedKey(agentTag, key);
+      await mem.update(nsKey, value, {
+        ...options,
+        tags: allTags
+      });
+    }, "update"),
+    /**
+     * Delete a memory entry.
+     */
+    forget: /* @__PURE__ */ __name(async (key) => {
+      const mem = await ensureDotMem();
+      const nsKey = namespacedKey(agentTag, key);
+      await mem.forget(nsKey);
+    }, "forget"),
+    /**
+     * Enable temporal/history tracking.
+     */
+    enable: /* @__PURE__ */ __name(async (bool = true) => {
+      const t = await ensureTemporal();
+      t.enable(bool);
+    }, "enable"),
+    /**
+     * Disable temporal tracking.
+     */
+    disable: /* @__PURE__ */ __name(async () => {
+      const t = await ensureTemporal();
+      t.enable(false);
+    }, "disable"),
+    /**
+     * Clear the temporal log and all memories.
+     */
+    clear: /* @__PURE__ */ __name(async () => {
+      const mem = await ensureDotMem();
+      const t = await ensureTemporal();
+      t.clear();
+      await mem.clear();
+    }, "clear")
+  };
+}
+__name(createAgentMemory, "createAgentMemory");
+function createDefaultAgentMemory() {
+  return createAgentMemory("default-agent");
+}
+__name(createDefaultAgentMemory, "createDefaultAgentMemory");
+
+exports.createAgentMemory = createAgentMemory;
+exports.createDefaultAgentMemory = createDefaultAgentMemory;

package/agent.js

@@ -0,0 +1,218 @@
+import 'memorio/global';
+
+var __defProp = Object.defineProperty;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __name = (target, value) => __defProp(target, "name", { value, configurable: true });
+var __esm = (fn, res, err) => function __init() {
+  if (err) throw err[0];
+  try {
+    return fn && (res = (0, fn[__getOwnPropNames(fn)[0]])(fn = 0)), res;
+  } catch (e) {
+    throw err = [e], e;
+  }
+};
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+
+// core/global.ts
+var global_exports = {};
+__export(global_exports, {
+  getPlatform: () => getPlatform
+});
+var getPlatform;
+var init_global = __esm({
+  "core/global.ts"() {
+    getPlatform = /* @__PURE__ */ __name(() => {
+      const proc = globalThis.process;
+      if (proc) {
+        return { platform: proc.platform ?? "unknown", arch: proc.arch ?? "unknown" };
+      }
+      const navigatorPlatform = typeof navigator !== "undefined" ? navigator.platform : "unknown";
+      return { platform: navigatorPlatform, arch: "unknown" };
+    }, "getPlatform");
+  }
+});
+
+// core/agent/index.ts
+function isExpired(entry) {
+  if (entry.ttl === null || entry.ttl === void 0) return false;
+  return Date.now() - entry.createdAt > entry.ttl;
+}
+__name(isExpired, "isExpired");
+function normalizeTags(tags) {
+  if (!tags) return [];
+  return Array.isArray(tags) ? tags : [tags];
+}
+__name(normalizeTags, "normalizeTags");
+function namespacedKey(agentTag, key) {
+  return `${agentTag}:${key}`;
+}
+__name(namespacedKey, "namespacedKey");
+function stripKeyPrefix(key) {
+  const idx = key.indexOf(":");
+  if (idx < 0) return key;
+  const rest = key.slice(idx + 1);
+  const idx2 = rest.indexOf(":");
+  if (idx2 < 0) return key;
+  return rest.slice(idx2 + 1);
+}
+__name(stripKeyPrefix, "stripKeyPrefix");
+function createAgentMemory(agentId) {
+  const agentTag = `agent:${agentId}`;
+  async function ensureDotMem() {
+    if (!globalThis.dotmem) {
+      await Promise.resolve().then(() => (init_global(), global_exports));
+    }
+    return globalThis.dotmem.memory;
+  }
+  __name(ensureDotMem, "ensureDotMem");
+  async function ensureTemporal() {
+    if (!globalThis.dotmem) {
+      await Promise.resolve().then(() => (init_global(), global_exports));
+    }
+    return globalThis.dotmem.temporal;
+  }
+  __name(ensureTemporal, "ensureTemporal");
+  return {
+    agentId,
+    /**
+     * Store a memory entry with type, confidence, scope, TTL, and tags.
+     * Keys are automatically namespaced with the agent ID for isolation.
+     */
+    remember: /* @__PURE__ */ __name(async (key, value, options) => {
+      const mem = await ensureDotMem();
+      const userTags = normalizeTags(options?.tags);
+      const allTags = [...userTags, agentTag];
+      const nsKey = namespacedKey(agentTag, key);
+      await mem.remember(nsKey, value, {
+        ...options,
+        tags: allTags,
+        source: options?.source ?? agentId
+      });
+    }, "remember"),
+    /**
+     * Retrieve a memory entry by key with optional filtering.
+     * Returns the full MemoryEntry with metadata (provenance, confidence, timestamp).
+     * Entries with expired TTL are treated as null.
+     */
+    recall: /* @__PURE__ */ __name(async (key, options) => {
+      const mem = await ensureDotMem();
+      const nsKey = namespacedKey(agentTag, key);
+      const entry = await mem._getEntry(nsKey);
+      if (!entry) return null;
+      if (isExpired(entry)) return null;
+      if (entry.status === "obsolete" || entry.status === "superseded") {
+        return options?.includeObsolete ? entry : null;
+      }
+      const cleanEntry = { ...entry, key };
+      return cleanEntry;
+    }, "recall"),
+    /**
+     * Get ranked, semantically relevant memories for context.
+     * Automatically filters to this agent's memories only (via agent tag).
+     *
+     * Tag filtering uses AND semantics: if additional tags are specified,
+     * an entry must have the agent tag AND at least one of the specified tags.
+     */
+    context: /* @__PURE__ */ __name(async (options) => {
+      const mem = await ensureDotMem();
+      const userTags = normalizeTags(options?.tags);
+      const agentTagOnly = await mem.context({
+        ...options,
+        tags: agentTag
+      });
+      let result = agentTagOnly;
+      if (userTags.length > 0) {
+        result = agentTagOnly.filter(
+          (entry) => userTags.some((t) => entry.tags?.includes(t) ?? false)
+        );
+      }
+      return result.map((entry) => ({
+        ...entry,
+        key: stripKeyPrefix(entry.key)
+      }));
+    }, "context"),
+    /**
+     * Access temporal history for a path (mutations over time).
+     */
+    history: /* @__PURE__ */ __name(async (path) => {
+      const t = await ensureTemporal();
+      return t.history(path);
+    }, "history"),
+    /**
+     * Replay the state evolution from a temporal range.
+     */
+    replay: /* @__PURE__ */ __name(async (opts) => {
+      const t = await ensureTemporal();
+      return t.replay({ from: opts.from, to: opts.to });
+    }, "replay"),
+    /**
+     * Create an isolated temporal branch for experimentation.
+     * Useful for "what-if" scenarios without affecting the main timeline.
+     */
+    branch: /* @__PURE__ */ __name(async () => {
+      const t = await ensureTemporal();
+      return t.branch();
+    }, "branch"),
+    /**
+     * Get memory usage statistics.
+     */
+    stats: /* @__PURE__ */ __name(async () => {
+      const mem = await ensureDotMem();
+      return mem.stats();
+    }, "stats"),
+    /**
+     * Update an existing memory entry.
+     */
+    update: /* @__PURE__ */ __name(async (key, value, options) => {
+      const mem = await ensureDotMem();
+      const userTags = normalizeTags(options?.tags);
+      const allTags = [...userTags, agentTag];
+      const nsKey = namespacedKey(agentTag, key);
+      await mem.update(nsKey, value, {
+        ...options,
+        tags: allTags
+      });
+    }, "update"),
+    /**
+     * Delete a memory entry.
+     */
+    forget: /* @__PURE__ */ __name(async (key) => {
+      const mem = await ensureDotMem();
+      const nsKey = namespacedKey(agentTag, key);
+      await mem.forget(nsKey);
+    }, "forget"),
+    /**
+     * Enable temporal/history tracking.
+     */
+    enable: /* @__PURE__ */ __name(async (bool = true) => {
+      const t = await ensureTemporal();
+      t.enable(bool);
+    }, "enable"),
+    /**
+     * Disable temporal tracking.
+     */
+    disable: /* @__PURE__ */ __name(async () => {
+      const t = await ensureTemporal();
+      t.enable(false);
+    }, "disable"),
+    /**
+     * Clear the temporal log and all memories.
+     */
+    clear: /* @__PURE__ */ __name(async () => {
+      const mem = await ensureDotMem();
+      const t = await ensureTemporal();
+      t.clear();
+      await mem.clear();
+    }, "clear")
+  };
+}
+__name(createAgentMemory, "createAgentMemory");
+function createDefaultAgentMemory() {
+  return createAgentMemory("default-agent");
+}
+__name(createDefaultAgentMemory, "createDefaultAgentMemory");
+
+export { createAgentMemory, createDefaultAgentMemory };

package/bin/cli.cjs

@@ -0,0 +1,35 @@
+#!/usr/bin/env node
+'use strict';
+
+var process = require('process');
+var url = require('url');
+
+var _documentCurrentScript = typeof document !== 'undefined' ? document.currentScript : null;
+function _interopDefault (e) { return e && e.__esModule ? e : { default: e }; }
+
+var process__default = /*#__PURE__*/_interopDefault(process);
+
+var rawArgs = process__default.default.argv.slice(2);
+var storageRootFlagIndex = rawArgs.indexOf("--storage-root");
+var hasStorageRootFlag = storageRootFlagIndex !== -1;
+var storageRootFlagValue = hasStorageRootFlag ? rawArgs[storageRootFlagIndex + 1] : void 0;
+if (hasStorageRootFlag && (storageRootFlagValue === void 0 || storageRootFlagValue.startsWith("--"))) {
+  console.error("Usage: npx dotmem <command> --storage-root <absolute-directory>");
+  process__default.default.exit(1);
+}
+var args = hasStorageRootFlag ? rawArgs.filter((_, index) => index !== storageRootFlagIndex && index !== storageRootFlagIndex + 1) : rawArgs;
+var command = args[0];
+var dispatchArgs = args.slice(1);
+void (async () => {
+  const cliModule = await import('../cli.js');
+  if (hasStorageRootFlag) {
+    try {
+      cliModule.noteDotMemPackageInstallPath(url.fileURLToPath((typeof document === 'undefined' ? require('u' + 'rl').pathToFileURL(__filename).href : (_documentCurrentScript && _documentCurrentScript.tagName.toUpperCase() === 'SCRIPT' && _documentCurrentScript.src || new URL('cli.cjs', document.baseURI).href))));
+      cliModule.setDotMemStorageRootOverride(storageRootFlagValue);
+    } catch (error) {
+      console.error(`Invalid --storage-root: ${error instanceof Error ? error.message : String(error)}`);
+      process__default.default.exit(1);
+    }
+  }
+  cliModule.dispatch(command, dispatchArgs);
+})();

package/bin/cli.js

@@ -0,0 +1,28 @@
+#!/usr/bin/env node
+import process from 'process';
+import { fileURLToPath } from 'url';
+
+var rawArgs = process.argv.slice(2);
+var storageRootFlagIndex = rawArgs.indexOf("--storage-root");
+var hasStorageRootFlag = storageRootFlagIndex !== -1;
+var storageRootFlagValue = hasStorageRootFlag ? rawArgs[storageRootFlagIndex + 1] : void 0;
+if (hasStorageRootFlag && (storageRootFlagValue === void 0 || storageRootFlagValue.startsWith("--"))) {
+  console.error("Usage: npx dotmem <command> --storage-root <absolute-directory>");
+  process.exit(1);
+}
+var args = hasStorageRootFlag ? rawArgs.filter((_, index) => index !== storageRootFlagIndex && index !== storageRootFlagIndex + 1) : rawArgs;
+var command = args[0];
+var dispatchArgs = args.slice(1);
+void (async () => {
+  const cliModule = await import('../cli.js');
+  if (hasStorageRootFlag) {
+    try {
+      cliModule.noteDotMemPackageInstallPath(fileURLToPath(import.meta.url));
+      cliModule.setDotMemStorageRootOverride(storageRootFlagValue);
+    } catch (error) {
+      console.error(`Invalid --storage-root: ${error instanceof Error ? error.message : String(error)}`);
+      process.exit(1);
+    }
+  }
+  cliModule.dispatch(command, dispatchArgs);
+})();

package/bin/mcp.cjs

@@ -0,0 +1,22 @@
+#!/usr/bin/env node
+'use strict';
+
+var process = require('process');
+
+function _interopDefault (e) { return e && e.__esModule ? e : { default: e }; }
+
+var process__default = /*#__PURE__*/_interopDefault(process);
+
+var nodeMajorVersion = Number.parseInt(process__default.default.versions.node.split(".")[0] ?? "", 10);
+if (!Number.isInteger(nodeMajorVersion) || nodeMajorVersion < 20) {
+  console.error("dotmem-mcp requires Node.js >=20; the normal dotmem runtime remains compatible with its declared Node.js version.");
+  process__default.default.exitCode = 1;
+} else {
+  void (async () => {
+    const mcpModule = await import('../mcp.js');
+    await mcpModule.startDotMemMcpServer();
+  })().catch((error) => {
+    console.error(error instanceof Error ? error.message : String(error));
+    process__default.default.exitCode = 1;
+  });
+}

package/bin/mcp.js

@@ -0,0 +1,16 @@
+#!/usr/bin/env node
+import process from 'process';
+
+var nodeMajorVersion = Number.parseInt(process.versions.node.split(".")[0] ?? "", 10);
+if (!Number.isInteger(nodeMajorVersion) || nodeMajorVersion < 20) {
+  console.error("dotmem-mcp requires Node.js >=20; the normal dotmem runtime remains compatible with its declared Node.js version.");
+  process.exitCode = 1;
+} else {
+  void (async () => {
+    const mcpModule = await import('../mcp.js');
+    await mcpModule.startDotMemMcpServer();
+  })().catch((error) => {
+    console.error(error instanceof Error ? error.message : String(error));
+    process.exitCode = 1;
+  });
+}