agenticaichat 1.0.0 → 1.0.3

package/dist/engines/nosql/MongoEngine.js

@@ -0,0 +1,194 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.MongoEngine = void 0;
+const mongodb_1 = require("mongodb");
+const NoSqlEngine_1 = require("./NoSqlEngine");
+const logger_1 = require("../../utils/logger");
+class MongoEngine extends NoSqlEngine_1.NoSqlEngine {
+    constructor(config) {
+        super(config);
+        this.client = null;
+        this.db = null;
+        logger_1.logger.info('MongoDB engine initialized');
+    }
+    async connect() {
+        try {
+            logger_1.logger.info('Connecting to MongoDB...');
+            this.client = new mongodb_1.MongoClient(this.config.url);
+            await this.client.connect();
+            // Extract database name from config or URL
+            const dbName = this.config.database ||
+                new URL(this.config.url).pathname.slice(1);
+            this.db = this.client.db(dbName);
+            this.connected = true;
+            logger_1.logger.info('✅ MongoDB connected successfully');
+        }
+        catch (error) {
+            logger_1.logger.error('MongoDB connection failed', error);
+            throw error;
+        }
+    }
+    async disconnect() {
+        if (!this.client)
+            return;
+        try {
+            await this.client.close();
+            this.connected = false;
+            this.client = null;
+            this.db = null;
+            logger_1.logger.info('MongoDB disconnected');
+        }
+        catch (error) {
+            logger_1.logger.error('MongoDB disconnect failed', error);
+        }
+    }
+    async getSchema() {
+        if (!this.connected || !this.db) {
+            throw new Error('Not connected to MongoDB');
+        }
+        try {
+            logger_1.logger.info('Extracting MongoDB schema...');
+            // Get all collections
+            const collections = await this.db.listCollections().toArray();
+            const schema = { tables: [] };
+            // Sample documents to infer schema
+            for (const collection of collections) {
+                const collectionName = collection.name;
+                // Get sample document to infer fields
+                const sampleDoc = await this.db.collection(collectionName).findOne({});
+                const columns = [];
+                if (sampleDoc) {
+                    for (const [key, value] of Object.entries(sampleDoc)) {
+                        columns.push({
+                            name: key,
+                            type: this.inferMongoType(value),
+                            nullable: true // MongoDB fields are always nullable
+                        });
+                    }
+                }
+                schema.tables.push({
+                    name: collectionName,
+                    columns
+                });
+            }
+            logger_1.logger.info(`Schema extracted: ${schema.tables.length} collections found`);
+            return schema;
+        }
+        catch (error) {
+            logger_1.logger.error('Schema extraction failed', error);
+            throw error;
+        }
+    }
+    async executeQuery(query) {
+        if (!this.connected || !this.db) {
+            throw new Error('Not connected to MongoDB');
+        }
+        // Parse query if it's a string
+        let parsedQuery;
+        if (typeof query === 'string') {
+            try {
+                parsedQuery = JSON.parse(query);
+            }
+            catch (error) {
+                throw new Error('Invalid MongoDB query format. Expected JSON.');
+            }
+        }
+        else {
+            parsedQuery = query;
+        }
+        if (!this.validateQuery(parsedQuery)) {
+            throw new Error('Invalid MongoDB query');
+        }
+        try {
+            logger_1.logger.debug_log('Executing MongoDB query:', parsedQuery);
+            const { collection, operation, filter = {}, options = {} } = parsedQuery;
+            if (!collection || !operation) {
+                throw new Error('MongoDB query must specify collection and operation');
+            }
+            const coll = this.db.collection(collection);
+            let result;
+            switch (operation.toLowerCase()) {
+                case 'find':
+                    result = await coll.find(filter, options).toArray();
+                    break;
+                case 'findone':
+                    result = await coll.findOne(filter, options);
+                    result = result ? [result] : [];
+                    break;
+                case 'count':
+                case 'countdocuments':
+                    result = await coll.countDocuments(filter);
+                    result = [{ count: result }];
+                    break;
+                case 'aggregate':
+                    const pipeline = parsedQuery.pipeline || [];
+                    result = await coll.aggregate(pipeline).toArray();
+                    break;
+                default:
+                    throw new Error(`Unsupported MongoDB operation: ${operation}`);
+            }
+            return {
+                rows: Array.isArray(result) ? result : [result],
+                rowCount: Array.isArray(result) ? result.length : 1
+            };
+        }
+        catch (error) {
+            logger_1.logger.error('MongoDB query execution failed', error);
+            throw error;
+        }
+    }
+    validateQuery(query) {
+        if (!super.validateQuery(query)) {
+            return false;
+        }
+        // Parse if string
+        let parsedQuery;
+        if (typeof query === 'string') {
+            try {
+                parsedQuery = JSON.parse(query);
+            }
+            catch {
+                logger_1.logger.error('Invalid JSON format for MongoDB query');
+                return false;
+            }
+        }
+        else {
+            parsedQuery = query;
+        }
+        // Check required fields
+        if (!parsedQuery.collection) {
+            logger_1.logger.error('MongoDB query must specify a collection');
+            return false;
+        }
+        if (!parsedQuery.operation) {
+            logger_1.logger.error('MongoDB query must specify an operation');
+            return false;
+        }
+        // Validate operation is read-only
+        const allowedOperations = ['find', 'findone', 'count', 'countdocuments', 'aggregate'];
+        if (!allowedOperations.includes(parsedQuery.operation.toLowerCase())) {
+            logger_1.logger.warn(`Unsafe MongoDB operation: ${parsedQuery.operation}`);
+            return false;
+        }
+        return true;
+    }
+    inferMongoType(value) {
+        if (value === null || value === undefined)
+            return 'null';
+        if (typeof value === 'string')
+            return 'string';
+        if (typeof value === 'number') {
+            return Number.isInteger(value) ? 'int' : 'double';
+        }
+        if (typeof value === 'boolean')
+            return 'boolean';
+        if (value instanceof Date)
+            return 'date';
+        if (Array.isArray(value))
+            return 'array';
+        if (typeof value === 'object')
+            return 'object';
+        return 'unknown';
+    }
+}
+exports.MongoEngine = MongoEngine;

