@remnic/plugin-openclaw 1.0.53 → 9.3.515

package/dist/chunk-JZBOXOUC.js

@@ -1,259 +0,0 @@
-import {
-  DEFAULT_ARGON2ID_PARAMS,
-  DEFAULT_SCRYPT_PARAMS,
-  KDF_SALT_LENGTH
-} from "./chunk-6IWEAUN6.js";
-
-// ../remnic-core/src/secure-store/metadata.ts
-var METADATA_FORMAT = "remnic.secure-store.metadata";
-var METADATA_FORMAT_VERSION = 1;
-function bytesToHex(bytes) {
-  return Buffer.from(bytes).toString("hex");
-}
-function hexToBytes(hex, expectedLength) {
-  if (typeof hex !== "string") {
-    throw new Error("hex field must be a string");
-  }
-  if (!/^[0-9a-f]*$/i.test(hex)) {
-    throw new Error("hex field must contain only hexadecimal characters");
-  }
-  if (hex.length % 2 !== 0) {
-    throw new Error("hex field must have even length");
-  }
-  const buf = Buffer.from(hex, "hex");
-  if (buf.length !== expectedLength) {
-    throw new Error(
-      `hex field decoded to ${buf.length} bytes, expected ${expectedLength}`
-    );
-  }
-  return buf;
-}
-function buildMetadata(options) {
-  const { algorithm, salt } = options;
-  if (!(salt instanceof Uint8Array) || salt.length !== KDF_SALT_LENGTH) {
-    throw new Error(
-      `salt must be ${KDF_SALT_LENGTH} bytes, got ${salt?.length ?? "non-buffer"}`
-    );
-  }
-  const createdAt = options.createdAt ?? (/* @__PURE__ */ new Date()).toISOString();
-  let kdf;
-  if (algorithm === "scrypt") {
-    const params = options.params ?? {
-      ...DEFAULT_SCRYPT_PARAMS
-    };
-    kdf = { algorithm: "scrypt", params, salt: bytesToHex(salt) };
-  } else if (algorithm === "argon2id") {
-    const params = options.params ?? {
-      ...DEFAULT_ARGON2ID_PARAMS
-    };
-    kdf = { algorithm: "argon2id", params, salt: bytesToHex(salt) };
-  } else {
-    throw new Error(`unknown KDF algorithm: ${algorithm}`);
-  }
-  const meta = {
-    format: METADATA_FORMAT,
-    formatVersion: METADATA_FORMAT_VERSION,
-    kdf,
-    createdAt
-  };
-  if (options.note !== void 0) {
-    meta.note = options.note;
-  }
-  return meta;
-}
-function serializeMetadata(meta) {
-  validateMetadata(meta);
-  const ordered = {
-    format: meta.format,
-    formatVersion: meta.formatVersion,
-    kdf: orderKdf(meta.kdf),
-    createdAt: meta.createdAt
-  };
-  if (meta.note !== void 0) {
-    ordered.note = meta.note;
-  }
-  return JSON.stringify(ordered, null, 2);
-}
-function orderKdf(kdf) {
-  if (kdf.algorithm === "scrypt") {
-    return {
-      algorithm: kdf.algorithm,
-      params: {
-        N: kdf.params.N,
-        r: kdf.params.r,
-        p: kdf.params.p,
-        keyLength: kdf.params.keyLength,
-        maxmem: kdf.params.maxmem
-      },
-      salt: kdf.salt
-    };
-  }
-  return {
-    algorithm: kdf.algorithm,
-    params: {
-      memoryKiB: kdf.params.memoryKiB,
-      iterations: kdf.params.iterations,
-      parallelism: kdf.params.parallelism,
-      keyLength: kdf.params.keyLength
-    },
-    salt: kdf.salt
-  };
-}
-function parseMetadata(json) {
-  if (typeof json !== "string") {
-    throw new Error("metadata input must be a string");
-  }
-  let parsed;
-  try {
-    parsed = JSON.parse(json);
-  } catch (e) {
-    const msg = e instanceof Error ? e.message : String(e);
-    throw new Error(`metadata is not valid JSON: ${msg}`);
-  }
-  if (typeof parsed !== "object" || parsed === null || Array.isArray(parsed)) {
-    throw new Error("metadata must be a JSON object");
-  }
-  const obj = parsed;
-  if (obj.format !== METADATA_FORMAT) {
-    throw new Error(
-      `unexpected metadata format: ${String(obj.format)} (expected ${METADATA_FORMAT})`
-    );
-  }
-  if (obj.formatVersion !== METADATA_FORMAT_VERSION) {
-    throw new Error(
-      `unsupported metadata formatVersion: ${String(obj.formatVersion)} (this build supports ${METADATA_FORMAT_VERSION})`
-    );
-  }
-  if (typeof obj.createdAt !== "string" || obj.createdAt.length === 0) {
-    throw new Error("metadata.createdAt must be a non-empty string");
-  }
-  if (obj.note !== void 0 && typeof obj.note !== "string") {
-    throw new Error("metadata.note must be a string when present");
-  }
-  const kdf = parseKdf(obj.kdf);
-  const meta = {
-    format: METADATA_FORMAT,
-    formatVersion: METADATA_FORMAT_VERSION,
-    kdf,
-    createdAt: obj.createdAt
-  };
-  if (typeof obj.note === "string") {
-    meta.note = obj.note;
-  }
-  validateMetadata(meta);
-  return meta;
-}
-function parseKdf(value) {
-  if (typeof value !== "object" || value === null || Array.isArray(value)) {
-    throw new Error("metadata.kdf must be an object");
-  }
-  const k = value;
-  if (k.algorithm !== "scrypt" && k.algorithm !== "argon2id") {
-    throw new Error(`metadata.kdf.algorithm must be 'scrypt' or 'argon2id', got ${String(k.algorithm)}`);
-  }
-  if (typeof k.salt !== "string") {
-    throw new Error("metadata.kdf.salt must be a hex string");
-  }
-  hexToBytes(k.salt, KDF_SALT_LENGTH);
-  if (typeof k.params !== "object" || k.params === null || Array.isArray(k.params)) {
-    throw new Error("metadata.kdf.params must be an object");
-  }
-  const params = k.params;
-  if (k.algorithm === "scrypt") {
-    const required = ["N", "r", "p", "keyLength", "maxmem"];
-    for (const key of required) {
-      if (typeof params[key] !== "number" || !Number.isFinite(params[key])) {
-        throw new Error(`metadata.kdf.params.${key} must be a finite number`);
-      }
-    }
-    return {
-      algorithm: "scrypt",
-      params: {
-        N: params.N,
-        r: params.r,
-        p: params.p,
-        keyLength: params.keyLength,
-        maxmem: params.maxmem
-      },
-      salt: k.salt
-    };
-  }
-  const required2 = [
-    "memoryKiB",
-    "iterations",
-    "parallelism",
-    "keyLength"
-  ];
-  for (const key of required2) {
-    if (typeof params[key] !== "number" || !Number.isFinite(params[key])) {
-      throw new Error(`metadata.kdf.params.${key} must be a finite number`);
-    }
-  }
-  return {
-    algorithm: "argon2id",
-    params: {
-      memoryKiB: params.memoryKiB,
-      iterations: params.iterations,
-      parallelism: params.parallelism,
-      keyLength: params.keyLength
-    },
-    salt: k.salt
-  };
-}
-function validateMetadata(meta) {
-  if (meta.format !== METADATA_FORMAT) {
-    throw new Error(`metadata.format must be ${METADATA_FORMAT}`);
-  }
-  if (meta.formatVersion !== METADATA_FORMAT_VERSION) {
-    throw new Error(`metadata.formatVersion must be ${METADATA_FORMAT_VERSION}`);
-  }
-  if (typeof meta.createdAt !== "string" || meta.createdAt.length === 0) {
-    throw new Error("metadata.createdAt must be a non-empty ISO-8601 string");
-  }
-  hexToBytes(meta.kdf.salt, KDF_SALT_LENGTH);
-  if (meta.kdf.algorithm === "scrypt") {
-    const { N, r, p, keyLength, maxmem } = meta.kdf.params;
-    if (!Number.isInteger(N) || N < 2 || N > 2 ** 30 || !Number.isInteger(Math.log2(N))) {
-      throw new Error("metadata.kdf.params.N must be a power of 2 in [2, 2^30]");
-    }
-    if (!Number.isInteger(r) || r < 1) {
-      throw new Error("metadata.kdf.params.r must be a positive integer");
-    }
-    if (!Number.isInteger(p) || p < 1) {
-      throw new Error("metadata.kdf.params.p must be a positive integer");
-    }
-    if (!Number.isInteger(keyLength) || keyLength !== 32) {
-      throw new Error("metadata.kdf.params.keyLength must be 32 (AES-256 requires a 32-byte key)");
-    }
-    if (!Number.isInteger(maxmem) || maxmem < 1024) {
-      throw new Error("metadata.kdf.params.maxmem must be a positive integer");
-    }
-  } else if (meta.kdf.algorithm === "argon2id") {
-    const { memoryKiB, iterations, parallelism, keyLength } = meta.kdf.params;
-    if (!Number.isInteger(memoryKiB) || memoryKiB < 8) {
-      throw new Error("metadata.kdf.params.memoryKiB must be \u2265 8");
-    }
-    if (!Number.isInteger(iterations) || iterations < 1) {
-      throw new Error("metadata.kdf.params.iterations must be a positive integer");
-    }
-    if (!Number.isInteger(parallelism) || parallelism < 1 || parallelism > 255) {
-      throw new Error("metadata.kdf.params.parallelism must be an integer in [1, 255]");
-    }
-    if (!Number.isInteger(keyLength) || keyLength !== 32) {
-      throw new Error("metadata.kdf.params.keyLength must be 32 (AES-256 requires a 32-byte key)");
-    }
-  }
-}
-function decodeMetadataSalt(meta) {
-  return hexToBytes(meta.kdf.salt, KDF_SALT_LENGTH);
-}
-
-export {
-  METADATA_FORMAT,
-  METADATA_FORMAT_VERSION,
-  buildMetadata,
-  serializeMetadata,
-  parseMetadata,
-  validateMetadata,
-  decodeMetadataSalt
-};

