openclaw-memory-decay 0.1.6 → 0.1.8

package/README.md

@@ -63,12 +63,11 @@ Activation
 python3 -m venv ~/.openclaw/venvs/memory-decay
 ~/.openclaw/venvs/memory-decay/bin/pip install memory-decay
 
-# 2. Install this plugin while that venv is active
-source ~/.openclaw/venvs/memory-decay/bin/activate
+# 2. Install this plugin from npm
 openclaw plugins install openclaw-memory-decay
 
 # 3. (Optional but recommended) Restrict auto-load to trusted plugins only
-openclaw config set plugins.allow '["memory-decay"]'
+openclaw config set plugins.allow '["openclaw-memory-decay"]'
 
 # 4. Restart the gateway
 openclaw gateway restart
@@ -94,14 +93,14 @@ openclaw plugins install openclaw-memory-decay
 openclaw gateway restart
 
 # 3. Verify
-openclaw plugins list | grep memory-decay  # should show: memory-decay | loaded
+openclaw plugins list | grep openclaw-memory-decay  # should show: openclaw-memory-decay | loaded
 curl -s http://127.0.0.1:8100/health       # should show: {"status":"ok","current_tick":0}
 ```
 
 If auto-detection does not recover your backend path after migration, set the interpreter explicitly:
 
 ```bash
-openclaw config set plugins.entries.memory-decay.config.pythonPath "~/.openclaw/venvs/memory-decay/bin/python"
+openclaw config set plugins.entries.openclaw-memory-decay.config.pythonPath "~/.openclaw/venvs/memory-decay/bin/python"
 openclaw gateway restart
 ```
 
@@ -109,19 +108,19 @@ openclaw gateway restart
 
 To update in the future:
 ```bash
