@almadar/evaluator 2.5.6 → 2.7.0

package/dist/{index-Cwku8aP4.d.ts → index-CvAGW0K_.d.ts}

@@ -1,4 +1,4 @@
-import { SExpr } from '@almadar/core';
+import { AgentContext, SExpr } from '@almadar/core';
 
 /**
  * Evaluation Context
@@ -8,6 +8,7 @@ import { SExpr } from '@almadar/core';
  *
  * @packageDocumentation
  */
+
 /**
  * User context for @user bindings (role-based UI).
  */
@@ -62,6 +63,8 @@ interface EvaluationContext {
     _probSeed?: {
         state: number;
     };
+    /** Agent context for agent/* operators (memory, LLM, tools, session) */
+    agent?: AgentContext;
     /** Mutate entity fields */
     mutateEntity?: (changes: Record<string, unknown>) => void;
     /** Emit an event */
@@ -82,6 +85,15 @@ interface EvaluationContext {
     renderUI?: (slot: string, pattern: unknown, props?: Record<string, unknown>, priority?: number) => void;
     /** Register an OS trigger (server-side only) */
     registerOsTrigger?: (type: string, config: Record<string, unknown>) => void;
+    /** Effect handlers for resource operators (grouped to avoid top-level pollution) */
+    effectHandlers?: {
+        ref?: (entityType: string, options?: unknown) => unknown;
+        deref?: (entityType: string, id?: unknown) => unknown;
+        swap?: (entityType: string, id: unknown, transformExpr: unknown, evaluate: unknown, ctx: unknown) => unknown;
+        watch?: (entityType: string, effects: unknown[], evaluate: unknown, ctx: unknown) => void;
+        atomic?: (effects: unknown[], evaluate: unknown, ctx: unknown) => unknown;
+        fetch?: (entityType: string, options?: unknown) => unknown;
+    };
 }
 /**
  * Create a minimal evaluation context for testing/guards.
@@ -383,5 +395,30 @@ declare function evalIncrement(args: SExpr[], evaluate: Evaluator, ctx: Evaluati
  * Evaluate decrement: ["decrement", "@entity.field"] or ["decrement", "@entity.field", amount]
  */
 declare function evalDecrement(args: SExpr[], evaluate: Evaluator, ctx: EvaluationContext): void;
+/**
+ * Evaluate ref: ["ref", "EntityType"] or ["ref", "EntityType", { filter, include }]
+ * Server-side: queries entity data. Client-side: subscribes to EntityStore.
+ */
+declare function evalRef(args: SExpr[], evaluate: Evaluator, ctx: EvaluationContext): unknown;
+/**
+ * Evaluate deref: ["deref", "EntityType"] or ["deref", "EntityType", idExpr]
+ * Pure snapshot read. Returns current entity data from store.
+ */
+declare function evalDeref(args: SExpr[], evaluate: Evaluator, ctx: EvaluationContext): unknown;
+/**
+ * Evaluate swap!: ["swap!", "EntityType", idExpr, transformExpr]
+ * Atomic read-modify-write with CAS retry.
+ */
+declare function evalSwap(args: SExpr[], evaluate: Evaluator, ctx: EvaluationContext): unknown;
+/**
+ * Evaluate watch: ["watch", "EntityType", [effect1, effect2, ...]]
+ * Client-only. Registers a callback on the EntityStore.
+ */
+declare function evalWatch(args: SExpr[], evaluate: Evaluator, ctx: EvaluationContext): void;
+/**
+ * Evaluate atomic: ["atomic", [effect1, effect2, ...]]
+ * Groups effects into a transaction. All succeed or all roll back.
+ */
+declare function evalAtomic(args: SExpr[], evaluate: Evaluator, ctx: EvaluationContext): unknown;
 
-export { evalWhen as $, evalIncludes as A, evalIncrement as B, evalLast as C, evalLessThan as D, type EvaluationContext as E, evalLessThanOrEqual as F, evalLet as G, evalMap as H, evalMatches as I, evalMax as J, evalMin as K, evalModulo as L, evalMultiply as M, evalNavigate as N, evalNot as O, evalNotEqual as P, evalNotify as Q, evalNth as R, evalOr as S, evalPersist as T, evalRenderUI as U, evalRound as V, evalSet as W, evalSetDynamic as X, evalSpawn as Y, evalSubtract as Z, evalSum as _, createEffectContext as a, resolveBinding as a0, createMinimalContext as b, createChildContext as c, evalAdd as d, evalAbs as e, evalAnd as f, evalCallService as g, evalCeil as h, evalClamp as i, evalConcat as j, evalCount as k, evalDecrement as l, evalDespawn as m, evalDivide as n, evalDo as o, evalEmit as p, evalEmpty as q, evalEqual as r, evalFilter as s, evalFind as t, evalFirst as u, evalFloor as v, evalFn as w, evalGreaterThan as x, evalGreaterThanOrEqual as y, evalIf as z };
+export { evalSpawn as $, evalGreaterThanOrEqual as A, evalIf as B, evalIncludes as C, evalIncrement as D, type EvaluationContext as E, evalLast as F, evalLessThan as G, evalLessThanOrEqual as H, evalLet as I, evalMap as J, evalMatches as K, evalMax as L, evalMin as M, evalModulo as N, evalMultiply as O, evalNavigate as P, evalNot as Q, evalNotEqual as R, evalNotify as S, evalNth as T, evalOr as U, evalPersist as V, evalRef as W, evalRenderUI as X, evalRound as Y, evalSet as Z, evalSetDynamic as _, createEffectContext as a, evalSubtract as a0, evalSum as a1, evalSwap as a2, evalWatch as a3, evalWhen as a4, resolveBinding as a5, createMinimalContext as b, createChildContext as c, evalAdd as d, evalAbs as e, evalAnd as f, evalAtomic as g, evalCallService as h, evalCeil as i, evalClamp as j, evalConcat as k, evalCount as l, evalDecrement as m, evalDeref as n, evalDespawn as o, evalDivide as p, evalDo as q, evalEmit as r, evalEmpty as s, evalEqual as t, evalFilter as u, evalFind as v, evalFirst as w, evalFloor as x, evalFn as y, evalGreaterThan as z };

package/dist/index.d.ts

@@ -1,7 +1,7 @@
 import { SExpr } from '@almadar/core';
 export { CORE_BINDINGS, CoreBinding, Expression, ExpressionSchema, ParsedBinding, SExpr, SExprAtom, SExprSchema, collectBindings, getArgs, getOperator, isBinding, isSExpr, isSExprAtom, isSExprCall, isValidBinding, parseBinding, sexpr, walkSExpr } from '@almadar/core';
-import { E as EvaluationContext } from './index-Cwku8aP4.js';
-export { c as createChildContext, a as createEffectContext, b as createMinimalContext, e as evalAbs, d as evalAdd, f as evalAnd, g as evalCallService, h as evalCeil, i as evalClamp, j as evalConcat, k as evalCount, l as evalDecrement, m as evalDespawn, n as evalDivide, o as evalDo, p as evalEmit, q as evalEmpty, r as evalEqual, s as evalFilter, t as evalFind, u as evalFirst, v as evalFloor, w as evalFn, x as evalGreaterThan, y as evalGreaterThanOrEqual, z as evalIf, A as evalIncludes, B as evalIncrement, C as evalLast, D as evalLessThan, F as evalLessThanOrEqual, G as evalLet, H as evalMap, I as evalMatches, J as evalMax, K as evalMin, L as evalModulo, M as evalMultiply, N as evalNavigate, O as evalNot, P as evalNotEqual, Q as evalNotify, R as evalNth, S as evalOr, T as evalPersist, U as evalRenderUI, V as evalRound, W as evalSet, X as evalSetDynamic, Y as evalSpawn, Z as evalSubtract, _ as evalSum, $ as evalWhen, a0 as resolveBinding } from './index-Cwku8aP4.js';
+import { E as EvaluationContext } from './index-CvAGW0K_.js';
+export { c as createChildContext, a as createEffectContext, b as createMinimalContext, e as evalAbs, d as evalAdd, f as evalAnd, g as evalAtomic, h as evalCallService, i as evalCeil, j as evalClamp, k as evalConcat, l as evalCount, m as evalDecrement, n as evalDeref, o as evalDespawn, p as evalDivide, q as evalDo, r as evalEmit, s as evalEmpty, t as evalEqual, u as evalFilter, v as evalFind, w as evalFirst, x as evalFloor, y as evalFn, z as evalGreaterThan, A as evalGreaterThanOrEqual, B as evalIf, C as evalIncludes, D as evalIncrement, F as evalLast, G as evalLessThan, H as evalLessThanOrEqual, I as evalLet, J as evalMap, K as evalMatches, L as evalMax, M as evalMin, N as evalModulo, O as evalMultiply, P as evalNavigate, Q as evalNot, R as evalNotEqual, S as evalNotify, T as evalNth, U as evalOr, V as evalPersist, W as evalRef, X as evalRenderUI, Y as evalRound, Z as evalSet, _ as evalSetDynamic, $ as evalSpawn, a0 as evalSubtract, a1 as evalSum, a2 as evalSwap, a3 as evalWatch, a4 as evalWhen, a5 as resolveBinding } from './index-CvAGW0K_.js';
 
 /**
  * S-Expression Evaluator

package/dist/index.js

@@ -574,6 +574,56 @@ function evalDecrement(args, evaluate2, ctx) {
   const newValue = toNumber3(currentValue) - amount;
   ctx.mutateEntity({ [fieldPath]: newValue });
 }
+function evalRef(args, evaluate2, ctx) {
+  const entityType = args[0];
+  if (ctx.effectHandlers?.ref) {
+    return ctx.effectHandlers.ref(entityType, args.length > 1 ? evaluate2(args[1], ctx) : void 0);
+  }
+  if (ctx.effectHandlers?.fetch) {
+    return ctx.effectHandlers.fetch(entityType, args.length > 1 ? evaluate2(args[1], ctx) : void 0);
+  }
+  return void 0;
+}
+function evalDeref(args, evaluate2, ctx) {
+  const entityType = args[0];
+  const id = args.length > 1 ? evaluate2(args[1], ctx) : void 0;
+  if (ctx.effectHandlers?.deref) {
+    return ctx.effectHandlers.deref(entityType, id);
+  }
+  if (id && ctx.effectHandlers?.fetch) {
+    return ctx.effectHandlers.fetch(entityType, id);
+  }
+  return ctx.entity?.[entityType] ?? [];
+}
+function evalSwap(args, evaluate2, ctx) {
+  const entityType = args[0];
+  const id = evaluate2(args[1], ctx);
+  const transformExpr = args[2];
+  if (ctx.effectHandlers?.swap) {
+    return ctx.effectHandlers.swap(entityType, id, transformExpr, evaluate2, ctx);
+  }
+  console.warn("No swap handler in context");
+  return void 0;
+}
+function evalWatch(args, evaluate2, ctx) {
+  const entityType = args[0];
+  const effects = args[1];
+  if (ctx.effectHandlers?.watch) {
+    ctx.effectHandlers.watch(entityType, effects, evaluate2, ctx);
+  }
+}
+function evalAtomic(args, evaluate2, ctx) {
+  const effects = args[0];
+  if (ctx.effectHandlers?.atomic) {
+    return ctx.effectHandlers.atomic(effects, evaluate2, ctx);
+  }
+  if (Array.isArray(effects)) {
+    for (const eff of effects) {
+      evaluate2(eff, ctx);
+    }
+  }
+  return void 0;
+}
 function toNumber3(value) {
   if (typeof value === "number") return value;
   if (typeof value === "string") {
@@ -2386,6 +2436,120 @@ function evalOsDebounce(args, evaluate2, ctx) {
   registerTrigger(ctx, "debounce", { ms, eventType });
 }
 
+// std/agent.ts
+function evalAgentRecall(args, evaluate2, ctx) {
+  if (!ctx.agent) return [];
+  const query = evaluate2(args[0], ctx);
+  const limit = args.length > 1 ? evaluate2(args[1], ctx) : void 0;
+  return ctx.agent.recall(query, limit);
+}
+function evalAgentMemories(args, evaluate2, ctx) {
+  if (!ctx.agent) return [];
+  const category = args.length > 0 ? evaluate2(args[0], ctx) : void 0;
+  return ctx.agent.memories(category);
+}
+function evalAgentMemoryStrength(args, evaluate2, ctx) {
+  if (!ctx.agent) return 0;
+  const id = evaluate2(args[0], ctx);
+  return ctx.agent.memoryStrength(id);
+}
+function evalAgentIsPinned(args, evaluate2, ctx) {
+  if (!ctx.agent) return false;
+  const id = evaluate2(args[0], ctx);
+  return ctx.agent.isPinned(id);
+}
+function evalAgentProvider(_args, _evaluate, ctx) {
+  if (!ctx.agent) return "";
+  return ctx.agent.provider();
+}
+function evalAgentModel(_args, _evaluate, ctx) {
+  if (!ctx.agent) return "";
+  return ctx.agent.model();
+}
+function evalAgentTools(_args, _evaluate, ctx) {
+  if (!ctx.agent) return [];
+  return ctx.agent.tools();
+}
+function evalAgentTokenCount(_args, _evaluate, ctx) {
+  if (!ctx.agent) return 0;
+  return ctx.agent.tokenCount();
+}
+function evalAgentContextUsage(_args, _evaluate, ctx) {
+  if (!ctx.agent) return 0;
+  return ctx.agent.contextUsage();
+}
+function evalAgentSessionId(_args, _evaluate, ctx) {
+  if (!ctx.agent) return "";
+  return ctx.agent.sessionId();
+}
+function evalAgentMemorize(args, evaluate2, ctx) {
+  if (!ctx.agent) return null;
+  const content = evaluate2(args[0], ctx);
+  const category = evaluate2(args[1], ctx);
+  const scope = args.length > 2 ? evaluate2(args[2], ctx) : void 0;
+  return ctx.agent.memorize(content, category, scope);
+}
+function evalAgentForget(args, evaluate2, ctx) {
+  if (!ctx.agent) return null;
+  const id = evaluate2(args[0], ctx);
+  return ctx.agent.forget(id);
+}
+function evalAgentPin(args, evaluate2, ctx) {
+  if (!ctx.agent) return null;
+  const id = evaluate2(args[0], ctx);
+  return ctx.agent.pin(id);
+}
+function evalAgentReinforce(args, evaluate2, ctx) {
+  if (!ctx.agent) return null;
+  const id = evaluate2(args[0], ctx);
+  return ctx.agent.reinforce(id);
+}
+function evalAgentDecay(_args, _evaluate, ctx) {
+  if (!ctx.agent) return null;
+  return ctx.agent.decay();
+}
+function evalAgentGenerate(args, evaluate2, ctx) {
+  if (!ctx.agent) return null;
+  const prompt = evaluate2(args[0], ctx);
+  const options = args.length > 1 ? evaluate2(args[1], ctx) : void 0;
+  return ctx.agent.generate(prompt, options);
+}
+function evalAgentSwitchProvider(args, evaluate2, ctx) {
+  if (!ctx.agent) return null;
+  const provider = evaluate2(args[0], ctx);
+  const model = args.length > 1 ? evaluate2(args[1], ctx) : void 0;
+  ctx.agent.switchProvider(provider, model);
+  return null;
+}
+function evalAgentInvoke(args, evaluate2, ctx) {
+  if (!ctx.agent) return null;
+  const toolName = evaluate2(args[0], ctx);
+  const toolArgs = evaluate2(args[1], ctx);
+  return ctx.agent.invoke(toolName, toolArgs);
+}
+function evalAgentCompact(args, evaluate2, ctx) {
+  if (!ctx.agent) return null;
+  const strategy = args.length > 0 ? evaluate2(args[0], ctx) : void 0;
+  return ctx.agent.compact(strategy);
+}
+function evalAgentFork(args, evaluate2, ctx) {
+  if (!ctx.agent) return null;
+  const label = args.length > 0 ? evaluate2(args[0], ctx) : void 0;
+  return ctx.agent.fork(label);
+}
+function evalAgentLabel(args, evaluate2, ctx) {
+  if (!ctx.agent) return null;
+  const text = evaluate2(args[0], ctx);
+  ctx.agent.label(text);
+  return null;
+}
+function evalAgentSearchCode(args, evaluate2, ctx) {
+  if (!ctx.agent) return null;
+  const query = evaluate2(args[0], ctx);
+  const language = args.length > 1 ? evaluate2(args[1], ctx) : void 0;
+  return ctx.agent.searchCode(query, language);
+}
+
 // SExpressionEvaluator.ts
 var jitCache = /* @__PURE__ */ new Map();
 var MAX_JIT_CACHE_SIZE = 1e3;
@@ -2593,6 +2757,18 @@ var SExpressionEvaluator = class {
       case "render-ui":
         evalRenderUI(args, evaluate2, ctx);
         return void 0;
+      // Resource operators
+      case "ref":
+        return evalRef(args, evaluate2, ctx);
+      case "deref":
+        return evalDeref(args, evaluate2, ctx);
+      case "swap!":
+        return evalSwap(args, evaluate2, ctx);
+      case "watch":
+        evalWatch(args, evaluate2, ctx);
+        return void 0;
+      case "atomic":
+        return evalAtomic(args, evaluate2, ctx);
       // ===============================
       // Standard Library: math/*
       // ===============================
@@ -3020,6 +3196,64 @@ var SExpressionEvaluator = class {
       case "os/debounce":
         evalOsDebounce(args, evaluate2, ctx);
         return void 0;
+      // ===============================
+      // Standard Library: agent/*
+      // ===============================
+      // Pure (memory)
+      case "agent/recall":
+        return evalAgentRecall(args, evaluate2, ctx);
+      case "agent/memories":
+        return evalAgentMemories(args, evaluate2, ctx);
+      case "agent/memory-strength":
+        return evalAgentMemoryStrength(args, evaluate2, ctx);
+      case "agent/is-pinned":
+        return evalAgentIsPinned(args, evaluate2, ctx);
+      // Pure (LLM)
+      case "agent/provider":
+        return evalAgentProvider(args, evaluate2, ctx);
+      case "agent/model":
+        return evalAgentModel(args, evaluate2, ctx);
+      // Pure (tools)
+      case "agent/tools":
+        return evalAgentTools(args, evaluate2, ctx);
+      // Pure (context)
+      case "agent/token-count":
+        return evalAgentTokenCount(args, evaluate2, ctx);
+      case "agent/context-usage":
+        return evalAgentContextUsage(args, evaluate2, ctx);
+      // Pure (session)
+      case "agent/session-id":
+        return evalAgentSessionId(args, evaluate2, ctx);
+      // Effects (memory)
+      case "agent/memorize":
+        return evalAgentMemorize(args, evaluate2, ctx);
+      case "agent/forget":
+        return evalAgentForget(args, evaluate2, ctx);
+      case "agent/pin":
+        return evalAgentPin(args, evaluate2, ctx);
+      case "agent/reinforce":
+        return evalAgentReinforce(args, evaluate2, ctx);
+      case "agent/decay":
+        return evalAgentDecay(args, evaluate2, ctx);
+      // Effects (LLM)
+      case "agent/generate":
+        return evalAgentGenerate(args, evaluate2, ctx);
+      case "agent/switch-provider":
+        return evalAgentSwitchProvider(args, evaluate2, ctx);
+      // Effects (tools)
+      case "agent/invoke":
+        return evalAgentInvoke(args, evaluate2, ctx);
+      // Effects (context)
+      case "agent/compact":
+        return evalAgentCompact(args, evaluate2, ctx);
+      // Effects (session)
+      case "agent/fork":
+        return evalAgentFork(args, evaluate2, ctx);
+      case "agent/label":
+        return evalAgentLabel(args, evaluate2, ctx);
+      // Effects (search)
+      case "agent/search-code":
+        return evalAgentSearchCode(args, evaluate2, ctx);
       default:
         console.warn(`Unknown operator: ${op}`);
         return void 0;
@@ -3040,6 +3274,6 @@ function executeEffects(effects, ctx) {
   evaluator.executeEffects(effects, ctx);
 }
 
-export { SExpressionEvaluator, createChildContext, createEffectContext, createMinimalContext, evalAbs, evalAdd, evalAnd, evalCallService, evalCeil, evalClamp, evalConcat, evalCount, evalDecrement, evalDespawn, evalDivide, evalDo, evalEmit, evalEmpty, evalEqual, evalFilter, evalFind, evalFirst, evalFloor, evalFn, evalGreaterThan, evalGreaterThanOrEqual, evalIf, evalIncludes, evalIncrement, evalLast, evalLessThan, evalLessThanOrEqual, evalLet, evalMap, evalMatches, evalMax, evalMin, evalModulo, evalMultiply, evalNavigate, evalNot, evalNotEqual, evalNotify, evalNth, evalOr, evalPersist, evalRenderUI, evalRound, evalSet, evalSetDynamic, evalSpawn, evalSubtract, evalSum, evalWhen, evaluate, evaluateGuard, evaluator, executeEffect, executeEffects, resolveBinding };
+export { SExpressionEvaluator, createChildContext, createEffectContext, createMinimalContext, evalAbs, evalAdd, evalAnd, evalAtomic, evalCallService, evalCeil, evalClamp, evalConcat, evalCount, evalDecrement, evalDeref, evalDespawn, evalDivide, evalDo, evalEmit, evalEmpty, evalEqual, evalFilter, evalFind, evalFirst, evalFloor, evalFn, evalGreaterThan, evalGreaterThanOrEqual, evalIf, evalIncludes, evalIncrement, evalLast, evalLessThan, evalLessThanOrEqual, evalLet, evalMap, evalMatches, evalMax, evalMin, evalModulo, evalMultiply, evalNavigate, evalNot, evalNotEqual, evalNotify, evalNth, evalOr, evalPersist, evalRef, evalRenderUI, evalRound, evalSet, evalSetDynamic, evalSpawn, evalSubtract, evalSum, evalSwap, evalWatch, evalWhen, evaluate, evaluateGuard, evaluator, executeEffect, executeEffects, resolveBinding };
 //# sourceMappingURL=index.js.map
 //# sourceMappingURL=index.js.map