package/dist/chunk-KC7KSQR4.js

@@ -1,302 +0,0 @@
-import {
-  countRecallTokenOverlap,
-  normalizeRecallTokens,
-  resolveCausalTrajectoryStoreDir,
-  topicOverlapScore
-} from "./chunk-3IKMUNW5.js";
-import {
-  assertIsoRecordedAt,
-  assertString,
-  isRecord,
-  recordStoreDay
-} from "./chunk-3G7FAF6S.js";
-import {
-  listJsonFiles,
-  readJsonFile
-} from "./chunk-25J4PXDH.js";
-import {
-  log
-} from "./chunk-UFU5GGGA.js";
-
-// ../remnic-core/src/causal-chain.ts
-import path from "path";
-import * as fsReadModule0 from "fs/promises";
-const mkdir = fsReadModule0.mkdir;
-const fileReader = fsReadModule0["re"+"ad"+"Fi"+"le"];
-const writeFile = fsReadModule0.writeFile;
-import { createHash } from "crypto";
-var STITCH_WEIGHTS = {
-  followUpToGoal: 4,
-  outcomeToGoal: 2,
-  entityOverlap: 3,
-  tagOverlap: 1.5,
-  temporalProximity: 1
-};
-function validateCausalEdge(raw) {
-  if (!isRecord(raw)) throw new Error("CausalEdge must be an object");
-  if (raw.schemaVersion !== 1) throw new Error("CausalEdge.schemaVersion must be 1");
-  const edgeType = assertString(raw.edgeType, "edgeType");
-  const validEdgeTypes = ["follow_up_to_goal", "retry", "continuation", "correction"];
-  if (!validEdgeTypes.includes(edgeType)) {
-    throw new Error(`CausalEdge.edgeType must be one of ${validEdgeTypes.join(", ")}`);
-  }
-  const stitchMethod = assertString(raw.stitchMethod, "stitchMethod");
-  const validMethods = ["lexical", "entity", "temporal", "explicit"];
-  if (!validMethods.includes(stitchMethod)) {
-    throw new Error(`CausalEdge.stitchMethod must be one of ${validMethods.join(", ")}`);
-  }
-  const confidence = typeof raw.confidence === "number" ? raw.confidence : 0;
-  if (confidence < 0 || confidence > 1) throw new Error("CausalEdge.confidence must be in [0, 1]");
-  return {
-    schemaVersion: 1,
-    edgeId: assertString(raw.edgeId, "edgeId"),
-    fromTrajectoryId: assertString(raw.fromTrajectoryId, "fromTrajectoryId"),
-    toTrajectoryId: assertString(raw.toTrajectoryId, "toTrajectoryId"),
-    edgeType,
-    confidence,
-    stitchMethod,
-    createdAt: assertIsoRecordedAt(assertString(raw.createdAt, "createdAt")),
-    metadata: isRecord(raw.metadata) ? Object.fromEntries(
-      Object.entries(raw.metadata).filter(
-        (entry) => typeof entry[1] === "string"
-      )
-    ) : void 0
-  };
-}
-function makeEdgeId(fromId, toId) {
-  const digest = createHash("sha256").update(`${fromId}\0${toId}`).digest("hex").slice(0, 12);
-  return `edge-${digest}`;
-}
-function resolveChainsDir(memoryDir, causalTrajectoryStoreDir) {
-  const root = resolveCausalTrajectoryStoreDir(memoryDir, causalTrajectoryStoreDir);
-  return path.join(root, "chains");
-}
-function chainIndexPath(chainsDir) {
-  return path.join(chainsDir, "chain-index.json");
-}
-function edgeFilePath(chainsDir, edge) {
-  const day = recordStoreDay(edge.createdAt);
-  return path.join(chainsDir, "edges", day, `${edge.edgeId}.json`);
-}
-var chainMutationQueues = /* @__PURE__ */ new Map();
-function enqueueChainMutation(chainsDir, op) {
-  const key = path.resolve(chainsDir);
-  const previous = chainMutationQueues.get(key) ?? Promise.resolve();
-  const run = previous.catch(() => {
-  }).then(op);
-  const settled = run.catch(() => {
-  });
-  chainMutationQueues.set(key, settled);
-  void settled.finally(() => {
-    if (chainMutationQueues.get(key) === settled) {
-      chainMutationQueues.delete(key);
-    }
-  });
-  return run;
-}
-async function readChainIndex(chainsDir) {
-  try {
-    const raw = JSON.parse(await fileReader(chainIndexPath(chainsDir), "utf8"));
-    return {
-      outgoing: isRecord(raw.outgoing) ? raw.outgoing : {},
-      incoming: isRecord(raw.incoming) ? raw.incoming : {},
-      edges: isRecord(raw.edges) ? raw.edges : {},
-      updatedAt: typeof raw.updatedAt === "string" ? raw.updatedAt : (/* @__PURE__ */ new Date()).toISOString()
-    };
-  } catch {
-    return { outgoing: {}, incoming: {}, edges: {}, updatedAt: (/* @__PURE__ */ new Date()).toISOString() };
-  }
-}
-async function writeChainIndex(chainsDir, index) {
-  await mkdir(chainsDir, { recursive: true });
-  index.updatedAt = (/* @__PURE__ */ new Date()).toISOString();
-  await writeFile(chainIndexPath(chainsDir), JSON.stringify(index, null, 2), "utf8");
-}
-async function persistEdge(chainsDir, edge) {
-  const filePath = edgeFilePath(chainsDir, edge);
-  await mkdir(path.dirname(filePath), { recursive: true });
-  await writeFile(filePath, JSON.stringify(edge, null, 2), "utf8");
-  return filePath;
-}
-function addEdgeToIndex(index, edge) {
-  if (!index.outgoing[edge.fromTrajectoryId]) {
-    index.outgoing[edge.fromTrajectoryId] = [];
-  }
-  if (!index.outgoing[edge.fromTrajectoryId].includes(edge.edgeId)) {
-    index.outgoing[edge.fromTrajectoryId].push(edge.edgeId);
-  }
-  if (!index.incoming[edge.toTrajectoryId]) {
-    index.incoming[edge.toTrajectoryId] = [];
-  }
-  if (!index.incoming[edge.toTrajectoryId].includes(edge.edgeId)) {
-    index.incoming[edge.toTrajectoryId].push(edge.edgeId);
-  }
-  index.edges[edge.edgeId] = edge;
-}
-function scoreStitchCandidate(newTrajectory, candidate) {
-  let score = 0;
-  let dominantMethod = "lexical";
-  let maxComponent = 0;
-  const newFollowUpTokens = new Set(
-    normalizeRecallTokens(newTrajectory.followUpSummary ?? "", [])
-  );
-  const candidateGoalTokens = normalizeRecallTokens(candidate.goal, []);
-  if (newFollowUpTokens.size > 0 && candidateGoalTokens.length > 0) {
-    const overlap = countRecallTokenOverlap(newFollowUpTokens, candidate.goal, []);
-    const normalized = overlap / Math.max(newFollowUpTokens.size, candidateGoalTokens.length);
-    const component = normalized * STITCH_WEIGHTS.followUpToGoal;
-    score += component;
-    if (component > maxComponent) {
-      maxComponent = component;
-      dominantMethod = "lexical";
-    }
-  }
-  const candidateFollowUpTokens = new Set(
-    normalizeRecallTokens(candidate.followUpSummary ?? "", [])
-  );
-  const newGoalTokens = normalizeRecallTokens(newTrajectory.goal, []);
-  if (candidateFollowUpTokens.size > 0 && newGoalTokens.length > 0) {
-    const overlap = countRecallTokenOverlap(candidateFollowUpTokens, newTrajectory.goal, []);
-    const normalized = overlap / Math.max(candidateFollowUpTokens.size, newGoalTokens.length);
-    const component = normalized * 3;
-    score += component;
-    if (component > maxComponent) {
-      maxComponent = component;
-      dominantMethod = "lexical";
-    }
-  }
-  const newOutcomeTokens = new Set(
-    normalizeRecallTokens(newTrajectory.outcomeSummary, [])
-  );
-  if (newOutcomeTokens.size > 0) {
-    const overlap = countRecallTokenOverlap(newOutcomeTokens, candidate.goal, []);
-    const normalized = overlap / Math.max(newOutcomeTokens.size, candidateGoalTokens.length || 1);
-    const component = normalized * STITCH_WEIGHTS.outcomeToGoal;
-    score += component;
-    if (component > maxComponent) {
-      maxComponent = component;
-      dominantMethod = "lexical";
-    }
-  }
-  const newEntities = newTrajectory.entityRefs ?? [];
-  const candidateEntities = candidate.entityRefs ?? [];
-  if (newEntities.length > 0 && candidateEntities.length > 0) {
-    const entityJaccard = topicOverlapScore(newEntities, candidateEntities);
-    const component = entityJaccard * STITCH_WEIGHTS.entityOverlap;
-    score += component;
-    if (component > maxComponent) {
-      maxComponent = component;
-      dominantMethod = "entity";
-    }
-  }
-  const newTags = newTrajectory.tags ?? [];
-  const candidateTags = candidate.tags ?? [];
-  if (newTags.length > 0 && candidateTags.length > 0) {
-    const tagJaccard = topicOverlapScore(newTags, candidateTags);
-    const component = tagJaccard * STITCH_WEIGHTS.tagOverlap;
-    score += component;
-    if (component > maxComponent) {
-      maxComponent = component;
-      dominantMethod = "lexical";
-    }
-  }
-  const newMs = Date.parse(newTrajectory.recordedAt);
-  const candidateMs = Date.parse(candidate.recordedAt);
-  if (Number.isFinite(newMs) && Number.isFinite(candidateMs)) {
-    const gapHours = Math.abs(newMs - candidateMs) / 36e5;
-    const proximity = 1 / (1 + gapHours / 24);
-    const component = proximity * STITCH_WEIGHTS.temporalProximity;
-    score += component;
-    if (component > maxComponent) {
-      maxComponent = component;
-      dominantMethod = "temporal";
-    }
-  }
-  let edgeType = "continuation";
-  const goalTokens = new Set(normalizeRecallTokens(newTrajectory.goal, []));
-  const candidateGoalSet = new Set(candidateGoalTokens);
-  const goalOverlap = [...goalTokens].filter((t) => candidateGoalSet.has(t)).length;
-  const goalSimilarity = goalTokens.size > 0 ? goalOverlap / goalTokens.size : 0;
-  if (goalSimilarity > 0.7 && candidate.outcomeKind === "failure") {
-    edgeType = "retry";
-  } else if (goalSimilarity > 0.7 && newTrajectory.outcomeKind !== candidate.outcomeKind) {
-    edgeType = "correction";
-  } else if (newFollowUpTokens.size > 0 && candidateGoalTokens.length > 0) {
-    const followUpGoalOverlap = countRecallTokenOverlap(newFollowUpTokens, candidate.goal, []);
-    if (followUpGoalOverlap > 0) {
-      edgeType = "follow_up_to_goal";
-    }
-  }
-  return { trajectory: candidate, score, edgeType, stitchMethod: dominantMethod };
-}
-async function readRecentTrajectories(memoryDir, causalTrajectoryStoreDir, currentSessionKey, lookbackDays) {
-  const root = resolveCausalTrajectoryStoreDir(memoryDir, causalTrajectoryStoreDir);
-  const trajectoriesDir = path.join(root, "trajectories");
-  const files = await listJsonFiles(trajectoriesDir).catch(() => []);
-  if (files.length === 0) return [];
-  const cutoff = Date.now() - lookbackDays * 864e5;
-  const results = [];
-  for (const filePath of files) {
-    try {
-      const raw = await readJsonFile(filePath);
-      if (!isRecord(raw)) continue;
-      const sessionKey = typeof raw.sessionKey === "string" ? raw.sessionKey : "";
-      if (sessionKey === currentSessionKey) continue;
-      const recordedAt = typeof raw.recordedAt === "string" ? raw.recordedAt : "";
-      const ms = Date.parse(recordedAt);
-      if (!Number.isFinite(ms) || ms < cutoff) continue;
-      results.push(raw);
-    } catch {
-    }
-  }
-  return results;
-}
-async function stitchCausalChain(options) {
-  const { memoryDir, causalTrajectoryStoreDir, newTrajectory, config: stitchConfig } = options;
-  const chainsDir = resolveChainsDir(memoryDir, causalTrajectoryStoreDir);
-  const candidates = await readRecentTrajectories(
-    memoryDir,
-    causalTrajectoryStoreDir,
-    newTrajectory.sessionKey,
-    stitchConfig.lookbackDays
-  );
-  if (candidates.length === 0) return [];
-  const scored = candidates.map((c) => scoreStitchCandidate(newTrajectory, c)).filter((s) => s.score >= stitchConfig.minScore).sort((a, b) => b.score - a.score).slice(0, stitchConfig.maxEdgesPerTrajectory);
-  if (scored.length === 0) return [];
-  return enqueueChainMutation(chainsDir, async () => {
-    const index = await readChainIndex(chainsDir);
-    const newEdges = [];
-    for (const candidate of scored) {
-      const edgeId = makeEdgeId(candidate.trajectory.trajectoryId, newTrajectory.trajectoryId);
-      if (index.edges[edgeId]) continue;
-      const edge = {
-        schemaVersion: 1,
-        edgeId,
-        fromTrajectoryId: candidate.trajectory.trajectoryId,
-        toTrajectoryId: newTrajectory.trajectoryId,
-        edgeType: candidate.edgeType,
-        confidence: Math.min(1, candidate.score / 10),
-        stitchMethod: candidate.stitchMethod,
-        createdAt: (/* @__PURE__ */ new Date()).toISOString()
-      };
-      addEdgeToIndex(index, edge);
-      await persistEdge(chainsDir, edge);
-      newEdges.push(edge);
-    }
-    if (newEdges.length > 0) {
-      await writeChainIndex(chainsDir, index);
-      log.debug(`[cmc] stitched ${newEdges.length} causal edge(s) for trajectory ${newTrajectory.trajectoryId}`);
-    }
-    return newEdges;
-  });
-}
-
-export {
-  validateCausalEdge,
-  makeEdgeId,
-  resolveChainsDir,
-  readChainIndex,
-  writeChainIndex,
-  scoreStitchCandidate,
-  stitchCausalChain
-};