mindcache 1.0.1 → 2.0.0-alpha.1

package/lib/index.js

@@ -1,1030 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.MindCache = exports.mindcache = void 0;
-/* eslint-disable @typescript-eslint/no-explicit-any */
-const zod_1 = require("zod");
-class MindCache {
-    constructor() {
-        this.stm = {};
-        this.listeners = {};
-        this.globalListeners = [];
-    }
-    // Helper method to encode file to base64
-    encodeFileToBase64(file) {
-        return new Promise((resolve, reject) => {
-            // Check if we're in a browser environment
-            if (typeof FileReader !== 'undefined') {
-                const reader = new FileReader();
-                reader.onload = () => {
-                    const result = reader.result;
-                    // Remove data URL prefix to get just the base64 data
-                    const base64Data = result.split(',')[1];
-                    resolve(base64Data);
-                };
-                reader.onerror = reject;
-                reader.readAsDataURL(file);
-            }
-            else {
-                // Node.js environment - reject with helpful error
-                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; // No content type validation needed for text/json
-        }
-        if (!contentType) {
-            return false; // Files and images require content type
-        }
-        if (type === 'image') {
-            return contentType.startsWith('image/');
-        }
-        if (type === 'file') {
-            return true; // Any content type is valid for generic files
-        }
-        return false;
-    }
-    // Get a value from the STM (deprecated - use get_value instead)
-    /** @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 = new Date();
-            return today.toISOString().split('T')[0];
-        }
-        if (key === '$time') {
-            const now = new Date();
-            return now.toTimeString().split(' ')[0];
-        }
-        const entry = this.stm[key];
-        if (!entry) {
-            return undefined;
-        }
-        // If template is enabled, process the value through injectSTM
-        if (entry.attributes.template) {
-            // Prevent circular references
-            const processingStack = _processingStack || new Set();
-            if (processingStack.has(key)) {
-                return entry.value; // Return raw value to break circular reference
-            }
-            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 : undefined;
-    }
-    // Set a value in the STM with default attributes
-    set_value(key, value, attributes) {
-        // Don't allow setting hardcoded system keys
-        if (key === '$date' || key === '$time') {
-            return;
-        }
-        const defaultAttributes = {
-            readonly: false,
-            visible: true,
-            hardcoded: false,
-            template: false,
-            type: 'text',
-            tags: []
-        };
-        // If key exists, preserve existing attributes unless explicitly overridden
-        const existingEntry = this.stm[key];
-        const baseAttributes = existingEntry ? existingEntry.attributes : defaultAttributes;
-        const finalAttributes = attributes ? { ...baseAttributes, ...attributes } : baseAttributes;
-        // If hardcoded is true, force readonly to true and template to false
-        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();
-    }
-    // Set attributes for an existing key
-    set_attributes(key, attributes) {
-        // Don't allow setting attributes for hardcoded system keys
-        if (key === '$date' || key === '$time') {
-            return false;
-        }
-        const entry = this.stm[key];
-        if (!entry) {
-            return false;
-        }
-        // Create a copy of attributes, excluding the hardcoded property to prevent modification
-        // eslint-disable-next-line @typescript-eslint/no-unused-vars, no-unused-vars
-        const { hardcoded, ...allowedAttributes } = attributes;
-        // Apply the allowed attributes
-        entry.attributes = { ...entry.attributes, ...allowedAttributes };
-        // If this is a hardcoded key, ensure readonly is always true and template is always false
-        if (entry.attributes.hardcoded) {
-            entry.attributes.readonly = true;
-            entry.attributes.template = false;
-        }
-        this.notifyGlobalListeners();
-        return true;
-    }
-    // Set a value in the STM (uses default attributes)
-    set(key, value) {
-        this.set_value(key, value);
-    }
-    // Set a file value in the STM with base64 encoding
-    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 a base64 encoded value with content type
-    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);
-    }
-    // Convenience method to add an image to STM with proper attributes
-    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);
-        // Explicitly ensure the type is set to 'image' after setting the value
-        this.set_attributes(key, {
-            type: 'image',
-            contentType: contentType
-        });
-    }
-    // Get a value as data URL (for files/images)
-    get_data_url(key) {
-        const entry = this.stm[key];
-        if (!entry || (entry.attributes.type !== 'image' && entry.attributes.type !== 'file')) {
-            return undefined;
-        }
-        if (!entry.attributes.contentType) {
-            return undefined;
-        }
-        return this.createDataUrl(entry.value, entry.attributes.contentType);
-    }
-    // Get raw base64 data
-    get_base64(key) {
-        const entry = this.stm[key];
-        if (!entry || (entry.attributes.type !== 'image' && entry.attributes.type !== 'file')) {
-            return undefined;
-        }
-        return entry.value;
-    }
-    // Check if a key exists in the STM
-    has(key) {
-        if (key === '$date' || key === '$time') {
-            return true;
-        }
-        return key in this.stm;
-    }
-    // Delete a key-value pair from the STM
-    delete(key) {
-        if (key === '$date' || key === '$time') {
-            return false; // Can't delete hardcoded system keys
-        }
-        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 the entire STM
-    clear() {
-        // Clear the STM
-        this.stm = {};
-        this.notifyGlobalListeners();
-    }
-    // Get all keys in the STM
-    keys() {
-        return [...Object.keys(this.stm), '$date', '$time'];
-    }
-    // Get all values in the STM
-    values() {
-        const now = new Date();
-        const stmValues = Object.values(this.stm).map(entry => entry.value);
-        return [
-            ...stmValues,
-            now.toISOString().split('T')[0],
-            now.toTimeString().split(' ')[0]
-        ];
-    }
-    // Get all entries (key-value pairs) in the STM
-    entries() {
-        const now = 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]]
-        ];
-    }
-    // Get the size of the STM
-    size() {
-        return Object.keys(this.stm).length + 2; // +2 for $date and $time
-    }
-    // Get a copy of the entire STM object (returns values only for backward compatibility)
-    getAll() {
-        const now = new Date();
-        const result = {};
-        // Add regular STM values
-        Object.entries(this.stm).forEach(([key, entry]) => {
-            result[key] = entry.value;
-        });
-        // Add system values
-        result['$date'] = now.toISOString().split('T')[0];
-        result['$time'] = now.toTimeString().split(' ')[0];
-        return result;
-    }
-    // Update the STM with multiple key-value pairs (uses default attributes)
-    update(newValues) {
-        Object.entries(newValues).forEach(([key, value]) => {
-            if (key !== '$date' && key !== '$time') {
-                // Set value without triggering individual notifications
-                const defaultAttributes = {
-                    readonly: false,
-                    visible: true,
-                    hardcoded: false,
-                    template: false,
-                    type: 'text',
-                    tags: []
-                };
-                this.stm[key] = {
-                    value,
-                    attributes: defaultAttributes
-                };
-                // Trigger key-specific listeners
-                if (this.listeners[key]) {
-                    this.listeners[key].forEach(listener => listener());
-                }
-            }
-        });
-        // Trigger global listeners only once at the end
-        this.notifyGlobalListeners();
-    }
-    // Subscribe to changes for a specific key
-    subscribe(key, listener) {
-        if (!this.listeners[key]) {
-            this.listeners[key] = [];
-        }
-        this.listeners[key].push(listener);
-    }
-    // Unsubscribe from changes for a specific key
-    unsubscribe(key, listener) {
-        if (this.listeners[key]) {
-            this.listeners[key] = this.listeners[key].filter(l => l !== listener);
-        }
-    }
-    // Subscribe to changes for all STM keys
-    subscribeToAll(listener) {
-        this.globalListeners.push(listener);
-    }
-    // Unsubscribe from all STM changes
-    unsubscribeFromAll(listener) {
-        this.globalListeners = this.globalListeners.filter(l => l !== listener);
-    }
-    // Helper method to notify all global listeners
-    notifyGlobalListeners() {
-        this.globalListeners.forEach(listener => listener());
-    }
-    // Replace placeholders in a string with STM values (only uses visible keys for public injectSTM calls)
-    // Note: Image and file type placeholders are NOT replaced - they remain as {{key}} for tools to process
-    injectSTM(template, _processingStack) {
-        // Handle null/undefined templates
-        if (template === null || template === undefined) {
-            return String(template);
-        }
-        // Convert to string if not already
-        const templateStr = String(template);
-        // find all the keys in the template using double brackets
-        const keys = templateStr.match(/\{\{([$\w]+)\}\}/g);
-        if (!keys) {
-            return templateStr;
-        }
-        // Extract the actual key names without the double curly braces
-        const cleanKeys = keys.map(key => key.replace(/[{}]/g, ''));
-        // Build inputValues with the clean keys
-        const inputValues = cleanKeys.reduce((acc, key) => {
-            // Always allow system keys
-            if (key === '$date' || key === '$time') {
-                return {
-                    ...acc,
-                    [key]: this.get_value(key, _processingStack)
-                };
-            }
-            // If this is internal processing (from template), allow all keys
-            // If this is external call, only allow visible keys
-            const attributes = this.get_attributes(key);
-            if (_processingStack || (attributes && attributes.visible)) {
-                // Skip replacement for image and file types - keep the placeholder
-                if (attributes && (attributes.type === 'image' || attributes.type === 'file')) {
-                    return acc; // Don't add to inputValues, placeholder will remain
-                }
-                return {
-                    ...acc,
-                    [key]: this.get_value(key, _processingStack)
-                };
-            }
-            // If key doesn't exist or is not visible (for external calls), don't include it
-            return acc;
-        }, {});
-        // Replace the placeholders with actual values using double brackets
-        // Image/file placeholders will remain as {{key}} since they're not in inputValues
-        return templateStr.replace(/\{\{([$\w]+)\}\}/g, (match, key) => {
-            // If value is in inputValues, use it
-            if (inputValues[key] !== undefined) {
-                return inputValues[key];
-            }
-            // Check if this is an image/file placeholder that should be preserved
-            const attributes = this.get_attributes(key);
-            if (attributes && (attributes.type === 'image' || attributes.type === 'file')) {
-                return match; // Keep the placeholder for images/files
-            }
-            // For missing or invisible keys, replace with empty string (original behavior)
-            return '';
-        });
-    }
-    // Get a formatted string of all visible STM key-value pairs
-    getSTM() {
-        const now = new Date();
-        const entries = [];
-        // Add visible regular STM entries
-        Object.entries(this.stm).forEach(([key, entry]) => {
-            if (entry.attributes.visible) {
-                // Use get_value to handle template processing
-                entries.push([key, this.get_value(key)]);
-            }
-        });
-        // Add system keys (always visible)
-        entries.push(['$date', now.toISOString().split('T')[0]]);
-        entries.push(['$time', now.toTimeString().split(' ')[0]]);
-        return entries
-            .map(([key, value]) => `${key}: ${value}`)
-            .join(', ');
-    }
-    // Get STM as a proper object (alias for getAll for clarity)
-    getSTMObject() {
-        return this.getAll();
-    }
-    // Get STM data formatted for API calls (multipart form data style)
-    getSTMForAPI() {
-        const now = new Date();
-        const apiData = [];
-        // Add visible regular STM entries
-        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
-                });
-            }
-        });
-        // Add system keys (always visible)
-        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;
-    }
-    // Get visible images formatted for AI SDK UIMessage file parts
-    getVisibleImages() {
-        const imageParts = [];
-        Object.entries(this.stm).forEach(([key, entry]) => {
-            if (entry.attributes.visible && entry.attributes.type === 'image' && entry.attributes.contentType) {
-                // Create data URL from base64 data
-                const dataUrl = this.createDataUrl(entry.value, entry.attributes.contentType);
-                imageParts.push({
-                    type: 'file',
-                    mediaType: entry.attributes.contentType,
-                    url: dataUrl,
-                    filename: key // Use the STM key as filename
-                });
-            }
-        });
-        return imageParts;
-    }
-    // Serialize STM to JSON string (complete state)
-    toJSON() {
-        return JSON.stringify(this.serialize());
-    }
-    // Deserialize from JSON string and update STM (complete state)
-    fromJSON(jsonString) {
-        try {
-            const data = JSON.parse(jsonString);
-            this.deserialize(data);
-        }
-        catch (error) {
-            // eslint-disable-next-line no-console
-            console.error('MindCache: Failed to deserialize JSON:', error);
-        }
-    }
-    // Serialize complete state (values + attributes, excluding hardcoded keys)
-    serialize() {
-        const result = {};
-        Object.entries(this.stm).forEach(([key, entry]) => {
-            // Only serialize non-hardcoded entries
-            if (!entry.attributes.hardcoded) {
-                result[key] = {
-                    value: entry.value,
-                    attributes: { ...entry.attributes }
-                };
-            }
-        });
-        return result;
-    }
-    // Deserialize complete state (values + attributes)
-    deserialize(data) {
-        if (typeof data === 'object' && data !== null) {
-            // Clear existing STM (preserves hardcoded keys via clear())
-            this.clear();
-            // Restore entries with their complete state
-            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 || [] // Ensure tags array exists
-                        }
-                    };
-                }
-            });
-            this.notifyGlobalListeners();
-        }
-    }
-    // Generate system prompt from all visible STM keys
-    get_system_prompt() {
-        const now = new Date();
-        const promptLines = [];
-        // Add visible regular STM entries
-        Object.entries(this.stm).forEach(([key, entry]) => {
-            if (entry.attributes.visible) {
-                // Skip images and large files in system prompt to save context
-                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) {
-                    // Readonly keys: just show the key-value pair
-                    promptLines.push(`${key}: ${formattedValue}`);
-                }
-                else {
-                    // Writable keys: show value and mention the tool (with sanitized tool name)
-                    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 — start your response with the old value ' +
-                        `(${formattedValue})`;
-                    promptLines.push(`${key}: ${formattedValue}. ${toolInstruction}`);
-                }
-            }
-        });
-        // Add system keys (always visible and readonly)
-        promptLines.push(`$date: ${now.toISOString().split('T')[0]}`);
-        promptLines.push(`$time: ${now.toTimeString().split(' ')[0]}`);
-        return promptLines.join('\n');
-    }
-    // Helper method to find original key from sanitized tool name
-    findKeyFromToolName(toolName) {
-        if (!toolName.startsWith('write_')) {
-            return undefined;
-        }
-        const sanitizedKey = toolName.replace('write_', '');
-        // Find the original key by checking all keys and their sanitized versions
-        const allKeys = Object.keys(this.stm);
-        return allKeys.find(k => k.replace(/[^a-zA-Z0-9_-]/g, '_') === sanitizedKey);
-    }
-    // Generate tools for Vercel AI SDK to write STM values (excludes readonly keys)
-    get_aisdk_tools() {
-        const tools = {};
-        // Get all current keys (excluding built-in $date and $time and readonly keys)
-        const writableKeys = Object.entries(this.stm)
-            .filter(([, entry]) => !entry.attributes.readonly)
-            .map(([key]) => key);
-        // Create a write tool for each writable key
-        writableKeys.forEach(key => {
-            // Sanitize tool name to match OpenAI's pattern: ^[a-zA-Z0-9_-]+$
-            const sanitizedKey = key.replace(/[^a-zA-Z0-9_-]/g, '_');
-            const toolName = `write_${sanitizedKey}`;
-            const entry = this.stm[key];
-            const keyType = entry?.attributes.type || 'text';
-            // Create appropriate schema based on the key's type
-            let inputSchema;
-            let description = `Write a value to the STM key: ${key}`;
-            if (keyType === 'image' || keyType === 'file') {
-                description += ' (expects base64 encoded data)';
-                inputSchema = zod_1.z.object({
-                    value: zod_1.z.string().describe(`Base64 encoded data for ${key}`),
-                    contentType: zod_1.z.string().optional().describe(`MIME type for the ${keyType}`)
-                });
-            }
-            else if (keyType === 'json') {
-                description += ' (expects JSON string)';
-                inputSchema = zod_1.z.object({
-                    value: zod_1.z.string().describe(`JSON string value for ${key}`)
-                });
-            }
-            else {
-                inputSchema = zod_1.z.object({
-                    value: zod_1.z.string().describe(`The text value to write to ${key}`)
-                });
-            }
-            tools[toolName] = {
-                description,
-                inputSchema,
-                execute: async (input) => {
-                    // Handle different types appropriately
-                    if (keyType === 'image' || keyType === 'file') {
-                        if (input.contentType) {
-                            this.set_base64(key, input.value, input.contentType, keyType);
-                        }
-                        else {
-                            // Use existing content type if available
-                            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 {
-                        // For text and json, use regular set_value
-                        this.set_value(key, input.value);
-                    }
-                    // Create specialized success message based on type
-                    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 {
-                        // For text type, include the actual value
-                        resultMessage = `Successfully wrote "${input.value}" to ${key}`;
-                    }
-                    return {
-                        result: resultMessage,
-                        key: key,
-                        value: input.value,
-                        type: keyType,
-                        contentType: input.contentType,
-                        sanitizedKey: sanitizedKey
-                    };
-                }
-            };
-        });
-        // If no writable keys exist yet, return an empty object
-        if (writableKeys.length === 0) {
-            return {};
-        }
-        return tools;
-    }
-    // Public method for client-side tool execution
-    executeToolCall(toolName, value) {
-        const originalKey = this.findKeyFromToolName(toolName);
-        if (!originalKey) {
-            return null;
-        }
-        // Check if key is readonly
-        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: value
-        };
-    }
-    // Add a tag to a key
-    addTag(key, tag) {
-        // Don't allow tagging hardcoded system keys
-        if (key === '$date' || key === '$time') {
-            return false;
-        }
-        const entry = this.stm[key];
-        if (!entry) {
-            return false;
-        }
-        // Initialize tags array if it doesn't exist
-        if (!entry.attributes.tags) {
-            entry.attributes.tags = [];
-        }
-        // Add tag if it doesn't already exist
-        if (!entry.attributes.tags.includes(tag)) {
-            entry.attributes.tags.push(tag);
-            this.notifyGlobalListeners();
-            return true;
-        }
-        return false; // Tag already exists
-    }
-    // Remove a tag from a key
-    removeTag(key, tag) {
-        // Don't allow modifying hardcoded system keys
-        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; // Tag not found
-    }
-    // Get all tags for a key
-    getTags(key) {
-        if (key === '$date' || key === '$time') {
-            return []; // System keys have no tags
-        }
-        const entry = this.stm[key];
-        return entry?.attributes.tags || [];
-    }
-    // Get all unique tags across all entries
-    getAllTags() {
-        const allTags = new Set();
-        Object.values(this.stm).forEach(entry => {
-            if (entry.attributes.tags) {
-                entry.attributes.tags.forEach(tag => allTags.add(tag));
-            }
-        });
-        return Array.from(allTags);
-    }
-    // Check if a key has a specific tag
-    hasTag(key, tag) {
-        if (key === '$date' || key === '$time') {
-            return false; // System keys have no tags
-        }
-        const entry = this.stm[key];
-        return entry?.attributes.tags?.includes(tag) || false;
-    }
-    // Get a formatted string of all entries with a specific tag (ignores visible attribute)
-    getTagged(tag) {
-        const entries = [];
-        // Add regular STM entries that have the specified tag
-        Object.entries(this.stm).forEach(([key, entry]) => {
-            if (entry.attributes.tags?.includes(tag)) {
-                // Use get_value to handle template processing
-                entries.push([key, this.get_value(key)]);
-            }
-        });
-        return entries
-            .map(([key, value]) => `${key}: ${value}`)
-            .join(', ');
-    }
-    // Export STM to Markdown format
-    toMarkdown() {
-        const now = new Date();
-        const lines = [];
-        const appendixEntries = [];
-        let appendixCounter = 0;
-        const appendixLabels = {};
-        // Header
-        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('');
-        // Process each entry
-        Object.entries(this.stm).forEach(([key, entry]) => {
-            // Skip hardcoded keys - they won't be serialized
-            if (entry.attributes.hardcoded) {
-                return;
-            }
-            lines.push(`### ${key}`);
-            // Bug fix #1: Ensure type is always 'text' if undefined or the string "undefined"
-            const entryType = (entry.attributes.type && entry.attributes.type !== 'undefined') ? entry.attributes.type : 'text';
-            lines.push(`- **Type**: \`${entryType}\``);
-            // Flatten attributes at the same level as Type
-            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('`, `')}\``);
-            }
-            // Handle content type for files/images
-            if (entry.attributes.contentType) {
-                lines.push(`- **Content Type**: \`${entry.attributes.contentType}\``);
-            }
-            // Handle value based on type - always use code blocks for text
-            if (entryType === 'image' || entryType === 'file') {
-                // Create appendix reference
-                const label = String.fromCharCode(65 + appendixCounter); // A, B, C, etc.
-                appendixLabels[key] = label;
-                appendixCounter++;
-                lines.push(`- **Value**: [See Appendix ${label}]`);
-                // Store for appendix section
-                appendixEntries.push({
-                    key,
-                    type: entryType,
-                    contentType: entry.attributes.contentType || 'application/octet-stream',
-                    base64: entry.value,
-                    label
-                });
-            }
-            else if (entryType === 'json') {
-                // Format JSON with proper indentation
-                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 {
-                // Text type - always use code blocks
-                const valueStr = String(entry.value);
-                lines.push('- **Value**:');
-                lines.push('```');
-                lines.push(valueStr);
-                lines.push('```');
-            }
-            lines.push('');
-            lines.push('---');
-            lines.push('');
-        });
-        // Add appendix section if there are binary entries
-        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');
-    }
-    // Import STM from Markdown format
-    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 = {};
-        // Clear existing STM first
-        this.clear();
-        for (let i = 0; i < lines.length; i++) {
-            const line = lines[i];
-            const trimmed = line.trim();
-            // Detect sections
-            if (trimmed === '## STM Entries') {
-                currentSection = 'entries';
-                continue;
-            }
-            if (trimmed === '## Appendix: Binary Data') {
-                currentSection = 'appendix';
-                continue;
-            }
-            // Handle code blocks
-            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) {
-                        // Store appendix base64 data
-                        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;
-            }
-            // Parse entries section
-            if (currentSection === 'entries') {
-                if (trimmed.startsWith('### ')) {
-                    // Save previous entry if exists
-                    if (currentKey && currentEntry && currentEntry.attributes) {
-                        pendingEntries[currentKey] = currentEntry;
-                    }
-                    // Start new entry
-                    currentKey = trimmed.substring(4);
-                    currentEntry = {
-                        value: undefined,
-                        attributes: {
-                            readonly: false,
-                            visible: true,
-                            hardcoded: false,
-                            template: false,
-                            type: 'text',
-                            tags: []
-                        }
-                    };
-                }
-                else if (trimmed.startsWith('- **Type**: `')) {
-                    const type = trimmed.match(/`([^`]+)`/)?.[1];
-                    // Don't store "undefined" string - treat it as missing and keep default 'text'
-                    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];
-                        // Set a placeholder value so the entry is saved
-                        currentEntry.value = '';
-                    }
-                }
-            }
-            // Parse appendix section
-            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;
-                    }
-                }
-            }
-        }
-        // Save last entry
-        if (currentKey && currentEntry && currentEntry.attributes) {
-            pendingEntries[currentKey] = currentEntry;
-        }
-        // Now combine entries with appendix data and populate STM
-        Object.entries(pendingEntries).forEach(([key, entry]) => {
-            const appendixLabel = entry.appendixLabel;
-            if (appendixLabel) {
-                // Find matching appendix data
-                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;
-                    }
-                }
-            }
-            // Set the entry in STM (value can be undefined for entries without value line)
-            if (entry.value !== undefined && entry.attributes) {
-                this.stm[key] = {
-                    value: entry.value,
-                    attributes: entry.attributes
-                };
-            }
-        });
-        this.notifyGlobalListeners();
-    }
-}
-exports.MindCache = MindCache;
-// Create and export a single instance of MindCache
-exports.mindcache = new MindCache();
-//# sourceMappingURL=index.js.map