import * as path from 'path';
import { toolLogger } from '../../index.js';
import { store, get, set } from './keyv.js';
// Helper function to get storage path
const getStoragePath = (options) => {
    // For now, use default path. Later this can be configured via options
    return path.join(process.cwd(), 'memory.json');
};
// Default collection name when none provided
const DEFAULT_COLLECTION = 'no-collection';
// Helper function to process value based on format
const processValueForStorage = (value, format) => {
    switch (format) {
        case 'json':
            try {
                // Validate JSON by parsing and re-stringifying
                JSON.parse(value);
                return value;
            }
            catch (error) {
                throw new Error('Invalid JSON format provided');
            }
        case 'binary':
            // For binary, we expect base64 encoded data
            try {
                // Validate base64
                Buffer.from(value, 'base64');
                return value;
            }
            catch (error) {
                throw new Error('Invalid base64 format for binary data');
            }
        case 'text':
        default:
            return value;
    }
};
// Helper function to create memory entry
const createMemoryEntry = (value, format) => {
    const now = new Date().toISOString();
    return {
        value: processValueForStorage(value, format),
        meta: {
            type: format,
            created: now,
            updated: now
        }
    };
};
export const tools = (target, options) => {
    const logger = toolLogger('memory', options);
    const storagePath = getStoragePath(options);
    return [
        {
            type: 'function',
            function: {
                name: 'memorize',
                description: `Store information in memory as a key-value collection with format support. Supports text, JSON, and binary (base64) formats.
                
Returns: {
  success: boolean,
  message: string,
  meta: {
    type: "text" | "json" | "binary",
    created: string (ISO timestamp),
    updated: string (ISO timestamp)
  }
}`,
                parameters: {
                    type: 'object',
                    properties: {
                        collection: {
                            type: 'string',
                            description: 'Collection name to organize related data (defaults to "no-collection" if not provided). Acts like a namespace.',
                            optional: true
                        },
                        key: {
                            type: 'string',
                            description: 'Unique identifier for the data within the collection. Must be a string.'
                        },
                        value: {
                            type: 'string',
                            description: 'The data to store. For format="text": any string. For format="json": valid JSON string. For format="binary": base64 encoded data.'
                        },
                        format: {
                            type: 'string',
                            description: 'Data format type. "text" for plain text (default), "json" for JSON data (validates structure), "binary" for base64 encoded binary data.',
                            enum: ['text', 'json', 'binary'],
                            optional: true
                        }
                    },
                    required: ['key', 'value']
                },
                function: async (params) => {
                    try {
                        const { collection = DEFAULT_COLLECTION, key, value, format = 'text' } = params;
                        logger.debug(`Tool::Memorize Storing ${key} in collection ${collection} as ${format}`);
                        const memoryEntry = createMemoryEntry(value, format);
                        await set(`${collection}:${key}`, memoryEntry, storagePath, collection);
                        return {
                            success: true,
                            message: `Stored ${key} in collection ${collection} as ${format}`,
                            meta: memoryEntry.meta
                        };
                    }
                    catch (error) {
                        logger.error('Error storing memory', error);
                        return {
                            success: false,
                            message: error instanceof Error ? error.message : 'Unknown error occurred'
                        };
                    }
                },
                parse: JSON.parse
            }
        },
        {
            type: 'function',
            function: {
                name: 'recall',
                description: `Retrieve stored information from memory by collection and key, including format metadata.
                
Returns: {
  success: boolean,
  value?: string (the stored data),
  meta?: {
    type: "text" | "json" | "binary",
    created: string (ISO timestamp),
    updated: string (ISO timestamp)
  },
  key: string,
  collection: string,
  message?: string (error message if success=false)
}`,
                parameters: {
                    type: 'object',
                    properties: {
                        collection: {
                            type: 'string',
                            description: 'Collection name to retrieve from (defaults to "no-collection" if not provided). Must match the collection used when storing.',
                            optional: true
                        },
                        key: {
                            type: 'string',
                            description: 'The unique identifier of the data to retrieve. Must match the key used when storing.'
                        }
                    },
                    required: ['key']
                },
                function: async (params) => {
                    try {
                        const { collection = DEFAULT_COLLECTION, key } = params;
                        logger.debug(`Tool::Recall Retrieving ${key} from collection ${collection}`);
                        const storedData = await get(`${collection}:${key}`, storagePath, collection);
                        if (storedData === undefined) {
                            return { success: false, message: `Key ${key} not found in collection ${collection}` };
                        }
                        // Handle both old format (plain string) and new format (MemoryEntry)
                        let memoryEntry;
                        if (typeof storedData === 'string') {
                            // Legacy format - convert to new format
                            memoryEntry = {
                                value: storedData,
                                meta: {
                                    type: 'text',
                                    created: new Date().toISOString(),
                                    updated: new Date().toISOString()
                                }
                            };
                        }
                        else {
                            memoryEntry = storedData;
                        }
                        return {
                            success: true,
                            value: memoryEntry.value,
                            meta: memoryEntry.meta,
                            key,
                            collection
                        };
                    }
                    catch (error) {
                        logger.error('Error retrieving memory', error);
                        return {
                            success: false,
                            message: error instanceof Error ? error.message : 'Unknown error occurred'
                        };
                    }
                },
                parse: JSON.parse
            }
        },
        {
            type: 'function',
            function: {
                name: 'forget',
                description: `Remove a specific key from memory collection.
                
Returns: {
  success: boolean,
  message: string (confirmation or error message)
}`,
                parameters: {
                    type: 'object',
                    properties: {
                        collection: {
                            type: 'string',
                            description: 'Collection name to remove from (defaults to "no-collection" if not provided). Must match the collection where the key was stored.',
                            optional: true
                        },
                        key: {
                            type: 'string',
                            description: 'The unique identifier of the data to remove. Must match exactly the key used when storing.'
                        }
                    },
                    required: ['key']
                },
                function: async (params) => {
                    try {
                        const { collection = DEFAULT_COLLECTION, key } = params;
                        logger.debug(`Tool::Forget Removing ${key} from collection ${collection}`);
                        const keyv = store(storagePath, collection);
                        const deleted = await keyv.delete(`${collection}:${key}`);
                        return { success: deleted, message: deleted ? `Removed ${key} from ${collection}` : `Key ${key} not found in ${collection}` };
                    }
                    catch (error) {
                        logger.error('Error removing from memory', error);
                        return {
                            success: false,
                            message: error instanceof Error ? error.message : 'Unknown error occurred'
                        };
                    }
                },
                parse: JSON.parse
            }
        },
        {
            type: 'function',
            function: {
                name: 'list_memories',
                description: `List all keys in a specific collection using Keyv's iterator method.
                
Returns: {
  success: boolean,
  collection: string (the collection name),
  keys: string[] (array of key names in the collection),
  entries: Array<{
    key: string,
    meta?: {
      type: "text" | "json" | "binary",
      created: string (ISO timestamp),
      updated: string (ISO timestamp)
    }
  }>,
  count: number (total number of keys),
  message?: string (info or error message)
}`,
                parameters: {
                    type: 'object',
                    properties: {
                        collection: {
                            type: 'string',
                            description: 'Collection name to list keys from (defaults to "no-collection" if not provided). Will return all keys stored in this collection namespace.',
                            optional: true
                        }
                    },
                    required: []
                },
                function: async (params) => {
                    try {
                        const { collection = DEFAULT_COLLECTION } = params;
                        logger.debug(`Tool::ListMemories Listing keys in collection ${collection}`);
                        // Create a Keyv instance for the specific collection to use iterator
                        const keyv = store(storagePath, collection);
                        const keys = [];
                        const entries = [];
                        try {
                            // Check if iterator method exists and use it
                            if (typeof keyv.iterator === 'function') {
                                try {
                                    // Try calling iterator without arguments first
                                    const iterator = keyv.iterator();
                                    for await (const [key, value] of iterator) {
                                        // Remove the collection prefix from the key to get the clean key name
                                        const cleanKey = key.replace(`${collection}:`, '');
                                        keys.push(cleanKey);
                                        // Try to extract metadata if it's a MemoryEntry
                                        let meta = undefined;
                                        if (value && typeof value === 'object' && value.meta) {
                                            meta = value.meta;
                                        }
                                        entries.push({ key: cleanKey, meta });
                                    }
                                }
                                catch (iteratorCallError) {
                                    logger.warn(`Tool::ListMemories Iterator call failed:`, iteratorCallError);
                                    // Fall through to the not available case
                                    return {
                                        success: true,
                                        collection,
                                        keys: [],
                                        entries: [],
                                        count: 0,
                                        message: 'Iterator call failed. Unable to list keys.'
                                    };
                                }
                            }
                            else {
                                // Iterator not available, provide helpful message
                                logger.warn(`Tool::ListMemories Iterator method not available for Keyv instance`);
                                return {
                                    success: true,
                                    collection,
                                    keys: [],
                                    entries: [],
                                    count: 0,
                                    message: 'Iterator method not available in this Keyv version. Use individual key operations instead.'
                                };
                            }
                            return {
                                success: true,
                                collection,
                                keys,
                                entries,
                                count: keys.length
                            };
                        }
                        catch (iteratorError) {
                            // If iterator fails, fall back to returning basic info
                            logger.warn(`Tool::ListMemories Iterator failed for collection ${collection}:`, iteratorError);
                            return {
                                success: true,
                                collection,
                                keys: [],
                                entries: [],
                                count: 0,
                                message: 'Iterator failed or collection is empty'
                            };
                        }
                    }
                    catch (error) {
                        logger.error('Error listing memories', error);
                        return {
                            success: false,
                            message: error instanceof Error ? error.message : 'Unknown error occurred'
                        };
                    }
                },
                parse: JSON.parse
            }
        }
    ];
};
//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"memory.js","sourceRoot":"","sources":["../../../src/lib/tools/memory.ts"],"names":[],"mappings":"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"}