mindcache 3.2.0 → 3.3.0

package/dist/index.mjs

@@ -801,18 +801,35 @@ var MindCache = class {
   }
   // Deserialize state (for IndexedDBAdapter compatibility)
   deserialize(data) {
+    if (!data || typeof data !== "object") {
+      return;
+    }
     this.doc.transact(() => {
+      for (const key of this.rootMap.keys()) {
+        this.rootMap.delete(key);
+      }
       for (const [key, entry] of Object.entries(data)) {
         if (key.startsWith("$")) {
           continue;
         }
-        let entryMap = this.rootMap.get(key);
-        if (!entryMap) {
-          entryMap = new Y.Map();
-          this.rootMap.set(key, entryMap);
-        }
+        const entryMap = new Y.Map();
+        this.rootMap.set(key, entryMap);
         entryMap.set("value", entry.value);
-        entryMap.set("attributes", entry.attributes);
+        const attrs = entry.attributes || {};
+        const normalizedAttrs = {
+          type: attrs.type || "text",
+          contentTags: attrs.contentTags || [],
+          systemTags: attrs.systemTags || this.normalizeSystemTags(attrs.visible !== false ? ["prompt"] : []),
+          zIndex: attrs.zIndex ?? 0,
+          // Legacy fields
+          readonly: attrs.readonly ?? false,
+          visible: attrs.visible ?? true,
+          hardcoded: attrs.hardcoded ?? false,
+          template: attrs.template ?? false,
+          tags: attrs.tags || [],
+          contentType: attrs.contentType
+        };
+        entryMap.set("attributes", normalizedAttrs);
       }
     });
   }
@@ -850,16 +867,46 @@ var MindCache = class {
     }
     return false;
   }
-  // InjectSTM replacement
-  injectSTM(template, _processingStack) {
+  // InjectSTM replacement (private helper)
+  _injectSTMInternal(template, _processingStack) {
     return template.replace(/\{\{([^}]+)\}\}/g, (_, key) => {
       const val = this.get_value(key.trim(), _processingStack);
       return val !== void 0 ? String(val) : `{{${key}}}`;
     });
   }
+  /**
+   * Replace {{key}} placeholders in a template string with values from MindCache.
+   * @param template The template string with {{key}} placeholders
+   * @returns The template with placeholders replaced by values
+   */
+  injectSTM(template) {
+    return this._injectSTMInternal(template, /* @__PURE__ */ new Set());
+  }
   // Public API Methods
   getAll() {
-    return this.serialize();
+    const result = {};
+    for (const [key] of this.rootMap) {
+      result[key] = this.get_value(key);
+    }
+    result["$date"] = this.get_value("$date");
+    result["$time"] = this.get_value("$time");
+    return result;
+  }
+  /**
+   * Get all entries with their full structure (value + attributes).
+   * Use this for UI/admin interfaces that need to display key properties.
+   * Unlike serialize(), this format is stable and won't change.
+   */
+  getAllEntries() {
+    const result = {};
+    for (const [key] of this.rootMap) {
+      const value = this.get_value(key);
+      const attributes = this.get_attributes(key);
+      if (attributes) {
+        result[key] = { value, attributes };
+      }
+    }
+    return result;
   }
   get_value(key, _processingStack) {
     if (key === "$date") {
@@ -889,7 +936,7 @@ var MindCache = class {
       if (typeof value === "string") {
         const stack = _processingStack || /* @__PURE__ */ new Set();
         stack.add(key);
-        return this.injectSTM(value, stack);
+        return this._injectSTMInternal(value, stack);
       }
     }
     return value;
@@ -987,6 +1034,638 @@ var MindCache = class {
       keys.forEach((k) => this.rootMap.delete(k));
     });
   }
