@remnic/plugin-openclaw 1.0.53 → 9.3.515

package/dist/chunk-3IKMUNW5.js

@@ -1,177 +0,0 @@
-import {
-  assertIsoRecordedAt,
-  assertSafePathSegment,
-  assertString,
-  isRecord,
-  optionalString,
-  optionalStringArray,
-  validateStringRecord
-} from "./chunk-3G7FAF6S.js";
-import {
-  listJsonFiles,
-  readJsonFile
-} from "./chunk-25J4PXDH.js";
-
-// ../remnic-core/src/boxes.ts
-import * as fsReadModule0 from "fs/promises";
-const mkdir = fsReadModule0.mkdir;
-const writeFile = fsReadModule0.writeFile;
-const fileReader = fsReadModule0["re"+"ad"+"Fi"+"le"];
-const readdir = fsReadModule0.readdir;
-import path from "path";
-import { createHash } from "crypto";
-function topicOverlapScore(a, b) {
-  if (a.length === 0 || b.length === 0) return 0;
-  const setA = new Set(a.map((t) => t.toLowerCase()));
-  const setB = new Set(b.map((t) => t.toLowerCase()));
-  const intersection = [...setA].filter((t) => setB.has(t)).length;
-  const union = (/* @__PURE__ */ new Set([...setA, ...setB])).size;
-  return union === 0 ? 0 : intersection / union;
-}
-
-// ../remnic-core/src/recall-tokenization.ts
-function normalizeRecallTokens(value, extraStopWords = []) {
-  const stopWords = /* @__PURE__ */ new Set([
-    "the",
-    "and",
-    "for",
-    "with",
-    "from",
-    "into",
-    "that",
-    "this",
-    "why",
-    "did",
-    ...extraStopWords
-  ]);
-  return value.toLowerCase().split(/[^a-z0-9]+/).map((token) => token.trim()).filter((token) => token.length >= 3 && !stopWords.has(token));
-}
-function countRecallTokenOverlap(queryTokens, value, extraStopWords = []) {
-  if (!value) return 0;
-  const tokens = new Set(normalizeRecallTokens(value, extraStopWords));
-  let matches = 0;
-  for (const token of queryTokens) {
-    if (tokens.has(token)) matches += 1;
-  }
-  return matches;
-}
-
-// ../remnic-core/src/causal-trajectory.ts
-import path2 from "path";
-import { mkdir as mkdir2, writeFile as writeFile2 } from "fs/promises";
-function validateMetadata(raw) {
-  return validateStringRecord(raw, "metadata");
-}
-function resolveCausalTrajectoryStoreDir(memoryDir, overrideDir) {
-  if (typeof overrideDir === "string" && overrideDir.trim().length > 0) {
-    return overrideDir.trim();
-  }
-  return path2.join(memoryDir, "state", "causal-trajectories");
-}
-function validateCausalTrajectoryRecord(raw) {
-  if (!isRecord(raw)) throw new Error("causal trajectory record must be an object");
-  if (raw.schemaVersion !== 1) throw new Error("schemaVersion must be 1");
-  const outcomeKind = assertString(raw.outcomeKind, "outcomeKind");
-  if (!["success", "failure", "partial", "unknown"].includes(outcomeKind)) {
-    throw new Error("outcomeKind must be one of success|failure|partial|unknown");
-  }
-  return {
-    schemaVersion: 1,
-    trajectoryId: assertSafePathSegment(assertString(raw.trajectoryId, "trajectoryId"), "trajectoryId"),
-    recordedAt: assertIsoRecordedAt(assertString(raw.recordedAt, "recordedAt")),
-    sessionKey: assertString(raw.sessionKey, "sessionKey"),
-    goal: assertString(raw.goal, "goal"),
-    actionSummary: assertString(raw.actionSummary, "actionSummary"),
-    observationSummary: assertString(raw.observationSummary, "observationSummary"),
-    outcomeKind,
-    outcomeSummary: assertString(raw.outcomeSummary, "outcomeSummary"),
-    followUpSummary: optionalString(raw.followUpSummary),
-    objectiveStateSnapshotRefs: optionalStringArray(raw.objectiveStateSnapshotRefs, "objectiveStateSnapshotRefs"),
-    entityRefs: optionalStringArray(raw.entityRefs, "entityRefs"),
-    tags: optionalStringArray(raw.tags, "tags"),
-    metadata: validateMetadata(raw.metadata)
-  };
-}
-async function readCausalTrajectoryRecords(options) {
-  const rootDir = resolveCausalTrajectoryStoreDir(options.memoryDir, options.causalTrajectoryStoreDir);
-  const files = await listJsonFiles(path2.join(rootDir, "trajectories"));
-  const trajectories = [];
-  const invalidTrajectories = [];
-  for (const filePath of files) {
-    try {
-      trajectories.push(validateCausalTrajectoryRecord(await readJsonFile(filePath)));
-    } catch (error) {
-      invalidTrajectories.push({
-        path: filePath,
-        error: error instanceof Error ? error.message : String(error)
-      });
-    }
-  }
-  return { files, trajectories, invalidTrajectories };
-}
-function lexicalScoreCausalTrajectoryRecord(record, queryTokens) {
-  const weightedFields = [
-    ["goal", record.goal, 4],
-    ["action", record.actionSummary, 3],
-    ["observation", record.observationSummary, 3],
-    ["outcome", record.outcomeSummary, 3],
-    ["follow_up", record.followUpSummary, 2],
-    ["outcome_kind", record.outcomeKind, 1],
-    ["tags", record.tags?.join(" "), 2],
-    ["entity_refs", record.entityRefs?.join(" "), 2],
-    ["objective_state_refs", record.objectiveStateSnapshotRefs?.join(" "), 1]
-  ];
-  let score = 0;
-  const matchedFields = [];
-  for (const [field, value, weight] of weightedFields) {
-    const matches = countRecallTokenOverlap(queryTokens, value, ["make"]);
-    if (matches > 0) matchedFields.push(field);
-    score += matches * weight;
-  }
-  return { score, matchedFields };
-}
-function scoreCausalTrajectoryRecord(record, lexicalScore, sessionKey) {
-  let score = lexicalScore;
-  if (sessionKey && record.sessionKey === sessionKey) score += 1.5;
-  const recordedAtMs = Date.parse(record.recordedAt);
-  if (Number.isFinite(recordedAtMs)) {
-    const ageHours = Math.max(0, (Date.now() - recordedAtMs) / 36e5);
-    score += 1 / (1 + ageHours);
-  }
-  return score;
-}
-async function searchCausalTrajectories(options) {
-  const maxResults = Math.max(0, Math.floor(options.maxResults));
-  if (maxResults === 0) return [];
-  const { trajectories } = await readCausalTrajectoryRecords(options);
-  if (trajectories.length === 0) return [];
-  const queryTokens = new Set(normalizeRecallTokens(options.query, ["make"]));
-  if (queryTokens.size === 0) return [];
-  const scored = trajectories.map((record) => {
-    const lexical = lexicalScoreCausalTrajectoryRecord(record, queryTokens);
-    return {
-      record,
-      matchedFields: lexical.matchedFields,
-      lexicalScore: lexical.score,
-      score: scoreCausalTrajectoryRecord(record, lexical.score, options.sessionKey)
-    };
-  });
-  const filtered = scored.filter((result) => result.lexicalScore > 0);
-  filtered.sort((left, right) => {
-    if (right.score !== left.score) return right.score - left.score;
-    return right.record.recordedAt.localeCompare(left.record.recordedAt);
-  });
-  return filtered.slice(0, maxResults).map(({ record, score, matchedFields }) => ({
-    record,
-    score,
-    matchedFields
-  }));
-}
-
-export {
-  topicOverlapScore,
-  normalizeRecallTokens,
-  countRecallTokenOverlap,
-  resolveCausalTrajectoryStoreDir,
-  searchCausalTrajectories
-};