-openclaw plugins update memory-decay
+openclaw plugins update openclaw-memory-decay
 openclaw gateway restart
 ```
 
 ## Configuration
 
-Add to `~/.openclaw/openclaw.json` under `plugins.entries.memory-decay.config`:
+Add to `~/.openclaw/openclaw.json` under `plugins.entries.openclaw-memory-decay.config`:
 
 ```json
 {
   "plugins": {
     "entries": {
-      "memory-decay": {
+      "openclaw-memory-decay": {
         "enabled": true,
         "config": {
           "dbPath": "~/.openclaw/memory-decay-data/memories.db",
@@ -138,7 +137,7 @@ Add to `~/.openclaw/openclaw.json` under `plugins.entries.memory-decay.config`:
 |--------|---------|-------------|
 | `serverPort` | `8100` | Port for the memory-decay HTTP server |
 | `memoryDecayPath` | (auto) | Path to memory-decay-core. Auto-detected from the install-time Python environment if not set |
-| `pythonPath` | `python3` | Path to Python interpreter. Set this explicitly if the gateway runs outside the install-time venv |
+| `pythonPath` | `python3` | Path to Python interpreter. Set this explicitly if you use a custom venv path instead of `~/.openclaw/venvs/memory-decay` |
 | `dbPath` | `~/.openclaw/memory-decay-data/memories.db` | SQLite database location |
 | `autoSave` | `true` | Auto-save every conversation turn at low importance. Set `false` to let the agent decide what to save |
 | `embeddingProvider` | `local` | Embedding provider: `local`, `openai`, or `gemini` |
@@ -244,7 +243,7 @@ The plugin registers these tools:
 This warning appears when `plugins.allow` is not set. While the plugin still loads (since it is explicitly configured in `plugins.entries`), it is good practice to restrict auto-load to trusted plugins only:
 
 ```bash
-openclaw config set plugins.allow '["memory-decay"]'
+openclaw config set plugins.allow '["openclaw-memory-decay"]'
 openclaw gateway restart
 ```
 
@@ -297,20 +296,17 @@ openclaw plugins doctor
 python3 -m venv ~/.openclaw/venvs/memory-decay
 ~/.openclaw/venvs/memory-decay/bin/pip install memory-decay
 
-# 2. Activate the venv so postinstall detects the same interpreter
-source ~/.openclaw/venvs/memory-decay/bin/activate
-
-# 3. Install plugin from npm
+# 2. Install plugin from npm
 openclaw plugins install openclaw-memory-decay
 
-# 4. Restart gateway
+# 3. Restart gateway
 openclaw gateway restart
 
-# 5. Verify plugin is loaded
+# 4. Verify plugin is loaded
 openclaw plugins list
-# Look for: memory-decay | loaded
+# Look for: openclaw-memory-decay | loaded
 
-# 6. Check server health
+# 5. Check server health
 curl -s http://127.0.0.1:8100/health
 # Expected: {"status":"ok","current_tick":0}
 ```

package/openclaw.plugin.json

@@ -1,8 +1,8 @@
 {
-  "id": "memory-decay",
+  "id": "openclaw-memory-decay",
   "name": "Memory Decay",
   "description": "Human-like memory with decay and reinforcement for OpenClaw agents",
-  "version": "0.1.6",
+  "version": "0.1.8",
   "configSchema": {
     "type": "object",
     "additionalProperties": true,

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "openclaw-memory-decay",
-  "version": "0.1.6",
+  "version": "0.1.8",
   "type": "module",
   "description": "OpenClaw memory plugin backed by memory-decay engine",
   "main": "./src/index.js",

package/scripts/detect-python-lib.mjs

@@ -1,6 +1,6 @@
 import { execFileSync as nodeExecFileSync } from "node:child_process";
 import { existsSync as nodeExistsSync, mkdtempSync, readFileSync, rmSync } from "node:fs";
-import { tmpdir } from "node:os";
+import { homedir as nodeHomedir, tmpdir } from "node:os";
 import { basename, dirname, isAbsolute, join, resolve } from "node:path";
 
 function resolvePythonPath(command, { execFileSync = nodeExecFileSync, isWin = process.platform === "win32" } = {}) {
@@ -23,7 +23,9 @@ export function buildPythonCandidates({
   env = process.env,
   isWin = process.platform === "win32",
   existsSync = nodeExistsSync,
+  homedir = nodeHomedir,
 } = {}) {
+  const openclawStateDir = resolve(env.OPENCLAW_HOME || homedir(), ".openclaw");
   const siblingRoots = [
     resolve(pluginRoot, "../memory-decay"),
     resolve(pluginRoot, "../memory-decay-core"),
@@ -31,6 +33,9 @@ export function buildPythonCandidates({
   const pathCandidates = [];
 
   if (env.MD_PYTHON_PATH) pathCandidates.push(env.MD_PYTHON_PATH);
+  pathCandidates.push(
+    join(openclawStateDir, "venvs", "memory-decay", isWin ? "Scripts/python.exe" : "bin/python"),
+  );
   if (env.VIRTUAL_ENV) {
     pathCandidates.push(join(env.VIRTUAL_ENV, isWin ? "Scripts/python.exe" : "bin/python"));
   }

package/src/index.ts

@@ -1,9 +1,10 @@
 import type { OpenClawPluginApi } from "openclaw/plugin-sdk";
 import { emptyPluginConfigSchema } from "openclaw/plugin-sdk";
 import { MemoryDecayClient } from "./client.js";
+import { loadLegacyPluginConfig } from "./legacy-config.js";
 import { MemoryDecayService, type ServiceConfig } from "./service.js";
 import { shouldMigrate, migrateMarkdownMemories } from "./migrator.js";
-import { mergePythonEnv } from "./python-env.js";
+import { detectPythonEnv, mergePythonEnv } from "./python-env.js";
 import { toFreshness } from "./types.js";
 
 const BOOTSTRAP_PROMPT = `## Memory System (memory-decay)
@@ -39,14 +40,14 @@ Your memories naturally decay over time. Frequently recalled memories grow stron
 const MIN_MESSAGE_LENGTH = 20;
 
 const memoryDecayPlugin = {
-  id: "memory-decay",
+  id: "openclaw-memory-decay",
   name: "Memory Decay",
   description: "Human-like memory with decay and reinforcement",
   kind: "memory" as const,
   configSchema: emptyPluginConfigSchema(),
 
   register(api: OpenClawPluginApi) {
-    const cfg = api.pluginConfig ?? {};
+    const cfg = loadLegacyPluginConfig((api.pluginConfig ?? {}) as Record<string, unknown>);
     const port = (cfg.serverPort as number) ?? 8100;
     const autoSave = cfg.autoSave !== false; // default true
 
@@ -90,15 +91,21 @@ const memoryDecayPlugin = {
         let memoryDecayPath = (cfg.memoryDecayPath as string) ?? "";
         let pythonPath = (cfg.pythonPath as string) ?? "";
         let detectedEnv: { memoryDecayPath?: string; pythonPath?: string } = {};
+        const { dirname, resolve } = await import("node:path");
+        const { fileURLToPath } = await import("node:url");
+        const pluginRoot = dirname(fileURLToPath(import.meta.url));
         if (!memoryDecayPath || !pythonPath) {
           try {
             const { readFileSync } = await import("node:fs");
-            const { resolve, dirname } = await import("node:path");
-            const { fileURLToPath } = await import("node:url");
-            const pluginRoot = dirname(fileURLToPath(import.meta.url));
             detectedEnv = JSON.parse(readFileSync(resolve(pluginRoot, "../.python-env.json"), "utf8"));
           } catch {}
         }
+        if (!detectedEnv.memoryDecayPath || !detectedEnv.pythonPath) {
+          detectedEnv = mergePythonEnv(
+            detectedEnv,
+            detectPythonEnv({ pluginRoot }) ?? {},
+          );
+        }
         ({ memoryDecayPath, pythonPath } = mergePythonEnv(
           { memoryDecayPath, pythonPath },
           detectedEnv,
@@ -106,7 +113,7 @@ const memoryDecayPlugin = {
         if (!memoryDecayPath) {
           ctx.logger.error(
             "Could not auto-detect memory-decay installation. " +
-            "Run `pip install memory-decay` or set memoryDecayPath in plugin config."
+            "Install the backend into ~/.openclaw/venvs/memory-decay or set pythonPath/memoryDecayPath in plugin config."
           );
           return;
         }

package/src/legacy-config.ts

@@ -0,0 +1,35 @@
+import { existsSync, readFileSync } from "node:fs";
+import { homedir } from "node:os";
+import { join, resolve } from "node:path";
+
+export type PluginConfigLike = Record<string, unknown>;
+
+function resolveOpenClawConfigPath(env: NodeJS.ProcessEnv = process.env): string {
+  return resolve(env.OPENCLAW_HOME || homedir(), ".openclaw", "openclaw.json");
+}
+
+export function loadLegacyPluginConfig(
+  currentConfig: PluginConfigLike,
+  {
+    env = process.env,
+    configPath = resolveOpenClawConfigPath(env),
+  }: { env?: NodeJS.ProcessEnv; configPath?: string } = {},
+): PluginConfigLike {
+  if (Object.keys(currentConfig).length > 0) {
+    return currentConfig;
+  }
+
+  if (!existsSync(configPath)) {
+    return currentConfig;
+  }
+
+  try {
+    const root = JSON.parse(readFileSync(configPath, "utf8"));
+    const legacyConfig = root?.plugins?.entries?.["memory-decay"]?.config;
+    return legacyConfig && typeof legacyConfig === "object"
+      ? { ...legacyConfig }
+      : currentConfig;
+  } catch {
+    return currentConfig;
+  }
+}

package/src/python-env.ts

@@ -1,8 +1,25 @@
+import { execFileSync as nodeExecFileSync } from "node:child_process";
+import { existsSync as nodeExistsSync, mkdtempSync, readFileSync, rmSync } from "node:fs";
+import { homedir as nodeHomedir, tmpdir } from "node:os";
+import { basename, dirname, isAbsolute, join, resolve } from "node:path";
+
 export interface PythonEnvLike {
   memoryDecayPath?: string;
   pythonPath?: string;
 }
 
+interface DetectPythonEnvOptions {
+  pluginRoot: string;
+  env?: NodeJS.ProcessEnv;
+  isWin?: boolean;
+  homedir?: () => string;
+  existsSync?: (path: string) => boolean;
+  execFileSync?: typeof nodeExecFileSync;
+  makeTempDir?: () => string;
+  readPathFile?: (path: string) => string;
+  removeTempDir?: (path: string) => void;
+}
+
 export function mergePythonEnv(
   configured: PythonEnvLike,
   detected: PythonEnvLike = {},
@@ -12,3 +29,105 @@ export function mergePythonEnv(
     pythonPath: configured.pythonPath || detected.pythonPath || "",
   };
 }
+
+function resolveOpenClawStateDir(
+  env: NodeJS.ProcessEnv,
+  homedir: () => string,
+): string {
+  return resolve(env.OPENCLAW_HOME || homedir(), ".openclaw");
+}
+
+export function resolveMemoryDecayPath(moduleFile: string): string {
+  const packageDir = dirname(resolve(moduleFile));
+  const packageParent = dirname(packageDir);
+  return basename(packageParent) === "src" ? dirname(packageParent) : packageParent;
+}
+
+export function buildPythonCandidates({
+  pluginRoot,
+  env = process.env,
+  isWin = process.platform === "win32",
+  homedir = nodeHomedir,
+  existsSync = nodeExistsSync,
+}: Omit<DetectPythonEnvOptions, "execFileSync" | "makeTempDir" | "readPathFile" | "removeTempDir">): string[] {
+  const siblingRoots = [
+    resolve(pluginRoot, "../../memory-decay"),
+    resolve(pluginRoot, "../../memory-decay-core"),
+    resolve(pluginRoot, "../memory-decay"),
+    resolve(pluginRoot, "../memory-decay-core"),
+  ];
+  const openclawStateDir = resolveOpenClawStateDir(env, homedir);
+  const recommendedVenv = join(
+    openclawStateDir,
+    "venvs",
+    "memory-decay",
+    isWin ? "Scripts/python.exe" : "bin/python",
+  );
+  const pathCandidates = [
+    env.MD_PYTHON_PATH,
+    recommendedVenv,
+    env.VIRTUAL_ENV
+      ? join(env.VIRTUAL_ENV, isWin ? "Scripts/python.exe" : "bin/python")
+      : undefined,
+    ...siblingRoots.map((root) =>
+      join(root, isWin ? ".venv/Scripts/python.exe" : ".venv/bin/python")),
+  ].filter((candidate): candidate is string => typeof candidate === "string" && candidate.length > 0 && existsSync(candidate));
+
+  const commandCandidates = isWin ? ["python"] : ["python3", "python"];
+  return [...new Set([...pathCandidates, ...commandCandidates])];
+}
+
+function resolvePythonPath(
+  command: string,
+  {
+    execFileSync = nodeExecFileSync,
+    isWin = process.platform === "win32",
+  }: Pick<DetectPythonEnvOptions, "execFileSync" | "isWin"> = {},
+): string {
+  if (isAbsolute(command)) {
+    return command;
+  }
+
+  const resolver = isWin ? "where" : "which";
+  return execFileSync(resolver, [command], { encoding: "utf8" }).trim().split(/\r?\n/)[0];
+}
+
+export function detectPythonEnv({
+  pluginRoot,
+  env = process.env,
+  isWin = process.platform === "win32",
+  homedir = nodeHomedir,
+  existsSync = nodeExistsSync,
+  execFileSync = nodeExecFileSync,
+  makeTempDir = () => mkdtempSync(join(tmpdir(), "memory-decay-python-env-")),
+  readPathFile = (path) => readFileSync(path, "utf8"),
+  removeTempDir = (path) => rmSync(path, { recursive: true, force: true }),
+}: DetectPythonEnvOptions): { memoryDecayPath: string; pythonPath: string } | null {
+  for (const candidate of buildPythonCandidates({ pluginRoot, env, isWin, homedir, existsSync })) {
+    try {
+      execFileSync(candidate, ["-c", "import memory_decay.server"], { stdio: "ignore" });
+      const tempDir = makeTempDir();
+      const outputPath = join(tempDir, "memory-decay-module-path.txt");
+
+      try {
+        execFileSync(candidate, [
+          "-c",
+          `import memory_decay, pathlib; pathlib.Path(${JSON.stringify(outputPath)}).write_text(str(pathlib.Path(memory_decay.__file__).resolve()))`,
+        ], { stdio: "ignore" });
+      } catch (error) {
+        removeTempDir(tempDir);
+        throw error;
+      }
+
+      const moduleFile = readPathFile(outputPath).trim();
+      removeTempDir(tempDir);
+
+      return {
+        pythonPath: resolvePythonPath(candidate, { execFileSync, isWin }),
+        memoryDecayPath: resolveMemoryDecayPath(moduleFile),
+      };
+    } catch {}
+  }
+
+  return null;
+}