@remnic/plugin-openclaw 1.0.54 → 9.3.515

package/dist/chunk-YJYZMLD5.js

@@ -1,360 +0,0 @@
-// ../remnic-core/src/contradiction/contradiction-review.ts
-import fs from "fs";
-import path from "path";
-import { createHash, randomUUID } from "crypto";
-var VALID_RESOLUTION_VERBS = [
-  "keep-a",
-  "keep-b",
-  "merge",
-  "both-valid",
-  "needs-more-context"
-];
-var NEEDS_MORE_CONTEXT_COOLDOWN_MS = 24 * 60 * 60 * 1e3;
-var UNSCOPED_MIGRATION_MARKER_PREFIX = ".unscoped-migrated-";
-var UNSCOPED_MIGRATION_MARKER_SUFFIX = ".done";
-function computePairId(memoryIdA, memoryIdB, namespace) {
-  const sorted = [memoryIdA, memoryIdB].sort();
-  const normalizedNamespace = namespace?.trim();
-  const scope = normalizedNamespace ? `ns:${normalizedNamespace}::` : "";
-  return createHash("sha256").update(`${scope}${sorted.join("::")}`).digest("hex").slice(0, 24);
-}
-function isDefaultReviewNamespace(defaultNamespace, requestedNamespace, resolvedNamespace) {
-  const requested = requestedNamespace?.trim();
-  return !requested || requested === defaultNamespace || resolvedNamespace === defaultNamespace;
-}
-function isTerminalResolution(resolution) {
-  return resolution === "keep-a" || resolution === "keep-b" || resolution === "merge";
-}
-function preservesDirectResolution(resolution) {
-  return isTerminalResolution(resolution) || resolution === "both-valid";
-}
-function isDormantReviewedPair(pair) {
-  return pair.verdict === "independent" || pair.resolution === "both-valid";
-}
-function reviewStateRank(pair, cooldownDays) {
-  if (isTerminalResolution(pair.resolution)) return 5;
-  if (pair.resolution === "both-valid") return 4;
-  if (isDeferralActive(pair)) return 3;
-  if (isDormantReviewedPair(pair)) {
-    if (cooldownDays === void 0) return 2;
-    return isCoolingDown(pair, cooldownDays) ? 2 : 0;
-  }
-  return 1;
-}
-function parseIsoMillis(value) {
-  if (!value) return null;
-  const millis = new Date(value).getTime();
-  return Number.isFinite(millis) ? millis : null;
-}
-function isDeferred(pair) {
-  return pair.resolution === "needs-more-context" || Boolean(pair.deferredUntil);
-}
-function deferralUntilMillis(pair) {
-  const deferredUntil = parseIsoMillis(pair.deferredUntil);
-  if (deferredUntil !== null) return deferredUntil;
-  if (pair.resolution === "needs-more-context") {
-    const lastReviewed = parseIsoMillis(pair.lastReviewedAt);
-    return lastReviewed === null ? null : lastReviewed + NEEDS_MORE_CONTEXT_COOLDOWN_MS;
-  }
-  return null;
-}
-function isDeferralActive(pair) {
-  const deferredUntil = deferralUntilMillis(pair);
-  return deferredUntil !== null && Date.now() < deferredUntil;
-}
-function reviewStateMillis(pair) {
-  return Math.max(
-    parseIsoMillis(pair.deferredUntil) ?? Number.NEGATIVE_INFINITY,
-    parseIsoMillis(pair.lastReviewedAt) ?? Number.NEGATIVE_INFINITY,
-    parseIsoMillis(pair.detectedAt) ?? Number.NEGATIVE_INFINITY
-  );
-}
-function mergeMigratedPair(existing, migrated, options) {
-  const existingRank = reviewStateRank(existing, options.cooldownDays);
-  const migratedRank = reviewStateRank(migrated, options.cooldownDays);
-  const selected = migratedRank > existingRank ? migrated : migratedRank < existingRank ? existing : reviewStateMillis(migrated) > reviewStateMillis(existing) ? migrated : existing;
-  return {
-    ...selected,
-    pairId: migrated.pairId,
-    namespace: migrated.namespace
-  };
-}
-function reviewDir(memoryDir) {
-  return path.join(memoryDir, ".review", "contradictions");
-}
-function migrationMarkerPath(memoryDir, namespace) {
-  const namespaceKey = createHash("sha256").update(namespace).digest("hex").slice(0, 16);
-  return path.join(reviewDir(memoryDir), `${UNSCOPED_MIGRATION_MARKER_PREFIX}${namespaceKey}${UNSCOPED_MIGRATION_MARKER_SUFFIX}`);
-}
-function clearUnscopedMigrationMarkers(memoryDir) {
-  const dir = reviewDir(memoryDir);
-  if (!fs.existsSync(dir)) return;
-  try {
-    for (const entry of fs.readdirSync(dir)) {
-      if (entry.startsWith(UNSCOPED_MIGRATION_MARKER_PREFIX) && entry.endsWith(UNSCOPED_MIGRATION_MARKER_SUFFIX)) {
-        fs.rmSync(path.join(dir, entry), { force: true });
-      }
-    }
-  } catch {
-  }
-}
-function pairPath(memoryDir, pairId) {
-  if (pairId.includes("/") || pairId.includes("\\") || pairId.includes("..")) {
-    throw new Error(`Invalid pairId: ${pairId}`);
-  }
-  return path.join(reviewDir(memoryDir), `${pairId}.json`);
-}
-function ensureDir(memoryDir) {
-  const dir = reviewDir(memoryDir);
-  if (!fs.existsSync(dir)) {
-    fs.mkdirSync(dir, { recursive: true });
-  }
-}
-function uniqueTempPath(filePath) {
-  return `${filePath}.${process.pid}.${Date.now()}.${randomUUID()}.tmp`;
-}
-function writePairFile(filePath, pair) {
-  const tmpPath = uniqueTempPath(filePath);
-  try {
-    fs.writeFileSync(tmpPath, JSON.stringify(pair, null, 2), "utf-8");
-    fs.renameSync(tmpPath, filePath);
-  } catch (error) {
-    try {
-      fs.rmSync(tmpPath, { force: true });
-    } catch {
-    }
-    throw error;
-  }
-}
-function computeMemoryContentHash(content, category) {
-  const normalized = JSON.stringify({
-    content: content.trim(),
-    category: (category ?? "").trim()
-  });
-  return createHash("sha256").update(normalized).digest("hex").slice(0, 16);
-}
-function suppliedMemoryHashesChanged(existing, pair) {
-  if (!existing.memoryContentHashes || !pair.memoryContentHashes) return false;
-  return pair.memoryIds.some((memoryId) => {
-    const current = pair.memoryContentHashes?.[memoryId];
-    return typeof current === "string" && existing.memoryContentHashes?.[memoryId] !== current;
-  });
-}
-function writePair(memoryDir, pair, options = {}) {
-  ensureDir(memoryDir);
-  if (pair.namespace === void 0) {
-    clearUnscopedMigrationMarkers(memoryDir);
-  }
-  const pairId = computePairId(pair.memoryIds[0], pair.memoryIds[1], pair.namespace);
-  const existing = readPair(memoryDir, pairId);
-  if (isTerminalResolution(existing?.resolution)) {
-    return existing;
-  }
-  if (existing?.resolution === "both-valid" && options.cooldownDays === void 0) {
-    return existing;
-  }
-  const existingDeferralExpired = Boolean(existing && isDeferred(existing) && !isDeferralActive(existing));
-  if (existing && isDeferralActive(existing)) {
-    return existing;
-  }
-  const existingDormantCooldownActive = Boolean(
-    existing && isDormantReviewedPair(existing) && options.cooldownDays !== void 0 && isCoolingDown(existing, options.cooldownDays)
-  );
-  const dormantContentChanged = Boolean(
-    existing && existingDormantCooldownActive && suppliedMemoryHashesChanged(existing, pair)
-  );
-  const existingDormantExpired = Boolean(
-    existing && isDormantReviewedPair(existing) && options.cooldownDays !== void 0 && !existingDormantCooldownActive
-  );
-  if (existing && !existingDeferralExpired && (existingDormantCooldownActive && !dormantContentChanged || !existingDormantExpired && !dormantContentChanged && existing.confidence >= pair.confidence)) {
-    return existing;
-  }
-  const full = {
-    ...pair,
-    pairId,
-    lastReviewedAt: existingDeferralExpired || existingDormantExpired || dormantContentChanged ? pair.lastReviewedAt : existing?.lastReviewedAt ?? pair.lastReviewedAt,
-    resolution: void 0,
-    deferredUntil: existingDeferralExpired || existingDormantExpired || dormantContentChanged ? void 0 : existing?.deferredUntil
-  };
-  const filePath = pairPath(memoryDir, pairId);
-  writePairFile(filePath, full);
-  return full;
-}
-function writePairs(memoryDir, pairs, options = {}) {
-  const seen = /* @__PURE__ */ new Set();
-  const results = [];
-  for (const pair of pairs) {
-    const key = computePairId(pair.memoryIds[0], pair.memoryIds[1], pair.namespace);
-    if (seen.has(key)) continue;
-    seen.add(key);
-    results.push(writePair(memoryDir, pair, options));
-  }
-  return results;
-}
-function readPair(memoryDir, pairId) {
-  const filePath = pairPath(memoryDir, pairId);
-  try {
-    const raw = fs["re"+"ad"+"Fi"+"le"+"Sync"](filePath, "utf-8");
-    const parsed = JSON.parse(raw);
-    if (typeof parsed === "object" && parsed !== null && Array.isArray(parsed.memoryIds)) {
-      return parsed;
-    }
-    return null;
-  } catch {
-    return null;
-  }
-}
-function listPairs(memoryDir, options) {
-  const startTime = Date.now();
-  const dir = reviewDir(memoryDir);
-  const { filter = "all", namespace, includeUnscopedForNamespace = false, limit = 50 } = options ?? {};
-  const pairs = [];
-  let total = 0;
-  if (!fs.existsSync(dir)) {
-    return { pairs: [], total: 0, durationMs: Date.now() - startTime };
-  }
-  for (const entry of fs.readdirSync(dir)) {
-    if (!entry.endsWith(".json")) continue;
-    try {
-      const raw = fs["re"+"ad"+"Fi"+"le"+"Sync"](path.join(dir, entry), "utf-8");
-      const pair = JSON.parse(raw);
-      if (typeof pair !== "object" || pair === null) continue;
-      if (!Array.isArray(pair.memoryIds)) continue;
-      if (namespace && pair.namespace !== namespace && !(includeUnscopedForNamespace && pair.namespace === void 0)) continue;
-      if (filter === "unresolved") {
-        if (isTerminalResolution(pair.resolution)) continue;
-        if (isDeferralActive(pair)) continue;
-        if (pair.resolution === "both-valid") continue;
-        if (pair.verdict === "independent") continue;
-      } else if (filter !== "all" && pair.verdict !== filter) {
-        continue;
-      }
-      total++;
-      if (pairs.length < limit) pairs.push(pair);
-    } catch {
-      continue;
-    }
-  }
-  return { pairs, total, durationMs: Date.now() - startTime };
-}
-function migrateUnscopedPairsToNamespace(memoryDir, namespace, options = {}) {
-  const resolvedNamespace = namespace.trim();
-  if (!resolvedNamespace) return 0;
-  const dir = reviewDir(memoryDir);
-  if (!fs.existsSync(dir)) return 0;
-  const markerPath = migrationMarkerPath(memoryDir, resolvedNamespace);
-  if (fs.existsSync(markerPath)) return 0;
-  let migrated = 0;
-  let hadMigrationFailure = false;
-  for (const entry of fs.readdirSync(dir)) {
-    if (!entry.endsWith(".json")) continue;
-    const filePath = path.join(dir, entry);
-    try {
-      const raw = fs["re"+"ad"+"Fi"+"le"+"Sync"](filePath, "utf-8");
-      const pair = JSON.parse(raw);
-      if (typeof pair !== "object" || pair === null) continue;
-      if (!Array.isArray(pair.memoryIds)) continue;
-      if (pair.namespace !== void 0) continue;
-      const pairId = computePairId(pair.memoryIds[0], pair.memoryIds[1], resolvedNamespace);
-      const migratedPair = { ...pair, namespace: resolvedNamespace, pairId };
-      const targetPath = pairPath(memoryDir, pairId);
-      try {
-        if (targetPath === filePath) {
-          writePairFile(filePath, migratedPair);
-        } else if (!fs.existsSync(targetPath)) {
-          writePairFile(targetPath, migratedPair);
-          fs.rmSync(filePath, { force: true });
-        } else {
-          const existing = readPair(memoryDir, pairId);
-          writePairFile(targetPath, existing ? mergeMigratedPair(existing, migratedPair, options) : migratedPair);
-          fs.rmSync(filePath, { force: true });
-        }
-        migrated += 1;
-      } catch {
-        hadMigrationFailure = true;
-        continue;
-      }
-    } catch {
-      continue;
-    }
-  }
-  if (!hadMigrationFailure) {
-    try {
-      fs.writeFileSync(markerPath, `${(/* @__PURE__ */ new Date()).toISOString()}
-`, { encoding: "utf-8", flag: "wx" });
-    } catch {
-    }
-  }
-  return migrated;
-}
-function isCoolingDown(pair, cooldownDays) {
-  if (cooldownDays <= 0) return false;
-  const deferredUntil = deferralUntilMillis(pair);
-  if (deferredUntil !== null) {
-    return Date.now() < deferredUntil;
-  }
-  if (!pair.lastReviewedAt) return false;
-  const lastReviewed = parseIsoMillis(pair.lastReviewedAt);
-  if (lastReviewed === null) return false;
-  const cooldownMs = cooldownDays * 24 * 60 * 60 * 1e3;
-  return Date.now() < lastReviewed + cooldownMs;
-}
-function resolvePair(memoryDir, pairId, verb) {
-  if (typeof verb !== "string" || !VALID_RESOLUTION_VERBS.includes(verb)) {
-    throw new Error(`Invalid contradiction resolution verb: ${String(verb)}`);
-  }
-  if (verb === "needs-more-context") {
-    return deferPair(memoryDir, pairId);
-  }
-  const existing = readPair(memoryDir, pairId);
-  if (!existing) return null;
-  if (preservesDirectResolution(existing.resolution)) return existing;
-  const updated = {
-    ...existing,
-    lastReviewedAt: (/* @__PURE__ */ new Date()).toISOString(),
-    resolution: verb,
-    deferredUntil: void 0
-  };
-  const filePath = pairPath(memoryDir, pairId);
-  writePairFile(filePath, updated);
-  return updated;
-}
-function deferPair(memoryDir, pairId, deferredUntil = new Date(Date.now() + NEEDS_MORE_CONTEXT_COOLDOWN_MS).toISOString()) {
-  const existing = readPair(memoryDir, pairId);
-  if (!existing) return null;
-  if (preservesDirectResolution(existing.resolution)) return existing;
-  const updated = {
-    ...existing,
-    lastReviewedAt: (/* @__PURE__ */ new Date()).toISOString(),
-    resolution: void 0,
-    deferredUntil
-  };
-  const filePath = pairPath(memoryDir, pairId);
-  writePairFile(filePath, updated);
-  return updated;
-}
-function memoryHashesChanged(_memoryDir, pair, getCurrentHash) {
-  if (!pair.memoryContentHashes) return false;
-  for (const memoryId of pair.memoryIds) {
-    const previousHash = pair.memoryContentHashes[memoryId];
-    if (typeof previousHash !== "string") continue;
-    const currentHash = getCurrentHash(memoryId);
-    if (currentHash !== null && currentHash !== previousHash) return true;
-  }
-  return false;
-}
-
-export {
-  computePairId,
-  isDefaultReviewNamespace,
-  computeMemoryContentHash,
-  writePair,
-  writePairs,
-  readPair,
-  listPairs,
-  migrateUnscopedPairsToNamespace,
-  isCoolingDown,
-  resolvePair,
-  deferPair,
-  memoryHashesChanged
-};