+  // ============================================
+  // Restored Methods (from v2.x)
+  // ============================================
+  /**
+   * Check if a key exists in MindCache.
+   */
+  has(key) {
+    if (key === "$date" || key === "$time" || key === "$version") {
+      return true;
+    }
+    return this.rootMap.has(key);
+  }
+  /**
+   * Delete a key from MindCache.
+   * @returns true if the key existed and was deleted
+   */
+  delete(key) {
+    if (key === "$date" || key === "$time" || key === "$version") {
+      return false;
+    }
+    if (!this.rootMap.has(key)) {
+      return false;
+    }
+    this.rootMap.delete(key);
+    this.notifyGlobalListeners();
+    if (this.listeners[key]) {
+      this.listeners[key].forEach((listener) => listener(void 0));
+    }
+    return true;
+  }
+  /** @deprecated Use get_value instead */
+  get(key) {
+    return this.get_value(key);
+  }
+  /** @deprecated Use set_value instead */
+  set(key, value) {
+    this.set_value(key, value);
+  }
+  /**
+   * Update multiple values at once from an object.
+   * @deprecated Use set_value for individual keys
+   */
+  update(data) {
+    this.doc.transact(() => {
+      for (const [key, value] of Object.entries(data)) {
+        if (key !== "$date" && key !== "$time" && key !== "$version") {
+          this.set_value(key, value);
+        }
+      }
+    });
+    this.notifyGlobalListeners();
+  }
+  /**
+   * Get the number of keys in MindCache.
+   */
+  size() {
+    return this.rootMap.size + 2;
+  }
+  /**
+   * Get all keys in MindCache (including temporal keys).
+   */
+  keys() {
+    const keys = Array.from(this.rootMap.keys());
+    keys.push("$date", "$time");
+    return keys;
+  }
+  /**
+   * Get all values in MindCache (including temporal values).
+   */
+  values() {
+    const result = [];
+    for (const [key] of this.rootMap) {
+      result.push(this.get_value(key));
+    }
+    result.push(this.get_value("$date"));
+    result.push(this.get_value("$time"));
+    return result;
+  }
+  /**
+   * Get all key-value entries (including temporal entries).
+   */
+  entries() {
+    const result = [];
+    for (const [key] of this.rootMap) {
+      result.push([key, this.get_value(key)]);
+    }
+    result.push(["$date", this.get_value("$date")]);
+    result.push(["$time", this.get_value("$time")]);
+    return result;
+  }
+  /**
+   * Unsubscribe from key changes.
+   * @deprecated Use the cleanup function returned by subscribe() instead
+   */
+  unsubscribe(key, listener) {
+    if (this.listeners[key]) {
+      this.listeners[key] = this.listeners[key].filter((l) => l !== listener);
+    }
+  }
+  /**
+   * Get the STM as a formatted string for LLM context.
+   * @deprecated Use get_system_prompt() instead
+   */
+  getSTM() {
+    return this.get_system_prompt();
+  }
+  /**
+   * Get the STM as an object with values directly (no attributes).
+   * Includes system keys ($date, $time).
+   * @deprecated Use getAll() for full STM format
+   */
+  getSTMObject() {
+    const result = {};
+    for (const [key] of this.rootMap) {
+      result[key] = this.get_value(key);
+    }
+    result["$date"] = this.get_value("$date");
+    result["$time"] = this.get_value("$time");
+    return result;
+  }
+  /**
+   * Add a content tag to a key.
+   * @returns true if the tag was added, false if key doesn't exist or tag already exists
+   */
+  addTag(key, tag) {
+    if (key === "$date" || key === "$time" || key === "$version") {
+      return false;
+    }
+    const entryMap = this.rootMap.get(key);
+    if (!entryMap) {
+      return false;
+    }
+    const attributes = entryMap.get("attributes");
+    const contentTags = attributes?.contentTags || [];
+    if (contentTags.includes(tag)) {
+      return false;
+    }
+    this.doc.transact(() => {
+      const newContentTags = [...contentTags, tag];
+      entryMap.set("attributes", {
+        ...attributes,
+        contentTags: newContentTags,
+        tags: newContentTags
+        // Sync legacy tags array
+      });
+    });
+    this.notifyGlobalListeners();
+    return true;
+  }
+  /**
+   * Remove a content tag from a key.
+   * @returns true if the tag was removed
+   */
+  removeTag(key, tag) {
+    if (key === "$date" || key === "$time" || key === "$version") {
+      return false;
+    }
+    const entryMap = this.rootMap.get(key);
+    if (!entryMap) {
+      return false;
+    }
+    const attributes = entryMap.get("attributes");
+    const contentTags = attributes?.contentTags || [];
+    const tagIndex = contentTags.indexOf(tag);
+    if (tagIndex === -1) {
+      return false;
+    }
+    this.doc.transact(() => {
+      const newContentTags = contentTags.filter((t) => t !== tag);
+      entryMap.set("attributes", {
+        ...attributes,
+        contentTags: newContentTags,
+        tags: newContentTags
+        // Sync legacy tags array
+      });
+    });
+    this.notifyGlobalListeners();
+    return true;
+  }
+  /**
+   * Get all content tags for a key.
+   */
+  getTags(key) {
+    if (key === "$date" || key === "$time" || key === "$version") {
+      return [];
+    }
+    const entryMap = this.rootMap.get(key);
+    if (!entryMap) {
+      return [];
+    }
+    const attributes = entryMap.get("attributes");
+    return attributes?.contentTags || [];
+  }
+  /**
+   * Get all unique content tags across all keys.
+   */
+  getAllTags() {
+    const allTags = /* @__PURE__ */ new Set();
+    for (const [, val] of this.rootMap) {
+      const entryMap = val;
+      const attributes = entryMap.get("attributes");
+      if (attributes?.contentTags) {
+        attributes.contentTags.forEach((tag) => allTags.add(tag));
+      }
+    }
+    return Array.from(allTags);
+  }
+  /**
+   * Check if a key has a specific content tag.
+   */
+  hasTag(key, tag) {
+    if (key === "$date" || key === "$time" || key === "$version") {
+      return false;
+    }
+    const entryMap = this.rootMap.get(key);
+    if (!entryMap) {
+      return false;
+    }
+    const attributes = entryMap.get("attributes");
+    return attributes?.contentTags?.includes(tag) || false;
+  }
+  /**
+   * Get all keys with a specific content tag as formatted string.
+   */
+  getTagged(tag) {
+    const entries = [];
+    const keys = this.getSortedKeys();
+    keys.forEach((key) => {
+      if (this.hasTag(key, tag)) {
+        entries.push([key, this.get_value(key)]);
+      }
+    });
+    return entries.map(([key, value]) => `${key}: ${value}`).join(", ");
+  }
+  /**
+   * Get array of keys with a specific content tag.
+   */
+  getKeysByTag(tag) {
+    const keys = this.getSortedKeys();
+    return keys.filter((key) => this.hasTag(key, tag));
+  }
+  // ============================================
+  // System Tag Methods (requires system access level)
+  // ============================================
+  /**
+   * Add a system tag to a key (requires system access).
+   * System tags: 'SystemPrompt', 'LLMRead', 'LLMWrite', 'readonly', 'protected', 'ApplyTemplate'
+   */
+  systemAddTag(key, tag) {
+    if (!this.hasSystemAccess) {
+      console.warn("MindCache: systemAddTag requires system access level");
+      return false;
+    }
+    if (key === "$date" || key === "$time" || key === "$version") {
+      return false;
+    }
+    const entryMap = this.rootMap.get(key);
+    if (!entryMap) {
+      return false;
+    }
+    const attributes = entryMap.get("attributes");
+    const systemTags = attributes?.systemTags || [];
+    if (systemTags.includes(tag)) {
+      return false;
+    }
+    this.doc.transact(() => {
+      const newSystemTags = [...systemTags, tag];
+      const normalizedTags = this.normalizeSystemTags(newSystemTags);
+      entryMap.set("attributes", {
+        ...attributes,
+        systemTags: normalizedTags
+      });
+    });
+    this.notifyGlobalListeners();
+    return true;
+  }
+  /**
+   * Remove a system tag from a key (requires system access).
+   */
+  systemRemoveTag(key, tag) {
+    if (!this.hasSystemAccess) {
+      console.warn("MindCache: systemRemoveTag requires system access level");
+      return false;
+    }
+    if (key === "$date" || key === "$time" || key === "$version") {
+      return false;
+    }
+    const entryMap = this.rootMap.get(key);
+    if (!entryMap) {
+      return false;
+    }
+    const attributes = entryMap.get("attributes");
+    const systemTags = attributes?.systemTags || [];
+    const tagIndex = systemTags.indexOf(tag);
+    if (tagIndex === -1) {
+      return false;
+    }
+    this.doc.transact(() => {
+      const newSystemTags = systemTags.filter((t) => t !== tag);
+      entryMap.set("attributes", {
+        ...attributes,
+        systemTags: newSystemTags
+      });
+    });
+    this.notifyGlobalListeners();
+    return true;
+  }
+  /**
+   * Get all system tags for a key (requires system access).
+   */
+  systemGetTags(key) {
+    if (!this.hasSystemAccess) {
+      console.warn("MindCache: systemGetTags requires system access level");
+      return [];
+    }
+    if (key === "$date" || key === "$time" || key === "$version") {
+      return [];
+    }
+    const entryMap = this.rootMap.get(key);
+    if (!entryMap) {
+      return [];
+    }
+    const attributes = entryMap.get("attributes");
+    return attributes?.systemTags || [];
+  }
+  /**
+   * Check if a key has a specific system tag (requires system access).
+   */
+  systemHasTag(key, tag) {
+    if (!this.hasSystemAccess) {
+      console.warn("MindCache: systemHasTag requires system access level");
+      return false;
+    }
+    if (key === "$date" || key === "$time" || key === "$version") {
+      return false;
+    }
+    const entryMap = this.rootMap.get(key);
+    if (!entryMap) {
+      return false;
+    }
+    const attributes = entryMap.get("attributes");
+    return attributes?.systemTags?.includes(tag) || false;
+  }
+  /**
+   * Set all system tags for a key at once (requires system access).
+   */
+  systemSetTags(key, tags) {
+    if (!this.hasSystemAccess) {
+      console.warn("MindCache: systemSetTags requires system access level");
+      return false;
+    }
+    if (key === "$date" || key === "$time" || key === "$version") {
+      return false;
+    }
+    const entryMap = this.rootMap.get(key);
+    if (!entryMap) {
+      return false;
+    }
+    this.doc.transact(() => {
+      const attributes = entryMap.get("attributes");
+      entryMap.set("attributes", {
+        ...attributes,
+        systemTags: [...tags]
+      });
+    });
+    this.notifyGlobalListeners();
+    return true;
+  }
+  /**
+   * Get all keys with a specific system tag (requires system access).
+   */
+  systemGetKeysByTag(tag) {
+    if (!this.hasSystemAccess) {
+      console.warn("MindCache: systemGetKeysByTag requires system access level");
+      return [];
+    }
+    const keys = this.getSortedKeys();
+    return keys.filter((key) => this.systemHasTag(key, tag));
+  }
+  /**
+   * Helper to get sorted keys (by zIndex).
+   */
+  getSortedKeys() {
+    const entries = [];
+    for (const [key, val] of this.rootMap) {
+      const entryMap = val;
+      const attributes = entryMap.get("attributes");
+      entries.push({ key, zIndex: attributes?.zIndex ?? 0 });
+    }
+    return entries.sort((a, b) => a.zIndex - b.zIndex).map((e) => e.key);
+  }
+  /**
+   * Serialize to JSON string.
+   */
+  toJSON() {
+    return JSON.stringify(this.serialize());
+  }
+  /**
+   * Deserialize from JSON string.
+   */
+  fromJSON(jsonString) {
+    try {
+      const data = JSON.parse(jsonString);
+      this.deserialize(data);
+    } catch (error) {
+      console.error("MindCache: Failed to deserialize JSON:", error);
+    }
+  }
+  /**
+   * Export to Markdown format.
+   */
+  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("");
+    const sortedKeys = this.getSortedKeys();
+    sortedKeys.forEach((key) => {
+      const entryMap = this.rootMap.get(key);
+      if (!entryMap) {
+        return;
+      }
+      const attributes = entryMap.get("attributes");
+      const value = entryMap.get("value");
+      if (attributes?.hardcoded) {
+        return;
+      }
+      lines.push(`### ${key}`);
+      const entryType = attributes?.type || "text";
+      lines.push(`- **Type**: \`${entryType}\``);
+      lines.push(`- **Readonly**: \`${attributes?.readonly ?? false}\``);
+      lines.push(`- **Visible**: \`${attributes?.visible ?? true}\``);
+      lines.push(`- **Template**: \`${attributes?.template ?? false}\``);
+      lines.push(`- **Z-Index**: \`${attributes?.zIndex ?? 0}\``);
+      if (attributes?.contentTags && attributes.contentTags.length > 0) {
+        lines.push(`- **Tags**: \`${attributes.contentTags.join("`, `")}\``);
+      }
+      if (attributes?.contentType) {
+        lines.push(`- **Content Type**: \`${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: attributes?.contentType || "application/octet-stream",
+          base64: value,
+          label
+        });
+      } else if (entryType === "json") {
+        lines.push("- **Value**:");
+        lines.push("```json");
+        try {
+          const jsonValue = typeof value === "string" ? value : JSON.stringify(value, null, 2);
+          lines.push(jsonValue);
+        } catch {
+          lines.push(String(value));
+        }
+        lines.push("```");
+      } else {
+        lines.push(`- **Value**: ${value}`);
+      }
+      lines.push("");
+    });
+    if (appendixEntries.length > 0) {
+      lines.push("---");
+      lines.push("");
+      lines.push("## Appendix: Binary Data");
+      lines.push("");
+      appendixEntries.forEach((entry) => {
+        lines.push(`### Appendix ${entry.label}: ${entry.key}`);
+        lines.push(`- **Type**: \`${entry.type}\``);
+        lines.push(`- **Content Type**: \`${entry.contentType}\``);
+        lines.push("- **Base64 Data**:");
+        lines.push("```");
+        lines.push(entry.base64);
+        lines.push("```");
+        lines.push("");
+      });
+    }
+    return lines.join("\n");
+  }
+  /**
+   * Import from Markdown format.
+   */
+  fromMarkdown(markdown) {
+    const lines = markdown.split("\n");
+    let currentKey = null;
+    let currentAttributes = {};
+    let currentValue = null;
+    let inCodeBlock = false;
+    let codeBlockContent = [];
+    for (const line of lines) {
+      if (line.startsWith("### ") && !line.startsWith("### Appendix")) {
+        if (currentKey && currentValue !== null) {
+          this.set_value(currentKey, currentValue, currentAttributes);
+        }
+        currentKey = line.substring(4).trim();
+        currentAttributes = {};
+        currentValue = null;
+        continue;
+      }
+      if (line.startsWith("### Appendix ")) {
+        const match = line.match(/### Appendix ([A-Z]): (.+)/);
+        if (match) {
+          currentKey = match[2];
+        }
+        continue;
+      }
+      if (line.startsWith("- **Type**:")) {
+        const type = line.match(/`(.+)`/)?.[1];
+        if (type) {
+          currentAttributes.type = type;
+        }
+        continue;
+      }
+      if (line.startsWith("- **Readonly**:")) {
+        currentAttributes.readonly = line.includes("`true`");
+        continue;
+      }
+      if (line.startsWith("- **Visible**:")) {
+        currentAttributes.visible = line.includes("`true`");
+        continue;
+      }
+      if (line.startsWith("- **Template**:")) {
+        currentAttributes.template = line.includes("`true`");
+        continue;
+      }
+      if (line.startsWith("- **Z-Index**:")) {
+        const zIndex = parseInt(line.match(/`(\d+)`/)?.[1] || "0", 10);
+        currentAttributes.zIndex = zIndex;
+        continue;
+      }
+      if (line.startsWith("- **Tags**:")) {
+        const tags = line.match(/`([^`]+)`/g)?.map((t) => t.slice(1, -1)) || [];
+        currentAttributes.contentTags = tags;
+        currentAttributes.tags = tags;
+        continue;
+      }
+      if (line.startsWith("- **Content Type**:")) {
+        currentAttributes.contentType = line.match(/`(.+)`/)?.[1];
+        continue;
+      }
+      if (line.startsWith("- **Value**:") && !line.includes("[See Appendix")) {
+        currentValue = line.substring(12).trim();
+        continue;
+      }
+      if (line === "```json" || line === "```") {
+        if (inCodeBlock) {
+          inCodeBlock = false;
+          if (currentKey && codeBlockContent.length > 0) {
+            currentValue = codeBlockContent.join("\n");
+          }
+          codeBlockContent = [];
+        } else {
+          inCodeBlock = true;
+        }
+        continue;
+      }
+      if (inCodeBlock) {
+        codeBlockContent.push(line);
+      }
+    }
+    if (currentKey && currentValue !== null) {
+      this.set_value(currentKey, currentValue, currentAttributes);
+    }
+  }
+  /**
+   * Set base64 binary data.
+   */
+  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 an image from base64 data.
+   */
+  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);
+  }
+  /**
+   * Get the data URL for an image or file key.
+   */
+  get_data_url(key) {
+    const entryMap = this.rootMap.get(key);
+    if (!entryMap) {
+      return void 0;
+    }
+    const attributes = entryMap.get("attributes");
+    if (attributes?.type !== "image" && attributes?.type !== "file") {
+      return void 0;
+    }
+    if (!attributes?.contentType) {
+      return void 0;
+    }
+    const value = entryMap.get("value");
+    return this.createDataUrl(value, attributes.contentType);
+  }
+  /**
+   * Get the base64 data for an image or file key.
+   */
+  get_base64(key) {
+    const entryMap = this.rootMap.get(key);
+    if (!entryMap) {
+      return void 0;
+    }
+    const attributes = entryMap.get("attributes");
+    if (attributes?.type !== "image" && attributes?.type !== "file") {
+      return void 0;
+    }
+    return entryMap.get("value");
+  }
   // File methods
   async set_file(key, file, attributes) {
     const base64 = await this.encodeFileToBase64(file);
@@ -1307,10 +1986,14 @@ var MindCache = class {
       const sanitizedKey = this.sanitizeKeyForTool(key);
       if (isWritable) {
         if (isDocument) {
-          lines.push(`${key}: ${displayValue}. Document tools: write_${sanitizedKey}, append_${sanitizedKey}, edit_${sanitizedKey}`);
+          lines.push(
+            `${key}: ${displayValue}. Document tools: write_${sanitizedKey}, append_${sanitizedKey}, edit_${sanitizedKey}`
+          );
         } else {
           const oldValueHint = displayValue ? ` This tool DOES NOT append \u2014 start your response with the old value (${displayValue})` : "";
-          lines.push(`${key}: ${displayValue}. You can rewrite "${key}" by using the write_${sanitizedKey} tool.${oldValueHint}`);
+          lines.push(
+            `${key}: ${displayValue}. You can rewrite "${key}" by using the write_${sanitizedKey} tool.${oldValueHint}`
+          );
         }
       } else {
         lines.push(`${key}: ${displayValue}`);
@@ -1451,6 +2134,9 @@ function useMindCache(options) {
   };
 }
 
-export { CloudAdapter, DEFAULT_KEY_ATTRIBUTES, IndexedDBAdapter, MindCache, useMindCache };
+// src/index.ts
+var mindcache = new MindCache();
+
+export { CloudAdapter, DEFAULT_KEY_ATTRIBUTES, IndexedDBAdapter, MindCache, mindcache, useMindCache };
 //# sourceMappingURL=index.mjs.map
 //# sourceMappingURL=index.mjs.map