grix-connector 1.0.2

package/openclaw-plugin/skills/openclaw-memory-setup/scripts/bench_ollama_embeddings.ts

@@ -0,0 +1,326 @@
+#!/usr/bin/env node
+/**
+ * Benchmark Ollama embedding models on the current machine.
+ *
+ * Emits a readable table by default, or JSON with --json.
+ */
+
+import { performance } from "node:perf_hooks";
+import { parseArgs } from "node:util";
+
+const DEFAULT_TEXT =
+  "Generate a stable semantic embedding for this short bilingual memory sample. " +
+  "It should be suitable for retrieval, recall, and near-duplicate detection.";
+
+type BenchmarkOk = {
+  model: string;
+  ok: true;
+  single_wall_seconds: number;
+  single_api_seconds: number | null;
+  batch_wall_seconds: number;
+  batch_api_seconds: number | null;
+  batch_size: number;
+  vector_dims: number;
+  rounds: number;
+};
+
+type BenchmarkErr = { model: string; ok: false; error: string };
+type BenchmarkResult = BenchmarkOk | BenchmarkErr;
+
+function usageText(): string {
+  return [
+    "Usage:",
+    "  node scripts/bench_ollama_embeddings.ts [options] <model...>",
+    "",
+    "Options:",
+    "  --host <url>           Ollama host (default http://127.0.0.1:11434)",
+    "  --rounds <n>           Measured rounds per test after warmup (default 1)",
+    "  --batch-size <n>       Inputs per batch test (default 4)",
+    "  --timeout <seconds>    Request timeout (default 300)",
+    "  --single-text <text>   Input used for the single-input benchmark",
+    "  --skip-warmup          Skip warmup request per model",
+    "  --json                 Emit JSON results",
+  ].join("\n");
+}
+
+function parseNumber(raw: unknown, name: string): number {
+  const value = Number(raw);
+  if (!Number.isFinite(value)) {
+    throw new Error(`Invalid --${name}: ${String(raw)}`);
+  }
+  return value;
+}
+
+function median(values: number[]): number {
+  if (!values.length) {
+    throw new Error("median() requires at least one value");
+  }
+  const sorted = [...values].sort((a, b) => a - b);
+  const mid = Math.floor(sorted.length / 2);
+  if (sorted.length % 2 === 0) {
+    return (sorted[mid - 1]! + sorted[mid]!) / 2;
+  }
+  return sorted[mid]!;
+}
+
+function medianOrNull(values: Array<number | null>): number | null {
+  const usable = values.filter((v): v is number => typeof v === "number" && Number.isFinite(v));
+  return usable.length ? median(usable) : null;
+}
+
+function buildBatchInputs(text: string, batchSize: number): string[] {
+  return Array.from({ length: batchSize }, (_, index) => `${text} [sample ${index + 1}]`);
+}
+
+async function fetchWithTimeout(url: string, init: RequestInit, timeoutMs: number): Promise<Response> {
+  const controller = new AbortController();
+  const timer = setTimeout(() => controller.abort(), timeoutMs);
+  try {
+    return await fetch(url, { ...init, signal: controller.signal });
+  } finally {
+    clearTimeout(timer);
+  }
+}
+
+async function postEmbed(params: {
+  host: string;
+  model: string;
+  inputs: string[];
+  timeoutSeconds: number;
+}): Promise<{ embeddings: unknown; total_duration?: unknown }> {
+  const url = params.host.replace(/\/+$/, "") + "/api/embed";
+  const payload = {
+    model: params.model,
+    input: params.inputs.length > 1 ? params.inputs : params.inputs[0],
+  };
+
+  const response = await fetchWithTimeout(
+    url,
+    {
+      method: "POST",
+      headers: { "Content-Type": "application/json" },
+      body: JSON.stringify(payload),
+    },
+    Math.max(1, params.timeoutSeconds) * 1000,
+  );
+
+  const text = await response.text();
+  if (!response.ok) {
+    throw new Error(`HTTP ${response.status}: ${text}`);
+  }
+
+  let data: unknown;
+  try {
+    data = JSON.parse(text);
+  } catch {
+    throw new Error(`Unexpected JSON from Ollama: ${text.slice(0, 256)}`);
+  }
+  return data as { embeddings: unknown; total_duration?: unknown };
+}
+
+async function runOne(params: {
+  host: string;
+  model: string;
+  inputs: string[];
+  timeoutSeconds: number;
+}): Promise<{ wall_seconds: number; api_seconds: number | null; items: number; vector_dims: number }> {
+  const started = performance.now();
+  const response = await postEmbed(params);
+  const elapsed = (performance.now() - started) / 1000;
+
+  const totalDuration = (response as { total_duration?: unknown }).total_duration;
+  const api_seconds =
+    typeof totalDuration === "number" && Number.isFinite(totalDuration)
+      ? totalDuration / 1_000_000_000
+      : null;
+
+  const embeddings = (response as { embeddings?: unknown }).embeddings;
+  if (!Array.isArray(embeddings)) {
+    throw new Error(`Unexpected Ollama response for ${params.model}: ${JSON.stringify(response)}`);
+  }
+  const first = embeddings[0];
+  const vector_dims = Array.isArray(first) ? first.length : 0;
+
+  return {
+    wall_seconds: elapsed,
+    api_seconds,
+    items: embeddings.length,
+    vector_dims,
+  };
+}
+
+async function benchmarkModel(params: {
+  host: string;
+  model: string;
+  singleText: string;
+  batchInputs: string[];
+  rounds: number;
+  timeoutSeconds: number;
+  skipWarmup: boolean;
+}): Promise<BenchmarkOk> {
+  if (!params.skipWarmup) {
+    await runOne({ host: params.host, model: params.model, inputs: [params.singleText], timeoutSeconds: params.timeoutSeconds });
+  }
+
+  const singleRuns = [];
+  const batchRuns = [];
+  for (let index = 0; index < params.rounds; index += 1) {
+    singleRuns.push(await runOne({ host: params.host, model: params.model, inputs: [params.singleText], timeoutSeconds: params.timeoutSeconds }));
+  }
+  for (let index = 0; index < params.rounds; index += 1) {
+    batchRuns.push(await runOne({ host: params.host, model: params.model, inputs: params.batchInputs, timeoutSeconds: params.timeoutSeconds }));
+  }
+
+  return {
+    model: params.model,
+    ok: true,
+    single_wall_seconds: median(singleRuns.map((run) => run.wall_seconds)),
+    single_api_seconds: medianOrNull(singleRuns.map((run) => run.api_seconds)),
+    batch_wall_seconds: median(batchRuns.map((run) => run.wall_seconds)),
+    batch_api_seconds: medianOrNull(batchRuns.map((run) => run.api_seconds)),
+    batch_size: params.batchInputs.length,
+    vector_dims: singleRuns.at(-1)?.vector_dims ?? 0,
+    rounds: params.rounds,
+  };
+}
+
+function formatSeconds(value: number | null): string {
+  return value === null ? "-" : value.toFixed(2);
+}
+
+function printTable(results: BenchmarkResult[], batchSize: number): void {
+  const headers = [
+    "Model",
+    "Single(s)",
+    `Batch${batchSize}(s)`,
+    "API Single(s)",
+    `API Batch${batchSize}(s)`,
+    "Dims",
+    "Status",
+  ];
+
+  const rows: string[][] = results.map((result) => {
+    if (!result.ok) {
+      return [result.model, "-", "-", "-", "-", "-", result.error];
+    }
+    return [
+      result.model,
+      formatSeconds(result.single_wall_seconds),
+      formatSeconds(result.batch_wall_seconds),
+      formatSeconds(result.single_api_seconds),
+      formatSeconds(result.batch_api_seconds),
+      String(result.vector_dims),
+      "ok",
+    ];
+  });
+
+  const widths = headers.map((header, index) =>
+    Math.max(header.length, ...rows.map((row) => (row[index] ?? "").length)),
+  );
+
+  const emit = (cols: string[]) => {
+    process.stdout.write(
+      `${cols.map((value, index) => value.padEnd(widths[index] ?? value.length)).join("  ")}\n`,
+    );
+  };
+
+  emit(headers);
+  emit(widths.map((width) => "-".repeat(width)));
+  for (const row of rows) {
+    emit(row);
+  }
+
+  const successful = results.filter((r): r is BenchmarkOk => r.ok);
+  if (successful.length) {
+    const ranked = [...successful].sort((a, b) => {
+      if (a.batch_wall_seconds !== b.batch_wall_seconds) return a.batch_wall_seconds - b.batch_wall_seconds;
+      if (a.single_wall_seconds !== b.single_wall_seconds) return a.single_wall_seconds - b.single_wall_seconds;
+      return a.model.localeCompare(b.model);
+    });
+    process.stdout.write(`\nRecommended by speed: ${ranked[0]!.model}\n`);
+  }
+}
+
+async function main(): Promise<number> {
+  const parsed = parseArgs({
+    args: process.argv.slice(2),
+    allowPositionals: true,
+    options: {
+      host: { type: "string", default: "http://127.0.0.1:11434" },
+      rounds: { type: "string", default: "1" },
+      "batch-size": { type: "string", default: "4" },
+      timeout: { type: "string", default: "300" },
+      "single-text": { type: "string", default: DEFAULT_TEXT },
+      "skip-warmup": { type: "boolean", default: false },
+      json: { type: "boolean", default: false },
+      help: { type: "boolean", default: false },
+    },
+  });
+
+  if (parsed.values.help) {
+    process.stdout.write(`${usageText()}\n`);
+    return 0;
+  }
+
+  const models = parsed.positionals.map((value) => String(value).trim()).filter(Boolean);
+  if (!models.length) {
+    process.stderr.write(`${usageText()}\n`);
+    return 1;
+  }
+
+  const host = String(parsed.values.host ?? "").trim() || "http://127.0.0.1:11434";
+  const rounds = parseNumber(parsed.values.rounds, "rounds");
+  const batchSize = parseNumber(parsed.values["batch-size"], "batch-size");
+  const timeoutSeconds = parseNumber(parsed.values.timeout, "timeout");
+  const singleText = String(parsed.values["single-text"] ?? DEFAULT_TEXT);
+  const skipWarmup = Boolean(parsed.values["skip-warmup"]);
+  const asJson = Boolean(parsed.values.json);
+
+  if (rounds < 1) {
+    throw new Error("--rounds must be at least 1");
+  }
+  if (batchSize < 1) {
+    throw new Error("--batch-size must be at least 1");
+  }
+
+  const batchInputs = buildBatchInputs(singleText, batchSize);
+  const results: BenchmarkResult[] = [];
+
+  for (const model of models) {
+    try {
+      results.push(
+        await benchmarkModel({
+          host,
+          model,
+          singleText,
+          batchInputs,
+          rounds,
+          timeoutSeconds,
+          skipWarmup,
+        }),
+      );
+    } catch (err) {
+      const message = err instanceof Error ? err.message : String(err);
+      results.push({ model, ok: false, error: message });
+    }
+  }
+
+  const successful = results.some((result) => result.ok);
+  if (asJson) {
+    process.stdout.write(`${JSON.stringify({ results }, null, 2)}\n`);
+  } else {
+    printTable(results, batchSize);
+  }
+
+  return successful ? 0 : 1;
+}
+
+void main()
+  .then((code) => {
+    process.exitCode = code;
+  })
+  .catch((err) => {
+    const message = err instanceof Error ? err.message : String(err);
+    process.stderr.write(`${message}\n`);
+    process.exitCode = 1;
+  });