package/dist/chunk-YKV4EFUI.js

@@ -1,199 +0,0 @@
-// ../remnic-core/src/transfer/fs-utils.ts
-import { createHash } from "crypto";
-import * as fsReadModule0 from "fs/promises";
-const lstat = fsReadModule0.lstat;
-const mkdir = fsReadModule0.mkdir;
-const readdir = fsReadModule0.readdir;
-const fileReader = fsReadModule0["re"+"ad"+"Fi"+"le"];
-const realpath = fsReadModule0.realpath;
-const stat = fsReadModule0.stat;
-const writeFile = fsReadModule0.writeFile;
-import path from "path";
-var fatalUtf8Decoder = new TextDecoder("utf-8", { fatal: true, ignoreBOM: true });
-async function sha256File(filePath) {
-  const buf = await fileReader(filePath);
-  const sha256 = createHash("sha256").update(buf).digest("hex");
-  return { sha256, bytes: buf.byteLength };
-}
-function sha256Bytes(content) {
-  const buf = Buffer.from(content);
-  const sha256 = createHash("sha256").update(buf).digest("hex");
-  return { sha256, bytes: buf.byteLength };
-}
-function sha256String(content) {
-  return sha256Bytes(Buffer.from(content, "utf-8"));
-}
-async function readUtf8FileStrict(filePath) {
-  const buf = await fileReader(filePath);
-  let content;
-  try {
-    content = fatalUtf8Decoder.decode(buf);
-  } catch {
-    throw new Error(`transfer export requires UTF-8 text files: ${filePath}`);
-  }
-  return { content, ...sha256Bytes(buf) };
-}
-async function writeJsonFile(filePath, value) {
-  await mkdir(path.dirname(filePath), { recursive: true });
-  await writeFile(filePath, JSON.stringify(value, null, 2) + "\n", "utf-8");
-}
-async function readJsonFile(filePath) {
-  const raw = await fileReader(filePath, "utf-8");
-  return JSON.parse(raw);
-}
-async function listFilesRecursive(rootDir) {
-  const out = [];
-  async function walk(dir) {
-    const entries = await readdir(dir, { withFileTypes: true });
-    for (const ent of entries) {
-      const fp = path.join(dir, ent.name);
-      if (ent.isDirectory()) {
-        await walk(fp);
-      } else if (ent.isFile()) {
-        out.push(fp);
-      }
-    }
-  }
-  await walk(rootDir);
-  return out.sort();
-}
-async function ensureDirExists(dirPath) {
-  await mkdir(dirPath, { recursive: true });
-}
-async function fileExists(filePath) {
-  try {
-    await stat(filePath);
-    return true;
-  } catch {
-    return false;
-  }
-}
-function toPosixRelPath(absPath, rootDir) {
-  const rel = path.relative(rootDir, absPath);
-  return rel.split(path.sep).join("/");
-}
-function fromPosixRelPath(relPath) {
-  return relPath.split("/").join(path.sep);
-}
-async function prepareSafeArchiveRoot(absPath, errorPrefix, argName) {
-  const rootAbs = path.resolve(absPath);
-  await assertIsDirectoryNotSymlink(rootAbs, errorPrefix, argName);
-  return {
-    abs: rootAbs,
-    real: await realpath(rootAbs),
-    errorPrefix,
-    argName
-  };
-}
-function validateArchiveRelativePath(relPath, errorPrefix) {
-  if (relPath.length === 0) {
-    throw new Error(`${errorPrefix}: record path must not be empty`);
-  }
-  if (relPath.includes("\\")) {
-    throw new Error(
-      `${errorPrefix}: record path must use POSIX separators: ${relPath}`
-    );
-  }
-  if (path.posix.isAbsolute(relPath)) {
-    throw new Error(
-      `${errorPrefix}: record path must be relative: ${relPath}`
-    );
-  }
-  const segments = relPath.split("/");
-  if (segments.some((segment) => segment === "" || segment === "." || segment === "..")) {
-    throw new Error(
-      `${errorPrefix}: record path contains unsafe segments: ${relPath}`
-    );
-  }
-  const normalized = path.posix.normalize(relPath);
-  if (normalized === "." || normalized === ".." || normalized.startsWith("../") || path.posix.isAbsolute(normalized)) {
-    throw new Error(
-      `${errorPrefix}: record path escapes target root: ${relPath}`
-    );
-  }
-  return normalized;
-}
-async function resolveSafeArchiveTarget(root, relPath) {
-  const safeRelPath = validateArchiveRelativePath(relPath, root.errorPrefix);
-  const targetAbs = path.resolve(root.abs, fromPosixRelPath(safeRelPath));
-  if (!isPathInsideRoot(root.abs, targetAbs)) {
-    throw new Error(
-      `${root.errorPrefix}: record path escapes target root: ${relPath}`
-    );
-  }
-  const targetStat = await lstat(targetAbs).catch((error) => {
-    if (error.code === "ENOENT") return null;
-    throw error;
-  });
-  if (targetStat?.isSymbolicLink()) {
-    throw new Error(
-      `${root.errorPrefix}: record path targets a symlink: ${relPath}`
-    );
-  }
-  await assertRealpathInsideRoot(
-    root.real,
-    targetAbs,
-    relPath,
-    root.errorPrefix
-  );
-  return targetAbs;
-}
-function isPathInsideRoot(rootReal, absPath) {
-  const rel = path.relative(rootReal, absPath);
-  if (rel === "") return true;
-  if (rel === "..") return false;
-  if (rel.startsWith(`..${path.sep}`)) return false;
-  if (path.isAbsolute(rel)) return false;
-  return true;
-}
-async function assertIsDirectoryNotSymlink(absPath, errorPrefix, argName) {
-  const st = await stat(absPath).catch(() => null);
-  if (!st || !st.isDirectory()) {
-    throw new Error(
-      `${errorPrefix}: '${argName}' must be an existing directory: ${absPath}`
-    );
-  }
-  const lst = await lstat(absPath).catch(() => null);
-  if (lst && lst.isSymbolicLink()) {
-    throw new Error(
-      `${errorPrefix}: '${argName}' must not be a symlink \u2014 resolve it to its real path first: ${absPath}`
-    );
-  }
-}
-async function assertRealpathInsideRoot(rootReal, targetAbs, sourcePath, errorPrefix) {
-  let existing = targetAbs;
-  const suffix = [];
-  while (existing !== path.dirname(existing)) {
-    const st = await lstat(existing).catch(() => null);
-    if (st !== null) break;
-    suffix.unshift(path.basename(existing));
-    existing = path.dirname(existing);
-  }
-  const existingReal = await realpath(existing).catch(() => existing);
-  const targetReal = suffix.length > 0 ? path.join(existingReal, ...suffix) : existingReal;
-  if (!isPathInsideRoot(rootReal, targetReal)) {
-    throw new Error(
-      `${errorPrefix}: record path escapes target root via symlink: ${sourcePath}`
-    );
-  }
-}
-
-export {
-  sha256File,
-  sha256Bytes,
-  sha256String,
-  readUtf8FileStrict,
-  writeJsonFile,
-  readJsonFile,
-  listFilesRecursive,
-  ensureDirExists,
-  fileExists,
-  toPosixRelPath,
-  fromPosixRelPath,
-  prepareSafeArchiveRoot,
-  validateArchiveRelativePath,
-  resolveSafeArchiveTarget,
-  isPathInsideRoot,
-  assertIsDirectoryNotSymlink,
-  assertRealpathInsideRoot
-};