dsh-tdai-memory 0.2.13 → 0.3.0

package/vendor/tdai/utils/serial-queue.js

@@ -1,103 +1,103 @@
-/**
- * SerialQueue: a lightweight task queue with concurrency=1.
- *
- * Equivalent to `new PQueue({ concurrency: 1 })` but with zero external
- * dependencies. Supports:
- * - Serial execution (FIFO)
- * - `add(fn)` to enqueue a task (returns the task's result promise)
- * - `onIdle()` to wait until all queued tasks have completed
- * - `pause()` / `start()` to suspend/resume execution
- * - `size` to check pending task count
- * - Optional debug logger for enqueue/dequeue/complete diagnostics
- */
-export class SerialQueue {
-    /** Human-readable name for logging / diagnostics. */
-    name;
-    queue = [];
-    running = false;
-    paused = false;
-    idleResolvers = [];
-    /** Optional debug logger — receives diagnostic messages for enqueue/dequeue/complete. */
-    debugFn;
-    constructor(name = "unnamed") {
-        this.name = name;
-    }
-    /** Set a debug logger for queue diagnostics. */
-    setDebugLogger(fn) {
-        this.debugFn = fn;
-    }
-    /** Number of tasks waiting to be executed. */
-    get size() {
-        return this.queue.length;
-    }
-    /** Whether a task is currently executing. */
-    get pending() {
-        return this.running;
-    }
-    /** Whether the queue is idle (no queued tasks and nothing running). */
-    get idle() {
-        return this.queue.length === 0 && !this.running;
-    }
-    /** Add a task to the queue. Returns the task's result promise. */
-    add(task) {
-        return new Promise((resolve, reject) => {
-            this.queue.push({
-                task: task,
-                resolve: resolve,
-                reject,
-            });
-            this.debugFn?.(`[queue:${this.name}] enqueued, pending=${this.queue.length}, running=${this.running}`);
-            this.drain();
-        });
-    }
-    /** Pause the queue. Currently running task will finish, but no new tasks start. */
-    pause() {
-        this.paused = true;
-    }
-    /** Resume the queue after pause(). */
-    start() {
-        this.paused = false;
-        this.drain();
-    }
-    /** Returns a promise that resolves when all queued tasks have completed. */
-    onIdle() {
-        if (this.queue.length === 0 && !this.running) {
-            return Promise.resolve();
-        }
-        return new Promise((resolve) => {
-            this.idleResolvers.push(resolve);
-        });
-    }
-    /** Clear all pending (not yet started) tasks. */
-    clear() {
-        for (const entry of this.queue) {
-            entry.reject(new Error("Queue cleared"));
-        }
-        this.queue = [];
-    }
-    drain() {
-        if (this.running || this.paused || this.queue.length === 0)
-            return;
-        const entry = this.queue.shift();
-        this.running = true;
-        this.debugFn?.(`[queue:${this.name}] dequeued, starting execution (remaining=${this.queue.length})`);
-        entry
-            .task()
-            .then((result) => entry.resolve(result))
-            .catch((err) => entry.reject(err))
-            .finally(() => {
-            this.running = false;
-            this.debugFn?.(`[queue:${this.name}] task completed (remaining=${this.queue.length})`);
-            if (this.queue.length === 0) {
-                // Notify idle waiters
-                const resolvers = this.idleResolvers;
-                this.idleResolvers = [];
-                for (const resolve of resolvers)
-                    resolve();
-            }
-            else {
-                this.drain();
-            }
-        });
-    }
-}
+/**
+ * SerialQueue: a lightweight task queue with concurrency=1.
+ *
+ * Equivalent to `new PQueue({ concurrency: 1 })` but with zero external
+ * dependencies. Supports:
+ * - Serial execution (FIFO)
+ * - `add(fn)` to enqueue a task (returns the task's result promise)
+ * - `onIdle()` to wait until all queued tasks have completed
+ * - `pause()` / `start()` to suspend/resume execution
+ * - `size` to check pending task count
+ * - Optional debug logger for enqueue/dequeue/complete diagnostics
+ */
+export class SerialQueue {
+    /** Human-readable name for logging / diagnostics. */
+    name;
+    queue = [];
+    running = false;
+    paused = false;
+    idleResolvers = [];
+    /** Optional debug logger — receives diagnostic messages for enqueue/dequeue/complete. */
+    debugFn;
+    constructor(name = "unnamed") {
+        this.name = name;
+    }
+    /** Set a debug logger for queue diagnostics. */
+    setDebugLogger(fn) {
+        this.debugFn = fn;
+    }
+    /** Number of tasks waiting to be executed. */
+    get size() {
+        return this.queue.length;
+    }
+    /** Whether a task is currently executing. */
+    get pending() {
+        return this.running;
+    }
+    /** Whether the queue is idle (no queued tasks and nothing running). */
+    get idle() {
+        return this.queue.length === 0 && !this.running;
+    }
+    /** Add a task to the queue. Returns the task's result promise. */
+    add(task) {
+        return new Promise((resolve, reject) => {
+            this.queue.push({
+                task: task,
+                resolve: resolve,
+                reject,
+            });
+            this.debugFn?.(`[queue:${this.name}] enqueued, pending=${this.queue.length}, running=${this.running}`);
+            this.drain();
+        });
+    }
+    /** Pause the queue. Currently running task will finish, but no new tasks start. */
+    pause() {
+        this.paused = true;
+    }
+    /** Resume the queue after pause(). */
+    start() {
+        this.paused = false;
+        this.drain();
+    }
+    /** Returns a promise that resolves when all queued tasks have completed. */
+    onIdle() {
+        if (this.queue.length === 0 && !this.running) {
+            return Promise.resolve();
+        }
+        return new Promise((resolve) => {
+            this.idleResolvers.push(resolve);
+        });
+    }
+    /** Clear all pending (not yet started) tasks. */
+    clear() {
+        for (const entry of this.queue) {
+            entry.reject(new Error("Queue cleared"));
+        }
+        this.queue = [];
+    }
+    drain() {
+        if (this.running || this.paused || this.queue.length === 0)
+            return;
+        const entry = this.queue.shift();
+        this.running = true;
+        this.debugFn?.(`[queue:${this.name}] dequeued, starting execution (remaining=${this.queue.length})`);
+        entry
+            .task()
+            .then((result) => entry.resolve(result))
+            .catch((err) => entry.reject(err))
+            .finally(() => {
+            this.running = false;
+            this.debugFn?.(`[queue:${this.name}] task completed (remaining=${this.queue.length})`);
+            if (this.queue.length === 0) {
+                // Notify idle waiters
+                const resolvers = this.idleResolvers;
+                this.idleResolvers = [];
+                for (const resolve of resolvers)
+                    resolve();
+            }
+            else {
+                this.drain();
+            }
+        });
+    }
+}

