@eleboucher/opencode-memini 0.7.8 → 0.7.10

package/memini.js

@@ -55,11 +55,16 @@ 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.
+// only) so the running copy stays current. opencode installs each plugin spec
+// into its own isolated wrapper directory under
+// ~/.cache/opencode/packages/<spec>/ (e.g. .../opencode-memini@latest/) — the
+// wrapper holds a package.json listing the plugin as a dependency plus a
+// node_modules/ tree — so the wrapper dir is where we rewrite the pin and
+// re-run npm install.
 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;
+const INSTALL_TIMEOUT_MS = 60000;
 let autoUpdateChecked = false;
 
 /**
@@ -87,23 +92,45 @@ export function compareVersions(a, b) {
 }
 
 /**
- * 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.
+ * resolveInstallContextFrom walks up from `startPath` looking for the opencode
+ * plugin cache wrapper dir: the first ancestor whose child is a `node_modules`
+ * directory AND that also has a `package.json` sibling. Returns
+ * { installDir, packageJsonPath } or null. Pure (no `import.meta.url` read) so
+ * it can be driven from a synthetic on-disk layout in tests. Exported for
+ * testing.
  */
-function resolveInstallContext() {
+export function resolveInstallContextFrom(startPath) {
   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 };
+    let dir = startPath;
+    for (let i = 0; i < 20; i++) {
+      const nodeModules = join(dir, "node_modules");
+      if (existsSync(nodeModules) && statSync(nodeModules).isDirectory()) {
+        const packageJsonPath = join(dir, "package.json");
+        if (existsSync(packageJsonPath)) {
+          return { installDir: dir, packageJsonPath };
+        }
+        return null; // node_modules found but no package.json — not a wrapper
+      }
+      const parent = dirname(dir);
+      if (parent === dir) break; // reached root
+      dir = parent;
     }
   } catch {}
   return null;
 }
 
+/**
+ * resolveInstallContext finds the opencode plugin cache wrapper directory
+ * holding this running plugin instance, by walking up from import.meta.url.
+ * Exported for testing.
+ */
+export function resolveInstallContext() {
+  try {
+    return resolveInstallContextFrom(dirname(fileURLToPath(import.meta.url)));
+  } catch {}
+  return null;
+}
+
 /**
  * fetchLatestVersion queries npm dist-tags with a timeout. Returns the version
  * string or null on failure.
@@ -129,14 +156,21 @@ async function fetchLatestVersion() {
 }
 
 /**
- * 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.
+ * prepareCacheUpdate rewrites the wrapper package.json to pin the new version,
+ * removes the installed node_modules package, and cleans any lockfile so the
+ * next install re-fetches. Returns the installDir on success, null on failure.
+ *
+ * `ctx` is optional: when omitted, resolves from `import.meta.url` (the live
+ * path); tests pass a synthetic { installDir, packageJsonPath } so the full
+ * rewrite-and-clean flow can be exercised against a temp dir without touching
+ * the dev checkout. Exported for testing.
  */
