opencode-self-improvement 0.8.11 → 0.8.12

package/README.md

@@ -225,6 +225,10 @@ Opencode installs the package (and its dependencies) automatically with Bun at
 startup. Quit and restart opencode; the plugin loads and `/repo-init` installs
 itself. Nothing else to do.
 
+The plugin runs on the Bun embedded in your opencode build; if that Bun is
+older than 1.3.0 (this repo's tested floor) the plugin says so once at startup
+and memory features may misbehave.
+
 An unpinned entry resolves `@latest` exactly once and is never re-resolved
 afterwards, so updates are deliberate: `opencode plugin update
 opencode-self-improvement`. To install a specific release, append

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "opencode-self-improvement",
-  "version": "0.8.11",
+  "version": "0.8.12",
   "description": "Durable memory for opencode: remember facts, decisions, and commands across sessions, plus a one-command per-repo setup (/repo-init).",
   "main": "index.ts",
   "exports": {
@@ -10,6 +10,9 @@
   "module": "index.ts",
   "type": "module",
   "license": "MIT",
+  "engines": {
+    "bun": ">=1.3.0"
+  },
   "author": "Alex Bogartz",
   "repository": {
     "type": "git",

package/src/index.ts

@@ -68,6 +68,7 @@ import { readLines } from "./logfmt.ts";
 import { buildCapturePrompt, flattenTranscript, parseCandidates, parseModelRef } from "./capture.ts";
 import { redactSecrets } from "./secrets.ts";
 import { flattenMemoryText } from "./sanitize.ts";
+import { bunFloorWarning } from "./runtime.ts";
 
 // Tool/input boundaries are zod schemas (src/schema.ts): the JSON Schema the
 // host sees is GENERATED from them, and raw args are re-parsed at execution.
@@ -130,6 +131,7 @@ interface PluginCtx {
       delivery?: "steer" | "queue";
     }) => Promise<unknown>;
     context?: (input: { sessionID: string }) => Promise<unknown>;
+    get?: (input: { sessionID: string }) => Promise<unknown>;
   };
   event?: {
     subscribe: (o?: { signal?: AbortSignal }) => AsyncIterable<unknown>;
@@ -167,6 +169,10 @@ function resultMeta(result: unknown): Record<string, unknown> {
 
 const PLUGIN_ID = "opencode-self-improvement";
 
+// The setup-time Bun-floor warning fires once per process (setup can run for
+// more than one location).
+let bunFloorChecked = false;
+
 // The real setup implementation, written against the loose local PluginCtx
 // (the only members of the V2 context this plugin actually touches).
 const impl = {
@@ -186,6 +192,15 @@ const impl = {
     const budget = Number(ctx.options?.injectBudget) || injectBudget();
     const openBudget = Number(ctx.options?.frontierBudget) || frontierBudget(budget);
 
+    // Warn-once Bun floor check (same setup-time warning style as the
+    // captureModel warnings below): opencode embeds Bun, and the store code's
+    // fs failure modes are Bun-version dependent, so flag an old host.
+    if (!bunFloorChecked) {
+      bunFloorChecked = true;
+      const floorWarning = bunFloorWarning(typeof Bun === "undefined" ? undefined : Bun.version);
+      if (floorWarning) console.warn(floorWarning);
+    }
+
     // Mirror the /repo-init slash command into opencode's global commands dir
     // (idempotent, write-if-missing). OpenCode 2.x loads `*.md` from
     // ~/.config/opencode/commands, so this is the canonical V2 install path.
@@ -212,8 +227,10 @@ const impl = {
     // Identity-event race backstop: a resumed session's FIRST turn can write
     // before the subscription has delivered its execution.started, and the
     // module-scope fallback is the last setup instance — possibly another
-    // workspace. The session context API is synchronous and its messages
-    // carry location.directory, so bind once from them for unmapped sids.
+    // workspace. Bind once from the session context API for unmapped sids —
+    // but note host 2.1.4 sends message payloads WITHOUT any location field,
+    // so this path is a legacy-shape best-effort; the session-row fallback
+    // below is what actually resolves serve-host sessions.
     // One-shot: never overwrites an event-bound entry.
     const bindingSids = new Set<string>();
     async function bindSessionFromMessages(sid: string | undefined): Promise<void> {
@@ -239,6 +256,37 @@ const impl = {
       }
     }
 
+    // Serve-host reality (recorded on 2.1.4 `serve --service`): the plugin
+    // instance loads AFTER the session was created, so `session.created` — the
+    // only event carrying a location — is never delivered; `execution.started`
+    // arrives with just {sessionID}. The session ROW is the remaining source
+    // of truth: the host's session get returns `location.directory`. One
+    // lookup per session; a miss is remembered so a host without the API is
+    // not re-asked on every turn (bounded LRU, same cap as the scope cache).
+    const apiBindTried = new Set<string>();
+    const apiBindOrder = new SessionLru(SESSION_CAP, (evicted) => apiBindTried.delete(evicted));
+    async function bindSessionFromApi(sid: string | undefined): Promise<void> {
+      if (!sid || sid === "?" || sessionDir(sid) || apiBindTried.has(sid)) return;
+      apiBindTried.add(sid);
+      apiBindOrder.touch(sid);
+      try {
+        const got = (await ctx.session?.get?.({ sessionID: sid })) as Record<string, any> | undefined;
+        const row = (got?.data ?? got) as Record<string, any> | undefined;
+        const dir = row?.location?.directory ?? row?.directory;
+        if (typeof dir === "string" && dir) rememberSessionDir(sid, dir);
+      } catch {
+        // no session.get on this host (or unknown session): stay unbound
+      }
+    }
+
+    // Identity must resolve BEFORE a row is stamped or a read is partitioned:
+    // try the (legacy) message payloads, then the session row.
+    async function bindSessionIdentity(sid: string | undefined): Promise<void> {
+      if (!sid || sid === "?" || sessionDir(sid)) return;
+      await bindSessionFromMessages(sid);
+      if (!sessionDir(sid)) await bindSessionFromApi(sid);
+    }
+
     // ---- tools --------------------------------------------------------------
     await ctx.tool?.transform((editor) => {
       const direct = { codemode: false } as const;
@@ -258,7 +306,7 @@ const impl = {
             status: args.status,
             repo: args.global ? "global" : undefined,
           };
-          await bindSessionFromMessages(getCurrent().sid);
+          await bindSessionIdentity(getCurrent().sid);
           const outcome = await runWriteGate(candidate, gateContext());
           if (outcome.action === "promoted") return { content: `Remembered: ${args.type} in ${args.scope}` };
           if (outcome.action === "collapsed") return { content: `Duplicate ignored: ${args.type}/${args.scope}` };
@@ -276,7 +324,7 @@ const impl = {
           "Initialize repository memory and knowledge graph. Ensures the codebase-memory graph for this repo is indexed (one-shot `cli` spawn; no session MCP needed) and re-derives build/lint/test/typecheck command memories through the write gate, then stores an init stamp keyed on git HEAD. Idempotent: a no-op when the stamp matches HEAD, unless force=true (refresh after a refactor).",
         options: direct,
         async execute(args): Promise<{ content: string }> {
-          await bindSessionFromMessages(getCurrent().sid);
+          await bindSessionIdentity(getCurrent().sid);
           const summary = await runInit({ liveRoot: gateContext().liveRoot, force: args.force, mode: args.mode });
           return { content: formatInit(summary) };
         },
@@ -323,7 +371,7 @@ const impl = {
           "Update an existing memory (gated like remember; the prior entry is superseded, not erased). `query` selects which row to update: its exact id (ts), a clock fragment (e.g. HH:MM:SS.mmm), or a unique substring of its content. Omitting `query` targets the most recent active row of scope+type. An unmatched or ambiguous `query` fails closed and writes nothing.",
         options: direct,
         async execute(args): Promise<{ content: string }> {
-          await bindSessionFromMessages(getCurrent().sid);
+          await bindSessionIdentity(getCurrent().sid);
           const prior = (await loadAll()).filter(
             (m) => m.scope === args.scope && m.type === args.type && isActive(m) && isVisibleHere(m),
           );
@@ -794,7 +842,7 @@ const impl = {
           sessions.touch(sid);
           markTurn(sid);
           await checkNewSession(sid);
-          await bindSessionFromMessages(sid);
+          await bindSessionIdentity(sid);
           latestPrompt.set(sid, event?.prompt?.text ?? "");
           await refreshEpoch(sid);
         }
@@ -850,6 +898,9 @@ const impl = {
               const dir =
                 info.location?.directory ?? d.location?.directory ?? ev.location?.directory ?? info.directory;
               if (typeof sid === "string" && typeof dir === "string") rememberSessionDir(sid, dir);
+              // 2.1.4 serve sends execution.started with no location at all:
+              // resolve the session row instead of leaving the session unbound.
+              else if (typeof sid === "string") void guarded("session bind (api)", () => bindSessionFromApi(sid));
               continue;
             }
             if (ev?.type !== "message.updated") continue;

package/src/runtime.ts

@@ -0,0 +1,40 @@
+// Bun version floor. The plugin runs inside opencode, whose v2 compiled
+// binaries embed Bun (upstream builds with BUN_COMPILE_RELEASE=bun-v1.4.4;
+// older v2 builds embed older bun). The store code's filesystem calls have
+// version-divergent failure modes — e.g. DirHandle.close() behaves differently
+// on some Bun+Windows combos — so an old host shows up as odd memory errors,
+// not as a clean "unsupported" signal. MIN_BUN is the lower bound of the Bun
+// versions this repo has actually been run against: 1.3.10 and 1.4.4. Pure
+// module: nothing here reads the environment; the caller (src/index.ts)
+// injects the version string, so these helpers are unit-testable anywhere.
+
+export const MIN_BUN: readonly [number, number, number] = [1, 3, 0];
+
+// Pulls the first x.y.z triple out of a version string: "1.4.4",
+// "v1.4.4-canary" and "bun-v1.4.4" all parse; junk or a partial version
+// (no patch component) yields null. Never throws.
+export function parseBunVersion(raw: string): [number, number, number] | null {
+  const m = /v?(\d+)\.(\d+)\.(\d+)/.exec(raw);
+  if (!m) return null;
+  return [Number(m[1]), Number(m[2]), Number(m[3])];
+}
+
+// Numeric (not lexical) triple compare: 1.10.0 > 1.3.0.
+function cmpTriples(a: readonly number[], b: readonly number[]): number {
+  return a[0] - b[0] || a[1] - b[1] || a[2] - b[2];
+}
+
+// One-line startup warning when the host's Bun is below MIN_BUN or its version
+// could not be parsed; null when the version looks fine. Warn-only by design:
+// an old embedded bun should be visible, but must not stop memory from
+// loading. The caller decides how often to emit it (src/index.ts: once).
+export function bunFloorWarning(versionString: string | undefined): string | null {
+  const floor = MIN_BUN.join(".");
+  const seen = typeof versionString === "string" ? parseBunVersion(versionString) : null;
+  if (seen) {
+    if (cmpTriples(seen, MIN_BUN) >= 0) return null;
+    return `[opencode-self-improvement] Bun ${seen.join(".")} is below the supported minimum ${floor}; memory features may misbehave.`;
+  }
+  const shown = versionString === undefined ? "unknown" : JSON.stringify(versionString);
+  return `[opencode-self-improvement] Bun version ${shown} is unrecognized (supported minimum ${floor}); memory features may misbehave.`;
+}