package/dist/engines/nosql/NoSqlEngine.d.ts

@@ -0,0 +1,20 @@
+import { DatabaseEngine } from '../base/DatabaseEngine';
+import { DatabaseConfig, DatabaseSchema, QueryResult } from '../../types';
+/**
+ * Base class for all NoSQL database engines
+ */
+export declare abstract class NoSqlEngine extends DatabaseEngine {
+    constructor(config: DatabaseConfig);
+    /**
+     * Validate NoSQL query
+     * Each NoSQL DB has different query format
+     */
+    validateQuery(query: string | object): boolean;
+    /**
+     * Abstract methods that implementations must provide
+     */
+    abstract connect(): Promise<void>;
+    abstract disconnect(): Promise<void>;
+    abstract getSchema(): Promise<DatabaseSchema>;
+    abstract executeQuery(query: object): Promise<QueryResult>;
+}

package/dist/engines/nosql/NoSqlEngine.js

@@ -0,0 +1,29 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.NoSqlEngine = void 0;
+const DatabaseEngine_1 = require("../base/DatabaseEngine");
+const logger_1 = require("../../utils/logger");
+/**
+ * Base class for all NoSQL database engines
+ */
+class NoSqlEngine extends DatabaseEngine_1.DatabaseEngine {
+    constructor(config) {
+        super(config);
+        if (config.category !== 'nosql') {
+            throw new Error('NoSqlEngine requires category to be "nosql"');
+        }
+    }
+    /**
+     * Validate NoSQL query
+     * Each NoSQL DB has different query format
+     */
+    validateQuery(query) {
+        // Basic validation - can be overridden by specific engines
+        if (!query) {
+            logger_1.logger.error('Query cannot be empty');
+            return false;
+        }
+        return true;
+    }
+}
+exports.NoSqlEngine = NoSqlEngine;

package/dist/engines/sql/SqlEngine.d.ts

@@ -0,0 +1,19 @@
+import { DatabaseEngine } from '../base/DatabaseEngine';
+import { DatabaseConfig, DatabaseSchema, QueryResult } from '../../types';
+/**
+ * Base class for all SQL database engines
+ */
+export declare abstract class SqlEngine extends DatabaseEngine {
+    constructor(config: DatabaseConfig);
+    /**
+     * Validate SQL query for security
+     */
+    validateQuery(query: string | object): boolean;
+    /**
+     * Abstract methods that dialects must implement
+     */
+    abstract connect(): Promise<void>;
+    abstract disconnect(): Promise<void>;
+    abstract getSchema(): Promise<DatabaseSchema>;
+    abstract executeQuery(query: string): Promise<QueryResult>;
+}

package/dist/engines/sql/SqlEngine.js