-function prepareCacheUpdate(newVersion, log) {
-  const ctx = resolveInstallContext();
+export function prepareCacheUpdate(newVersion, log, ctx) {
+  if (!ctx) {
+    ctx = resolveInstallContext();
+  }
   if (!ctx) {
-    log.warn("auto-update: could not resolve install context");
+    log.error("auto-update: could not resolve install context");
     return null;
   }
   // Rewrite package.json with the new version pin
@@ -148,50 +182,44 @@ function prepareCacheUpdate(newVersion, log) {
     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)}`);
+    log.error(`auto-update: failed to rewrite cache package.json: ${String(err)}`);
     return null;
   }
-  // Remove installed node_modules so bun install re-fetches
+  // Remove installed node_modules so the 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)}`);
+    log.error(`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)) {
+  // Clean lockfiles: opencode's installer may write either package-lock.json
+  // (npm/arborist) or bun.lock depending on the bundler. Remove both if
+  // present; the install regenerates them.
+  for (const lockName of ["package-lock.json", "bun.lock"]) {
+    const lockPath = join(ctx.installDir, lockName);
+    if (!existsSync(lockPath)) continue;
     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));
+      rmSync(lockPath, { force: true });
     } catch {
-      // bun.lock format varies; if we can't parse it, leave it — bun install
-      // will reconcile.
+      // A lock we can't remove isn't fatal — npm install reconciles it.
     }
   }
   return ctx.installDir;
 }
 
 /**
- * runBunInstall runs `bun install` in the given directory with a timeout.
- * Returns true on success (exit code 0), false otherwise.
+ * runNpmInstall runs `npm install` in the given directory with a timeout.
+ * Returns true on success (exit code 0), false otherwise. opencode uses
+ * @npmcli/arborist under the hood, so `npm install` matches the lockfile
+ * format it produces; `bun install` would rewrite it. Exported for testing.
  */
-function runBunInstall(installDir) {
+export function runNpmInstall(installDir) {
   try {
-    const result = spawnSync(process.execPath, ["install"], {
+    const result = spawnSync("npm", ["install"], {
       cwd: installDir,
       stdio: ["ignore", "pipe", "pipe"],
-      timeout: BUN_INSTALL_TIMEOUT_MS,
+      timeout: INSTALL_TIMEOUT_MS,
     });
     return result.status === 0;
   } catch {
@@ -1098,15 +1126,42 @@ export function lastAssistantFailed(messages) {
 }
 
 export const MeminiPlugin = async ({ client, worktree, directory }, options) => {
+  // Structured logger is primary; console.error is the fallback when it
+  // throws (absent client.app.log). Direct call so a missing app.log reaches
+  // the catch. Symbols match oh-my-opencode-slim: [ok]/[x]/[!]/[i].
+  const GREEN = "\x1b[32m";
+  const RED = "\x1b[31m";
+  const YELLOW = "\x1b[33m";
+  const BLUE = "\x1b[34m";
+  const RESET = "\x1b[0m";
   const log = {
+    error: (message) => {
+      try {
+        client.app.log({ body: { service: "memini", level: "error", message } });
+      } catch {
+        console.error(`${RED}[x]${RESET} [memini] ${message}`);
+      }
+    },
     warn: (message) => {
-      // client.app.log is opencode's structured logger; fall back to stderr.
       try {
-        client?.app?.log?.({ body: { service: "memini", level: "warn", message } });
+        client.app.log({ body: { service: "memini", level: "warn", message } });
+      } catch {
+        console.error(`${YELLOW}[!]${RESET} [memini] ${message}`);
+      }
+    },
+    info: (message) => {
+      try {
+        client.app.log({ body: { service: "memini", level: "info", message } });
+      } catch {
+        console.error(`${BLUE}[i]${RESET} [memini] ${message}`);
+      }
+    },
+    success: (message) => {
+      try {
+        client.app.log({ body: { service: "memini", level: "info", message } });
       } catch {
-        /* ignore logging failures */
+        console.error(`${GREEN}[ok]${RESET} [memini] ${message}`);
       }
-      console.error(`[memini] ${message}`);
     },
   };
 
@@ -1212,7 +1267,7 @@ export const MeminiPlugin = async ({ client, worktree, directory }, options) =>
       excludeIds: serverExcludeIds ? excludeIds : [],
       onExcludeIdsUnsupported: () => {
         serverExcludeIds = false;
-        log.warn("memini: server does not accept exclude_ids; using client-side dedupe only");
+        log.info("memini: server does not accept exclude_ids; using client-side dedupe only");
       },
     });
 
@@ -1223,7 +1278,7 @@ export const MeminiPlugin = async ({ client, worktree, directory }, options) =>
     try {
       return await fn(...args);
     } catch (error) {
-      log.warn(`${name} hook failed: ${String(error)}`);
+      log.error(`${name} hook failed: ${String(error)}`);
     }
   };
 
@@ -1342,7 +1397,7 @@ export const MeminiPlugin = async ({ client, worktree, directory }, options) =>
         result = await Promise.race([settled, budget]);
         clearTimeout(timer);
         if (result === BUDGET_EXPIRED) {
-          log.warn(
+          log.info(
             `recall exceeded its ${live.recall_budget_ms}ms budget; late results will inject next turn`,
           );
           if (sessionID) {
@@ -1447,20 +1502,20 @@ export const MeminiPlugin = async ({ client, worktree, directory }, options) =>
               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)`);
+                log.info(`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}`);
+              log.info(`auto-update: updating ${CLIENT_VERSION} → ${latest}`);
               const installDir = prepareCacheUpdate(latest, log);
               if (!installDir) return;
-              const ok = runBunInstall(installDir);
+              const ok = runNpmInstall(installDir);
               if (ok) {
-                log.warn(`auto-update: installed v${latest} — restart opencode to apply`);
+                log.success(`auto-update: installed v${latest} — restart opencode to apply`);
               } else {
-                log.warn(`auto-update: bun install failed; will retry next session`);
+                log.error(`auto-update: npm install failed; will retry next session`);
               }
             } catch (err) {
-              log.warn(`auto-update: check failed: ${String(err)}`);
+              log.error(`auto-update: check failed: ${String(err)}`);
             }
           })();
         }

package/package.json

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