opencode-claude-memory 1.7.7 → 2.0.0

package/dist/util/ownedSessions.d.ts

@@ -0,0 +1,7 @@
+export declare class OwnedSessions {
+    private readonly timers;
+    add(id: string): void;
+    has(id: string | undefined): boolean;
+    release(id: string, graceMs: number): void;
+    dispose(): void;
+}

package/dist/util/ownedSessions.js

@@ -0,0 +1,39 @@
+// Registry of sub-sessions the plugin created itself (recall selectors, extraction and auto-dream
+// forks). Their events and transforms must be ignored, otherwise a fork's own `session.idle` would
+// trigger another extraction of the fork, and the recall hooks would inject memory into the selector.
+//
+// A fork's `session.idle` can arrive after its `session.delete` HTTP call resolved, so ownership is
+// released with a grace period; `session.deleted` shortens that to a few seconds.
+export class OwnedSessions {
+    timers = new Map();
+    add(id) {
+        const existing = this.timers.get(id);
+        if (existing)
+            clearTimeout(existing);
+        this.timers.set(id, undefined);
+    }
+    has(id) {
+        return id !== undefined && this.timers.has(id);
+    }
+    release(id, graceMs) {
+        if (!this.timers.has(id))
+            return;
+        const existing = this.timers.get(id);
+        if (existing)
+            clearTimeout(existing);
+        if (graceMs <= 0) {
+            this.timers.delete(id);
+            return;
+        }
+        const timer = setTimeout(() => this.timers.delete(id), graceMs);
+        timer.unref?.();
+        this.timers.set(id, timer);
+    }
+    dispose() {
+        for (const timer of this.timers.values()) {
+            if (timer)
+                clearTimeout(timer);
+        }
+        this.timers.clear();
+    }
+}

package/dist/util/timeout.d.ts

@@ -0,0 +1,5 @@
+export declare class TimeoutError extends Error {
+    constructor(what: string, timeoutMs: number);
+}
+export declare function withTimeout<T>(promise: Promise<T>, timeoutMs: number, error: () => Error): Promise<T>;
+export declare function withDeadline<T>(what: string, timeoutMs: number, call: (signal: AbortSignal) => Promise<T>): Promise<T>;

package/dist/util/timeout.js

@@ -0,0 +1,39 @@
+// Bounded waits for SDK calls. The plugin SDK client disables fetch timeouts, so every request
+// the plugin makes must carry its own deadline; the AbortSignal is passed to the request so a hung
+// connection is actually torn down instead of leaking.
+export class TimeoutError extends Error {
+    constructor(what, timeoutMs) {
+        super(`${what} timed out after ${timeoutMs}ms`);
+        this.name = "TimeoutError";
+    }
+}
+// The deadline timer is deliberately *not* unref'd: it is cleared as soon as the call settles, and
+// an unref'd timer is the only thing that has to fire when a request hangs. On Windows, Bun's event
+// loop does not wake up for unref'd timers while nothing else is pending (observed on CI), so an
+// unref'd deadline would never expire exactly when it is needed.
+export function withTimeout(promise, timeoutMs, error) {
+    let timer;
+    const timeout = new Promise((_, reject) => {
+        timer = setTimeout(() => reject(error()), timeoutMs);
+    });
+    return Promise.race([promise, timeout]).finally(() => {
+        if (timer)
+            clearTimeout(timer);
+    });
+}
+// Runs `call` with a fresh AbortSignal that fires when the deadline passes. The SDK request
+// options extend `RequestInit`, so the signal cancels the underlying fetch.
+export function withDeadline(what, timeoutMs, call) {
+    const controller = new AbortController();
+    let invoked;
+    try {
+        invoked = Promise.resolve(call(controller.signal));
+    }
+    catch (error) {
+        return Promise.reject(error);
+    }
+    return withTimeout(invoked, timeoutMs, () => {
+        controller.abort();
+        return new TimeoutError(what, timeoutMs);
+    });
+}

package/package.json

@@ -1,13 +1,10 @@
 {
   "name": "opencode-claude-memory",
-  "version": "1.7.7",
+  "version": "2.0.0",
   "type": "module",
-  "description": "OpenCode plugin for Claude Code memory: persistent, local-first shared memory with Claude Code-compatible Markdown files, auto extraction, and auto-dream",
+  "description": "OpenCode plugin for Claude Code memory: persistent, local-first shared memory with Claude Code-compatible Markdown files, LLM recall, in-process auto extraction, and auto-dream consolidation",
   "main": "dist/index.js",
   "types": "dist/index.d.ts",
-  "bin": {
-    "opencode-memory": "./bin/opencode-memory"
-  },
   "exports": {
     ".": {
       "types": "./dist/index.d.ts",
@@ -18,8 +15,16 @@
   "files": [
     "dist"
   ],
+  "engines": {
+    "opencode": ">=1.18.0"
+  },
   "scripts": {
-    "build": "tsc -p tsconfig.json",
+    "build": "tsc -p tsconfig.build.json",
+    "typecheck": "tsc -p tsconfig.json --noEmit",
+    "lint": "biome ci .",
+    "format": "biome check --write .",
+    "test": "bun test",
+    "evals": "bun run test/evals/run.ts",
     "prepack": "npm run build"
   },
   "repository": {
@@ -53,14 +58,16 @@
   ],
   "license": "MIT",
   "peerDependencies": {
-    "@opencode-ai/plugin": "*"
+    "@opencode-ai/plugin": ">=1.18.0"
   },
   "dependencies": {
     "zod": "^3.24.0"
   },
   "devDependencies": {
+    "@biomejs/biome": "^2",
+    "@opencode-ai/plugin": "^1.18.16",
     "bun-types": "^1.3.11",
-    "@opencode-ai/plugin": "^1.3.10",
+    "conventional-changelog-conventionalcommits": "^9",
     "typescript": "^6.0.2"
   }
 }