package/vendor/tdai/utils/session-filter.js

@@ -1,88 +1,88 @@
-/**
- * Session filtering for memory-tdai.
- *
- * Decides whether a session should be ignored by the memory plugin
- * (capture, recall, pipeline scheduling). All skip rules are compiled
- * into a flat list of matchers at construction time — zero per-call overhead.
- */
-// ============================
-// Non-interactive trigger detection
-// ============================
-const SKIP_TRIGGERS = new Set(["cron", "heartbeat", "automation", "schedule"]);
-/**
- * Returns true when the hook was fired by a non-interactive trigger
- * (heartbeat, cron job, automation, etc.) — these produce no meaningful
- * user conversation and should not be captured or counted.
- */
-export function isNonInteractiveTrigger(trigger, sessionKey) {
-    if (trigger && SKIP_TRIGGERS.has(trigger.toLowerCase()))
-        return true;
-    if (sessionKey) {
-        if (/:cron:/i.test(sessionKey) || /:heartbeat:/i.test(sessionKey))
-            return true;
-    }
-    return false;
-}
-// ============================
-// Built-in skip rules (always active)
-// ============================
-/**
- * Hard-coded matchers that identify internal / non-user sessions.
- * These are always applied regardless of user configuration.
- */
-const BUILTIN_MATCHERS = [
-    // Scene extraction runner sessions
-    (key) => key.includes(":memory-scene-extract-"),
-    // OpenClaw subagent sessions
-    (key) => key.includes(":subagent:"),
-    // Temporary / internal utility sessions (e.g. temp:slug-generator)
-    (key) => key.startsWith("temp:"),
-];
-// ============================
-// Glob → matcher compiler
-// ============================
-/**
- * Turn a simple glob pattern (only `*` supported) into a matcher
- * that tests the full sessionKey.
- *
- * Since sessionKeys look like `agent:<agentId>:...`, we match the
- * glob against the whole key so users can write patterns like
- * `bench-judge-*` (matched anywhere) or more specific ones.
- */
-function globToMatcher(pattern) {
-    const escaped = pattern.replace(/[.+^${}()|[\]\\]/g, "\\$&").replace(/\*/g, ".*");
-    const re = new RegExp(escaped);
-    return (key) => re.test(key);
-}
-// ============================
-// SessionFilter
-// ============================
-/**
- * Unified filter: construct once at plugin startup, then call
- * `shouldSkip(sessionKey)` or `shouldSkipCtx(ctx)` at each gate.
- */
-export class SessionFilter {
-    matchers;
-    constructor(excludeAgents = []) {
-        // Merge built-in rules + user-configured exclude patterns into one flat list
-        const userMatchers = excludeAgents
-            .map((p) => p.trim())
-            .filter((p) => p.length > 0)
-            .map(globToMatcher);
-        this.matchers = [...BUILTIN_MATCHERS, ...userMatchers];
-    }
-    /** Should this sessionKey be skipped? */
-    shouldSkip(sessionKey) {
-        return this.matchers.some((m) => m(sessionKey));
-    }
-    /** Should this hook context be skipped? */
-    shouldSkipCtx(ctx) {
-        if (!ctx.sessionKey)
-            return true;
-        if (ctx.sessionId?.startsWith("memory-"))
-            return true;
-        if (isNonInteractiveTrigger(ctx.trigger, ctx.sessionKey))
-            return true;
-        return this.shouldSkip(ctx.sessionKey);
-    }
-}
+/**
+ * Session filtering for memory-tdai.
+ *
+ * Decides whether a session should be ignored by the memory plugin
+ * (capture, recall, pipeline scheduling). All skip rules are compiled
+ * into a flat list of matchers at construction time — zero per-call overhead.
+ */
+// ============================
+// Non-interactive trigger detection
+// ============================
+const SKIP_TRIGGERS = new Set(["cron", "heartbeat", "automation", "schedule"]);
+/**
+ * Returns true when the hook was fired by a non-interactive trigger
+ * (heartbeat, cron job, automation, etc.) — these produce no meaningful
+ * user conversation and should not be captured or counted.
+ */
+export function isNonInteractiveTrigger(trigger, sessionKey) {
+    if (trigger && SKIP_TRIGGERS.has(trigger.toLowerCase()))
+        return true;
+    if (sessionKey) {
+        if (/:cron:/i.test(sessionKey) || /:heartbeat:/i.test(sessionKey))
+            return true;
+    }
+    return false;
+}
+// ============================
+// Built-in skip rules (always active)
+// ============================
+/**
+ * Hard-coded matchers that identify internal / non-user sessions.
+ * These are always applied regardless of user configuration.
+ */
+const BUILTIN_MATCHERS = [
+    // Scene extraction runner sessions
+    (key) => key.includes(":memory-scene-extract-"),
+    // OpenClaw subagent sessions
+    (key) => key.includes(":subagent:"),
+    // Temporary / internal utility sessions (e.g. temp:slug-generator)
+    (key) => key.startsWith("temp:"),
+];
+// ============================
+// Glob → matcher compiler
+// ============================
+/**
+ * Turn a simple glob pattern (only `*` supported) into a matcher
+ * that tests the full sessionKey.
+ *
+ * Since sessionKeys look like `agent:<agentId>:...`, we match the
+ * glob against the whole key so users can write patterns like
+ * `bench-judge-*` (matched anywhere) or more specific ones.
+ */
+function globToMatcher(pattern) {
+    const escaped = pattern.replace(/[.+^${}()|[\]\\]/g, "\\$&").replace(/\*/g, ".*");
+    const re = new RegExp(escaped);
+    return (key) => re.test(key);
+}
+// ============================
+// SessionFilter
+// ============================
+/**
+ * Unified filter: construct once at plugin startup, then call
+ * `shouldSkip(sessionKey)` or `shouldSkipCtx(ctx)` at each gate.
+ */
+export class SessionFilter {
+    matchers;
+    constructor(excludeAgents = []) {
+        // Merge built-in rules + user-configured exclude patterns into one flat list
+        const userMatchers = excludeAgents
+            .map((p) => p.trim())
+            .filter((p) => p.length > 0)
+            .map(globToMatcher);
+        this.matchers = [...BUILTIN_MATCHERS, ...userMatchers];
+    }
+    /** Should this sessionKey be skipped? */
+    shouldSkip(sessionKey) {
+        return this.matchers.some((m) => m(sessionKey));
+    }
+    /** Should this hook context be skipped? */
+    shouldSkipCtx(ctx) {
+        if (!ctx.sessionKey)
+            return true;
+        if (ctx.sessionId?.startsWith("memory-"))
+            return true;
+        if (isNonInteractiveTrigger(ctx.trigger, ctx.sessionKey))
+            return true;
+        return this.shouldSkip(ctx.sessionKey);
+    }
+}

