@agenr/openclaw-plugin 1.5.0 → 2026.6.2

package/dist/chunk-VBPYU7GO.js

@@ -0,0 +1,597 @@
+// src/core/claim-key.ts
+var UNKNOWN_SEGMENT = "unknown";
+var SELF_REFERENTIAL_ENTITIES = /* @__PURE__ */ new Set(["i", "me", "myself", "the_user", "user", "we", "our_team", "the_project", "this_project"]);
+var GENERIC_ENTITIES = /* @__PURE__ */ new Set([
+  "app",
+  "company",
+  "config",
+  "data",
+  "device",
+  "entity",
+  "environment",
+  "item",
+  "organization",
+  "person",
+  "place",
+  "project",
+  "service",
+  "setting",
+  "system",
+  "team",
+  "thing",
+  "user",
+  "workspace"
+]);
+var GENERIC_ATTRIBUTES = /* @__PURE__ */ new Set(["info", "details", "config", "stuff", "thing", "data"]);
+var COMPACTION_RELATION_TOKENS = /* @__PURE__ */ new Set([
+  "after",
+  "before",
+  "depend",
+  "depends",
+  "follows",
+  "follow",
+  "keep",
+  "keeps",
+  "maintain",
+  "maintains",
+  "need",
+  "needs",
+  "precede",
+  "precedes",
+  "preserve",
+  "preserves",
+  "require",
+  "required",
+  "requires",
+  "retain",
+  "retains"
+]);
+var COMPACTION_BREAK_TOKENS = /* @__PURE__ */ new Set(["about", "across", "and", "between", "during", "for", "from", "into", "onto", "or", "to", "with"]);
+var COMPACTION_WEAK_LEADING_TOKENS = /* @__PURE__ */ new Set(["actual", "authoritative", "canonical", "concrete", "current", "durable", "existing", "real"]);
+var ACTION_CONDITION_TOKENS = /* @__PURE__ */ new Set(["activate", "activation", "apply", "fire", "launch", "run", "start", "trigger"]);
+var TRAILING_OBJECT_COMPACTION_PREPOSITIONS = /* @__PURE__ */ new Set(["about", "for", "from", "into", "onto", "to", "with"]);
+var TRAILING_OBJECT_TRANSFER_HEADS = /* @__PURE__ */ new Set([
+  "access",
+  "boundary",
+  "condition",
+  "contract",
+  "guide",
+  "path",
+  "policy",
+  "preference",
+  "process",
+  "rule",
+  "schedule",
+  "support",
+  "surface",
+  "window",
+  "workflow"
+]);
+var STABLE_ATTRIBUTE_HEADS = /* @__PURE__ */ new Set([
+  "access",
+  "boundary",
+  "condition",
+  "contract",
+  "default",
+  "dependency",
+  "guide",
+  "mode",
+  "order",
+  "path",
+  "policy",
+  "preference",
+  "preservation",
+  "process",
+  "requirement",
+  "rule",
+  "schedule",
+  "setting",
+  "status",
+  "strategy",
+  "support",
+  "surface",
+  "timezone",
+  "truth",
+  "version",
+  "window",
+  "workflow"
+]);
+function normalizeClaimKeySegment(value) {
+  return value.trim().toLowerCase().replace(/[^a-z0-9]+/g, "_").replace(/_+/g, "_").replace(/^_+|_+$/g, "");
+}
+function normalizeClaimKey(value) {
+  const trimmed = value.trim();
+  if (trimmed.length === 0) {
+    return { ok: false, reason: "empty" };
+  }
+  const slashCount = Array.from(trimmed).filter((character) => character === "/").length;
+  if (slashCount === 0) {
+    return { ok: false, reason: "missing_separator" };
+  }
+  if (slashCount !== 1) {
+    return { ok: false, reason: "too_many_segments" };
+  }
+  const [rawEntity = "", rawAttribute = ""] = trimmed.split("/");
+  const entity = normalizeClaimKeySegment(rawEntity);
+  if (entity.length === 0) {
+    return { ok: false, reason: "empty_entity" };
+  }
+  const attribute = normalizeClaimKeySegment(rawAttribute);
+  if (attribute.length === 0) {
+    return { ok: false, reason: "empty_attribute" };
+  }
+  if (entity === UNKNOWN_SEGMENT && attribute === UNKNOWN_SEGMENT) {
+    return { ok: false, reason: "unknown_pair" };
+  }
+  return {
+    ok: true,
+    value: {
+      claimKey: `${entity}/${attribute}`,
+      entity,
+      attribute
+    }
+  };
+}
+function compactClaimKey(claimKey) {
+  const normalized = normalizeClaimKey(claimKey);
+  if (!normalized.ok) {
+    return null;
+  }
+  let attributeTokens = normalized.value.attribute.split("_").filter((token) => token.length > 0);
+  const entityTokens = normalized.value.entity.split("_").filter((token) => token.length > 0);
+  const reasons = [];
+  if (entityTokens.length > 0 && startsWithTokens(attributeTokens, entityTokens) && attributeTokens.length > entityTokens.length) {
+    attributeTokens = attributeTokens.slice(entityTokens.length);
+    reasons.push("removed duplicated entity prefix from attribute");
+  }
+  if (entityTokens.length > 0 && attributeTokens.length > entityTokens.length + 1 && endsWithTokens(attributeTokens, entityTokens) && TRAILING_OBJECT_COMPACTION_PREPOSITIONS.has(attributeTokens[attributeTokens.length - entityTokens.length - 1] ?? "")) {
+    attributeTokens = attributeTokens.slice(0, attributeTokens.length - entityTokens.length - 1);
+    reasons.push("removed duplicated entity suffix from attribute");
+  }
+  const sourceOfTruthCompaction = compactSourceOfTruthAttribute(attributeTokens);
+  if (sourceOfTruthCompaction) {
+    attributeTokens = sourceOfTruthCompaction.attributeTokens;
+    reasons.push(sourceOfTruthCompaction.reason);
+  } else {
+    const relationCompaction = compactRelationAttribute(attributeTokens);
+    if (relationCompaction) {
+      attributeTokens = relationCompaction.attributeTokens;
+      reasons.push(relationCompaction.reason);
+    } else {
+      const trailingObjectCompaction = compactTrailingObjectAttribute(attributeTokens);
+      if (trailingObjectCompaction) {
+        attributeTokens = trailingObjectCompaction.attributeTokens;
+        reasons.push(trailingObjectCompaction.reason);
+      }
+    }
+  }
+  const attribute = attributeTokens.join("_");
+  if (attribute.length === 0) {
+    return {
+      claimKey: normalized.value.claimKey,
+      entity: normalized.value.entity,
+      attribute: normalized.value.attribute,
+      compactedFrom: null,
+      reason: null
+    };
+  }
+  const compactedClaimKey = `${normalized.value.entity}/${attribute}`;
+  return {
+    claimKey: compactedClaimKey,
+    entity: normalized.value.entity,
+    attribute,
+    compactedFrom: compactedClaimKey !== normalized.value.claimKey ? normalized.value.claimKey : null,
+    reason: reasons.length > 0 ? joinCompactionReasons(reasons) : null
+  };
+}
+function validateExtractedClaimKey(claimKey) {
+  if (SELF_REFERENTIAL_ENTITIES.has(claimKey.entity)) {
+    return {
+      ok: false,
+      reason: "self_referential_entity",
+      value: claimKey
+    };
+  }
+  if (GENERIC_ATTRIBUTES.has(claimKey.attribute)) {
+    return {
+      ok: false,
+      reason: "generic_attribute",
+      value: claimKey
+    };
+  }
+  if (isValueShapedAttribute(claimKey.attribute)) {
+    return {
+      ok: false,
+      reason: "value_shaped_attribute",
+      value: claimKey
+    };
+  }
+  return {
+    ok: true,
+    value: claimKey
+  };
+}
+function inspectClaimKey(value) {
+  const rawClaimKey = value.trim();
+  const normalized = normalizeClaimKey(rawClaimKey);
+  if (!normalized.ok) {
+    return {
+      rawClaimKey,
+      canonical: false,
+      normalizationFailure: normalized.reason,
+      suspectReasons: []
+    };
+  }
+  const suspectReasons = /* @__PURE__ */ new Set();
+  const validation = validateExtractedClaimKey(normalized.value);
+  if (!validation.ok) {
+    suspectReasons.add(validation.reason);
+  }
+  if (GENERIC_ENTITIES.has(normalized.value.entity)) {
+    suspectReasons.add("generic_entity");
+  }
+  return {
+    rawClaimKey,
+    canonical: normalized.value.claimKey === rawClaimKey,
+    normalized: normalized.value,
+    suspectReasons: [...suspectReasons]
+  };
+}
+function isTrustedClaimKeyForCleanup(value) {
+  const inspection = inspectClaimKey(value);
+  return Boolean(inspection.canonical && inspection.normalized && inspection.suspectReasons.length === 0);
+}
+function describeClaimKeyNormalizationFailure(reason) {
+  switch (reason) {
+    case "empty":
+      return "claim key was empty";
+    case "missing_separator":
+      return "claim key must contain exactly one '/'";
+    case "too_many_segments":
+      return "claim key must contain exactly one '/'";
+    case "empty_entity":
+      return "claim key entity was empty after normalization";
+    case "empty_attribute":
+      return "claim key attribute was empty after normalization";
+    case "unknown_pair":
+      return 'claim key "unknown/unknown" is not allowed';
+  }
+}
+function describeExtractedClaimKeyRejection(reason, claimKey) {
+  switch (reason) {
+    case "self_referential_entity":
+      return `entity "${claimKey.entity}" is self-referential`;
+    case "generic_attribute":
+      return `attribute "${claimKey.attribute}" is too generic`;
+    case "value_shaped_attribute":
+      return `attribute "${claimKey.attribute}" looks value-shaped`;
+  }
+}
+function describeClaimKeySuspicion(reason, claimKey) {
+  switch (reason) {
+    case "generic_entity":
+      return `entity "${claimKey.entity}" is too generic`;
+    case "self_referential_entity":
+    case "generic_attribute":
+    case "value_shaped_attribute":
+      return describeExtractedClaimKeyRejection(reason, claimKey);
+  }
+}
+function isValueShapedAttribute(attribute) {
+  return /^\d+(?:_\d+)*$/u.test(attribute) || /^v\d+(?:_\d+)*$/u.test(attribute);
+}
+function compactSourceOfTruthAttribute(attributeTokens) {
+  const sourceOfTruthIndex = findSourceOfTruthPhraseIndex(attributeTokens);
+  if (sourceOfTruthIndex === -1) {
+    return null;
+  }
+  const normalizedPhrase = ["source", "of", "truth"];
+  if (attributeTokens.length === normalizedPhrase.length && startsWithTokens(attributeTokens, normalizedPhrase)) {
+    return null;
+  }
+  const before = attributeTokens.slice(0, sourceOfTruthIndex);
+  const after = attributeTokens.slice(sourceOfTruthIndex + normalizedPhrase.length);
+  const leadingAllowed = before.every((token) => COMPACTION_WEAK_LEADING_TOKENS.has(token));
+  const hasMixedStableFamily = before.some((token) => STABLE_ATTRIBUTE_HEADS.has(token)) || after.some((token) => STABLE_ATTRIBUTE_HEADS.has(token));
+  const hasConjunctionNoise = before.includes("and") || before.includes("or") || after.includes("and") || after.includes("or");
+  if (!leadingAllowed || hasMixedStableFamily || hasConjunctionNoise) {
+    return null;
+  }
+  return {
+    attributeTokens: normalizedPhrase,
+    reason: "collapsed source-of-truth phrasing into the stable canonical slot"
+  };
+}
+function compactRelationAttribute(attributeTokens) {
+  const relationIndex = attributeTokens.findIndex((token) => COMPACTION_RELATION_TOKENS.has(token));
+  if (relationIndex === -1) {
+    return null;
+  }
+  const relation = attributeTokens[relationIndex] ?? "";
+  const left = attributeTokens.slice(0, relationIndex);
+  const right = attributeTokens.slice(relationIndex + 1);
+  if (left.length === 0 && right.length === 0) {
+    return null;
+  }
+  if (isRequirementRelation(relation)) {
+    const conditionAction = extractConditionAction(right);
+    if (conditionAction) {
+      return {
+        attributeTokens: [conditionAction, "condition"],
+        reason: `collapsed a sentence-like ${conditionAction} requirement into a stable condition slot`
+      };
+    }
+    const requirementFocus = extractCompactionFocus(right, 2) ?? extractCompactionFocus(left, 2);
+    if (!requirementFocus) {
+      return null;
+    }
+    return {
+      attributeTokens: [...requirementFocus, "requirement"],
+      reason: "collapsed a sentence-like requirement phrase into a stable requirement slot"
+    };
+  }
+  if (isOrderingRelation(relation)) {
+    const orderingFocus = extractCompactionFocus(right, 2) ?? extractCompactionFocus(left, 2);
+    if (!orderingFocus) {
+      return null;
+    }
+    return {
+      attributeTokens: [...orderingFocus, "order"],
+      reason: "collapsed a sentence-like ordering phrase into a stable order slot"
+    };
+  }
+  if (isPreservationRelation(relation)) {
+    const preservationFocus = extractCompactionFocus(right, 2) ?? extractCompactionFocus(left, 2);
+    if (!preservationFocus) {
+      return null;
+    }
+    return {
+      attributeTokens: [...preservationFocus, "preservation"],
+      reason: "collapsed a sentence-like preservation phrase into a stable preservation slot"
+    };
+  }
+  return null;
+}
+function compactTrailingObjectAttribute(attributeTokens) {
+  const prepositionIndex = attributeTokens.findIndex((token) => TRAILING_OBJECT_COMPACTION_PREPOSITIONS.has(token));
+  if (prepositionIndex <= 0 || prepositionIndex >= attributeTokens.length - 1) {
+    return null;
+  }
+  const left = trimWeakLeadingTokens(attributeTokens.slice(0, prepositionIndex));
+  const right = attributeTokens.slice(prepositionIndex + 1);
+  if (left.length === 0 || left.length > 3 || left.includes("and") || left.includes("or") || left.some((token) => COMPACTION_RELATION_TOKENS.has(token))) {
+    return null;
+  }
+  const head = left[left.length - 1];
+  if (!head || !TRAILING_OBJECT_TRANSFER_HEADS.has(head)) {
+    return null;
+  }
+  const objectFocus = extractCompactionFocus(right, 2);
+  if (!objectFocus) {
+    return null;
+  }
+  const headCore = extractStableHeadCore(left, 2);
+  if (!headCore) {
+    return null;
+  }
+  return {
+    attributeTokens: [...objectFocus, ...headCore],
+    reason: "collapsed a trailing object phrase into a compact stable slot name"
+  };
+}
+function findSourceOfTruthPhraseIndex(tokens) {
+  for (let index = 0; index <= tokens.length - 3; index += 1) {
+    if (tokens[index] === "source" && tokens[index + 1] === "of" && tokens[index + 2] === "truth") {
+      return index;
+    }
+  }
+  return -1;
+}
+function extractConditionAction(tokens) {
+  for (let index = tokens.length - 1; index >= 0; index -= 1) {
+    const token = tokens[index];
+    if (token && ACTION_CONDITION_TOKENS.has(token)) {
+      return token;
+    }
+  }
+  return null;
+}
+function extractCompactionFocus(tokens, limit) {
+  const compactable = trimWeakLeadingTokens(tokens).filter((token) => token.length > 0);
+  const segments = splitTokensOnBreaks(compactable).filter((segment) => segment.length > 0);
+  const preferredSegment = segments[0];
+  if (!preferredSegment || preferredSegment.length === 0) {
+    return null;
+  }
+  return preferredSegment.slice(0, limit);
+}
+function extractStableHeadCore(tokens, limit) {
+  const compactable = trimWeakLeadingTokens(tokens).filter((token) => token.length > 0);
+  const head = compactable[compactable.length - 1];
+  if (!head || !STABLE_ATTRIBUTE_HEADS.has(head)) {
+    return null;
+  }
+  return compactable.slice(Math.max(0, compactable.length - limit));
+}
+function splitTokensOnBreaks(tokens) {
+  const segments = [];
+  let current = [];
+  for (const token of tokens) {
+    if (COMPACTION_BREAK_TOKENS.has(token)) {
+      if (current.length > 0) {
+        segments.push(current);
+        current = [];
+      }
+      continue;
+    }
+    current.push(token);
+  }
+  if (current.length > 0) {
+    segments.push(current);
+  }
+  return segments;
+}
+function trimWeakLeadingTokens(tokens) {
+  let start = 0;
+  while (start < tokens.length && COMPACTION_WEAK_LEADING_TOKENS.has(tokens[start] ?? "")) {
+    start += 1;
+  }
+  return tokens.slice(start);
+}
+function joinCompactionReasons(reasons) {
+  if (reasons.length <= 1) {
+    return reasons[0] ?? "";
+  }
+  return `${reasons.slice(0, -1).join(", ")} and ${reasons[reasons.length - 1]}`;
+}
+function isRequirementRelation(token) {
+  return token === "depend" || token === "depends" || token === "need" || token === "needs" || token === "required" || token === "require" || token === "requires";
+}
+function isOrderingRelation(token) {
+  return token === "after" || token === "before" || token === "follow" || token === "follows" || token === "precede" || token === "precedes";
+}
+function isPreservationRelation(token) {
+  return token === "keep" || token === "keeps" || token === "maintain" || token === "maintains" || token === "preserve" || token === "preserves" || token === "retain" || token === "retains";
+}
+function startsWithTokens(tokens, prefix) {
+  return prefix.every((token, index) => tokens[index] === token);
+}
+function endsWithTokens(tokens, suffix) {
+  return suffix.every((token, index) => tokens[tokens.length - suffix.length + index] === token);
+}
+
+// src/core/keyed-durable-lifecycle.ts
+function hasKeyedDurableLifecycleStatus(entry) {
+  return Boolean(entry.claim_key?.trim() && entry.claim_key_status);
+}
+function assertKeyedDurableHasLifecycle(entry) {
+  if (!entry.claim_key?.trim()) {
+    return;
+  }
+  if (!entry.claim_key_status) {
+    const idSuffix = entry.id ? ` "${entry.id}"` : "";
+    throw new Error(`Missing claim_key_status for keyed durable${idSuffix}.`);
+  }
+}
+function resolveKeyedDurableLifecycleStatus(entry) {
+  if (!entry.claim_key?.trim()) {
+    return "no_key";
+  }
+  assertKeyedDurableHasLifecycle(entry);
+  return entry.claim_key_status;
+}
+
+// src/core/temporal-validity.ts
+function validateTemporalValidityRange(validFrom, validTo) {
+  const normalizedValidFrom = normalizeOptionalTimestamp(validFrom);
+  if (validFrom !== void 0 && validFrom !== null && normalizedValidFrom === null) {
+    return {
+      ok: false,
+      code: "invalid_valid_from",
+      message: "valid_from must be a valid ISO 8601 timestamp."
+    };
+  }
+  const normalizedValidTo = normalizeOptionalTimestamp(validTo);
+  if (validTo !== void 0 && validTo !== null && normalizedValidTo === null) {
+    return {
+      ok: false,
+      code: "invalid_valid_to",
+      message: "valid_to must be a valid ISO 8601 timestamp."
+    };
+  }
+  if (normalizedValidFrom !== void 0 && normalizedValidFrom !== null && normalizedValidTo !== void 0 && normalizedValidTo !== null && Date.parse(normalizedValidFrom) >= Date.parse(normalizedValidTo)) {
+    return {
+      ok: false,
+      code: "invalid_range",
+      message: "valid_from must be earlier than valid_to."
+    };
+  }
+  const validFromValue = normalizedValidFrom ?? void 0;
+  const validToValue = normalizedValidTo ?? void 0;
+  return {
+    ok: true,
+    value: {
+      validFrom: validFromValue,
+      validTo: validToValue
+    }
+  };
+}
+function isWithinValidityWindow(validFrom, validTo, asOfMs) {
+  const fromMs = parseInstantMs(validFrom);
+  if (fromMs !== null && asOfMs < fromMs) {
+    return false;
+  }
+  const toMs = parseInstantMs(validTo);
+  if (toMs !== null && asOfMs > toMs) {
+    return false;
+  }
+  return true;
+}
+function isCurrentlyValidMemory(row, nowMs) {
+  const supersededBy = row.superseded_by?.trim();
+  if (supersededBy) {
+    return false;
+  }
+  const toMs = parseInstantMs(row.valid_to);
+  if (toMs !== null && nowMs >= toMs) {
+    return false;
+  }
+  return true;
+}
+function isStaleMemory(row, nowMs) {
+  const supersededBy = row.superseded_by?.trim();
+  if (supersededBy) {
+    return false;
+  }
+  const toMs = parseInstantMs(row.valid_to);
+  if (toMs === null) {
+    return false;
+  }
+  return nowMs >= toMs;
+}
+function parseInstantMs(value) {
+  if (value === void 0 || value === null) {
+    return null;
+  }
+  const trimmed = value.trim();
+  if (trimmed.length === 0) {
+    return null;
+  }
+  const parsed = Date.parse(trimmed);
+  if (Number.isNaN(parsed)) {
+    return null;
+  }
+  return parsed;
+}
+function normalizeOptionalTimestamp(value) {
+  if (value === void 0 || value === null) {
+    return void 0;
+  }
+  const normalized = value.trim();
+  if (normalized.length === 0) {
+    return void 0;
+  }
+  if (!normalized.includes("T") || Number.isNaN(Date.parse(normalized))) {
+    return null;
+  }
+  return normalized;
+}
+
+export {
+  normalizeClaimKeySegment,
+  normalizeClaimKey,
+  compactClaimKey,
+  validateExtractedClaimKey,
+  inspectClaimKey,
+  isTrustedClaimKeyForCleanup,
+  describeClaimKeyNormalizationFailure,
+  describeExtractedClaimKeyRejection,
+  describeClaimKeySuspicion,
+  hasKeyedDurableLifecycleStatus,
+  assertKeyedDurableHasLifecycle,
+  resolveKeyedDurableLifecycleStatus,
+  validateTemporalValidityRange,
+  isWithinValidityWindow,
+  isCurrentlyValidMemory,
+  isStaleMemory
+};