mindcache 1.0.1 → 2.0.0

package/dist/index.mjs

@@ -0,0 +1,1299 @@
+import { z } from 'zod';
+
+var __defProp = Object.defineProperty;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __esm = (fn, res) => function __init() {
+  return fn && (res = (0, fn[__getOwnPropNames(fn)[0]])(fn = 0)), res;
+};
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+
+// src/cloud/CloudAdapter.ts
+var CloudAdapter_exports = {};
+__export(CloudAdapter_exports, {
+  CloudAdapter: () => CloudAdapter
+});
+var DEFAULT_BASE_URL, RECONNECT_DELAY, MAX_RECONNECT_DELAY, CloudAdapter;
+var init_CloudAdapter = __esm({
+  "src/cloud/CloudAdapter.ts"() {
+    DEFAULT_BASE_URL = "wss://api.mindcache.io";
+    RECONNECT_DELAY = 1e3;
+    MAX_RECONNECT_DELAY = 3e4;
+    CloudAdapter = class {
+      constructor(config) {
+        this.config = config;
+        this.config.baseUrl = config.baseUrl || DEFAULT_BASE_URL;
+      }
+      ws = null;
+      queue = [];
+      mindcache = null;
+      unsubscribe = null;
+      reconnectAttempts = 0;
+      reconnectTimeout = null;
+      _state = "disconnected";
+      listeners = {};
+      token = null;
+      /**
+       * Set auth token (short-lived, from /api/ws-token)
+       * Call this before connect() or use setTokenProvider for auto-refresh
+       */
+      setToken(token) {
+        this.token = token;
+      }
+      /**
+       * Set a function that returns a fresh token
+       * Used for automatic token refresh on reconnect
+       */
+      setTokenProvider(provider) {
+        this.config.tokenProvider = provider;
+      }
+      /**
+       * Get current connection state
+       */
+      get state() {
+        return this._state;
+      }
+      /**
+       * Attach to a MindCache instance and start syncing
+       */
+      attach(mc) {
+        if (this.mindcache) {
+          this.detach();
+        }
+        this.mindcache = mc;
+        const listener = () => {
+          if (mc.isRemoteUpdate()) {
+            console.log("\u2601\uFE0F CloudAdapter: Skipping remote update");
+            return;
+          }
+          console.log("\u2601\uFE0F CloudAdapter: Local change detected, syncing...");
+          this.syncLocalChanges();
+        };
+        mc.subscribeToAll(listener);
+        this.unsubscribe = () => mc.unsubscribeFromAll(listener);
+        console.log("\u2601\uFE0F CloudAdapter: Attached to MindCache instance");
+      }
+      /**
+       * Detach from the MindCache instance
+       */
+      detach() {
+        if (this.unsubscribe) {
+          this.unsubscribe();
+          this.unsubscribe = null;
+        }
+        this.mindcache = null;
+      }
+      /**
+       * Connect to the cloud service
+       */
+      async connect() {
+        if (this._state === "connecting" || this._state === "connected") {
+          return;
+        }
+        this._state = "connecting";
+        try {
+          if (this.config.tokenProvider && !this.token) {
+            this.token = await this.config.tokenProvider();
+          }
+          let url = `${this.config.baseUrl}/sync/${this.config.instanceId}`;
+          if (this.token) {
+            url += `?token=${encodeURIComponent(this.token)}`;
+            this.token = null;
+          }
+          this.ws = new WebSocket(url);
+          this.setupWebSocket();
+        } catch (error) {
+          this._state = "error";
+          this.emit("error", error);
+          this.scheduleReconnect();
+        }
+      }
+      /**
+       * Disconnect from the cloud service
+       */
+      disconnect() {
+        if (this.reconnectTimeout) {
+          clearTimeout(this.reconnectTimeout);
+          this.reconnectTimeout = null;
+        }
+        if (this.ws) {
+          this.ws.close();
+          this.ws = null;
+        }
+        this._state = "disconnected";
+        this.emit("disconnected");
+      }
+      /**
+       * Push an operation to the cloud
+       */
+      push(op) {
+        if (this.ws?.readyState === WebSocket.OPEN) {
+          this.ws.send(JSON.stringify(op));
+        } else {
+          this.queue.push(op);
+        }
+      }
+      /**
+       * Add event listener
+       */
+      on(event, listener) {
+        if (!this.listeners[event]) {
+          this.listeners[event] = [];
+        }
+        this.listeners[event].push(listener);
+      }
+      /**
+       * Remove event listener
+       */
+      off(event, listener) {
+        if (this.listeners[event]) {
+          this.listeners[event] = this.listeners[event].filter((l) => l !== listener);
+        }
+      }
+      emit(event, ...args) {
+        if (this.listeners[event]) {
+          this.listeners[event].forEach((listener) => listener(...args));
+        }
+      }
+      setupWebSocket() {
+        if (!this.ws) {
+          return;
+        }
+        this.ws.onopen = () => {
+          if (this.config.apiKey) {
+            this.ws.send(JSON.stringify({
+              type: "auth",
+              apiKey: this.config.apiKey
+            }));
+          }
+        };
+        this.ws.onmessage = (event) => {
+          try {
+            const msg = JSON.parse(event.data);
+            this.handleMessage(msg);
+          } catch (error) {
+            console.error("MindCache Cloud: Failed to parse message:", error);
+          }
+        };
+        this.ws.onclose = () => {
+          this._state = "disconnected";
+          this.emit("disconnected");
+          this.scheduleReconnect();
+        };
+        this.ws.onerror = (error) => {
+          this._state = "error";
+          this.emit("error", new Error("WebSocket error"));
+          console.error("MindCache Cloud: WebSocket error:", error);
+        };
+      }
+      handleMessage(msg) {
+        switch (msg.type) {
+          case "auth_success":
+            this._state = "connected";
+            this.reconnectAttempts = 0;
+            this.emit("connected");
+            this.flushQueue();
+            break;
+          case "auth_error":
+            this._state = "error";
+            this.emit("error", new Error(msg.error));
+            this.disconnect();
+            break;
+          case "sync":
+            if (this.mindcache && msg.data) {
+              Object.entries(msg.data).forEach(([key, entry]) => {
+                const { value, attributes } = entry;
+                this.mindcache._setFromRemote(key, value, attributes);
+              });
+              this.emit("synced");
+            }
+            break;
+          case "set":
+            if (this.mindcache) {
+              this.mindcache._setFromRemote(msg.key, msg.value, msg.attributes);
+            }
+            break;
+          case "key_updated":
+            if (this.mindcache) {
+              this.mindcache._setFromRemote(msg.key, msg.value, msg.attributes);
+            }
+            break;
+          case "delete":
+            if (this.mindcache) {
+              this.mindcache._deleteFromRemote(msg.key);
+            }
+            break;
+          case "key_deleted":
+            if (this.mindcache) {
+              this.mindcache._deleteFromRemote(msg.key);
+            }
+            break;
+          case "clear":
+            if (this.mindcache) {
+              this.mindcache._clearFromRemote();
+            }
+            break;
+          case "cleared":
+            if (this.mindcache) {
+              this.mindcache._clearFromRemote();
+            }
+            break;
+          case "error":
+            this.emit("error", new Error(msg.error));
+            break;
+        }
+      }
+      flushQueue() {
+        while (this.queue.length > 0 && this.ws?.readyState === WebSocket.OPEN) {
+          const op = this.queue.shift();
+          this.ws.send(JSON.stringify(op));
+        }
+      }
+      scheduleReconnect() {
+        if (this.reconnectTimeout) {
+          return;
+        }
+        const delay = Math.min(
+          RECONNECT_DELAY * Math.pow(2, this.reconnectAttempts),
+          MAX_RECONNECT_DELAY
+        );
+        this.reconnectTimeout = setTimeout(async () => {
+          this.reconnectTimeout = null;
+          this.reconnectAttempts++;
+          if (this.config.tokenProvider) {
+            try {
+              this.token = await this.config.tokenProvider();
+            } catch (error) {
+              console.error("MindCache Cloud: Failed to get token for reconnect:", error);
+              this.emit("error", error);
+              return;
+            }
+          }
+          this.connect();
+        }, delay);
+      }
+      syncLocalChanges() {
+        if (!this.mindcache) {
+          return;
+        }
+        const entries = this.mindcache.serialize();
+        console.log("\u2601\uFE0F CloudAdapter: Syncing local changes:", Object.keys(entries));
+        Object.entries(entries).forEach(([key, entry]) => {
+          console.log("\u2601\uFE0F CloudAdapter: Pushing key:", key, "=", entry.value);
+          this.push({
+            type: "set",
+            key,
+            value: entry.value,
+            attributes: entry.attributes,
+            timestamp: Date.now()
+          });
+        });
+      }
+    };
+  }
+});
+
+// src/core/types.ts
+var DEFAULT_KEY_ATTRIBUTES = {
+  readonly: false,
+  visible: true,
+  hardcoded: false,
+  template: false,
+  type: "text",
+  tags: []
+};
+
+// src/core/MindCache.ts
+var MindCache = class {
+  stm = {};
+  listeners = {};
+  globalListeners = [];
+  // Internal flag to prevent sync loops when receiving remote updates
+  _isRemoteUpdate = false;
+  // Cloud sync state
+  _cloudAdapter = null;
+  _connectionState = "disconnected";
+  _isLoaded = true;
+  // Default true for local mode
+  _cloudConfig = null;
+  constructor(options) {
+    if (options?.cloud) {
+      this._cloudConfig = options.cloud;
+      this._isLoaded = false;
+      this._connectionState = "disconnected";
+      this._initCloud();
+    }
+  }
+  async _initCloud() {
+    if (!this._cloudConfig) {
+      return;
+    }
+    try {
+      const { CloudAdapter: CloudAdapter2 } = await Promise.resolve().then(() => (init_CloudAdapter(), CloudAdapter_exports));
+      const configUrl = this._cloudConfig.baseUrl || "https://api.mindcache.io";
+      const baseUrl = configUrl.replace("https://", "wss://").replace("http://", "ws://");
+      const adapter = new CloudAdapter2({
+        instanceId: this._cloudConfig.instanceId,
+        projectId: this._cloudConfig.projectId || "default",
+        baseUrl,
+        apiKey: this._cloudConfig.apiKey
+      });
+      if (this._cloudConfig.tokenEndpoint) {
+        const tokenEndpoint = this._cloudConfig.tokenEndpoint;
+        const instanceId = this._cloudConfig.instanceId;
+        let resolvedBaseUrl;
+        if (tokenEndpoint.startsWith("http://") || tokenEndpoint.startsWith("https://")) {
+          resolvedBaseUrl = tokenEndpoint;
+        } else if (typeof window !== "undefined" && window.location?.origin) {
+          resolvedBaseUrl = `${window.location.origin}${tokenEndpoint.startsWith("/") ? "" : "/"}${tokenEndpoint}`;
+        } else {
+          console.warn("MindCache: Cannot resolve tokenEndpoint to absolute URL - window.location not available");
+          resolvedBaseUrl = tokenEndpoint;
+        }
+        adapter.setTokenProvider(async () => {
+          const url = resolvedBaseUrl.includes("?") ? `${resolvedBaseUrl}&instanceId=${instanceId}` : `${resolvedBaseUrl}?instanceId=${instanceId}`;
+          const response = await fetch(url);
+          if (!response.ok) {
+            const error = await response.json().catch(() => ({ error: "Failed to get token" }));
+            throw new Error(error.error || "Failed to get token");
+          }
+          const data = await response.json();
+          return data.token;
+        });
+      }
+      adapter.on("connected", () => {
+        this._connectionState = "connected";
+        this.notifyGlobalListeners();
+      });
+      adapter.on("disconnected", () => {
+        this._connectionState = "disconnected";
+        this.notifyGlobalListeners();
+      });
+      adapter.on("error", () => {
+        this._connectionState = "error";
+        this.notifyGlobalListeners();
+      });
+      adapter.on("synced", () => {
+        this._isLoaded = true;
+        this.notifyGlobalListeners();
+      });
+      adapter.attach(this);
+      this._cloudAdapter = adapter;
+      this._connectionState = "connecting";
+      adapter.connect();
+    } catch (error) {
+      console.error("MindCache: Failed to initialize cloud connection:", error);
+      this._connectionState = "error";
+      this._isLoaded = true;
+    }
+  }
+  /**
+   * Get the current cloud connection state
+   */
+  get connectionState() {
+    return this._connectionState;
+  }
+  /**
+   * Check if data is loaded (true for local, true after sync for cloud)
+   */
+  get isLoaded() {
+    return this._isLoaded;
+  }
+  /**
+   * Check if this instance is connected to cloud
+   */
+  get isCloud() {
+    return this._cloudConfig !== null;
+  }
+  /**
+   * Disconnect from cloud (if connected)
+   */
+  disconnect() {
+    if (this._cloudAdapter) {
+      this._cloudAdapter.disconnect();
+      this._cloudAdapter.detach();
+      this._cloudAdapter = null;
+      this._connectionState = "disconnected";
+    }
+  }
+  // Helper method to encode file to base64
+  encodeFileToBase64(file) {
+    return new Promise((resolve, reject) => {
+      if (typeof FileReader !== "undefined") {
+        const reader = new FileReader();
+        reader.onload = () => {
+          const result = reader.result;
+          const base64Data = result.split(",")[1];
+          resolve(base64Data);
+        };
+        reader.onerror = reject;
+        reader.readAsDataURL(file);
+      } else {
+        reject(new Error("FileReader not available in Node.js environment. Use set_base64() method instead."));
+      }
+    });
+  }
+  // Helper method to create data URL from base64 and content type
+  createDataUrl(base64Data, contentType) {
+    return `data:${contentType};base64,${base64Data}`;
+  }
+  // Helper method to validate content type for different STM types
+  validateContentType(type, contentType) {
+    if (type === "text" || type === "json") {
+      return true;
+    }
+    if (!contentType) {
+      return false;
+    }
+    if (type === "image") {
+      return contentType.startsWith("image/");
+    }
+    if (type === "file") {
+      return true;
+    }
+    return false;
+  }
+  /** @deprecated Use get_value instead */
+  get(key) {
+    return this.get_value(key);
+  }
+  // Get a value from the STM with template processing if enabled
+  get_value(key, _processingStack) {
+    if (key === "$date") {
+      const today = /* @__PURE__ */ new Date();
+      return today.toISOString().split("T")[0];
+    }
+    if (key === "$time") {
+      const now = /* @__PURE__ */ new Date();
+      return now.toTimeString().split(" ")[0];
+    }
+    const entry = this.stm[key];
+    if (!entry) {
+      return void 0;
+    }
+    if (entry.attributes.template) {
+      const processingStack = _processingStack || /* @__PURE__ */ new Set();
+      if (processingStack.has(key)) {
+        return entry.value;
+      }
+      processingStack.add(key);
+      const result = this.injectSTM(entry.value, processingStack);
+      processingStack.delete(key);
+      return result;
+    }
+    return entry.value;
+  }
+  // Get attributes for a key
+  get_attributes(key) {
+    if (key === "$date" || key === "$time") {
+      return {
+        readonly: true,
+        visible: true,
+        hardcoded: true,
+        template: false,
+        type: "text",
+        tags: []
+      };
+    }
+    const entry = this.stm[key];
+    return entry ? entry.attributes : void 0;
+  }
+  // Set a value in the STM with default attributes
+  set_value(key, value, attributes) {
+    if (key === "$date" || key === "$time") {
+      return;
+    }
+    const existingEntry = this.stm[key];
+    const baseAttributes = existingEntry ? existingEntry.attributes : { ...DEFAULT_KEY_ATTRIBUTES };
+    const finalAttributes = attributes ? { ...baseAttributes, ...attributes } : baseAttributes;
+    if (finalAttributes.hardcoded) {
+      finalAttributes.readonly = true;
+      finalAttributes.template = false;
+    }
+    this.stm[key] = {
+      value,
+      attributes: finalAttributes
+    };
+    if (this.listeners[key]) {
+      this.listeners[key].forEach((listener) => listener());
+    }
+    this.notifyGlobalListeners();
+  }
+  // Internal method for setting values from remote (cloud sync)
+  // This doesn't trigger the global listener to prevent sync loops
+  _setFromRemote(key, value, attributes) {
+    if (key === "$date" || key === "$time") {
+      return;
+    }
+    this._isRemoteUpdate = true;
+    this.stm[key] = {
+      value,
+      attributes
+    };
+    if (this.listeners[key]) {
+      this.listeners[key].forEach((listener) => listener());
+    }
+    this.notifyGlobalListeners();
+    this._isRemoteUpdate = false;
+  }
+  // Check if current update is from remote
+  isRemoteUpdate() {
+    return this._isRemoteUpdate;
+  }
+  // Internal method for deleting from remote (cloud sync)
+  _deleteFromRemote(key) {
+    if (key === "$date" || key === "$time") {
+      return;
+    }
+    this._isRemoteUpdate = true;
+    if (key in this.stm) {
+      delete this.stm[key];
+      if (this.listeners[key]) {
+        this.listeners[key].forEach((listener) => listener());
+      }
+      this.notifyGlobalListeners();
+    }
+    this._isRemoteUpdate = false;
+  }
+  // Internal method for clearing from remote (cloud sync)
+  _clearFromRemote() {
+    this._isRemoteUpdate = true;
+    this.stm = {};
+    this.notifyGlobalListeners();
+    this._isRemoteUpdate = false;
+  }
+  // Set attributes for an existing key
+  set_attributes(key, attributes) {
+    if (key === "$date" || key === "$time") {
+      return false;
+    }
+    const entry = this.stm[key];
+    if (!entry) {
+      return false;
+    }
+    const { hardcoded: _hardcoded, ...allowedAttributes } = attributes;
+    entry.attributes = { ...entry.attributes, ...allowedAttributes };
+    if (entry.attributes.hardcoded) {
+      entry.attributes.readonly = true;
+      entry.attributes.template = false;
+    }
+    this.notifyGlobalListeners();
+    return true;
+  }
+  set(key, value) {
+    this.set_value(key, value);
+  }
+  async set_file(key, file, attributes) {
+    const base64Data = await this.encodeFileToBase64(file);
+    const contentType = file.type;
+    const fileAttributes = {
+      type: contentType.startsWith("image/") ? "image" : "file",
+      contentType,
+      ...attributes
+    };
+    this.set_value(key, base64Data, fileAttributes);
+  }
+  set_base64(key, base64Data, contentType, type = "file", attributes) {
+    if (!this.validateContentType(type, contentType)) {
+      throw new Error(`Invalid content type ${contentType} for type ${type}`);
+    }
+    const fileAttributes = {
+      type,
+      contentType,
+      ...attributes
+    };
+    this.set_value(key, base64Data, fileAttributes);
+  }
+  add_image(key, base64Data, contentType = "image/jpeg", attributes) {
+    if (!contentType.startsWith("image/")) {
+      throw new Error(`Invalid image content type: ${contentType}. Must start with 'image/'`);
+    }
+    this.set_base64(key, base64Data, contentType, "image", attributes);
+    this.set_attributes(key, {
+      type: "image",
+      contentType
+    });
+  }
+  get_data_url(key) {
+    const entry = this.stm[key];
+    if (!entry || entry.attributes.type !== "image" && entry.attributes.type !== "file") {
+      return void 0;
+    }
+    if (!entry.attributes.contentType) {
+      return void 0;
+    }
+    return this.createDataUrl(entry.value, entry.attributes.contentType);
+  }
+  get_base64(key) {
+    const entry = this.stm[key];
+    if (!entry || entry.attributes.type !== "image" && entry.attributes.type !== "file") {
+      return void 0;
+    }
+    return entry.value;
+  }
+  has(key) {
+    if (key === "$date" || key === "$time") {
+      return true;
+    }
+    return key in this.stm;
+  }
+  delete(key) {
+    if (key === "$date" || key === "$time") {
+      return false;
+    }
+    if (!(key in this.stm)) {
+      return false;
+    }
+    const deleted = delete this.stm[key];
+    if (deleted) {
+      this.notifyGlobalListeners();
+      if (this.listeners[key]) {
+        this.listeners[key].forEach((listener) => listener());
+      }
+    }
+    return deleted;
+  }
+  clear() {
+    this.stm = {};
+    this.notifyGlobalListeners();
+  }
+  keys() {
+    return [...Object.keys(this.stm), "$date", "$time"];
+  }
+  values() {
+    const now = /* @__PURE__ */ new Date();
+    const stmValues = Object.values(this.stm).map((entry) => entry.value);
+    return [
+      ...stmValues,
+      now.toISOString().split("T")[0],
+      now.toTimeString().split(" ")[0]
+    ];
+  }
+  entries() {
+    const now = /* @__PURE__ */ new Date();
+    const stmEntries = Object.entries(this.stm).map(
+      ([key, entry]) => [key, entry.value]
+    );
+    return [
+      ...stmEntries,
+      ["$date", now.toISOString().split("T")[0]],
+      ["$time", now.toTimeString().split(" ")[0]]
+    ];
+  }
+  size() {
+    return Object.keys(this.stm).length + 2;
+  }
+  getAll() {
+    const now = /* @__PURE__ */ new Date();
+    const result = {};
+    Object.entries(this.stm).forEach(([key, entry]) => {
+      result[key] = entry.value;
+    });
+    result["$date"] = now.toISOString().split("T")[0];
+    result["$time"] = now.toTimeString().split(" ")[0];
+    return result;
+  }
+  update(newValues) {
+    Object.entries(newValues).forEach(([key, value]) => {
+      if (key !== "$date" && key !== "$time") {
+        this.stm[key] = {
+          value,
+          attributes: { ...DEFAULT_KEY_ATTRIBUTES }
+        };
+        if (this.listeners[key]) {
+          this.listeners[key].forEach((listener) => listener());
+        }
+      }
+    });
+    this.notifyGlobalListeners();
+  }
+  subscribe(key, listener) {
+    if (!this.listeners[key]) {
+      this.listeners[key] = [];
+    }
+    this.listeners[key].push(listener);
+  }
+  unsubscribe(key, listener) {
+    if (this.listeners[key]) {
+      this.listeners[key] = this.listeners[key].filter((l) => l !== listener);
+    }
+  }
+  subscribeToAll(listener) {
+    this.globalListeners.push(listener);
+  }
+  unsubscribeFromAll(listener) {
+    this.globalListeners = this.globalListeners.filter((l) => l !== listener);
+  }
+  notifyGlobalListeners() {
+    this.globalListeners.forEach((listener) => listener());
+  }
+  injectSTM(template, _processingStack) {
+    if (template === null || template === void 0) {
+      return String(template);
+    }
+    const templateStr = String(template);
+    const keys = templateStr.match(/\{\{([$\w]+)\}\}/g);
+    if (!keys) {
+      return templateStr;
+    }
+    const cleanKeys = keys.map((key) => key.replace(/[{}]/g, ""));
+    const inputValues = cleanKeys.reduce((acc, key) => {
+      if (key === "$date" || key === "$time") {
+        return {
+          ...acc,
+          [key]: this.get_value(key, _processingStack)
+        };
+      }
+      const attributes = this.get_attributes(key);
+      if (_processingStack || attributes && attributes.visible) {
+        if (attributes && (attributes.type === "image" || attributes.type === "file")) {
+          return acc;
+        }
+        return {
+          ...acc,
+          [key]: this.get_value(key, _processingStack)
+        };
+      }
+      return acc;
+    }, {});
+    return templateStr.replace(/\{\{([$\w]+)\}\}/g, (match, key) => {
+      if (inputValues[key] !== void 0) {
+        return inputValues[key];
+      }
+      const attributes = this.get_attributes(key);
+      if (attributes && (attributes.type === "image" || attributes.type === "file")) {
+        return match;
+      }
+      return "";
+    });
+  }
+  getSTM() {
+    const now = /* @__PURE__ */ new Date();
+    const entries = [];
+    Object.entries(this.stm).forEach(([key, entry]) => {
+      if (entry.attributes.visible) {
+        entries.push([key, this.get_value(key)]);
+      }
+    });
+    entries.push(["$date", now.toISOString().split("T")[0]]);
+    entries.push(["$time", now.toTimeString().split(" ")[0]]);
+    return entries.map(([key, value]) => `${key}: ${value}`).join(", ");
+  }
+  getSTMObject() {
+    return this.getAll();
+  }
+  getSTMForAPI() {
+    const now = /* @__PURE__ */ new Date();
+    const apiData = [];
+    Object.entries(this.stm).forEach(([key, entry]) => {
+      if (entry.attributes.visible) {
+        const processedValue = entry.attributes.template ? this.get_value(key) : entry.value;
+        apiData.push({
+          key,
+          value: processedValue,
+          type: entry.attributes.type,
+          contentType: entry.attributes.contentType
+        });
+      }
+    });
+    apiData.push({
+      key: "$date",
+      value: now.toISOString().split("T")[0],
+      type: "text"
+    });
+    apiData.push({
+      key: "$time",
+      value: now.toTimeString().split(" ")[0],
+      type: "text"
+    });
+    return apiData;
+  }
+  getVisibleImages() {
+    const imageParts = [];
+    Object.entries(this.stm).forEach(([key, entry]) => {
+      if (entry.attributes.visible && entry.attributes.type === "image" && entry.attributes.contentType) {
+        const dataUrl = this.createDataUrl(entry.value, entry.attributes.contentType);
+        imageParts.push({
+          type: "file",
+          mediaType: entry.attributes.contentType,
+          url: dataUrl,
+          filename: key
+        });
+      }
+    });
+    return imageParts;
+  }
+  toJSON() {
+    return JSON.stringify(this.serialize());
+  }
+  fromJSON(jsonString) {
+    try {
+      const data = JSON.parse(jsonString);
+      this.deserialize(data);
+    } catch (error) {
+      console.error("MindCache: Failed to deserialize JSON:", error);
+    }
+  }
+  serialize() {
+    const result = {};
+    Object.entries(this.stm).forEach(([key, entry]) => {
+      if (!entry.attributes.hardcoded) {
+        result[key] = {
+          value: entry.value,
+          attributes: { ...entry.attributes }
+        };
+      }
+    });
+    return result;
+  }
+  deserialize(data) {
+    if (typeof data === "object" && data !== null) {
+      this.clear();
+      Object.entries(data).forEach(([key, entry]) => {
+        if (entry && typeof entry === "object" && "value" in entry && "attributes" in entry) {
+          this.stm[key] = {
+            value: entry.value,
+            attributes: {
+              ...entry.attributes,
+              tags: entry.attributes.tags || []
+            }
+          };
+        }
+      });
+      this.notifyGlobalListeners();
+    }
+  }
+  get_system_prompt() {
+    const now = /* @__PURE__ */ new Date();
+    const promptLines = [];
+    Object.entries(this.stm).forEach(([key, entry]) => {
+      if (entry.attributes.visible) {
+        if (entry.attributes.type === "image") {
+          promptLines.push(`image ${key} available`);
+          return;
+        }
+        if (entry.attributes.type === "file") {
+          if (entry.attributes.readonly) {
+            promptLines.push(`${key}: [${entry.attributes.type.toUpperCase()}] - ${entry.attributes.contentType || "unknown format"}`);
+          } else {
+            const sanitizedKey = key.replace(/[^a-zA-Z0-9_-]/g, "_");
+            promptLines.push(`${key}: [${entry.attributes.type.toUpperCase()}] - ${entry.attributes.contentType || "unknown format"}. You can update this ${entry.attributes.type} using the write_${sanitizedKey} tool.`);
+          }
+          return;
+        }
+        const value = this.get_value(key);
+        const formattedValue = typeof value === "object" && value !== null ? JSON.stringify(value) : String(value);
+        if (entry.attributes.readonly) {
+          promptLines.push(`${key}: ${formattedValue}`);
+        } else {
+          const sanitizedKey = key.replace(/[^a-zA-Z0-9_-]/g, "_");
+          const toolInstruction = `You can rewrite "${key}" by using the write_${sanitizedKey} tool. This tool DOES NOT append \u2014 start your response with the old value (${formattedValue})`;
+          promptLines.push(`${key}: ${formattedValue}. ${toolInstruction}`);
+        }
+      }
+    });
+    promptLines.push(`$date: ${now.toISOString().split("T")[0]}`);
+    promptLines.push(`$time: ${now.toTimeString().split(" ")[0]}`);
+    return promptLines.join("\n");
+  }
+  findKeyFromToolName(toolName) {
+    if (!toolName.startsWith("write_")) {
+      return void 0;
+    }
+    const sanitizedKey = toolName.replace("write_", "");
+    const allKeys = Object.keys(this.stm);
+    return allKeys.find(
+      (k) => k.replace(/[^a-zA-Z0-9_-]/g, "_") === sanitizedKey
+    );
+  }
+  get_aisdk_tools() {
+    const tools = {};
+    const writableKeys = Object.entries(this.stm).filter(([, entry]) => !entry.attributes.readonly).map(([key]) => key);
+    writableKeys.forEach((key) => {
+      const sanitizedKey = key.replace(/[^a-zA-Z0-9_-]/g, "_");
+      const toolName = `write_${sanitizedKey}`;
+      const entry = this.stm[key];
+      const keyType = entry?.attributes.type || "text";
+      let inputSchema;
+      let description = `Write a value to the STM key: ${key}`;
+      if (keyType === "image" || keyType === "file") {
+        description += " (expects base64 encoded data)";
+        inputSchema = z.object({
+          value: z.string().describe(`Base64 encoded data for ${key}`),
+          contentType: z.string().optional().describe(`MIME type for the ${keyType}`)
+        });
+      } else if (keyType === "json") {
+        description += " (expects JSON string)";
+        inputSchema = z.object({
+          value: z.string().describe(`JSON string value for ${key}`)
+        });
+      } else {
+        inputSchema = z.object({
+          value: z.string().describe(`The text value to write to ${key}`)
+        });
+      }
+      tools[toolName] = {
+        description,
+        inputSchema,
+        execute: async (input) => {
+          if (keyType === "image" || keyType === "file") {
+            if (input.contentType) {
+              this.set_base64(key, input.value, input.contentType, keyType);
+            } else {
+              const existingContentType = entry?.attributes.contentType;
+              if (existingContentType) {
+                this.set_base64(key, input.value, existingContentType, keyType);
+              } else {
+                throw new Error(`Content type required for ${keyType} data`);
+              }
+            }
+          } else {
+            this.set_value(key, input.value);
+          }
+          let resultMessage;
+          if (keyType === "image") {
+            resultMessage = `Successfully saved image to ${key}`;
+          } else if (keyType === "file") {
+            resultMessage = `Successfully saved file to ${key}`;
+          } else if (keyType === "json") {
+            resultMessage = `Successfully saved JSON data to ${key}`;
+          } else {
+            resultMessage = `Successfully wrote "${input.value}" to ${key}`;
+          }
+          return {
+            result: resultMessage,
+            key,
+            value: input.value,
+            type: keyType,
+            contentType: input.contentType,
+            sanitizedKey
+          };
+        }
+      };
+    });
+    if (writableKeys.length === 0) {
+      return {};
+    }
+    return tools;
+  }
+  executeToolCall(toolName, value) {
+    const originalKey = this.findKeyFromToolName(toolName);
+    if (!originalKey) {
+      return null;
+    }
+    const entry = this.stm[originalKey];
+    if (entry && entry.attributes.readonly) {
+      return null;
+    }
+    this.set_value(originalKey, value);
+    return {
+      result: `Successfully wrote "${value}" to ${originalKey}`,
+      key: originalKey,
+      value
+    };
+  }
+  addTag(key, tag) {
+    if (key === "$date" || key === "$time") {
+      return false;
+    }
+    const entry = this.stm[key];
+    if (!entry) {
+      return false;
+    }
+    if (!entry.attributes.tags) {
+      entry.attributes.tags = [];
+    }
+    if (!entry.attributes.tags.includes(tag)) {
+      entry.attributes.tags.push(tag);
+      this.notifyGlobalListeners();
+      return true;
+    }
+    return false;
+  }
+  removeTag(key, tag) {
+    if (key === "$date" || key === "$time") {
+      return false;
+    }
+    const entry = this.stm[key];
+    if (!entry || !entry.attributes.tags) {
+      return false;
+    }
+    const tagIndex = entry.attributes.tags.indexOf(tag);
+    if (tagIndex > -1) {
+      entry.attributes.tags.splice(tagIndex, 1);
+      this.notifyGlobalListeners();
+      return true;
+    }
+    return false;
+  }
+  getTags(key) {
+    if (key === "$date" || key === "$time") {
+      return [];
+    }
+    const entry = this.stm[key];
+    return entry?.attributes.tags || [];
+  }
+  getAllTags() {
+    const allTags = /* @__PURE__ */ new Set();
+    Object.values(this.stm).forEach((entry) => {
+      if (entry.attributes.tags) {
+        entry.attributes.tags.forEach((tag) => allTags.add(tag));
+      }
+    });
+    return Array.from(allTags);
+  }
+  hasTag(key, tag) {
+    if (key === "$date" || key === "$time") {
+      return false;
+    }
+    const entry = this.stm[key];
+    return entry?.attributes.tags?.includes(tag) || false;
+  }
+  getTagged(tag) {
+    const entries = [];
+    Object.entries(this.stm).forEach(([key, entry]) => {
+      if (entry.attributes.tags?.includes(tag)) {
+        entries.push([key, this.get_value(key)]);
+      }
+    });
+    return entries.map(([key, value]) => `${key}: ${value}`).join(", ");
+  }
+  toMarkdown() {
+    const now = /* @__PURE__ */ new Date();
+    const lines = [];
+    const appendixEntries = [];
+    let appendixCounter = 0;
+    lines.push("# MindCache STM Export");
+    lines.push("");
+    lines.push(`Export Date: ${now.toISOString().split("T")[0]}`);
+    lines.push("");
+    lines.push("---");
+    lines.push("");
+    lines.push("## STM Entries");
+    lines.push("");
+    Object.entries(this.stm).forEach(([key, entry]) => {
+      if (entry.attributes.hardcoded) {
+        return;
+      }
+      lines.push(`### ${key}`);
+      const entryType = entry.attributes.type && entry.attributes.type !== "undefined" ? entry.attributes.type : "text";
+      lines.push(`- **Type**: \`${entryType}\``);
+      lines.push(`- **Readonly**: \`${entry.attributes.readonly}\``);
+      lines.push(`- **Visible**: \`${entry.attributes.visible}\``);
+      lines.push(`- **Template**: \`${entry.attributes.template}\``);
+      if (entry.attributes.tags && entry.attributes.tags.length > 0) {
+        lines.push(`- **Tags**: \`${entry.attributes.tags.join("`, `")}\``);
+      }
+      if (entry.attributes.contentType) {
+        lines.push(`- **Content Type**: \`${entry.attributes.contentType}\``);
+      }
+      if (entryType === "image" || entryType === "file") {
+        const label = String.fromCharCode(65 + appendixCounter);
+        appendixCounter++;
+        lines.push(`- **Value**: [See Appendix ${label}]`);
+        appendixEntries.push({
+          key,
+          type: entryType,
+          contentType: entry.attributes.contentType || "application/octet-stream",
+          base64: entry.value,
+          label
+        });
+      } else if (entryType === "json") {
+        lines.push("- **Value**:");
+        lines.push("```json");
+        try {
+          const jsonValue = typeof entry.value === "string" ? entry.value : JSON.stringify(entry.value, null, 2);
+          lines.push(jsonValue);
+        } catch {
+          lines.push(String(entry.value));
+        }
+        lines.push("```");
+      } else {
+        const valueStr = String(entry.value);
+        lines.push("- **Value**:");
+        lines.push("```");
+        lines.push(valueStr);
+        lines.push("```");
+      }
+      lines.push("");
+      lines.push("---");
+      lines.push("");
+    });
+    if (appendixEntries.length > 0) {
+      lines.push("## Appendix: Binary Data");
+      lines.push("");
+      appendixEntries.forEach(({ key, contentType, base64, label }) => {
+        lines.push(`### Appendix ${label}: ${key}`);
+        lines.push(`**Type**: ${contentType}`);
+        lines.push("");
+        lines.push("```");
+        lines.push(base64);
+        lines.push("```");
+        lines.push("");
+        lines.push("---");
+        lines.push("");
+      });
+    }
+    lines.push("*End of MindCache Export*");
+    return lines.join("\n");
+  }
+  fromMarkdown(markdown) {
+    const lines = markdown.split("\n");
+    let currentSection = "header";
+    let currentKey = null;
+    let currentEntry = null;
+    let inCodeBlock = false;
+    let codeBlockContent = [];
+    let codeBlockType = null;
+    const appendixData = {};
+    let currentAppendixKey = null;
+    const pendingEntries = {};
+    this.clear();
+    for (let i = 0; i < lines.length; i++) {
+      const line = lines[i];
+      const trimmed = line.trim();
+      if (trimmed === "## STM Entries") {
+        currentSection = "entries";
+        continue;
+      }
+      if (trimmed === "## Appendix: Binary Data") {
+        currentSection = "appendix";
+        continue;
+      }
+      if (trimmed === "```" || trimmed === "```json") {
+        if (!inCodeBlock) {
+          inCodeBlock = true;
+          codeBlockContent = [];
+          codeBlockType = currentSection === "appendix" ? "base64" : trimmed === "```json" ? "json" : "value";
+        } else {
+          inCodeBlock = false;
+          const content = codeBlockContent.join("\n");
+          if (currentSection === "appendix" && currentAppendixKey) {
+            appendixData[currentAppendixKey].base64 = content;
+          } else if (currentEntry && codeBlockType === "json") {
+            currentEntry.value = content;
+          } else if (currentEntry && codeBlockType === "value") {
+            currentEntry.value = content;
+          }
+          codeBlockContent = [];
+          codeBlockType = null;
+        }
+        continue;
+      }
+      if (inCodeBlock) {
+        codeBlockContent.push(line);
+        continue;
+      }
+      if (currentSection === "entries") {
+        if (trimmed.startsWith("### ")) {
+          if (currentKey && currentEntry && currentEntry.attributes) {
+            pendingEntries[currentKey] = currentEntry;
+          }
+          currentKey = trimmed.substring(4);
+          currentEntry = {
+            value: void 0,
+            attributes: {
+              readonly: false,
+              visible: true,
+              hardcoded: false,
+              template: false,
+              type: "text",
+              tags: []
+            }
+          };
+        } else if (trimmed.startsWith("- **Type**: `")) {
+          const type = trimmed.match(/`([^`]+)`/)?.[1];
+          if (currentEntry && type && type !== "undefined") {
+            currentEntry.attributes.type = type;
+          }
+        } else if (trimmed.startsWith("- **Readonly**: `")) {
+          const value = trimmed.match(/`([^`]+)`/)?.[1] === "true";
+          if (currentEntry) {
+            currentEntry.attributes.readonly = value;
+          }
+        } else if (trimmed.startsWith("- **Visible**: `")) {
+          const value = trimmed.match(/`([^`]+)`/)?.[1] === "true";
+          if (currentEntry) {
+            currentEntry.attributes.visible = value;
+          }
+        } else if (trimmed.startsWith("- **Template**: `")) {
+          const value = trimmed.match(/`([^`]+)`/)?.[1] === "true";
+          if (currentEntry) {
+            currentEntry.attributes.template = value;
+          }
+        } else if (trimmed.startsWith("- **Tags**: `")) {
+          const tagsStr = trimmed.substring(13, trimmed.length - 1);
+          if (currentEntry) {
+            currentEntry.attributes.tags = tagsStr.split("`, `");
+          }
+        } else if (trimmed.startsWith("- **Content Type**: `")) {
+          const contentType = trimmed.match(/`([^`]+)`/)?.[1];
+          if (currentEntry && contentType) {
+            currentEntry.attributes.contentType = contentType;
+          }
+        } else if (trimmed.startsWith("- **Value**: `")) {
+          const value = trimmed.substring(14, trimmed.length - 1);
+          if (currentEntry) {
+            currentEntry.value = value;
+          }
+        } else if (trimmed.startsWith("- **Value**: [See Appendix ")) {
+          const labelMatch = trimmed.match(/Appendix ([A-Z])\]/);
+          if (currentEntry && labelMatch && currentKey) {
+            currentEntry.appendixLabel = labelMatch[1];
+            currentEntry.value = "";
+          }
+        }
+      }
+      if (currentSection === "appendix") {
+        if (trimmed.startsWith("### Appendix ")) {
+          const match = trimmed.match(/### Appendix ([A-Z]): (.+)/);
+          if (match) {
+            const label = match[1];
+            const key = match[2];
+            currentAppendixKey = `${label}:${key}`;
+            appendixData[currentAppendixKey] = { contentType: "", base64: "" };
+          }
+        } else if (trimmed.startsWith("**Type**: ")) {
+          const contentType = trimmed.substring(10);
+          if (currentAppendixKey) {
+            appendixData[currentAppendixKey].contentType = contentType;
+          }
+        }
+      }
+    }
+    if (currentKey && currentEntry && currentEntry.attributes) {
+      pendingEntries[currentKey] = currentEntry;
+    }
+    Object.entries(pendingEntries).forEach(([key, entry]) => {
+      const appendixLabel = entry.appendixLabel;
+      if (appendixLabel) {
+        const appendixKey = `${appendixLabel}:${key}`;
+        const appendixInfo = appendixData[appendixKey];
+        if (appendixInfo && appendixInfo.base64) {
+          entry.value = appendixInfo.base64;
+          if (!entry.attributes.contentType && appendixInfo.contentType) {
+            entry.attributes.contentType = appendixInfo.contentType;
+          }
+        }
+      }
+      if (entry.value !== void 0 && entry.attributes) {
+        this.stm[key] = {
+          value: entry.value,
+          attributes: entry.attributes
+        };
+      }
+    });
+    this.notifyGlobalListeners();
+  }
+};
+var mindcache = new MindCache();
+
+// src/cloud/index.ts
+init_CloudAdapter();
+init_CloudAdapter();
+
+export { CloudAdapter, DEFAULT_KEY_ATTRIBUTES, MindCache, mindcache };
+//# sourceMappingURL=index.mjs.map
+//# sourceMappingURL=index.mjs.map