@ggakila/agentx-framework 0.1.0

package/dist/integrations/DatabaseTool.js

@@ -0,0 +1,900 @@
+"use strict";
+/**
+ * Database Integration Tools
+ * Provides integrations for SQL and NoSQL databases
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.RedisTool = exports.redisToolSpec = exports.MongoDBTool = exports.mongoDBToolSpec = exports.SQLDatabaseTool = exports.sqlDatabaseToolSpec = void 0;
+/**
+ * SQL Database Tool Specification
+ */
+exports.sqlDatabaseToolSpec = {
+    name: 'sql-database',
+    version: '1.0.0',
+    description: 'Execute SQL queries on PostgreSQL, MySQL, or SQLite databases',
+    inputSchema: {
+        type: 'object',
+        properties: {
+            action: {
+                type: 'string',
+                enum: ['query', 'execute', 'insert', 'update', 'delete', 'transaction'],
+                description: 'Database action',
+            },
+            sql: { type: 'string', description: 'SQL query or statement' },
+            params: { type: 'array', description: 'Query parameters' },
+            table: { type: 'string', description: 'Table name for CRUD operations' },
+            data: { type: 'object', description: 'Data for insert/update' },
+            where: { type: 'object', description: 'WHERE conditions' },
+            statements: { type: 'array', description: 'Array of statements for transaction' },
+        },
+        required: ['action'],
+    },
+    outputSchema: {
+        type: 'object',
+        properties: {
+            success: { type: 'boolean' },
+            rows: { type: 'array' },
+            rowCount: { type: 'number' },
+            lastInsertId: { type: 'number' },
+        },
+    },
+};
+/**
+ * SQL Database Integration (In-memory implementation for testing)
+ */
+class SQLDatabaseTool {
+    config;
+    logger;
+    tables = new Map();
+    autoIncrementCounters = new Map();
+    constructor(config, logger) {
+        this.config = config;
+        this.logger = logger;
+    }
+    async execute(input) {
+        try {
+            switch (input.action) {
+                case 'query':
+                    return this.executeQuery(input.sql, input.params);
+                case 'execute':
+                    return this.executeStatement(input.sql, input.params);
+                case 'insert':
+                    return this.insertRecord(input.table, input.data);
+                case 'update':
+                    return this.updateRecords(input.table, input.data, input.where);
+                case 'delete':
+                    return this.deleteRecords(input.table, input.where);
+                case 'transaction':
+                    return this.executeTransaction(input.statements);
+                default:
+                    return { success: false, error: `Unknown action: ${input.action}` };
+            }
+        }
+        catch (error) {
+            this.logger.error('SQL Database error', error);
+            return { success: false, error: error.message };
+        }
+    }
+    async executeQuery(sql, params) {
+        if (!sql) {
+            return { success: false, error: 'SQL query is required' };
+        }
+        // Simple SELECT parser for in-memory implementation
+        const selectMatch = sql.match(/SELECT\s+(.+?)\s+FROM\s+(\w+)(?:\s+WHERE\s+(.+))?/i);
+        if (selectMatch) {
+            const [, columns, tableName, whereClause] = selectMatch;
+            const table = this.tables.get(tableName.toLowerCase());
+            if (!table) {
+                return {
+                    success: true,
+                    data: { rows: [], rowCount: 0, fields: [] },
+                };
+            }
+            let rows = [...table];
+            // Apply WHERE clause if present
+            if (whereClause && params && params.length > 0) {
+                rows = this.applyWhereClause(rows, whereClause, params);
+            }
+            // Select columns
+            const selectedColumns = columns.trim() === '*'
+                ? Object.keys(rows[0] || {})
+                : columns.split(',').map(c => c.trim());
+            const result = rows.map(row => {
+                const selected = {};
+                for (const col of selectedColumns) {
+                    if (col in row) {
+                        selected[col] = row[col];
+                    }
+                }
+                return selected;
+            });
+            return {
+                success: true,
+                data: {
+                    rows: result,
+                    rowCount: result.length,
+                    fields: selectedColumns,
+                },
+            };
+        }
+        return { success: false, error: 'Unsupported SQL query' };
+    }
+    async executeStatement(sql, params) {
+        if (!sql) {
+            return { success: false, error: 'SQL statement is required' };
+        }
+        // CREATE TABLE
+        const createMatch = sql.match(/CREATE\s+TABLE\s+(?:IF\s+NOT\s+EXISTS\s+)?(\w+)/i);
+        if (createMatch) {
+            const tableName = createMatch[1].toLowerCase();
+            if (!this.tables.has(tableName)) {
+                this.tables.set(tableName, []);
+                this.autoIncrementCounters.set(tableName, 1);
+            }
+            return { success: true, data: { message: `Table ${tableName} created` } };
+        }
+        // DROP TABLE
+        const dropMatch = sql.match(/DROP\s+TABLE\s+(?:IF\s+EXISTS\s+)?(\w+)/i);
+        if (dropMatch) {
+            const tableName = dropMatch[1].toLowerCase();
+            this.tables.delete(tableName);
+            this.autoIncrementCounters.delete(tableName);
+            return { success: true, data: { message: `Table ${tableName} dropped` } };
+        }
+        // INSERT
+        const insertMatch = sql.match(/INSERT\s+INTO\s+(\w+)\s*\(([^)]+)\)\s*VALUES\s*\(([^)]+)\)/i);
+        if (insertMatch) {
+            const [, tableName, columnsStr, valuesStr] = insertMatch;
+            const columns = columnsStr.split(',').map(c => c.trim());
+            const values = this.parseValues(valuesStr, params);
+            const data = {};
+            columns.forEach((col, i) => {
+                data[col] = values[i];
+            });
+            return this.insertRecord(tableName, data);
+        }
+        return { success: false, error: 'Unsupported SQL statement' };
+    }
+    async insertRecord(table, data) {
+        if (!table || !data) {
+            return { success: false, error: 'Table and data are required' };
+        }
+        const tableName = table.toLowerCase();
+        if (!this.tables.has(tableName)) {
+            this.tables.set(tableName, []);
+            this.autoIncrementCounters.set(tableName, 1);
+        }
+        const tableData = this.tables.get(tableName);
+        const counter = this.autoIncrementCounters.get(tableName);
+        const record = {
+            id: data.id ?? counter,
+            ...data,
+        };
+        tableData.push(record);
+        this.autoIncrementCounters.set(tableName, counter + 1);
+        this.logger.info('Record inserted', { table: tableName, id: record.id });
+        return {
+            success: true,
+            data: {
+                lastInsertId: record.id,
+                rowCount: 1,
+            },
+        };
+    }
+    async updateRecords(table, data, where) {
+        if (!table || !data) {
+            return { success: false, error: 'Table and data are required' };
+        }
+        const tableName = table.toLowerCase();
+        const tableData = this.tables.get(tableName);
+        if (!tableData) {
+            return { success: false, error: `Table ${table} not found` };
+        }
+        let updatedCount = 0;
+        for (const row of tableData) {
+            if (this.matchesWhere(row, where)) {
+                Object.assign(row, data);
+                updatedCount++;
+            }
+        }
+        this.logger.info('Records updated', { table: tableName, count: updatedCount });
+        return {
+            success: true,
+            data: { rowCount: updatedCount },
+        };
+    }
+    async deleteRecords(table, where) {
+        if (!table) {
+            return { success: false, error: 'Table is required' };
+        }
+        const tableName = table.toLowerCase();
+        const tableData = this.tables.get(tableName);
+        if (!tableData) {
+            return { success: false, error: `Table ${table} not found` };
+        }
+        const initialCount = tableData.length;
+        const remaining = tableData.filter(row => !this.matchesWhere(row, where));
+        this.tables.set(tableName, remaining);
+        const deletedCount = initialCount - remaining.length;
+        this.logger.info('Records deleted', { table: tableName, count: deletedCount });
+        return {
+            success: true,
+            data: { rowCount: deletedCount },
+        };
+    }
+    async executeTransaction(statements) {
+        if (!statements || statements.length === 0) {
+            return { success: false, error: 'Statements are required for transaction' };
+        }
+        // Create snapshot for rollback
+        const snapshot = new Map(Array.from(this.tables.entries()).map(([k, v]) => [k, [...v.map(r => ({ ...r }))]]));
+        const results = [];
+        try {
+            for (const stmt of statements) {
+                const result = await this.executeStatement(stmt.sql, stmt.params);
+                if (!result.success) {
+                    throw new Error(result.error || 'Statement failed');
+                }
+                results.push(result);
+            }
+            this.logger.info('Transaction committed', { statementCount: statements.length });
+            return {
+                success: true,
+                data: {
+                    committed: true,
+                    statementCount: statements.length,
+                    results,
+                },
+            };
+        }
+        catch (error) {
+            // Rollback
+            this.tables = snapshot;
+            this.logger.warn('Transaction rolled back', { error: error.message });
+            return {
+                success: false,
+                error: `Transaction failed: ${error.message}`,
+                data: { rolledBack: true },
+            };
+        }
+    }
+    matchesWhere(row, where) {
+        if (!where)
+            return true;
+        for (const [key, value] of Object.entries(where)) {
+            if (row[key] !== value)
+                return false;
+        }
+        return true;
+    }
+    applyWhereClause(rows, whereClause, params) {
+        // Simple WHERE clause parser (column = $1)
+        const conditions = whereClause.split(/\s+AND\s+/i);
+        return rows.filter(row => {
+            for (const condition of conditions) {
+                const match = condition.match(/(\w+)\s*=\s*\$(\d+)/);
+                if (match) {
+                    const [, column, paramIndex] = match;
+                    const paramValue = params[parseInt(paramIndex, 10) - 1];
+                    if (row[column] !== paramValue)
+                        return false;
+                }
+            }
+            return true;
+        });
+    }
+    parseValues(valuesStr, params) {
+        const values = [];
+        const parts = valuesStr.split(',').map(v => v.trim());
+        for (const part of parts) {
+            if (part.startsWith('$') && params) {
+                const index = parseInt(part.slice(1), 10) - 1;
+                values.push(params[index]);
+            }
+            else if (part.startsWith("'") && part.endsWith("'")) {
+                values.push(part.slice(1, -1));
+            }
+            else if (!isNaN(Number(part))) {
+                values.push(Number(part));
+            }
+            else {
+                values.push(part);
+            }
+        }
+        return values;
+    }
+    // Test helpers
+    getTables() {
+        return new Map(this.tables);
+    }
+    clearTables() {
+        this.tables.clear();
+        this.autoIncrementCounters.clear();
+    }
+}
+exports.SQLDatabaseTool = SQLDatabaseTool;
+/**
+ * MongoDB Tool Specification
+ */
+exports.mongoDBToolSpec = {
+    name: 'mongodb',
+    version: '1.0.0',
+    description: 'Interact with MongoDB databases',
+    inputSchema: {
+        type: 'object',
+        properties: {
+            action: {
+                type: 'string',
+                enum: ['find', 'findOne', 'insertOne', 'insertMany', 'updateOne', 'updateMany', 'deleteOne', 'deleteMany', 'aggregate'],
+                description: 'MongoDB action',
+            },
+            collection: { type: 'string', description: 'Collection name' },
+            filter: { type: 'object', description: 'Query filter' },
+            document: { type: 'object', description: 'Document to insert' },
+            documents: { type: 'array', description: 'Documents to insert' },
+            update: { type: 'object', description: 'Update operations' },
+            pipeline: { type: 'array', description: 'Aggregation pipeline' },
+            options: { type: 'object', description: 'Query options (sort, limit, skip)' },
+        },
+        required: ['action', 'collection'],
+    },
+    outputSchema: {
+        type: 'object',
+        properties: {
+            success: { type: 'boolean' },
+            documents: { type: 'array' },
+            insertedId: { type: 'string' },
+            insertedIds: { type: 'array' },
+            modifiedCount: { type: 'number' },
+            deletedCount: { type: 'number' },
+        },
+    },
+};
+/**
+ * MongoDB Integration (In-memory implementation for testing)
+ */
+class MongoDBTool {
+    config;
+    logger;
+    collections = new Map();
+    idCounter = 1;
+    constructor(config, logger) {
+        this.config = { ...config, type: 'mongodb' };
+        this.logger = logger;
+    }
+    async execute(input) {
+        try {
+            switch (input.action) {
+                case 'find':
+                    return this.find(input.collection, input.filter, input.options);
+                case 'findOne':
+                    return this.findOne(input.collection, input.filter);
+                case 'insertOne':
+                    return this.insertOne(input.collection, input.document);
+                case 'insertMany':
+                    return this.insertMany(input.collection, input.documents);
+                case 'updateOne':
+                    return this.updateOne(input.collection, input.filter, input.update);
+                case 'updateMany':
+                    return this.updateMany(input.collection, input.filter, input.update);
+                case 'deleteOne':
+                    return this.deleteOne(input.collection, input.filter);
+                case 'deleteMany':
+                    return this.deleteMany(input.collection, input.filter);
+                case 'aggregate':
+                    return this.aggregate(input.collection, input.pipeline);
+                default:
+                    return { success: false, error: `Unknown action: ${input.action}` };
+            }
+        }
+        catch (error) {
+            this.logger.error('MongoDB error', error);
+            return { success: false, error: error.message };
+        }
+    }
+    async find(collection, filter, options) {
+        const coll = this.getCollection(collection);
+        let docs = this.applyFilter(coll, filter);
+        if (options?.sort) {
+            docs = this.applySort(docs, options.sort);
+        }
+        if (options?.skip) {
+            docs = docs.slice(options.skip);
+        }
+        if (options?.limit) {
+            docs = docs.slice(0, options.limit);
+        }
+        return {
+            success: true,
+            data: { documents: docs },
+        };
+    }
+    async findOne(collection, filter) {
+        const coll = this.getCollection(collection);
+        const docs = this.applyFilter(coll, filter);
+        return {
+            success: true,
+            data: { document: docs[0] || null },
+        };
+    }
+    async insertOne(collection, document) {
+        if (!document) {
+            return { success: false, error: 'Document is required' };
+        }
+        const coll = this.getCollection(collection);
+        const _id = document._id || `${this.idCounter++}`;
+        const doc = { _id, ...document };
+        coll.push(doc);
+        this.logger.info('Document inserted', { collection, _id });
+        return {
+            success: true,
+            data: { insertedId: _id, acknowledged: true },
+        };
+    }
+    async insertMany(collection, documents) {
+        if (!documents || documents.length === 0) {
+            return { success: false, error: 'Documents are required' };
+        }
+        const coll = this.getCollection(collection);
+        const insertedIds = [];
+        for (const document of documents) {
+            const _id = document._id || `${this.idCounter++}`;
+            coll.push({ _id, ...document });
+            insertedIds.push(_id);
+        }
+        this.logger.info('Documents inserted', { collection, count: insertedIds.length });
+        return {
+            success: true,
+            data: { insertedIds, insertedCount: insertedIds.length, acknowledged: true },
+        };
+    }
+    async updateOne(collection, filter, update) {
+        const coll = this.getCollection(collection);
+        const docs = this.applyFilter(coll, filter);
+        if (docs.length > 0) {
+            this.applyUpdate(docs[0], update);
+            this.logger.info('Document updated', { collection });
+            return {
+                success: true,
+                data: { matchedCount: 1, modifiedCount: 1, acknowledged: true },
+            };
+        }
+        return {
+            success: true,
+            data: { matchedCount: 0, modifiedCount: 0, acknowledged: true },
+        };
+    }
+    async updateMany(collection, filter, update) {
+        const coll = this.getCollection(collection);
+        const docs = this.applyFilter(coll, filter);
+        for (const doc of docs) {
+            this.applyUpdate(doc, update);
+        }
+        this.logger.info('Documents updated', { collection, count: docs.length });
+        return {
+            success: true,
+            data: { matchedCount: docs.length, modifiedCount: docs.length, acknowledged: true },
+        };
+    }
+    async deleteOne(collection, filter) {
+        const coll = this.getCollection(collection);
+        const index = coll.findIndex(doc => this.matchesFilter(doc, filter));
+        if (index >= 0) {
+            coll.splice(index, 1);
+            this.logger.info('Document deleted', { collection });
+            return {
+                success: true,
+                data: { deletedCount: 1, acknowledged: true },
+            };
+        }
+        return {
+            success: true,
+            data: { deletedCount: 0, acknowledged: true },
+        };
+    }
+    async deleteMany(collection, filter) {
+        const coll = this.getCollection(collection);
+        const initialCount = coll.length;
+        const remaining = coll.filter(doc => !this.matchesFilter(doc, filter));
+        this.collections.set(collection, remaining);
+        const deletedCount = initialCount - remaining.length;
+        this.logger.info('Documents deleted', { collection, count: deletedCount });
+        return {
+            success: true,
+            data: { deletedCount, acknowledged: true },
+        };
+    }
+    async aggregate(collection, pipeline) {
+        let docs = [...this.getCollection(collection)];
+        for (const stage of pipeline) {
+            if ('$match' in stage) {
+                docs = this.applyFilter(docs, stage.$match);
+            }
+            else if ('$sort' in stage) {
+                docs = this.applySort(docs, stage.$sort);
+            }
+            else if ('$limit' in stage) {
+                docs = docs.slice(0, stage.$limit);
+            }
+            else if ('$skip' in stage) {
+                docs = docs.slice(stage.$skip);
+            }
+            else if ('$project' in stage) {
+                const projection = stage.$project;
+                docs = docs.map(doc => {
+                    const projected = {};
+                    for (const [key, include] of Object.entries(projection)) {
+                        if (include && key in doc) {
+                            projected[key] = doc[key];
+                        }
+                    }
+                    return projected;
+                });
+            }
+        }
+        return {
+            success: true,
+            data: { documents: docs },
+        };
+    }
+    getCollection(name) {
+        if (!this.collections.has(name)) {
+            this.collections.set(name, []);
+        }
+        return this.collections.get(name);
+    }
+    applyFilter(docs, filter) {
+        if (!filter || Object.keys(filter).length === 0)
+            return [...docs];
+        return docs.filter(doc => this.matchesFilter(doc, filter));
+    }
+    matchesFilter(doc, filter) {
+        for (const [key, value] of Object.entries(filter)) {
+            if (typeof value === 'object' && value !== null) {
+                // Handle operators like $gt, $lt, $in, etc.
+                for (const [op, opValue] of Object.entries(value)) {
+                    switch (op) {
+                        case '$gt':
+                            if (!(doc[key] > opValue))
+                                return false;
+                            break;
+                        case '$gte':
+                            if (!(doc[key] >= opValue))
+                                return false;
+                            break;
+                        case '$lt':
+                            if (!(doc[key] < opValue))
+                                return false;
+                            break;
+                        case '$lte':
+                            if (!(doc[key] <= opValue))
+                                return false;
+                            break;
+                        case '$ne':
+                            if (doc[key] === opValue)
+                                return false;
+                            break;
+                        case '$in':
+                            if (!opValue.includes(doc[key]))
+                                return false;
+                            break;
+                        case '$nin':
+                            if (opValue.includes(doc[key]))
+                                return false;
+                            break;
+                    }
+                }
+            }
+            else if (doc[key] !== value) {
+                return false;
+            }
+        }
+        return true;
+    }
+    applySort(docs, sort) {
+        return [...docs].sort((a, b) => {
+            for (const [key, direction] of Object.entries(sort)) {
+                const aVal = a[key];
+                const bVal = b[key];
+                if (aVal < bVal)
+                    return -direction;
+                if (aVal > bVal)
+                    return direction;
+            }
+            return 0;
+        });
+    }
+    applyUpdate(doc, update) {
+        if ('$set' in update) {
+            Object.assign(doc, update.$set);
+        }
+        if ('$unset' in update) {
+            for (const key of Object.keys(update.$unset)) {
+                delete doc[key];
+            }
+        }
+        if ('$inc' in update) {
+            for (const [key, value] of Object.entries(update.$inc)) {
+                doc[key] = (doc[key] || 0) + value;
+            }
+        }
+    }
+    // Test helpers
+    getCollections() {
+        return new Map(this.collections);
+    }
+    clearCollections() {
+        this.collections.clear();
+        this.idCounter = 1;
+    }
+}
+exports.MongoDBTool = MongoDBTool;
+/**
+ * Redis Tool Specification
+ */
+exports.redisToolSpec = {
+    name: 'redis',
+    version: '1.0.0',
+    description: 'Interact with Redis key-value store',
+    inputSchema: {
+        type: 'object',
+        properties: {
+            action: {
+                type: 'string',
+                enum: ['get', 'set', 'del', 'exists', 'keys', 'expire', 'ttl', 'incr', 'decr', 'hget', 'hset', 'hgetall', 'lpush', 'rpush', 'lpop', 'rpop', 'lrange'],
+                description: 'Redis command',
+            },
+            key: { type: 'string', description: 'Key name' },
+            value: { type: 'string', description: 'Value to set' },
+            field: { type: 'string', description: 'Hash field name' },
+            fields: { type: 'object', description: 'Hash fields to set' },
+            seconds: { type: 'number', description: 'TTL in seconds' },
+            pattern: { type: 'string', description: 'Key pattern for KEYS command' },
+            start: { type: 'number', description: 'Start index for LRANGE' },
+            stop: { type: 'number', description: 'Stop index for LRANGE' },
+        },
+        required: ['action'],
+    },
+    outputSchema: {
+        type: 'object',
+        properties: {
+            success: { type: 'boolean' },
+            value: { type: 'string' },
+            values: { type: 'array' },
+            count: { type: 'number' },
+        },
+    },
+};
+/**
+ * Redis Integration (In-memory implementation for testing)
+ */
+class RedisTool {
+    config;
+    logger;
+    store = new Map();
+    constructor(config, logger) {
+        this.config = { ...config, type: 'redis' };
+        this.logger = logger;
+    }
+    async execute(input) {
+        try {
+            // Clean up expired keys
+            this.cleanupExpired();
+            switch (input.action) {
+                case 'get': return this.get(input.key);
+                case 'set': return this.set(input.key, input.value, input.seconds);
+                case 'del': return this.del(input.key);
+                case 'exists': return this.exists(input.key);
+                case 'keys': return this.keys(input.pattern || '*');
+                case 'expire': return this.expire(input.key, input.seconds);
+                case 'ttl': return this.ttl(input.key);
+                case 'incr': return this.incr(input.key);
+                case 'decr': return this.decr(input.key);
+                case 'hget': return this.hget(input.key, input.field);
+                case 'hset': return this.hset(input.key, input.fields || { [input.field]: input.value });
+                case 'hgetall': return this.hgetall(input.key);
+                case 'lpush': return this.lpush(input.key, input.value);
+                case 'rpush': return this.rpush(input.key, input.value);
+                case 'lpop': return this.lpop(input.key);
+                case 'rpop': return this.rpop(input.key);
+                case 'lrange': return this.lrange(input.key, input.start || 0, input.stop || -1);
+                default:
+                    return { success: false, error: `Unknown action: ${input.action}` };
+            }
+        }
+        catch (error) {
+            this.logger.error('Redis error', error);
+            return { success: false, error: error.message };
+        }
+    }
+    async get(key) {
+        if (!key)
+            return { success: false, error: 'Key is required' };
+        const entry = this.store.get(key);
+        if (!entry || entry.type !== 'string') {
+            return { success: true, data: { value: null } };
+        }
+        return { success: true, data: { value: entry.value } };
+    }
+    async set(key, value, seconds) {
+        if (!key)
+            return { success: false, error: 'Key is required' };
+        const entry = {
+            value,
+            type: 'string',
+        };
+        if (seconds) {
+            entry.expireAt = Date.now() + seconds * 1000;
+        }
+        this.store.set(key, entry);
+        return { success: true, data: { ok: true } };
+    }
+    async del(key) {
+        if (!key)
+            return { success: false, error: 'Key is required' };
+        const deleted = this.store.delete(key) ? 1 : 0;
+        return { success: true, data: { count: deleted } };
+    }
+    async exists(key) {
+        if (!key)
+            return { success: false, error: 'Key is required' };
+        return { success: true, data: { exists: this.store.has(key) ? 1 : 0 } };
+    }
+    async keys(pattern) {
+        const regex = new RegExp('^' + pattern.replace(/\*/g, '.*').replace(/\?/g, '.') + '$');
+        const matchingKeys = Array.from(this.store.keys()).filter(k => regex.test(k));
+        return { success: true, data: { keys: matchingKeys } };
+    }
+    async expire(key, seconds) {
+        if (!key)
+            return { success: false, error: 'Key is required' };
+        const entry = this.store.get(key);
+        if (!entry) {
+            return { success: true, data: { set: 0 } };
+        }
+        entry.expireAt = Date.now() + seconds * 1000;
+        return { success: true, data: { set: 1 } };
+    }
+    async ttl(key) {
+        if (!key)
+            return { success: false, error: 'Key is required' };
+        const entry = this.store.get(key);
+        if (!entry) {
+            return { success: true, data: { ttl: -2 } };
+        }
+        if (!entry.expireAt) {
+            return { success: true, data: { ttl: -1 } };
+        }
+        const ttl = Math.ceil((entry.expireAt - Date.now()) / 1000);
+        return { success: true, data: { ttl: Math.max(0, ttl) } };
+    }
+    async incr(key) {
+        if (!key)
+            return { success: false, error: 'Key is required' };
+        const entry = this.store.get(key);
+        const currentValue = entry?.type === 'string' ? parseInt(entry.value, 10) || 0 : 0;
+        const newValue = currentValue + 1;
+        this.store.set(key, { value: newValue.toString(), type: 'string', expireAt: entry?.expireAt });
+        return { success: true, data: { value: newValue } };
+    }
+    async decr(key) {
+        if (!key)
+            return { success: false, error: 'Key is required' };
+        const entry = this.store.get(key);
+        const currentValue = entry?.type === 'string' ? parseInt(entry.value, 10) || 0 : 0;
+        const newValue = currentValue - 1;
+        this.store.set(key, { value: newValue.toString(), type: 'string', expireAt: entry?.expireAt });
+        return { success: true, data: { value: newValue } };
+    }
+    async hget(key, field) {
+        if (!key || !field)
+            return { success: false, error: 'Key and field are required' };
+        const entry = this.store.get(key);
+        if (!entry || entry.type !== 'hash') {
+            return { success: true, data: { value: null } };
+        }
+        const hash = entry.value;
+        return { success: true, data: { value: hash[field] ?? null } };
+    }
+    async hset(key, fields) {
+        if (!key || !fields)
+            return { success: false, error: 'Key and fields are required' };
+        let entry = this.store.get(key);
+        if (!entry || entry.type !== 'hash') {
+            entry = { value: {}, type: 'hash' };
+            this.store.set(key, entry);
+        }
+        const hash = entry.value;
+        let added = 0;
+        for (const [field, value] of Object.entries(fields)) {
+            if (!(field in hash))
+                added++;
+            hash[field] = value;
+        }
+        return { success: true, data: { added } };
+    }
+    async hgetall(key) {
+        if (!key)
+            return { success: false, error: 'Key is required' };
+        const entry = this.store.get(key);
+        if (!entry || entry.type !== 'hash') {
+            return { success: true, data: { value: {} } };
+        }
+        return { success: true, data: { value: entry.value } };
+    }
+    async lpush(key, value) {
+        if (!key)
+            return { success: false, error: 'Key is required' };
+        let entry = this.store.get(key);
+        if (!entry || entry.type !== 'list') {
+            entry = { value: [], type: 'list' };
+            this.store.set(key, entry);
+        }
+        const list = entry.value;
+        list.unshift(value);
+        return { success: true, data: { length: list.length } };
+    }
+    async rpush(key, value) {
+        if (!key)
+            return { success: false, error: 'Key is required' };
+        let entry = this.store.get(key);
+        if (!entry || entry.type !== 'list') {
+            entry = { value: [], type: 'list' };
+            this.store.set(key, entry);
+        }
+        const list = entry.value;
+        list.push(value);
+        return { success: true, data: { length: list.length } };
+    }
+    async lpop(key) {
+        if (!key)
+            return { success: false, error: 'Key is required' };
+        const entry = this.store.get(key);
+        if (!entry || entry.type !== 'list') {
+            return { success: true, data: { value: null } };
+        }
+        const list = entry.value;
+        const value = list.shift();
+        return { success: true, data: { value: value ?? null } };
+    }
+    async rpop(key) {
+        if (!key)
+            return { success: false, error: 'Key is required' };
+        const entry = this.store.get(key);
+        if (!entry || entry.type !== 'list') {
+            return { success: true, data: { value: null } };
+        }
+        const list = entry.value;
+        const value = list.pop();
+        return { success: true, data: { value: value ?? null } };
+    }
+    async lrange(key, start, stop) {
+        if (!key)
+            return { success: false, error: 'Key is required' };
+        const entry = this.store.get(key);
+        if (!entry || entry.type !== 'list') {
+            return { success: true, data: { values: [] } };
+        }
+        const list = entry.value;
+        const end = stop < 0 ? list.length + stop + 1 : stop + 1;
+        const values = list.slice(start, end);
+        return { success: true, data: { values } };
+    }
+    cleanupExpired() {
+        const now = Date.now();
+        for (const [key, entry] of this.store.entries()) {
+            if (entry.expireAt && entry.expireAt <= now) {
+                this.store.delete(key);
+            }
+        }
+    }
+    // Test helpers
+    getStore() {
+        return new Map(this.store);
+    }
+    clearStore() {
+        this.store.clear();
+    }
+}
+exports.RedisTool = RedisTool;
+//# sourceMappingURL=DatabaseTool.js.map