@@ -0,0 +1,52 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.SqlEngine = void 0;
+const DatabaseEngine_1 = require("../base/DatabaseEngine");
+const logger_1 = require("../../utils/logger");
+/**
+ * Base class for all SQL database engines
+ */
+class SqlEngine extends DatabaseEngine_1.DatabaseEngine {
+    constructor(config) {
+        super(config);
+        if (config.category !== 'sql') {
+            throw new Error('SqlEngine requires category to be "sql"');
+        }
+    }
+    /**
+     * Validate SQL query for security
+     */
+    validateQuery(query) {
+        if (typeof query !== 'string') {
+            logger_1.logger.error('SQL query must be a string');
+            return false;
+        }
+        const sql = query.toUpperCase().trim();
+        // Check for dangerous keywords
+        const dangerousKeywords = [
+            'DROP',
+            'DELETE',
+            'TRUNCATE',
+            'ALTER',
+            'CREATE TABLE',
+            'CREATE DATABASE',
+            'GRANT',
+            'REVOKE',
+            'INSERT',
+            'UPDATE'
+        ];
+        for (const keyword of dangerousKeywords) {
+            if (sql.includes(keyword)) {
+                logger_1.logger.warn(`Dangerous SQL keyword detected: ${keyword}`);
+                return false;
+            }
+        }
+        // Must start with SELECT
+        if (!sql.startsWith('SELECT') && !sql.startsWith('WITH')) {
+            logger_1.logger.warn('Only SELECT queries are allowed');
+            return false;
+        }
+        return true;
+    }
+}
+exports.SqlEngine = SqlEngine;

package/dist/engines/sql/dialects/MySQLDialect.d.ts

@@ -0,0 +1,12 @@
+import mysql from 'mysql2/promise';
+import { SqlEngine } from '../SqlEngine';
+import { DatabaseConfig, DatabaseSchema, QueryResult } from '../../../types';
+export declare class MySQLDialect extends SqlEngine {
+    protected connection: mysql.Connection | null;
+    constructor(config: DatabaseConfig);
+    connect(): Promise<void>;
+    disconnect(): Promise<void>;
+    getSchema(): Promise<DatabaseSchema>;
+    executeQuery(query: string): Promise<QueryResult>;
+    private formatSchema;
+}

package/dist/engines/sql/dialects/MySQLDialect.js

@@ -0,0 +1,109 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.MySQLDialect = void 0;
+const promise_1 = __importDefault(require("mysql2/promise"));
+const SqlEngine_1 = require("../SqlEngine");
+const logger_1 = require("../../../utils/logger");
+class MySQLDialect extends SqlEngine_1.SqlEngine {
+    constructor(config) {
+        super(config);
+        this.connection = null;
+        logger_1.logger.info('MySQL dialect initialized');
+    }
+    async connect() {
+        try {
+            logger_1.logger.info('Connecting to MySQL...');
+            this.connection = await promise_1.default.createConnection(this.config.url);
+            this.connected = true;
+            logger_1.logger.info('✅ MySQL connected successfully');
+        }
+        catch (error) {
+            logger_1.logger.error('MySQL connection failed', error);
+            throw error;
+        }
+    }
+    async disconnect() {
+        if (!this.connection)
+            return;
+        try {
+            await this.connection.end();
+            this.connected = false;
+            this.connection = null;
+            logger_1.logger.info('MySQL disconnected');
+        }
+        catch (error) {
+            logger_1.logger.error('MySQL disconnect failed', error);
+        }
+    }
+    async getSchema() {
+        if (!this.connected || !this.connection) {
+            throw new Error('Not connected to MySQL');
+        }
+        try {
+            logger_1.logger.info('Extracting MySQL schema...');
+            const query = `
+        SELECT 
+          TABLE_NAME as table_name,
+          COLUMN_NAME as column_name,
+          DATA_TYPE as data_type,
+          IS_NULLABLE as is_nullable
+        FROM INFORMATION_SCHEMA.COLUMNS
+        WHERE TABLE_SCHEMA = DATABASE()
+        ORDER BY TABLE_NAME, ORDINAL_POSITION;
+      `;
+            const [rows] = await this.connection.query(query);
+            const schema = this.formatSchema(rows);
+            logger_1.logger.info(`Schema extracted: ${schema.tables.length} tables found`);
+            return schema;
+        }
+        catch (error) {
+            logger_1.logger.error('Schema extraction failed', error);
+            throw error;
+        }
+    }
+    async executeQuery(query) {
+        if (!this.connected || !this.connection) {
+            throw new Error('Not connected to MySQL');
+        }
+        if (!this.validateQuery(query)) {
+            throw new Error('Invalid or unsafe SQL query');
+        }
+        try {
+            logger_1.logger.debug_log('Executing MySQL query:', query);
+            const [rows, fields] = await this.connection.query(query);
+            return {
+                rows: rows,
+                rowCount: Array.isArray(rows) ? rows.length : 0,
+                fields: fields
+            };
+        }
+        catch (error) {
+            logger_1.logger.error('Query execution failed', error);
+            throw error;
+        }
+    }
+    formatSchema(rows) {
+        const tablesMap = new Map();
+        for (const row of rows) {
+            const tableName = row.table_name;
+            const column = {
+                name: row.column_name,
+                type: row.data_type,
+                nullable: row.is_nullable === 'YES'
+            };
+            if (!tablesMap.has(tableName)) {
+                tablesMap.set(tableName, []);
+            }
+            tablesMap.get(tableName).push(column);
+        }
+        const tables = [];
+        for (const [name, columns] of tablesMap.entries()) {
+            tables.push({ name, columns });
+        }
+        return { tables };
+    }
+}
+exports.MySQLDialect = MySQLDialect;

