agenticaichat 1.0.1 → 1.0.3

package/dist/core/ChatbotEngine.js

@@ -1,17 +1,34 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.ChatbotEngine = void 0;
-const DatabaseConnector_1 = require("./DatabaseConnector");
+const EngineFactory_1 = require("./EngineFactory");
 const NLToSQLConverter_1 = require("./NLToSQLConverter");
+const LLMFactory_1 = require("../llm/LLMFactory");
 const logger_1 = require("../utils/logger");
 class ChatbotEngine {
     constructor(config) {
         this.schema = null;
         this.initialized = false;
-        this.dbConnector = new DatabaseConnector_1.DatabaseConnector(config.database);
-        this.nlConverter = new NLToSQLConverter_1.NLToSQLConverter(config.openai);
+        // Validate database config
+        const dbValidation = EngineFactory_1.EngineFactory.validateConfig(config.database);
+        if (!dbValidation.valid) {
+            throw new Error(`Database configuration invalid: ${dbValidation.error}`);
+        }
+        // Validate LLM config
+        const llmValidation = LLMFactory_1.LLMFactory.validateConfig(config.llm);
+        if (!llmValidation.valid) {
+            throw new Error(`LLM configuration invalid: ${llmValidation.error}`);
+        }
+        // Create database engine
+        this.dbEngine = EngineFactory_1.EngineFactory.createEngine(config.database);
+        // Create LLM provider
+        const llmProvider = LLMFactory_1.LLMFactory.createProvider(config.llm);
+        // Initialize NL converter
+        this.nlConverter = new NLToSQLConverter_1.NLToSQLConverter(llmProvider);
         if (config.debug) {
             logger_1.logger.info('ChatbotEngine initialized in DEBUG mode');
+            logger_1.logger.info(`Database: ${config.database.type} (${config.database.category})`);
+            logger_1.logger.info(`LLM Provider: ${config.llm.provider}`);
         }
     }
     /**
@@ -21,12 +38,12 @@ class ChatbotEngine {
         try {
             logger_1.logger.info('Initializing ChatbotEngine...');
             // Connect to database
-            await this.dbConnector.connect();
+            await this.dbEngine.connect();
             // Load schema
-            this.schema = await this.dbConnector.getSchema();
-            logger_1.logger.info(`Schema loaded: ${this.schema.tables.length} tables found`);
+            this.schema = await this.dbEngine.getSchema();
+            logger_1.logger.info(`Schema loaded: ${this.schema.tables.length} tables/collections found`);
             this.initialized = true;
-            logger_1.logger.info('ChatbotEngine initialized successfully');
+            logger_1.logger.info('✅ ChatbotEngine initialized successfully');
         }
         catch (error) {
             logger_1.logger.error('Initialization failed', error);
@@ -42,23 +59,29 @@ class ChatbotEngine {
         }
         try {
             logger_1.logger.info(`Processing query: "${request.query}"`);
-            // Step 1: Convert NL to SQL
-            const sqlQuery = await this.nlConverter.convertToSQL(request.query, this.schema);
-            // Step 2: Validate SQL
-            if (!this.nlConverter.validateSQL(sqlQuery)) {
+            // Get database type for context
+            const dbType = this.dbEngine.getDatabaseType();
+            const dbCategory = this.dbEngine.getDatabaseCategory();
+            logger_1.logger.debug_log(`Database type: ${dbType}, Category: ${dbCategory}`);
+            // Step 1: Convert NL to Query (SQL or NoSQL)
+            const query = await this.nlConverter.convertToSQL(request.query, this.schema);
+            logger_1.logger.debug_log('Generated query:', query);
+            // Step 2: Validate query
+            if (!this.dbEngine.validateQuery(query)) {
                 return {
                     answer: 'Sorry, I cannot execute this query for security reasons.',
-                    error: 'SQL validation failed'
+                    error: 'Query validation failed'
                 };
             }
-            // Step 3: Execute SQL
-            const queryResult = await this.dbConnector.executeQuery(sqlQuery);
+            // Step 3: Execute query
+            const queryResult = await this.dbEngine.executeQuery(query);
+            logger_1.logger.debug_log('Query result:', queryResult);
             // Step 4: Generate human response
-            const humanAnswer = await this.nlConverter.generateHumanResponse(request.query, queryResult);
+            const humanAnswer = await this.nlConverter.generateHumanResponse(request.query, queryResult.rows);
             return {
                 answer: humanAnswer,
-                sql: sqlQuery,
-                data: queryResult
+                sql: typeof query === 'string' ? query : JSON.stringify(query),
+                data: queryResult.rows
             };
         }
         catch (error) {
@@ -73,8 +96,8 @@ class ChatbotEngine {
      * Disconnect from database
      */
     async shutdown() {
-        if (this.dbConnector.isConnected()) {
-            await this.dbConnector.disconnect();
+        if (this.dbEngine.isConnected()) {
+            await this.dbEngine.disconnect();
         }
         this.initialized = false;
         logger_1.logger.info('ChatbotEngine shut down');
@@ -91,5 +114,15 @@ class ChatbotEngine {
     getSchema() {
         return this.schema;
     }
+    /**
+     * Get database engine status
+     */
+    getStatus() {
+        return {
+            initialized: this.initialized,
+            engine: this.dbEngine.getStatus(),
+            schema: this.schema ? `${this.schema.tables.length} tables` : 'Not loaded'
+        };
+    }
 }
 exports.ChatbotEngine = ChatbotEngine;

package/dist/core/EngineFactory.d.ts

@@ -0,0 +1,45 @@
+import { DatabaseEngine } from '../engines/base/DatabaseEngine';
+import { DatabaseConfig, SupportedDatabaseType } from '../types';
+export declare class EngineFactory {
+    /**
+     * Create appropriate database engine based on config
+     */
+    static createEngine(config: DatabaseConfig): DatabaseEngine;
+    /**
+     * Get list of supported databases with metadata
+     */
+    static getSupportedDatabases(): {
+        sql: ({
+            name: string;
+            value: string;
+            description: string;
+            category: string;
+            defaultPort: number;
+        } | {
+            name: string;
+            value: string;
+            description: string;
+            category: string;
+            defaultPort: null;
+        })[];
+        nosql: {
+            name: string;
+            value: string;
+            description: string;
+            category: string;
+            defaultPort: number;
+        }[];
+    };
+    /**
+     * Validate database configuration
+     */
+    static validateConfig(config: DatabaseConfig): {
+        valid: boolean;
+        error?: string;
+    };
+    /**
+     * Check if database type is SQL or NoSQL
+     */
+    static isSqlDatabase(type: SupportedDatabaseType): boolean;
+    static isNoSqlDatabase(type: SupportedDatabaseType): boolean;
+}

package/dist/core/EngineFactory.js

@@ -0,0 +1,126 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.EngineFactory = void 0;
+const PostgresDialect_1 = require("../engines/sql/dialects/PostgresDialect");
+const MySQLDialect_1 = require("../engines/sql/dialects/MySQLDialect");
+const SQLiteDialect_1 = require("../engines/sql/dialects/SQLiteDialect");
+const MongoEngine_1 = require("../engines/nosql/MongoEngine");
+const logger_1 = require("../utils/logger");
+class EngineFactory {
+    /**
+     * Create appropriate database engine based on config
+     */
+    static createEngine(config) {
+        logger_1.logger.info(`Creating engine for: ${config.type} (${config.category})`);
+        switch (config.type) {
+            // SQL Databases
+            case 'postgresql':
+                return new PostgresDialect_1.PostgresDialect(config);
+            case 'mysql':
+                return new MySQLDialect_1.MySQLDialect(config);
+            case 'sqlite':
+            case 'turso': // Turso is SQLite-compatible
+                return new SQLiteDialect_1.SQLiteDialect(config);
+            // NoSQL Databases
+            case 'mongodb':
+                return new MongoEngine_1.MongoEngine(config);
+            default:
+                throw new Error(`Unsupported database type: ${config.type}`);
+        }
+    }
+    /**
+     * Get list of supported databases with metadata
+     */
+    static getSupportedDatabases() {
+        return {
+            sql: [
+                {
+                    name: 'PostgreSQL',
+                    value: 'postgresql',
+                    description: 'Most popular, production-ready',
+                    category: 'sql',
+                    defaultPort: 5432
+                },
+                {
+                    name: 'MySQL',
+                    value: 'mysql',
+                    description: 'Web standard, widely used',
+                    category: 'sql',
+                    defaultPort: 3306
+                },
+                {
+                    name: 'SQLite',
+                    value: 'sqlite',
+                    description: 'Local file, perfect for testing',
+                    category: 'sql',
+                    defaultPort: null
+                },
+                {
+                    name: 'Turso (LibSQL)',
+                    value: 'turso',
+                    description: 'Modern SQLite, edge-ready',
+                    category: 'sql',
+                    defaultPort: null
+                },
+                {
+                    name: 'Microsoft SQL Server',
+                    value: 'mssql',
+                    description: 'Enterprise standard',
+                    category: 'sql',
+                    defaultPort: 1433
+                }
+            ],
+            nosql: [
+                {
+                    name: 'MongoDB',
+                    value: 'mongodb',
+                    description: 'Document store, flexible schema',
+                    category: 'nosql',
+                    defaultPort: 27017
+                }
+            ]
+        };
+    }
+    /**
+     * Validate database configuration
+     */
+    static validateConfig(config) {
+        // Check category
+        if (!config.category || !['sql', 'nosql'].includes(config.category)) {
+            return {
+                valid: false,
+                error: 'Database category must be "sql" or "nosql"'
+            };
+        }
+        // Check type is supported
+        const supportedDbs = this.getSupportedDatabases();
+        const allDbs = [...supportedDbs.sql, ...supportedDbs.nosql];
+        const dbExists = allDbs.some(db => db.value === config.type);
+        if (!dbExists) {
+            return {
+                valid: false,
+                error: `Unsupported database type: ${config.type}`
+            };
+        }
+        // Check URL
+        if (!config.url || config.url.trim() === '') {
+            return {
+                valid: false,
+                error: 'Database URL is required'
+            };
+        }
+        return { valid: true };
+    }
+    /**
+     * Check if database type is SQL or NoSQL
+     */
+    static isSqlDatabase(type) {
+        const sqlTypes = ['postgresql', 'mysql', 'sqlite', 'turso', 'mssql'];
+        return sqlTypes.includes(type);
+    }
+    static isNoSqlDatabase(type) {
+        const nosqlTypes = ['mongodb'];
+        return nosqlTypes.includes(type);
+    }
+}
+exports.EngineFactory = EngineFactory;

package/dist/core/NLToSQLConverter.d.ts

@@ -1,24 +1,15 @@
-import { OpenAIConfig, DatabaseSchema } from '../types';
+import { ILLMProvider } from '../llm/types';
 export declare class NLToSQLConverter {
-    private openai;
-    private model;
-    constructor(config: OpenAIConfig);
+    private provider;
+    constructor(provider: ILLMProvider);
     /**
-     * Convert natural language to SQL
+     * Convert natural language to SQL using configured provider
      */
-    convertToSQL(userQuery: string, schema: DatabaseSchema): Promise<string>;
+    convertToSQL(userQuery: string, schema: any): Promise<string>;
     /**
-     * Generate human-readable response
+     * Generate human-readable response using configured provider
      */
     generateHumanResponse(userQuery: string, queryResult: any): Promise<string>;
-    /**
-     * Build SQL generation prompt
-     */
-    private buildPrompt;
-    /**
-     * Format schema for prompt
-     */
-    private formatSchemaForPrompt;
     /**
      * Validate SQL query for security
      */

package/dist/core/NLToSQLConverter.js

@@ -1,130 +1,25 @@
 "use strict";
-var __importDefault = (this && this.__importDefault) || function (mod) {
-    return (mod && mod.__esModule) ? mod : { "default": mod };
-};
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.NLToSQLConverter = void 0;
-const openai_1 = __importDefault(require("openai"));
 const logger_1 = require("../utils/logger");
 class NLToSQLConverter {
-    constructor(config) {
-        this.openai = new openai_1.default({
-            apiKey: config.apiKey
-        });
-        this.model = config.model;
+    constructor(provider) {
+        if (!provider.isConfigured()) {
+            throw new Error('LLM Provider is not properly configured');
+        }
+        this.provider = provider;
     }
     /**
-     * Convert natural language to SQL
+     * Convert natural language to SQL using configured provider
      */
     async convertToSQL(userQuery, schema) {
-        try {
-            logger_1.logger.info('Converting NL to SQL...');
-            const schemaDescription = this.formatSchemaForPrompt(schema);
-            const prompt = this.buildPrompt(userQuery, schemaDescription);
-            const response = await this.openai.chat.completions.create({
-                model: this.model,
-                messages: [
-                    {
-                        role: 'system',
-                        content: 'You are an expert SQL query generator. Generate ONLY valid SQL queries without any explanation or markdown.'
-                    },
-                    {
-                        role: 'user',
-                        content: prompt
-                    }
-                ],
-                temperature: 0.2,
-                max_tokens: 500
-            });
-            const sqlQuery = response.choices[0]?.message?.content?.trim() || '';
-            // Remove markdown code blocks if present
-            const cleanedSQL = sqlQuery
-                .replace(/```sql\n?/g, '')
-                .replace(/```\n?/g, '')
-                .trim();
-            logger_1.logger.debug_log('Generated SQL:', cleanedSQL);
-            return cleanedSQL;
-        }
-        catch (error) {
-            logger_1.logger.error('NL to SQL conversion failed', error);
-            throw error;
-        }
+        return await this.provider.generateSQL(userQuery, schema);
     }
     /**
-     * Generate human-readable response
+     * Generate human-readable response using configured provider
      */
     async generateHumanResponse(userQuery, queryResult) {
-        try {
-            logger_1.logger.info('Generating human response...');
-            const prompt = `
-User asked: "${userQuery}"
-
-Database returned this result:
-${JSON.stringify(queryResult, null, 2)}
-
-Please provide a clear, conversational answer in Hindi/English mix (Hinglish) that explains this data to a business owner. Be specific with numbers.
-`;
-            const response = await this.openai.chat.completions.create({
-                model: this.model,
-                messages: [
-                    {
-                        role: 'system',
-                        content: 'You are a helpful business analytics assistant. Explain data clearly in Hinglish (Hindi-English mix).'
-                    },
-                    {
-                        role: 'user',
-                        content: prompt
-                    }
-                ],
-                temperature: 0.7,
-                max_tokens: 300
-            });
-            const answer = response.choices[0]?.message?.content?.trim() || 'Sorry, I could not generate a response.';
-            logger_1.logger.debug_log('Generated response:', answer);
-            return answer;
-        }
-        catch (error) {
-            logger_1.logger.error('Response generation failed', error);
-            throw error;
-        }
-    }
-    /**
-     * Build SQL generation prompt
-     */
-    buildPrompt(userQuery, schemaDescription) {
-        return `
-You are a SQL expert. Generate a SQL query based on the user's question.
-
-Database Schema:
-${schemaDescription}
-
-User Question: "${userQuery}"
-
-Rules:
-1. Return ONLY the SQL query, nothing else
-2. Use correct table and column names from the schema
-3. Add WHERE clauses for date filtering when needed
-4. Use SUM, COUNT, AVG for aggregations
-5. Handle both singular and plural forms (sales/sale, orders/order)
-6. Use CURRENT_DATE, CURRENT_MONTH for time-based queries
-7. Make sure the query is syntactically correct
-
-SQL Query:
-`;
-    }
-    /**
-     * Format schema for prompt
-     */
-    formatSchemaForPrompt(schema) {
-        let description = '';
-        for (const table of schema.tables) {
-            description += `\nTable: ${table.name}\n`;
-            description += 'Columns:\n';
-            for (const column of table.columns) {
-                description += `  - ${column.name} (${column.type})${column.nullable ? ' [nullable]' : ''}\n`;
-            }
-        }
-        return description;
+        return await this.provider.generateHumanResponse(userQuery, queryResult);
     }
     /**
      * Validate SQL query for security

package/dist/engines/base/DatabaseEngine.d.ts

@@ -0,0 +1,46 @@
+import { DatabaseConfig, DatabaseSchema, QueryResult, EngineStatus } from '../../types';
+/**
+ * Base interface for all database engines
+ */
+export declare abstract class DatabaseEngine {
+    protected config: DatabaseConfig;
+    protected connection: any;
+    protected connected: boolean;
+    constructor(config: DatabaseConfig);
+    /**
+     * Connect to database
+     */
+    abstract connect(): Promise<void>;
+    /**
+     * Disconnect from database
+     */
+    abstract disconnect(): Promise<void>;
+    /**
+     * Get database schema
+     */
+    abstract getSchema(): Promise<DatabaseSchema>;
+    /**
+     * Execute query (SQL or NoSQL)
+     */
+    abstract executeQuery(query: string | object): Promise<QueryResult>;
+    /**
+     * Validate query before execution
+     */
+    abstract validateQuery(query: string | object): boolean;
+    /**
+     * Check if connected
+     */
+    isConnected(): boolean;
+    /**
+     * Get engine status
+     */
+    getStatus(): EngineStatus;
+    /**
+     * Get database type
+     */
+    getDatabaseType(): string;
+    /**
+     * Get database category
+     */
+    getDatabaseCategory(): string;
+}

package/dist/engines/base/DatabaseEngine.js

@@ -0,0 +1,42 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.DatabaseEngine = void 0;
+/**
+ * Base interface for all database engines
+ */
+class DatabaseEngine {
+    constructor(config) {
+        this.connection = null;
+        this.connected = false;
+        this.config = config;
+    }
+    /**
+     * Check if connected
+     */
+    isConnected() {
+        return this.connected;
+    }
+    /**
+     * Get engine status
+     */
+    getStatus() {
+        return {
+            connected: this.connected,
+            type: this.config.type,
+            category: this.config.category
+        };
+    }
+    /**
+     * Get database type
+     */
+    getDatabaseType() {
+        return this.config.type;
+    }
+    /**
+     * Get database category
+     */
+    getDatabaseCategory() {
+        return this.config.category;
+    }
+}
+exports.DatabaseEngine = DatabaseEngine;

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

@@ -0,0 +1,13 @@
+import { NoSqlEngine } from './NoSqlEngine';
+import { DatabaseConfig, DatabaseSchema, QueryResult } from '../../types';
+export declare class MongoEngine extends NoSqlEngine {
+    private client;
+    private db;
+    constructor(config: DatabaseConfig);
+    connect(): Promise<void>;
+    disconnect(): Promise<void>;
+    getSchema(): Promise<DatabaseSchema>;
+    executeQuery(query: object | string): Promise<QueryResult>;
+    validateQuery(query: string | object): boolean;
+    private inferMongoType;
+}