@openviking/openclaw-plugin 2026.5.8

package/dist/memory-ranking.js

@@ -0,0 +1,221 @@
+export function clampScore(value) {
+    if (typeof value !== "number" || Number.isNaN(value)) {
+        return 0;
+    }
+    return Math.max(0, Math.min(1, value));
+}
+function normalizeDedupeText(text) {
+    return text.toLowerCase().replace(/\s+/g, " ").trim();
+}
+function isEventOrCaseMemory(item) {
+    const category = (item.category ?? "").toLowerCase();
+    const uri = item.uri.toLowerCase();
+    return (category === "events" ||
+        category === "cases" ||
+        uri.includes("/events/") ||
+        uri.includes("/cases/"));
+}
+function getMemoryDedupeKey(item) {
+    const abstract = normalizeDedupeText(item.abstract ?? item.overview ?? "");
+    const category = (item.category ?? "").toLowerCase() || "unknown";
+    if (abstract && !isEventOrCaseMemory(item)) {
+        return `abstract:${category}:${abstract}`;
+    }
+    return `uri:${item.uri}`;
+}
+export function postProcessMemories(items, options) {
+    const deduped = [];
+    const seen = new Set();
+    const sorted = [...items].sort((a, b) => clampScore(b.score) - clampScore(a.score));
+    for (const item of sorted) {
+        if (options.leafOnly && item.level !== 2) {
+            continue;
+        }
+        if (clampScore(item.score) < options.scoreThreshold) {
+            continue;
+        }
+        const key = getMemoryDedupeKey(item);
+        if (seen.has(key)) {
+            continue;
+        }
+        seen.add(key);
+        deduped.push(item);
+        if (deduped.length >= options.limit) {
+            break;
+        }
+    }
+    return deduped;
+}
+export function formatMemoryLines(items) {
+    return items
+        .map((item, index) => {
+        const score = clampScore(item.score);
+        const abstract = item.abstract?.trim() || item.overview?.trim() || item.uri;
+        const category = item.category ?? "memory";
+        return `${index + 1}. [${category}] ${abstract} (${(score * 100).toFixed(0)}%)`;
+    })
+        .join("\n");
+}
+export function trimForLog(value, limit = 260) {
+    const normalized = value.trim();
+    if (normalized.length <= limit) {
+        return normalized;
+    }
+    return `${normalized.slice(0, limit)}...`;
+}
+export function toJsonLog(value, maxLen = 6000) {
+    try {
+        const json = JSON.stringify(value);
+        if (json.length <= maxLen) {
+            return json;
+        }
+        return JSON.stringify({
+            truncated: true,
+            length: json.length,
+            preview: `${json.slice(0, maxLen)}...`,
+        });
+    }
+    catch {
+        return JSON.stringify({ error: "stringify_failed" });
+    }
+}
+export function summarizeInjectionMemories(items) {
+    return items.map((item) => ({
+        uri: item.uri,
+        category: item.category ?? null,
+        abstract: trimForLog(item.abstract?.trim() || item.overview?.trim() || item.uri, 180),
+        score: clampScore(item.score),
+        is_leaf: item.level === 2,
+    }));
+}
+export function summarizeExtractedMemories(items) {
+    return items.slice(0, 10).map((item) => {
+        const abstractRaw = typeof item.abstract === "string"
+            ? item.abstract
+            : typeof item.overview === "string"
+                ? item.overview
+                : typeof item.title === "string"
+                    ? item.title
+                    : "";
+        return {
+            uri: typeof item.uri === "string" ? item.uri : null,
+            category: typeof item.category === "string" ? item.category : null,
+            abstract: trimForLog(abstractRaw, 180),
+            is_leaf: item.level === 2,
+        };
+    });
+}
+function isPreferencesMemory(item) {
+    return (item.category === "preferences" ||
+        item.uri.includes("/preferences/") ||
+        item.uri.endsWith("/preferences"));
+}
+function isEventMemory(item) {
+    const category = (item.category ?? "").toLowerCase();
+    return category === "events" || item.uri.includes("/events/");
+}
+function isLeafLikeMemory(item) {
+    return item.level === 2;
+}
+const PREFERENCE_QUERY_RE = /prefer|preference|favorite|favourite|like|偏好|喜欢|爱好|更倾向/i;
+const TEMPORAL_QUERY_RE = /when|what time|date|day|month|year|yesterday|today|tomorrow|last|next|什么时候|何时|哪天|几月|几年|昨天|今天|明天|上周|下周|上个月|下个月|去年|明年/i;
+const QUERY_TOKEN_RE = /[a-z0-9]{2,}/gi;
+const QUERY_TOKEN_STOPWORDS = new Set([
+    "what",
+    "when",
+    "where",
+    "which",
+    "who",
+    "whom",
+    "whose",
+    "why",
+    "how",
+    "did",
+    "does",
+    "is",
+    "are",
+    "was",
+    "were",
+    "the",
+    "and",
+    "for",
+    "with",
+    "from",
+    "that",
+    "this",
+    "your",
+    "you",
+]);
+function buildRecallQueryProfile(query) {
+    const text = query.trim();
+    const allTokens = text.toLowerCase().match(QUERY_TOKEN_RE) ?? [];
+    const tokens = allTokens.filter((token) => !QUERY_TOKEN_STOPWORDS.has(token));
+    return {
+        tokens,
+        wantsPreference: PREFERENCE_QUERY_RE.test(text),
+        wantsTemporal: TEMPORAL_QUERY_RE.test(text),
+    };
+}
+function lexicalOverlapBoost(tokens, text) {
+    if (tokens.length === 0 || !text) {
+        return 0;
+    }
+    const haystack = ` ${text.toLowerCase()} `;
+    let matched = 0;
+    for (const token of tokens.slice(0, 8)) {
+        if (haystack.includes(` ${token} `) || haystack.includes(token)) {
+            matched += 1;
+        }
+    }
+    return Math.min(0.2, (matched / Math.min(tokens.length, 4)) * 0.2);
+}
+function rankForInjection(item, query) {
+    // Keep ranking simple and stable: semantic score + light query-aware boosts.
+    const baseScore = clampScore(item.score);
+    const abstract = (item.abstract ?? item.overview ?? "").trim();
+    const leafBoost = isLeafLikeMemory(item) ? 0.12 : 0;
+    const eventBoost = query.wantsTemporal && isEventMemory(item) ? 0.1 : 0;
+    const preferenceBoost = query.wantsPreference && isPreferencesMemory(item) ? 0.08 : 0;
+    const overlapBoost = lexicalOverlapBoost(query.tokens, `${item.uri} ${abstract}`);
+    return baseScore + leafBoost + eventBoost + preferenceBoost + overlapBoost;
+}
+export function pickMemoriesForInjection(items, limit, queryText, scoreThreshold = 0) {
+    if (items.length === 0 || limit <= 0) {
+        return [];
+    }
+    const query = buildRecallQueryProfile(queryText);
+    const sorted = [...items].sort((a, b) => rankForInjection(b, query) - rankForInjection(a, query));
+    const deduped = [];
+    const seen = new Set();
+    for (const item of sorted) {
+        const abstractKey = (item.abstract ?? item.overview ?? "").trim().toLowerCase();
+        const key = abstractKey || item.uri;
+        if (seen.has(key)) {
+            continue;
+        }
+        seen.add(key);
+        deduped.push(item);
+    }
+    const leaves = deduped.filter((item) => isLeafLikeMemory(item));
+    if (leaves.length >= limit) {
+        return leaves.slice(0, limit);
+    }
+    const picked = [...leaves];
+    const used = new Set(leaves.map((item) => item.uri));
+    for (const item of deduped) {
+        if (picked.length >= limit) {
+            break;
+        }
+        if (used.has(item.uri)) {
+            continue;
+        }
+        // Respect score threshold when supplementing leaf memories with
+        // non-leaf items. Without this check, low-scoring memories bypass
+        // the threshold configured in recallScoreThreshold (see #1106).
+        if (clampScore(item.score) < scoreThreshold) {
+            continue;
+        }
+        picked.push(item);
+    }
+    return picked;
+}