package/dist/engines/sql/dialects/PostgresDialect.d.ts

@@ -0,0 +1,11 @@
+import { SqlEngine } from '../SqlEngine';
+import { DatabaseConfig, DatabaseSchema, QueryResult } from '../../../types';
+export declare class PostgresDialect extends SqlEngine {
+    private client;
+    constructor(config: DatabaseConfig);
+    connect(): Promise<void>;
+    disconnect(): Promise<void>;
+    getSchema(): Promise<DatabaseSchema>;
+    executeQuery(query: string): Promise<QueryResult>;
+    private formatSchema;
+}

package/dist/engines/sql/dialects/PostgresDialect.js

@@ -0,0 +1,109 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.PostgresDialect = void 0;
+const pg_1 = require("pg");
+const SqlEngine_1 = require("../SqlEngine");
+const logger_1 = require("../../../utils/logger");
+class PostgresDialect extends SqlEngine_1.SqlEngine {
+    constructor(config) {
+        super(config);
+        this.client = null;
+        logger_1.logger.info('PostgreSQL dialect initialized');
+    }
+    async connect() {
+        try {
+            logger_1.logger.info('Connecting to PostgreSQL...');
+            this.client = new pg_1.Client({
+                connectionString: this.config.url
+            });
+            await this.client.connect();
+            this.connected = true;
+            logger_1.logger.info('✅ PostgreSQL connected successfully');
+        }
+        catch (error) {
+            logger_1.logger.error('PostgreSQL connection failed', error);
+            throw error;
+        }
+    }
+    async disconnect() {
+        if (!this.client)
+            return;
+        try {
+            await this.client.end();
+            this.connected = false;
+            this.client = null;
+            logger_1.logger.info('PostgreSQL disconnected');
+        }
+        catch (error) {
+            logger_1.logger.error('PostgreSQL disconnect failed', error);
+        }
+    }
+    async getSchema() {
+        if (!this.connected || !this.client) {
+            throw new Error('Not connected to PostgreSQL');
+        }
+        try {
+            logger_1.logger.info('Extracting PostgreSQL schema...');
+            const query = `
+        SELECT 
+          table_name,
+          column_name,
+          data_type,
+          is_nullable
+        FROM information_schema.columns
+        WHERE table_schema = 'public'
+        ORDER BY table_name, ordinal_position;
+      `;
+            const result = await this.client.query(query);
+            const schema = this.formatSchema(result.rows);
+            logger_1.logger.info(`Schema extracted: ${schema.tables.length} tables found`);
+            return schema;
+        }
+        catch (error) {
+            logger_1.logger.error('Schema extraction failed', error);
+            throw error;
+        }
+    }
+    async executeQuery(query) {
+        if (!this.connected || !this.client) {
+            throw new Error('Not connected to PostgreSQL');
+        }
+        if (!this.validateQuery(query)) {
+            throw new Error('Invalid or unsafe SQL query');
+        }
+        try {
+            logger_1.logger.debug_log('Executing PostgreSQL query:', query);
+            const result = await this.client.query(query);
+            return {
+                rows: result.rows,
+                rowCount: result.rowCount || 0,
+                fields: result.fields
+            };
+        }
+        catch (error) {
+            logger_1.logger.error('Query execution failed', error);
+            throw error;
+        }
+    }
+    formatSchema(rows) {
+        const tablesMap = new Map();
+        for (const row of rows) {
+            const tableName = row.table_name;
+            const column = {
+                name: row.column_name,
+                type: row.data_type,
+                nullable: row.is_nullable === 'YES'
+            };
+            if (!tablesMap.has(tableName)) {
+                tablesMap.set(tableName, []);
+            }
+            tablesMap.get(tableName).push(column);
+        }
+        const tables = [];
+        for (const [name, columns] of tablesMap.entries()) {
+            tables.push({ name, columns });
+        }
+        return { tables };
+    }
+}
+exports.PostgresDialect = PostgresDialect;

