@agenr/openclaw-plugin 1.5.0 → 2026.6.2

package/dist/chunk-MC3C2XM5.js

@@ -0,0 +1,148 @@
+import {
+  buildManualClaimKeyLifecycle
+} from "./chunk-VTHBPXDQ.js";
+
+// src/core/procedures/hashing.ts
+import { createHash } from "crypto";
+function computeProcedureSourceHash(sourceText) {
+  return createHash("sha256").update(sourceText).digest("hex");
+}
+function computeProcedureRevisionHash(procedure) {
+  return createHash("sha256").update(stringifyCanonical(procedure)).digest("hex");
+}
+function stringifyCanonical(value) {
+  if (value === null || typeof value === "string" || typeof value === "number" || typeof value === "boolean") {
+    return JSON.stringify(value);
+  }
+  if (Array.isArray(value)) {
+    return `[${value.map((item) => stringifyCanonical(item)).join(",")}]`;
+  }
+  const keys = Object.keys(value).sort((left, right) => left.localeCompare(right));
+  return `{${keys.map((key) => `${JSON.stringify(key)}:${stringifyCanonical(value[key])}`).join(",")}}`;
+}
+
+// src/core/procedures/recall-text.ts
+function composeProcedureRecallText(procedure) {
+  const lines = [
+    `procedure_key: ${procedure.procedure_key}`,
+    `title: ${procedure.title}`,
+    `goal: ${procedure.goal}`,
+    ...formatSection("when_to_use", procedure.when_to_use),
+    ...formatSection("when_not_to_use", procedure.when_not_to_use),
+    ...formatSection("prerequisites", procedure.prerequisites),
+    "steps:",
+    ...procedure.steps.flatMap((step, index) => formatStep(step, index)),
+    ...formatSection("verification", procedure.verification),
+    ...formatSection("failure_modes", procedure.failure_modes),
+    "sources:",
+    ...procedure.sources.map((source, index) => `  ${index + 1}. ${formatSource(source)}`)
+  ];
+  return lines.join("\n");
+}
+function formatSection(label, values) {
+  if (values.length === 0) {
+    return [`${label}: none`];
+  }
+  return [`${label}:`, ...values.map((value, index) => `  ${index + 1}. ${value}`)];
+}
+function formatStep(step, index) {
+  const lines = [`  ${index + 1}. [${step.kind}] ${step.id} - ${step.instruction}`];
+  switch (step.kind) {
+    case "run_command":
+      lines.push(`     command: ${step.command}`);
+      break;
+    case "read_reference":
+      lines.push(`     ref: ${formatSource(step.ref)}`);
+      break;
+    case "inspect_state":
+      if (step.target) {
+        lines.push(`     target: ${step.target}`);
+      }
+      if (step.query) {
+        lines.push(`     query: ${step.query}`);
+      }
+      break;
+    case "edit_file":
+      lines.push(`     path: ${step.path}`);
+      lines.push(`     edit: ${step.edit}`);
+      break;
+    case "ask_user":
+      lines.push(`     prompt: ${step.prompt}`);
+      break;
+    case "invoke_tool":
+      lines.push(`     tool: ${step.tool}`);
+      if (step.arguments) {
+        lines.push(`     arguments: ${JSON.stringify(step.arguments)}`);
+      }
+      break;
+    case "verify":
+      lines.push(...step.checks.map((check, checkIndex) => `     check ${checkIndex + 1}: ${check}`));
+      break;
+  }
+  if (step.conditions?.length) {
+    lines.push(`     conditions: ${step.conditions.map((condition) => formatCondition(condition)).join("; ")}`);
+  }
+  if (step.stop_if?.length) {
+    lines.push(`     stop_if: ${step.stop_if.map((condition) => formatCondition(condition)).join("; ")}`);
+  }
+  return lines;
+}
+function formatCondition(condition) {
+  switch (condition.kind) {
+    case "file_exists":
+    case "path_exists":
+      return `${condition.kind}=${condition.path}`;
+    case "env_flag":
+      return condition.value ? `${condition.kind}=${condition.name}:${condition.value}` : `${condition.kind}=${condition.name}`;
+    default:
+      return `${condition.kind}=${condition.value}`;
+  }
+}
+function formatSource(source) {
+  const parts = [source.kind];
+  if (source.path) {
+    parts.push(`path=${source.path}`);
+  }
+  if (source.locator) {
+    parts.push(`locator=${source.locator}`);
+  }
+  if (source.label) {
+    parts.push(`label=${source.label}`);
+  }
+  return parts.join(" ");
+}
+
+// src/app/fixtures/default-claim-key-lifecycle.ts
+function applyDefaultClaimKeyLifecycle(durable, rationale) {
+  const claimKey = durable.claim_key?.trim();
+  if (!claimKey || durable.claim_key_status) {
+    return durable;
+  }
+  const lifecycle = buildManualClaimKeyLifecycle({
+    claimKey,
+    rawClaimKey: durable.claim_key_raw ?? durable.claim_key,
+    supportSourceKind: durable.claim_support_source_kind,
+    supportLocator: durable.claim_support_locator,
+    supportObservedAt: durable.claim_support_observed_at,
+    supportMode: durable.claim_support_mode
+  });
+  return {
+    ...durable,
+    claim_key_raw: durable.claim_key_raw ?? lifecycle.claim_key_raw,
+    claim_key_status: lifecycle.claim_key_status,
+    claim_key_source: durable.claim_key_source ?? lifecycle.claim_key_source,
+    claim_key_confidence: durable.claim_key_confidence ?? lifecycle.claim_key_confidence,
+    claim_key_rationale: durable.claim_key_rationale ?? rationale,
+    claim_support_source_kind: durable.claim_support_source_kind ?? lifecycle.claim_support_source_kind,
+    claim_support_locator: durable.claim_support_locator ?? lifecycle.claim_support_locator,
+    claim_support_observed_at: durable.claim_support_observed_at ?? lifecycle.claim_support_observed_at,
+    claim_support_mode: durable.claim_support_mode ?? lifecycle.claim_support_mode
+  };
+}
+
+export {
+  computeProcedureSourceHash,
+  computeProcedureRevisionHash,
+  composeProcedureRecallText,
+  applyDefaultClaimKeyLifecycle
+};