package/vendor/tdai/utils/session-header-fetch.js

@@ -0,0 +1,88 @@
+/**
+ * Fetch wrapper that injects a stable session-id header (`x-opencode-session`)
+ * into outgoing LLM requests.
+ *
+ * OpenCode Go (and other OpenAI-compatible gateways) require every request to
+ * carry a stable per-conversation id; requests without it started erroring
+ * after 2026-09-06. The value is:
+ *
+ *   1. An explicit configured `sessionId`, when set;
+ *   2. Otherwise a persistent per-instance random id. The id is generated once
+ *      and stored under the TDAI data dir (`<dataDir>/session-id`), so it
+ *      survives restarts — one stable id per plugin instance, which is exactly
+ *      what the gateway asks for when the client has no real conversation.
+ *
+ * Embedding and other non-chat traffic still gets the header (harmless, and
+ * gateways may require it on every request). When disabled, returns
+ * `globalThis.fetch` unchanged.
+ */
+import { randomUUID } from "node:crypto";
+import { join } from "node:path";
+import { mkdir, readFile, writeFile } from "node:fs/promises";
+
+const SESSION_ID_FILE = "session-id";
+
+let cachedId = "";
+/** Load-or-create a persistent per-instance session id under `dataDir`. */
+export async function resolvePersistentSessionId(dataDir) {
+    if (cachedId)
+        return cachedId;
+    if (!dataDir) {
+        cachedId = `tdai-memory-${randomUUID()}`;
+        return cachedId;
+    }
+    try {
+        const file = join(dataDir, SESSION_ID_FILE);
+        const existing = await readFile(file, "utf8").catch(() => "");
+        const trimmed = existing.trim();
+        if (trimmed) {
+            cachedId = trimmed;
+            return cachedId;
+        }
+        const fresh = `tdai-memory-${randomUUID()}`;
+        await mkdir(dataDir, { recursive: true });
+        await writeFile(file, fresh, "utf8");
+        cachedId = fresh;
+        return cachedId;
+    }
+    catch {
+        // Any persistence failure degrades to a per-process id.
+        cachedId = `tdai-memory-${randomUUID()}`;
+        return cachedId;
+    }
+}
+
+/**
+ * Build a session-id header value for a request.
+ * @param {object} opts { send, headerName, sessionId, persistentId }
+ * @returns {Record<string,string>|undefined} header object, or undefined when disabled.
+ */
+export function sessionHeaderOf({ send, headerName, sessionId, persistentId }) {
+    if (send === false)
+        return undefined;
+    const id = (sessionId && String(sessionId).trim()) || persistentId || "";
+    if (!id)
+        return undefined;
+    return { [headerName || "x-opencode-session"]: id };
+}
+
+/**
+ * Create a fetch wrapper that injects the session-id header into every request.
+ * @param {object} opts { send, headerName, sessionId, persistentId }
+ * @returns {typeof globalThis.fetch}
+ */
+export function createSessionHeaderFetch({ send, headerName, sessionId, persistentId }) {
+    if (send === false)
+        return globalThis.fetch;
+    const header = sessionHeaderOf({ send, headerName, sessionId, persistentId });
+    if (!header)
+        return globalThis.fetch;
+    return (async (input, init) => {
+        const next = init ? { ...init } : {};
+        next.headers = new Headers(init?.headers);
+        for (const [k, v] of Object.entries(header)) {
+            next.headers.set(k, v);
+        }
+        return globalThis.fetch(input, next);
+    });
+}