package/dist/engines/sql/dialects/SQLiteDialect.d.ts

@@ -0,0 +1,10 @@
+import { SqlEngine } from '../SqlEngine';
+import { DatabaseConfig, DatabaseSchema, QueryResult } from '../../../types';
+export declare class SQLiteDialect extends SqlEngine {
+    private db;
+    constructor(config: DatabaseConfig);
+    connect(): Promise<void>;
+    disconnect(): Promise<void>;
+    getSchema(): Promise<DatabaseSchema>;
+    executeQuery(query: string): Promise<QueryResult>;
+}

package/dist/engines/sql/dialects/SQLiteDialect.js

@@ -0,0 +1,101 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.SQLiteDialect = void 0;
+const better_sqlite3_1 = __importDefault(require("better-sqlite3"));
+const SqlEngine_1 = require("../SqlEngine");
+const logger_1 = require("../../../utils/logger");
+class SQLiteDialect extends SqlEngine_1.SqlEngine {
+    constructor(config) {
+        super(config);
+        this.db = null;
+        logger_1.logger.info('SQLite dialect initialized');
+    }
+    async connect() {
+        try {
+            logger_1.logger.info('Connecting to SQLite...');
+            // Extract file path from URL (sqlite:///path/to/db.sqlite)
+            const dbPath = this.config.url.replace('sqlite:///', '').replace('sqlite://', '');
+            this.db = new better_sqlite3_1.default(dbPath);
+            this.connected = true;
+            logger_1.logger.info('✅ SQLite connected successfully');
+        }
+        catch (error) {
+            logger_1.logger.error('SQLite connection failed', error);
+            throw error;
+        }
+    }
+    async disconnect() {
+        if (!this.db)
+            return;
+        try {
+            this.db.close();
+            this.connected = false;
+            this.db = null;
+            logger_1.logger.info('SQLite disconnected');
+        }
+        catch (error) {
+            logger_1.logger.error('SQLite disconnect failed', error);
+        }
+    }
+    async getSchema() {
+        if (!this.connected || !this.db) {
+            throw new Error('Not connected to SQLite');
+        }
+        try {
+            logger_1.logger.info('Extracting SQLite schema...');
+            // Get all tables
+            const tablesQuery = `
+        SELECT name FROM sqlite_master 
+        WHERE type='table' 
+        AND name NOT LIKE 'sqlite_%';
+      `;
+            const tables = this.db.prepare(tablesQuery).all();
+            const schema = { tables: [] };
+            // Get columns for each table
+            for (const table of tables) {
+                const columnsQuery = `PRAGMA table_info(${table.name});`;
+                const columns = this.db.prepare(columnsQuery).all();
+                const tableSchema = {
+                    name: table.name,
+                    columns: columns.map(col => ({
+                        name: col.name,
+                        type: col.type,
+                        nullable: col.notnull === 0
+                    }))
+                };
+                schema.tables.push(tableSchema);
+            }
+            logger_1.logger.info(`Schema extracted: ${schema.tables.length} tables found`);
+            return schema;
+        }
+        catch (error) {
+            logger_1.logger.error('Schema extraction failed', error);
+            throw error;
+        }
+    }
+    async executeQuery(query) {
+        if (!this.connected || !this.db) {
+            throw new Error('Not connected to SQLite');
+        }
+        if (!this.validateQuery(query)) {
+            throw new Error('Invalid or unsafe SQL query');
+        }
+        try {
+            logger_1.logger.debug_log('Executing SQLite query:', query);
+            const stmt = this.db.prepare(query);
+            const rows = stmt.all();
+            return {
+                rows: rows,
+                rowCount: rows.length
+            };
+        }
+        catch (error) {
+            logger_1.logger.error('Query execution failed', error);
+            throw error;
+        }
+    }
+}
+exports.SQLiteDialect = SQLiteDialect;