package/dist/process-manager.js

@@ -0,0 +1,127 @@
+import { Socket } from "node:net";
+export function waitForHealth(baseUrl, timeoutMs, intervalMs) {
+    const deadline = Date.now() + timeoutMs;
+    return new Promise((resolve, reject) => {
+        const tick = () => {
+            if (Date.now() > deadline) {
+                reject(new Error(`OpenViking health check timeout at ${baseUrl}`));
+                return;
+            }
+            fetch(`${baseUrl}/health`)
+                .then((r) => r.json())
+                .then((body) => {
+                if (body?.status === "ok") {
+                    resolve();
+                    return;
+                }
+                setTimeout(tick, intervalMs);
+            })
+                .catch(() => setTimeout(tick, intervalMs));
+        };
+        tick();
+    });
+}
+export function waitForHealthOrExit(baseUrl, timeoutMs, intervalMs, child) {
+    const exited = child.killed || child.exitCode !== null || child.signalCode !== null;
+    if (exited) {
+        return Promise.reject(new Error(`OpenViking subprocess exited before health check ` +
+            `(code=${child.exitCode}, signal=${child.signalCode})`));
+    }
+    return new Promise((resolve, reject) => {
+        let settled = false;
+        const cleanup = () => {
+            child.off?.("error", onError);
+            child.off?.("exit", onExit);
+        };
+        const finishResolve = () => {
+            if (settled) {
+                return;
+            }
+            settled = true;
+            cleanup();
+            resolve();
+        };
+        const finishReject = (err) => {
+            if (settled) {
+                return;
+            }
+            settled = true;
+            cleanup();
+            reject(err instanceof Error ? err : new Error(String(err)));
+        };
+        const onError = (err) => {
+            finishReject(err);
+        };
+        const onExit = (code, signal) => {
+            finishReject(new Error(`OpenViking subprocess exited before health check ` +
+                `(code=${code}, signal=${signal})`));
+        };
+        child.once("error", onError);
+        child.once("exit", onExit);
+        waitForHealth(baseUrl, timeoutMs, intervalMs).then(finishResolve, finishReject);
+    });
+}
+export function withTimeout(promise, timeoutMs, timeoutMessage) {
+    return new Promise((resolve, reject) => {
+        const timer = setTimeout(() => reject(new Error(timeoutMessage)), timeoutMs);
+        promise.then((value) => {
+            clearTimeout(timer);
+            resolve(value);
+        }, (err) => {
+            clearTimeout(timer);
+            reject(err);
+        });
+    });
+}
+export function quickTcpProbe(host, port, timeoutMs) {
+    return new Promise((resolve) => {
+        const socket = new Socket();
+        let done = false;
+        const finish = (ok) => {
+            if (done) {
+                return;
+            }
+            done = true;
+            socket.destroy();
+            resolve(ok);
+        };
+        socket.setTimeout(timeoutMs);
+        socket.once("connect", () => finish(true));
+        socket.once("timeout", () => finish(false));
+        socket.once("error", () => finish(false));
+        try {
+            socket.connect(port, host);
+        }
+        catch {
+            finish(false);
+        }
+    });
+}
+export async function quickHealthCheck(baseUrl, timeoutMs) {
+    const controller = new AbortController();
+    const timer = setTimeout(() => controller.abort(), timeoutMs);
+    try {
+        const response = await fetch(`${baseUrl}/health`, {
+            method: "GET",
+            signal: controller.signal,
+        });
+        if (!response.ok) {
+            return false;
+        }
+        const body = (await response.json().catch(() => ({})));
+        return body.status === "ok";
+    }
+    catch {
+        return false;
+    }
+    finally {
+        clearTimeout(timer);
+    }
+}
+export async function quickRecallPrecheck(baseUrl) {
+    const healthOk = await quickHealthCheck(baseUrl, 500);
+    if (healthOk) {
+        return { ok: true };
+    }
+    return { ok: false, reason: "health check failed" };
+}

package/dist/runtime-utils.js

@@ -0,0 +1,7 @@
+const _env = globalThis["process"];
+export function sysEnv() {
+    return _env.env;
+}
+export function getEnv(key) {
+    return _env.env[key];
+}