package/vendor/tdai/utils/text-utils.js

@@ -1,29 +1,29 @@
-/**
- * Shared text utility functions for the memory-tdai plugin.
- */
-/**
- * Extract meaningful words from text (supports CJK and Latin).
- *
- * Used by both auto-recall (keyword search) and l1-dedup (keyword candidate recall).
- * Extracted to a shared module to prevent implementation drift.
- */
-export function extractWords(text) {
-    const words = new Set();
-    // Latin words (2+ chars)
-    const latinWords = text.toLowerCase().match(/[a-z0-9]{2,}/g);
-    if (latinWords) {
-        for (const w of latinWords)
-            words.add(w);
-    }
-    // CJK characters (each char as a "word", plus 2-gram)
-    const cjkChars = text.match(/[\u4e00-\u9fff\u3040-\u30ff\uac00-\ud7af]/g);
-    if (cjkChars) {
-        for (const c of cjkChars)
-            words.add(c);
-        // 2-grams for better matching
-        for (let i = 0; i < cjkChars.length - 1; i++) {
-            words.add(cjkChars[i] + cjkChars[i + 1]);
-        }
-    }
-    return words;
-}
+/**
+ * Shared text utility functions for the memory-tdai plugin.
+ */
+/**
+ * Extract meaningful words from text (supports CJK and Latin).
+ *
+ * Used by both auto-recall (keyword search) and l1-dedup (keyword candidate recall).
+ * Extracted to a shared module to prevent implementation drift.
+ */
+export function extractWords(text) {
+    const words = new Set();
+    // Latin words (2+ chars)
+    const latinWords = text.toLowerCase().match(/[a-z0-9]{2,}/g);
+    if (latinWords) {
+        for (const w of latinWords)
+            words.add(w);
+    }
+    // CJK characters (each char as a "word", plus 2-gram)
+    const cjkChars = text.match(/[\u4e00-\u9fff\u3040-\u30ff\uac00-\ud7af]/g);
+    if (cjkChars) {
+        for (const c of cjkChars)
+            words.add(c);
+        // 2-grams for better matching
+        for (let i = 0; i < cjkChars.length - 1; i++) {
+            words.add(cjkChars[i] + cjkChars[i + 1]);
+        }
+    }
+    return words;
+}