package/openclaw-plugin/skills/openclaw-memory-setup/scripts/set_openclaw_memory_model.ts

@@ -0,0 +1,385 @@
+#!/usr/bin/env node
+/**
+ * Preview or update OpenClaw memory model settings in openclaw.json files.
+ *
+ * Without --write, prints a preview only.
+ */
+
+import { copyFile, readFile, rename, stat, writeFile } from "node:fs/promises";
+import os from "node:os";
+import { dirname, join } from "node:path";
+import { parseArgs } from "node:util";
+
+type JsonValue = null | boolean | number | string | JsonValue[] | { [key: string]: JsonValue };
+
+const SENSITIVE_KEY_MARKERS = [
+  "apikey",
+  "api_key",
+  "token",
+  "secret",
+  "authorization",
+  "password",
+  "passwd",
+  "credential",
+];
+
+function usageText(): string {
+  return [
+    "Usage:",
+    "  node scripts/set_openclaw_memory_model.ts --model <model> [--provider <provider>] [--set KEY=VALUE...] [--write] <target...>",
+    "",
+    "Targets:",
+    "  Profile directories (containing openclaw.json) or direct openclaw.json paths.",
+    "",
+    "Options:",
+    "  --model <model>       Required, e.g. embeddinggemma:300m-qat-q8_0",
+    "  --provider <provider> Default: ollama",
+    "  --set KEY=VALUE       Keys are relative to agents.defaults.memorySearch; repeatable",
+    "  --write               Apply the change (otherwise preview only)",
+  ].join("\n");
+}
+
+function expandUser(rawPath: string): string {
+  const text = String(rawPath ?? "");
+  if (text === "~") return os.homedir();
+  if (text.startsWith("~/")) return join(os.homedir(), text.slice(2));
+  return text;
+}
+
+function isRecord(value: unknown): value is Record<string, unknown> {
+  return Boolean(value) && typeof value === "object" && !Array.isArray(value);
+}
+
+async function fileExists(path: string): Promise<boolean> {
+  try {
+    await stat(path);
+    return true;
+  } catch {
+    return false;
+  }
+}
+
+async function resolveConfigPath(rawTarget: string): Promise<string> {
+  const target = expandUser(rawTarget);
+  if (target.endsWith("/")) {
+    return resolveConfigPath(target.slice(0, -1));
+  }
+
+  const looksLikeConfig = target.endsWith("openclaw.json");
+  if (looksLikeConfig) {
+    if (!target.endsWith("/openclaw.json") && target.split("/").at(-1) !== "openclaw.json") {
+      throw new Error(`Refusing to edit non-OpenClaw config file: ${target}`);
+    }
+    return target;
+  }
+
+  const asDirConfig = join(target, "openclaw.json");
+  if (await fileExists(asDirConfig)) {
+    return asDirConfig;
+  }
+
+  if (await fileExists(target)) {
+    throw new Error(`Refusing to edit non-OpenClaw config file: ${target}`);
+  }
+
+  throw new Error(`Config not found: ${asDirConfig}`);
+}
+
+async function loadConfig(path: string): Promise<Record<string, unknown>> {
+  let raw: string;
+  try {
+    raw = await readFile(path, "utf8");
+  } catch (err) {
+    const message = err instanceof Error ? err.message : String(err);
+    throw new Error(`Config not found: ${path} (${message})`);
+  }
+
+  try {
+    const parsed = JSON.parse(raw) as unknown;
+    if (!isRecord(parsed)) {
+      throw new Error("Top-level JSON must be an object");
+    }
+    return parsed;
+  } catch (err) {
+    const message = err instanceof Error ? err.message : String(err);
+    throw new Error(`Invalid JSON in ${path}: ${message}`);
+  }
+}
+
+function ensureMemorySearch(config: Record<string, unknown>): Record<string, unknown> {
+  if (!("agents" in config)) {
+    throw new Error("Refusing to edit a config without a top-level 'agents' object");
+  }
+  const agents = config.agents;
+  if (!isRecord(agents)) {
+    throw new Error("Top-level 'agents' must be a JSON object");
+  }
+
+  const defaults = agents.defaults;
+  if (defaults === undefined) {
+    agents.defaults = {};
+  } else if (!isRecord(defaults)) {
+    throw new Error("'agents.defaults' must be a JSON object");
+  }
+
+  const ensuredDefaults = agents.defaults as Record<string, unknown>;
+  const memorySearch = ensuredDefaults.memorySearch;
+  if (memorySearch === undefined) {
+    ensuredDefaults.memorySearch = {};
+  } else if (!isRecord(memorySearch)) {
+    throw new Error("'agents.defaults.memorySearch' must be a JSON object");
+  }
+
+  return ensuredDefaults.memorySearch as Record<string, unknown>;
+}
+
+function deepClone<T>(value: T): T {
+  return JSON.parse(JSON.stringify(value)) as T;
+}
+
+function parseExtraSettings(entries: string[]): Array<{ keyParts: string[]; value: unknown }> {
+  return entries.map((entry) => {
+    const index = entry.indexOf("=");
+    if (index < 0) {
+      throw new Error(`Invalid --set value (expected KEY=VALUE): ${entry}`);
+    }
+    const keyText = entry.slice(0, index);
+    const valueText = entry.slice(index + 1);
+    const keyParts = keyText
+      .split(".")
+      .map((part) => part.trim())
+      .filter(Boolean);
+    if (!keyParts.length) {
+      throw new Error(`Invalid --set key: ${entry}`);
+    }
+    try {
+      return { keyParts, value: JSON.parse(valueText) };
+    } catch {
+      return { keyParts, value: valueText };
+    }
+  });
+}
+
+function setDottedValue(root: Record<string, unknown>, keyParts: string[], value: unknown): void {
+  let current: Record<string, unknown> = root;
+  for (const part of keyParts.slice(0, -1)) {
+    const existing = current[part];
+    if (existing === undefined) {
+      current[part] = {};
+    } else if (!isRecord(existing)) {
+      throw new Error(`Cannot set ${keyParts.join(".")}: ${part} is not a JSON object`);
+    }
+    current = current[part] as Record<string, unknown>;
+  }
+  current[keyParts[keyParts.length - 1]!] = value;
+}
+
+function jsonDeepEqual(a: unknown, b: unknown): boolean {
+  if (a === b) return true;
+  if (typeof a !== typeof b) return false;
+  if (a === null || b === null) return false;
+
+  if (Array.isArray(a) && Array.isArray(b)) {
+    if (a.length !== b.length) return false;
+    for (let index = 0; index < a.length; index += 1) {
+      if (!jsonDeepEqual(a[index], b[index])) return false;
+    }
+    return true;
+  }
+
+  if (isRecord(a) && isRecord(b)) {
+    const keysA = Object.keys(a).sort();
+    const keysB = Object.keys(b).sort();
+    if (keysA.length !== keysB.length) return false;
+    for (let index = 0; index < keysA.length; index += 1) {
+      if (keysA[index] !== keysB[index]) return false;
+    }
+    for (const key of keysA) {
+      if (!jsonDeepEqual(a[key], b[key])) return false;
+    }
+    return true;
+  }
+
+  return false;
+}
+
+function updateConfig(params: {
+  config: Record<string, unknown>;
+  provider: string;
+  model: string;
+  extraSettings: string[];
+}): { before: unknown; after: unknown } {
+  const memorySearch = ensureMemorySearch(params.config);
+  const before = deepClone(memorySearch);
+
+  const providerChanged = String(memorySearch.provider ?? "") !== params.provider;
+  if (providerChanged) {
+    for (const key of Object.keys(memorySearch)) {
+      delete memorySearch[key];
+    }
+  }
+
+  memorySearch.provider = params.provider;
+  memorySearch.model = params.model;
+  for (const entry of parseExtraSettings(params.extraSettings)) {
+    setDottedValue(memorySearch, entry.keyParts, entry.value);
+  }
+
+  const after = deepClone(memorySearch);
+  return { before, after };
+}
+
+function keyLooksSensitive(key: string): boolean {
+  const normalized = key.toLowerCase().replace(/[-_]/g, "");
+  return SENSITIVE_KEY_MARKERS.some((marker) => normalized.includes(marker.replace(/_/g, "")));
+}
+
+function redactForDisplay(value: unknown): unknown {
+  if (Array.isArray(value)) {
+    return value.map((item) => redactForDisplay(item));
+  }
+  if (isRecord(value)) {
+    const redacted: Record<string, unknown> = {};
+    for (const [key, nested] of Object.entries(value)) {
+      redacted[key] = keyLooksSensitive(key) ? "<redacted>" : redactForDisplay(nested);
+    }
+    return redacted;
+  }
+  return value;
+}
+
+function sortKeysRecursively(value: unknown): unknown {
+  if (Array.isArray(value)) {
+    return value.map((item) => sortKeysRecursively(item));
+  }
+  if (isRecord(value)) {
+    const out: Record<string, unknown> = {};
+    for (const key of Object.keys(value).sort()) {
+      out[key] = sortKeysRecursively(value[key]);
+    }
+    return out;
+  }
+  return value;
+}
+
+function stableStringify(value: unknown): string {
+  return JSON.stringify(sortKeysRecursively(value));
+}
+
+function formatStamp(date: Date): string {
+  const pad2 = (n: number) => String(n).padStart(2, "0");
+  return (
+    `${date.getFullYear()}` +
+    `${pad2(date.getMonth() + 1)}` +
+    `${pad2(date.getDate())}-` +
+    `${pad2(date.getHours())}` +
+    `${pad2(date.getMinutes())}` +
+    `${pad2(date.getSeconds())}`
+  );
+}
+
+async function backupPath(configPath: string, stamp: string): Promise<string> {
+  let candidate = `${configPath}.bak.${stamp}`;
+  let index = 1;
+  while (await fileExists(candidate)) {
+    candidate = `${configPath}.bak.${stamp}-${index}`;
+    index += 1;
+  }
+  return candidate;
+}
+
+async function writeConfig(configPath: string, config: Record<string, unknown>, stamp: string): Promise<string> {
+  const backup = await backupPath(configPath, stamp);
+  await copyFile(configPath, backup);
+
+  const tempPath = join(dirname(configPath), `openclaw.json.tmp.${stamp}.${Math.random().toString(16).slice(2)}`);
+  await writeFile(tempPath, `${JSON.stringify(config, null, 2)}\n`, "utf8");
+  await rename(tempPath, configPath);
+
+  return backup;
+}
+
+async function main(): Promise<number> {
+  const parsed = parseArgs({
+    args: process.argv.slice(2),
+    allowPositionals: true,
+    options: {
+      model: { type: "string" },
+      provider: { type: "string", default: "ollama" },
+      set: { type: "string", multiple: true, default: [] },
+      write: { type: "boolean", default: false },
+      help: { type: "boolean", default: false },
+    },
+  });
+
+  if (parsed.values.help) {
+    process.stdout.write(`${usageText()}\n`);
+    return 0;
+  }
+
+  const model = String(parsed.values.model ?? "").trim();
+  if (!model) {
+    process.stderr.write(`${usageText()}\n`);
+    return 1;
+  }
+
+  const targets = parsed.positionals.map((value) => String(value)).filter(Boolean);
+  if (!targets.length) {
+    process.stderr.write(`${usageText()}\n`);
+    return 1;
+  }
+
+  const provider = String(parsed.values.provider ?? "ollama").trim() || "ollama";
+  const extraSettings = (parsed.values.set ?? []) as unknown as string[];
+  const doWrite = Boolean(parsed.values.write);
+  const stamp = formatStamp(new Date());
+
+  let exitCode = 0;
+
+  for (const rawTarget of targets) {
+    try {
+      const configPath = await resolveConfigPath(rawTarget);
+      const config = await loadConfig(configPath);
+      const { before, after } = updateConfig({
+        config,
+        provider,
+        model,
+        extraSettings,
+      });
+      const changed = !jsonDeepEqual(before, after);
+
+      process.stdout.write(`${configPath}\n`);
+      process.stdout.write(`  before: ${stableStringify(redactForDisplay(before))}\n`);
+      process.stdout.write(`  after:  ${stableStringify(redactForDisplay(after))}\n`);
+
+      if (!changed) {
+        process.stdout.write("  result: unchanged\n");
+        continue;
+      }
+
+      if (doWrite) {
+        const backup = await writeConfig(configPath, config, stamp);
+        process.stdout.write("  result: written\n");
+        process.stdout.write(`  backup: ${backup}\n`);
+      } else {
+        process.stdout.write("  result: preview only (add --write to apply)\n");
+      }
+    } catch (err) {
+      exitCode = 1;
+      const message = err instanceof Error ? err.message : String(err);
+      process.stdout.write(`${rawTarget}\n  error: ${message}\n`);
+    }
+  }
+
+  return exitCode;
+}
+
+void main()
+  .then((code) => {
+    process.exitCode = code;
+  })
+  .catch((err) => {
+    const message = err instanceof Error ? err.message : String(err);
+    process.stderr.write(`${message}\n`);
+    process.exitCode = 1;
+  });