@eleboucher/opencode-memini 0.7.2 → 0.7.4

package/README.md

@@ -83,6 +83,7 @@ Pass options inline via the `[name, options]` form:
 | `recall_budget_ms`  | `MEMINI_RECALL_BUDGET_MS`        | `2000`                  | how long a turn waits for recall before proceeding without it (`0` = wait for the full `timeout_ms`)                                   |
 | `timeout_ms`        | `MEMINI_TIMEOUT_MS`              | `30000`                 | per-request timeout (recall past its budget keeps running in the background under this bound)                                          |
 | `fallback_on_error` | `MEMINI_FALLBACK`                | on                      | `false` surfaces errors instead of degrading silently                                                                                  |
+| `auto_update`       | `MEMINI_AUTO_UPDATE`             | on                      | `false` disables npm auto-update checks (opencode never re-fetches cached plugins otherwise)                                           |
 | —                   | `MEMINI_INJECT_LABELS`           | —                       | comma-separated label toggles for each bullet: `tier`, `confidence`, `age`, `reason`                                                   |
 | —                   | `MEMINI_API_KEY`                 | —                       | bearer token, if memini needs auth (env only — secret)                                                                                 |
 | —                   | `MEMINI_REQUIRE_HTTPS`           | —                       | `1` refuses to send the token over plaintext HTTP                                                                                      |

package/memini-v2.js

