@avasapp/agent-bridge 0.3.0 → 0.4.1

package/dist/adapters/zustand.cjs

@@ -23,15 +23,70 @@ __export(zustand_exports, {
   storeTools: () => storeTools
 });
 module.exports = __toCommonJS(zustand_exports);
+
+// src/runtime/to-json.ts
+function toJson(value) {
+  if (value === void 0) return null;
+  const seen = /* @__PURE__ */ new WeakSet();
+  const text = JSON.stringify(value, (_key, v) => {
+    if (typeof v === "bigint") return v.toString();
+    if (typeof v === "function" || typeof v === "symbol") return void 0;
+    if (v instanceof Error) return { name: v.name, message: v.message };
+    if (v instanceof Map) return Object.fromEntries(v);
+    if (v instanceof Set) return [...v];
+    if (v && typeof v === "object") {
+      if (seen.has(v)) return "[Circular]";
+      seen.add(v);
+    }
+    return v;
+  });
+  return text === void 0 ? null : JSON.parse(text);
+}
+
+// src/adapters/zustand.ts
 var snapshots = /* @__PURE__ */ new WeakMap();
 var isObject = (value) => typeof value === "object" && value !== null;
-function pick(value, path) {
-  if (!path) return value;
-  return path.split(".").reduce(
+function toPath(part) {
+  if (typeof part === "string") return part === "" ? [] : part.split(".");
+  if (typeof part === "number") return [part];
+  if (Array.isArray(part) && part.every((p) => typeof p === "string" || typeof p === "number"))
+    return part;
+  throw new Error(
+    `A store path is a dotted string or an array of segments, got ${JSON.stringify(part)}`
+  );
+}
+function at(value, path) {
+  return path.reduce(
     (v, k) => v?.[k],
     value
   );
 }
+var kindOf = (v) => v === null ? "null" : Array.isArray(v) ? "array" : typeof v;
+function readState(state, given) {
+  const args = given.filter((a) => a != null);
+  const last = args.at(-1);
+  const isOptions = isObject(last) && !Array.isArray(last);
+  const options = isOptions ? last : {};
+  const unknown = Object.keys(options).filter((k) => k !== "pick" && k !== "keys");
+  if (unknown.length)
+    throw new Error(
+      `Unknown store.get option ${unknown.map((k) => `"${k}"`).join(", ")}. Options: pick, keys`
+    );
+  const value = at(state, (isOptions ? args.slice(0, -1) : args).flatMap(toPath));
+  if (options.pick !== void 0) {
+    if (!Array.isArray(options.pick))
+      throw new Error("store.get pick is an array of paths");
+    return Object.fromEntries(
+      options.pick.map((p) => [
+        Array.isArray(p) ? p.join(".") : String(p),
+        at(value, toPath(p))
+      ])
+    );
+  }
+  if (options.keys)
+    return isObject(value) ? Object.fromEntries(Object.entries(value).map(([k, v]) => [k, kindOf(v)])) : kindOf(value);
+  return value;
+}
 function restore(store, snapshot) {
   const current = store.getState();
   if (!isObject(snapshot) || !isObject(current)) {
@@ -43,7 +98,47 @@ function restore(store, snapshot) {
   );
   store.setState({ ...snapshot, ...actions }, true);
 }
-function storeTools(stores) {
+var PREVIEW = 200;
+function preview(value) {
+  try {
+    const safe = toJson(value);
+    const text = JSON.stringify(safe);
+    if (text.length <= PREVIEW) return safe;
+    return `${text.slice(0, PREVIEW)}\u2026 (${text.length} chars)`;
+  } catch {
+    return "[unserializable]";
+  }
+}
+function differences(snapshot, current, show) {
+  if (!isObject(snapshot) || !isObject(current)) return {};
+  const out = {};
+  for (const k of /* @__PURE__ */ new Set([...Object.keys(snapshot), ...Object.keys(current)])) {
+    const a = snapshot[k];
+    const b = current[k];
+    if (typeof a === "function" || typeof b === "function") continue;
+    if (!Object.is(a, b))
+      out[k] = { snapshot: preview(show(k, a)), current: preview(show(k, b)) };
+  }
+  return out;
+}
+var REDACTED = "[redacted]";
+function redactValue(redact, name, value, path, seen = []) {
+  if (!redact || typeof value === "function") return value;
+  if (typeof redact === "function") {
+    if (path) value = redact(name, path, value);
+  } else if (path && redact[name]?.some((p) => path === p || path.startsWith(`${p}.`))) {
+    return REDACTED;
+  }
+  if (!isObject(value) || seen.includes(value)) return value;
+  const next = [...seen, value];
+  const entries = Object.entries(value).map(([k, v]) => [
+    k,
+    redactValue(redact, name, v, path ? `${path}.${k}` : k, next)
+  ]);
+  return Array.isArray(value) ? entries.map(([, v]) => v) : Object.fromEntries(entries);
+}
+function storeTools(stores, options = {}) {
+  const out = (name, value, path = "") => redactValue(options.redact, name, value, path);
   const get = (name) => {
     const store = stores[name];
     if (!store)
@@ -58,34 +153,79 @@ function storeTools(stores) {
   return {
     "store.list": {
       description: "Store names.",
+      maxArgs: 0,
       run: () => Object.keys(stores)
     },
     "store.get": {
-      description: 'State of a store, or one dotted path inside it (e.g. "auth.isLoggedIn").',
-      run: (name, path) => pick(get(name).getState(), path)
+      description: 'State of a store, or a path inside it: ("auth", "auth.isLoggedIn"), ("auth", "auth", "isLoggedIn") or ("auth", ["auth", "isLoggedIn"]). A last { pick: ["a.b", "c"] } returns just those fields; { keys: true } lists keys and their types without values. Paths configured with redact print as "[redacted]".',
+      // Redact the whole state first, so paths, pick and keys all see it.
+      run: (name, ...rest) => readState(out(name, get(name).getState()), rest)
     },
     "store.set": {
-      description: "Shallow-merge a partial into a store.",
+      description: "Shallow-merge a partial into a store. Returns only the keys you set, with their new values, not the whole store. A store is snapshotted on its first store.set or store.call since the last restore (or store.commit); bridge.restore puts that snapshot back. Changes made before that, e.g. by tapping the UI, are not in it: run store.set <store> {} first to snapshot early, and see bridge.pending.",
       run: (name, partial) => {
         const store = get(name);
         beforeChange(store);
         store.setState(partial);
-        return store.getState();
+        const state = store.getState();
+        return out(
+          name,
+          Object.fromEntries(Object.keys(partial).map((k) => [k, state[k]]))
+        );
       }
     },
     "store.call": {
-      description: 'Call an action on a store, e.g. ("settings", "setColorScheme", "dark").',
-      run: (name, action, ...args) => {
+      description: `Call an action on a store, e.g. ("settings", "setColorScheme", "dark"). Returns the action's return value, or { changed: [keys] } when it returns nothing or the store state. Snapshots the store first, like store.set: the first store.set or store.call since the last restore is the state bridge.restore returns to.`,
+      run: async (name, action, ...args) => {
         const store = get(name);
         const fn = store.getState()[action];
         if (typeof fn !== "function")
           throw new Error(`Store "${name}" has no action "${action}"`);
         beforeChange(store);
-        return fn(...args);
+        const before = store.getState();
+        const result = await fn(...args);
+        const after = store.getState();
+        if (result !== void 0 && result !== before && result !== after) {
+          const key = isObject(after) ? Object.keys(after).find((k) => after[k] === result) : void 0;
+          return out(name, result, key);
+        }
+        const a = before;
+        const b = after;
+        return {
+          changed: Object.keys(b).filter(
+            (k) => typeof b[k] !== "function" && !Object.is(a?.[k], b[k])
+          )
+        };
+      }
+    },
+    "store.commit": {
+      maxArgs: 1,
+      description: "Keep a store as it is now: drops its pending snapshot, so bridge.restore leaves it alone and the next store.set or store.call snapshots again from this state. Use it after repairing a value that was already wrong when the snapshot was taken. Returns { store, committed } (committed: false when nothing was pending).",
+      run: (name) => {
+        const store = get(name);
+        return { store: name, committed: snapshots.delete(store) };
       }
     },
     "store.restore": {
-      description: "Undo the agent: put back each store changed with store.set or store.call. Returns their names.",
+      maxArgs: 0,
+      // Per store, its snapshot against now (secrets redacted), so an agent can
+      // tell what a restore will put back before it does.
+      pending: ({ detail } = {}) => {
+        const changed = Object.entries(stores).filter(([, s]) => snapshots.has(s));
+        if (!changed.length) return false;
+        if (!detail) return true;
+        return Object.fromEntries(
+          changed.map(([name, store]) => [
+            name,
+            differences(
+              snapshots.get(store),
+              store.getState(),
+              (key, value) => out(name, value, key)
+            )
+          ])
+        );
+      },
+      description: "Undo the agent: put back each store changed with store.set or store.call, to its state at the first of those (store.commit drops a snapshot). Returns their names.",
       run: () => Object.entries(stores).flatMap(([name, store]) => {
         if (!snapshots.has(store)) return [];
         restore(store, snapshots.get(store));

package/dist/adapters/zustand.d.cts

@@ -1,4 +1,4 @@
-import { T as Tools } from '../types-6kKQsLC1.cjs';
+import { T as Tools } from '../types-BmpykP1P.cjs';
 
 /** Anything with zustand's store shape. */
 type StoreLike = {
@@ -9,7 +9,23 @@ type StoreLike = {
      */
     setState(partial: Record<string, unknown>, replace?: boolean): void;
 };
+/**
+ * Keeps secrets out of what store.* prints. Either dotted paths per store
+ * (`{ auth: ['accessToken', 'user.phone'] }`), or a hook called for the store
+ * value and every nested value with its dotted path; what it returns is
+ * printed instead.
+ *
+ * Paths are store paths. A `store.call` result that is a piece of the store's
+ * state (same object, e.g. `() => get().user`) is matched by where it lives; a
+ * copy or derived value (`() => ({ ...get().user })`) is not, so its paths are
+ * matched relative to the result and store paths like `user.phone` won't apply.
+ * Use the hook, or don't return secrets from actions.
+ */
+type Redact = Record<string, string[]> | ((store: string, path: string, value: unknown) => unknown);
+type StoreToolsOptions = {
+    redact?: Redact;
+};
 /** Read, merge into, and call actions on named stores. */
-declare function storeTools(stores: Record<string, StoreLike>): Tools;
+declare function storeTools(stores: Record<string, StoreLike>, options?: StoreToolsOptions): Tools;
 
-export { type StoreLike, storeTools };
+export { type Redact, type StoreLike, type StoreToolsOptions, storeTools };