@@ -34,6 +34,7 @@ import {
   resolveConfig,
   buildFacts,
   effectiveConfig,
+  buildTurnCapture,
   memoizeAsync,
   extractPartsText,
   formatResults,
@@ -322,7 +323,7 @@ export async function setup(ctx) {
     const stored = await rest.postJson(
       "/v1/memories",
       {
-        content: `${userText.slice(0, 1000)}\n\n${assistantText.slice(0, 3000)}`,
+        content: buildTurnCapture(userText, assistantText, live.capture_user_max_chars, live.capture_assistant_max_chars),
         tags: ["opencode"],
         metadata,
       },

package/memini.js

@@ -19,9 +19,11 @@
  * the options/env table in ../README.md.
  */
 
-import { execSync } from "node:child_process";
-import { readFileSync } from "node:fs";
-import { resolve } from "node:path";
+import { execSync, spawnSync } from "node:child_process";
+import { readFileSync, existsSync, rmSync, writeFileSync, statSync } from "node:fs";
+import { resolve, join, dirname } from "node:path";
+import { homedir } from "node:os";
+import { fileURLToPath } from "node:url";
 
 const DEFAULT_BASE_URL = "http://localhost:8080";
 const DEFAULT_TIMEOUT_MS = 30000;
@@ -50,6 +52,152 @@ function readPluginVersion() {
 }
 const CLIENT_VERSION = readPluginVersion();
 
+// Auto-update: opencode never re-fetches cached npm plugins, so the plugin
+// checks npm dist-tags once per process and self-updates (same major version
+// only) so the running copy stays current.
+const PACKAGE_NAME = "@eleboucher/opencode-memini";
+const NPM_REGISTRY_URL = `https://registry.npmjs.org/-/package/${PACKAGE_NAME}/dist-tags`;
+const NPM_FETCH_TIMEOUT = 5000;
+const BUN_INSTALL_TIMEOUT_MS = 60000;
+let autoUpdateChecked = false;
+
+/**
+ * parseVersion extracts major.minor.patch from a semver string. Exported for
+ * testing.
+ */
+export function parseVersion(version) {
+  const normalized = String(version).trim().replace(/^[~^=<>\s]+/, "");
+  const match = normalized.match(/^(\d+)\.(\d+)\.(\d+)/);
+  if (!match) return null;
+  return { major: Number(match[1]), minor: Number(match[2]), patch: Number(match[3]) };
+}
+
+/**
+ * compareVersions returns -1, 0, or 1. Exported for testing.
+ */
+export function compareVersions(a, b) {
+  const va = parseVersion(a);
+  const vb = parseVersion(b);
+  if (!va || !vb) return 0;
+  if (va.major !== vb.major) return va.major < vb.major ? -1 : 1;
+  if (va.minor !== vb.minor) return va.minor < vb.minor ? -1 : 1;
+  if (va.patch !== vb.patch) return va.patch < vb.patch ? -1 : 1;
+  return 0;
+}
+
+/**
+ * resolveInstallContext finds the opencode plugin cache directory that holds
+ * this running plugin instance, by walking up from import.meta.url. Returns
+ * { installDir, packageJsonPath } or null.
+ */
+function resolveInstallContext() {
+  try {
+    const pluginDir = dirname(fileURLToPath(import.meta.url));
+    const nodeModulesDir = dirname(pluginDir);
+    const installDir = dirname(nodeModulesDir);
+    const packageJsonPath = join(installDir, "package.json");
+    if (existsSync(packageJsonPath)) {
+      return { installDir, packageJsonPath };
+    }
+  } catch {}
+  return null;
+}
+
+/**
+ * fetchLatestVersion queries npm dist-tags with a timeout. Returns the version
+ * string or null on failure.
+ */
+async function fetchLatestVersion() {
+  try {
+    const controller = new AbortController();
+    const timer = setTimeout(() => controller.abort(), NPM_FETCH_TIMEOUT);
+    try {
+      const resp = await fetch(NPM_REGISTRY_URL, {
+        signal: controller.signal,
+        headers: { Accept: "application/json" },
+      });
+      if (!resp.ok) return null;
+      const data = await resp.json();
+      return data?.latest ?? null;
+    } finally {
+      clearTimeout(timer);
+    }
+  } catch {
+    return null;
+  }
+}
+
+/**
+ * prepareCacheUpdate rewrites the cache package.json to pin the new version,
+ * removes the installed node_modules package, and cleans bun.lock. Returns
+ * the installDir on success, null on failure.
+ */
+function prepareCacheUpdate(newVersion, log) {
+  const ctx = resolveInstallContext();
+  if (!ctx) {
+    log.warn("auto-update: could not resolve install context");
+    return null;
+  }
+  // Rewrite package.json with the new version pin
+  try {
+    const pkg = JSON.parse(readFileSync(ctx.packageJsonPath, "utf8"));
+    if (pkg.dependencies && pkg.dependencies[PACKAGE_NAME] === newVersion) {
+      return ctx.installDir; // already updated
+    }
+    pkg.dependencies = { ...pkg.dependencies, [PACKAGE_NAME]: newVersion };
+    writeFileSync(ctx.packageJsonPath, JSON.stringify(pkg, null, 2));
+  } catch (err) {
+    log.warn(`auto-update: failed to rewrite cache package.json: ${String(err)}`);
+    return null;
+  }
+  // Remove installed node_modules so bun install re-fetches
+  try {
+    const pkgDir = join(ctx.installDir, "node_modules", "@eleboucher", "opencode-memini");
+    if (existsSync(pkgDir)) rmSync(pkgDir, { recursive: true, force: true });
+  } catch (err) {
+    log.warn(`auto-update: failed to remove cached node_modules: ${String(err)}`);
+    return null;
+  }
+  // Clean bun.lock entry if it exists
+  const lockPath = join(ctx.installDir, "bun.lock");
+  if (existsSync(lockPath)) {
+    try {
+      const lock = JSON.parse(readFileSync(lockPath, "utf8"));
+      let modified = false;
+      if (lock.workspaces?.[""]?.dependencies?.[PACKAGE_NAME]) {
+        delete lock.workspaces[""].dependencies[PACKAGE_NAME];
+        modified = true;
+      }
+      if (lock.packages?.[PACKAGE_NAME]) {
+        delete lock.packages[PACKAGE_NAME];
+        modified = true;
+      }
+      if (modified) writeFileSync(lockPath, JSON.stringify(lock, null, 2));
+    } catch {
+      // bun.lock format varies; if we can't parse it, leave it — bun install
+      // will reconcile.
+    }
+  }
+  return ctx.installDir;
+}
+
+/**
+ * runBunInstall runs `bun install` in the given directory with a timeout.
+ * Returns true on success (exit code 0), false otherwise.
+ */
+function runBunInstall(installDir) {
+  try {
+    const result = spawnSync(process.execPath, ["install"], {
+      cwd: installDir,
+      stdio: ["ignore", "pipe", "pipe"],
+      timeout: BUN_INSTALL_TIMEOUT_MS,
+    });
+    return result.status === 0;
+  } catch {
+    return false;
+  }
+}
+
 // How long a memoized handshake stays trustworthy on a live plugin instance,
 // and how long a single handshake call is allowed to block before falling
 // back. Mirrors packages/memini-client's HANDSHAKE_TTL_MS / default timeout;
@@ -204,6 +352,13 @@ export function resolveConfig(env, options, worktree) {
       o.recall_max_tokens !== undefined
         ? Number(o.recall_max_tokens) || 0
         : intEnv("MEMINI_INJECT_RECALL_MAX_TOK", 0),
+    // Capture bounds: env override, else the built-in default; effectiveConfig
+    // fills in the server's value once a handshake is in hand, but only when
+    // the env var was not explicitly set (see `explicit` below). This plugin
+    // ships standalone (no build step), so it carries its own copy of the
+    // wire keys rather than importing @memini/client.
+    capture_user_max_chars: intEnvFrom(e, "MEMINI_CAPTURE_USER_MAX_CHARS", 1000),
+    capture_assistant_max_chars: intEnvFrom(e, "MEMINI_CAPTURE_ASSISTANT_MAX_CHARS", 3000),
     recall_min_score:
       o.recall_min_score !== undefined
         ? Number(o.recall_min_score) || 0
@@ -214,6 +369,7 @@ export function resolveConfig(env, options, worktree) {
       o.fallback_on_error !== undefined
         ? o.fallback_on_error !== false
         : envBool(e.MEMINI_FALLBACK, true),
+    auto_update: o.auto_update !== undefined ? o.auto_update !== false : envBool(e.MEMINI_AUTO_UPDATE, true),
     // Recorded so effectiveConfig() can tell "explicitly set to the built-in
     // default" apart from "not set at all" — only the latter may be filled in
     // from the server.
@@ -223,6 +379,8 @@ export function resolveConfig(env, options, worktree) {
       recall_limit: o.recall_limit !== undefined || isSet(e.MEMINI_RECALL_LIMIT),
       recall_max_tokens: o.recall_max_tokens !== undefined || isSet(process.env.MEMINI_INJECT_RECALL_MAX_TOK),
       recall_min_score: o.recall_min_score !== undefined || isSet(process.env.MEMINI_INJECT_RECALL_MIN_SCORE),
+      capture_user_max_chars: isSet(e.MEMINI_CAPTURE_USER_MAX_CHARS),
+      capture_assistant_max_chars: isSet(e.MEMINI_CAPTURE_ASSISTANT_MAX_CHARS),
     },
   };
 }
@@ -233,7 +391,8 @@ export function resolveConfig(env, options, worktree) {
 //   namespace: option/env (cfg.namespace_source already "option"/"env") beats
 //     the handshake's resolved namespace beats cfg's own local
 //     worktree/default fallback.
-//   recall/capture/recall_limit/recall_max_tokens/recall_min_score: option
+//   recall/capture/recall_limit/recall_max_tokens/recall_min_score/
+//   capture_user_max_chars/capture_assistant_max_chars: option
 //     beats env (both already baked into cfg, tracked by cfg.explicit) beats
 //     the handshake's `settings` (ClientSettings — api/openapi.yaml) beats
 //     the built-in default already baked into cfg.
@@ -268,6 +427,14 @@ export function effectiveConfig(cfg, hs) {
       explicit.recall_min_score || !Number.isFinite(s.inject_recall_min_score)
         ? cfg.recall_min_score
         : s.inject_recall_min_score,
+    capture_user_max_chars:
+      explicit.capture_user_max_chars || !Number.isFinite(s.capture_user_max_chars)
+        ? cfg.capture_user_max_chars
+        : s.capture_user_max_chars,
+    capture_assistant_max_chars:
+      explicit.capture_assistant_max_chars || !Number.isFinite(s.capture_assistant_max_chars)
+        ? cfg.capture_assistant_max_chars
+        : s.capture_assistant_max_chars,
   };
 }
 
@@ -383,7 +550,17 @@ export function createPlaintextBearerAuthGuard(warn, env) {
  * input and shouldn't crash a hook.
  */
 export function intEnv(name, defaultValue) {
-  const raw = process.env[name];
+  return intEnvFrom(process.env, name, defaultValue);
+}
+
+/**
+ * intEnv against an explicit env bag. resolveConfig and describeSettings are
+ * handed an `env` and read every other value off it; a knob resolved through
+ * intEnv (which closes over process.env) silently ignores that argument, so a
+ * caller inspecting a hypothetical environment gets the ambient one instead.
+ */
+export function intEnvFrom(env, name, defaultValue) {
+  const raw = (env || {})[name];
   if (raw == null || raw === "") return defaultValue;
   const n = Number.parseInt(raw, 10);
   if (!Number.isFinite(n) || n < 0) return defaultValue;
@@ -455,6 +632,44 @@ export function fitByTokens(items, maxTokens) {
   return { items: out, tokens: used, dropped };
 }
 
+/**
+ * Truncate `s` to `max` CHARACTERS for a turn capture, marking the cut. `max <= 0`
+ * captures it whole. Mirrors @memini/client's truncateForCapture — this plugin
+ * ships standalone (no build step), so it carries a copy rather than importing it.
+ *
+ * Distinct from truncate() below, and deliberately so: this one spreads into an
+ * array to iterate by code point, because `slice` indexes UTF-16 code units and
+ * would cut an emoji in half into a lone surrogate — invalid UTF-8 on the wire.
+ * It also treats 0 as uncapped rather than as "".
+ */
+export function truncateForCapture(s, max) {
+  s = String(s);
+  // Anything not a positive finite number means "no cap": 0 (uncapped by
+  // contract), negatives, and also NaN/null/undefined/strings, since a server's
+  // settings value reaches here unvalidated. Failing open (store the text) is
+  // the only safe direction this close to the write.
+  if (typeof max !== "number" || !Number.isFinite(max) || max <= 0) return s;
+  const cap = Math.floor(max);
+  // UTF-16 length >= code-point count, so this proves it fits without counting.
+  if (s.length <= cap) return s;
+  // Walk to the cut rather than spreading the whole string, stepping by code
+  // point so a surrogate pair is never split.
+  let i = 0;
+  for (let n = 0; i < s.length && n < cap; n++) {
+    i += s.codePointAt(i) > 0xffff ? 2 : 1;
+  }
+  if (i >= s.length) return s;
+  return s.slice(0, i) + "\n[...truncated]";
+}
+
+/**
+ * Assemble a captured turn's stored body from its two sides, each under its own
+ * server-resolved bound. 0 on a side captures that side whole.
+ */
+export function buildTurnCapture(userText, assistantText, userMax, assistantMax) {
+  return `${truncateForCapture(userText, userMax)}\n\n${truncateForCapture(assistantText, assistantMax)}`;
+}
+
 /**
  * Truncate to `max` bytes, suffix with a marker. Same shape as the Claude
  * Code plugin's truncate helper.
@@ -1040,6 +1255,46 @@ export const MeminiPlugin = async ({ client, worktree, directory }, options) =>
     }),
 
     event: guard("event", async ({ event }) => {
+      // Auto-update check: fires once per process on the first session.created
+      if (
+        !autoUpdateChecked &&
+        event &&
+        event.type === "session.created" &&
+        !event.properties?.info?.parentID // skip sub-sessions
+      ) {
+        autoUpdateChecked = true;
+        const live = await currentConfig();
+        if (live.auto_update) {
+          // Fire-and-forget — never blocks the event hook
+          (async () => {
+            try {
+              const latest = await fetchLatestVersion();
+              if (!latest) return;
+              if (compareVersions(CLIENT_VERSION, latest) >= 0) return; // already up to date
+              // Only auto-update within the same major version
+              const cur = parseVersion(CLIENT_VERSION);
+              const nxt = parseVersion(latest);
+              if (!cur || !nxt || cur.major !== nxt.major) {
+                log.warn(`auto-update: v${latest} available (major bump — update manually: pin @eleboucher/opencode-memini@${latest} in opencode.json)`);
+                return;
+              }
+              log.warn(`auto-update: updating ${CLIENT_VERSION} → ${latest}`);
+              const installDir = prepareCacheUpdate(latest, log);
+              if (!installDir) return;
+              const ok = runBunInstall(installDir);
+              if (ok) {
+                log.warn(`auto-update: installed v${latest} — restart opencode to apply`);
+              } else {
+                log.warn(`auto-update: bun install failed; will retry next session`);
+              }
+            } catch (err) {
+              log.warn(`auto-update: check failed: ${String(err)}`);
+            }
+          })();
+        }
+        return;
+      }
+
       const live = await currentConfig();
       if (!live.capture || !event || event.type !== "session.idle") return;
       const sessionID = event.properties && event.properties.sessionID;
@@ -1053,7 +1308,7 @@ export const MeminiPlugin = async ({ client, worktree, directory }, options) =>
       const stored = await rest.postJson(
         "/v1/memories",
         {
-          content: `${userText.slice(0, 1000)}\n\n${assistantText.slice(0, 3000)}`,
+          content: buildTurnCapture(userText, assistantText, live.capture_user_max_chars, live.capture_assistant_max_chars),
           tags: ["opencode"],
           metadata,
         },

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@eleboucher/opencode-memini",
-  "version": "0.7.2",
+  "version": "0.7.4",
   "description": "Automatic cross-session memory for opencode via memini — recall before each turn, capture after.",
   "keywords": [
     "memini",