agenticaichat 1.0.0

package/README.md

@@ -0,0 +1,71 @@
+# 🤖 AgenticAIChat
+
+AI-powered chatbot for business analytics with natural language database queries.
+
+## ✨ Features
+
+- 🚀 **5-Minute Setup**: Interactive CLI wizard
+- 💬 **Natural Language**: Ask in English/Hindi
+- 🗄️ **Multi-Database**: PostgreSQL, MySQL, MongoDB
+- 🎨 **Beautiful Widget**: Pre-built React component
+- 🔒 **Secure**: Encrypted API keys
+- 💰 **Free**: User pays OpenAI API only
+- 📦 **TypeScript**: Full type safety
+
+## 📦 Installation
+```bash
+npm install agenticaichat
+```
+
+## 🚀 Quick Start
+
+### Step 1: Run Setup Wizard
+```bash
+npx agenticai-setup
+```
+
+### Step 2: Add Widget
+```tsx
+// app/dashboard/page.tsx
+import { ChatbotWidget } from 'agenticaichat';
+
+export default function Dashboard() {
+  return (
+    <div>
+      <h1>Dashboard</h1>
+      <ChatbotWidget />
+    </div>
+  );
+}
+```
+
+### Step 3: Full Page Chat (Optional)
+```tsx
+// app/chat/page.tsx
+import { ChatbotWidget } from 'agenticaichat';
+
+export default function ChatPage() {
+  return <ChatbotWidget fullScreen />;
+}
+```
+
+## 📖 Documentation
+
+Coming soon!
+
+## 🤝 Contributing
+
+Contributions welcome!
+
+## 📄 License
+
+MIT License
+
+## 🙋‍♂️ Support
+
+- GitHub: [Issues](https://github.com/yourusername/agenticaichat/issues)
+- Email: your.email@example.com
+
+---
+
+Made with ❤️ for developers

package/bin/cli.js

@@ -0,0 +1,222 @@
+#!/usr/bin/env node
+
+const inquirer = require('inquirer').default;
+const chalk = require('chalk');
+const ora = require('ora');
+const fs = require('fs');
+const path = require('path');
+const crypto = require('crypto');
+
+async function main() {
+  console.log(chalk.bold.cyan(`
+╔════════════════════════════════════════╗
+║   🤖 AgenticAIChat Setup Wizard       ║
+║   Interactive Configuration            ║
+╚════════════════════════════════════════╝
+  `));
+
+  console.log(chalk.white('Let\'s set up your AI chatbot!\n'));
+
+  // Step 1: Database Configuration
+  console.log(chalk.bold.blue('📦 Step 1: Database Configuration\n'));
+
+  const dbAnswers = await inquirer.prompt([
+    {
+      type: 'list',
+      name: 'dbType',
+      message: 'Select your database type:',
+      choices: ['PostgreSQL', 'MySQL', 'MongoDB'],
+      default: 'PostgreSQL'
+    },
+    {
+      type: 'input',
+      name: 'host',
+      message: 'Database host:',
+      default: 'localhost'
+    },
+    {
+      type: 'input',
+      name: 'port',
+      message: 'Database port:',
+      default: (answers) => {
+        if (answers.dbType === 'PostgreSQL') return '5432';
+        if (answers.dbType === 'MySQL') return '3306';
+        return '27017';
+      }
+    },
+    {
+      type: 'input',
+      name: 'user',
+      message: 'Database username:',
+      default: 'postgres'
+    },
+    {
+      type: 'password',
+      name: 'password',
+      message: 'Database password:',
+      mask: '*'
+    },
+    {
+      type: 'input',
+      name: 'database',
+      message: 'Database name:',
+      default: 'mydb'
+    }
+  ]);
+
+  // Step 2: OpenAI Configuration
+  console.log(chalk.bold.blue('\n🔑 Step 2: OpenAI Configuration\n'));
+
+  const aiAnswers = await inquirer.prompt([
+    {
+      type: 'password',
+      name: 'apiKey',
+      message: 'Enter your OpenAI API key:',
+      mask: '*',
+      validate: (input) => {
+        if (!input.startsWith('sk-')) {
+          return 'Invalid API key format! Should start with "sk-"';
+        }
+        if (input.length < 20) {
+          return 'API key too short!';
+        }
+        return true;
+      }
+    },
+    {
+      type: 'list',
+      name: 'model',
+      message: 'Select GPT model:',
+      choices: ['gpt-3.5-turbo', 'gpt-4'],
+      default: 'gpt-3.5-turbo'
+    }
+  ]);
+
+  // Step 3: Create configuration files
+  console.log(chalk.bold.blue('\n📝 Step 3: Generating Configuration Files\n'));
+  
+  const spinner = ora('Creating files...').start();
+
+  // Build database URL
+  let databaseUrl;
+  const dbType = dbAnswers.dbType.toLowerCase();
+  
+  if (dbType === 'postgresql') {
+    databaseUrl = `postgresql://${dbAnswers.user}:${dbAnswers.password}@${dbAnswers.host}:${dbAnswers.port}/${dbAnswers.database}`;
+  } else if (dbType === 'mysql') {
+    databaseUrl = `mysql://${dbAnswers.user}:${dbAnswers.password}@${dbAnswers.host}:${dbAnswers.port}/${dbAnswers.database}`;
+  } else {
+    databaseUrl = `mongodb://${dbAnswers.user}:${dbAnswers.password}@${dbAnswers.host}:${dbAnswers.port}/${dbAnswers.database}`;
+  }
+
+  // Create .env.chatbot
+  const envContent = `# AgenticAIChat Configuration
+# Generated on ${new Date().toISOString()}
+
+OPENAI_API_KEY=${aiAnswers.apiKey}
+DATABASE_URL=${databaseUrl}
+DB_TYPE=${dbType}
+GPT_MODEL=${aiAnswers.model}
+SECRET_KEY=${crypto.randomBytes(32).toString('hex')}
+CHATBOT_ENABLED=true
+`;
+
+  const envPath = path.join(process.cwd(), '.env.chatbot');
+  fs.writeFileSync(envPath, envContent);
+  spinner.text = 'Created .env.chatbot';
+
+  // Create chatbot-config.json
+  const configContent = {
+    dbType: dbType,
+    model: aiAnswers.model,
+    setupDate: new Date().toISOString(),
+    version: '1.0.0'
+  };
+
+  const configPath = path.join(process.cwd(), 'chatbot-config.json');
+  fs.writeFileSync(configPath, JSON.stringify(configContent, null, 2));
+  spinner.text = 'Created chatbot-config.json';
+
+  // Update .gitignore
+  const gitignorePath = path.join(process.cwd(), '.gitignore');
+  let gitignoreContent = '';
+  
+  if (fs.existsSync(gitignorePath)) {
+    gitignoreContent = fs.readFileSync(gitignorePath, 'utf8');
+  }
+  
+  if (!gitignoreContent.includes('.env.chatbot')) {
+    gitignoreContent += '\n# AgenticAIChat\n.env.chatbot\nchatbot-config.json\n';
+    fs.writeFileSync(gitignorePath, gitignoreContent);
+    spinner.text = 'Updated .gitignore';
+  }
+
+  spinner.succeed('Configuration files created successfully!');
+
+  // Create API route file
+  try {
+    const apiDir = path.join(process.cwd(), 'app', 'api', 'chatbot', 'query');
+    if (!fs.existsSync(apiDir)) {
+      fs.mkdirSync(apiDir, { recursive: true });
+    }
+
+    const apiTemplate = fs.readFileSync(
+      path.join(__dirname, '..', 'templates', 'api-route.template.ts'),
+      'utf8'
+    );
+
+    const apiPath = path.join(apiDir, 'route.ts');
+    fs.writeFileSync(apiPath, apiTemplate);
+    spinner.text = 'Created API route: app/api/chatbot/query/route.ts';
+  } catch (error) {
+    spinner.warn('Could not create API route automatically');
+    console.log(chalk.yellow('\nℹ️  You can manually create the API route later'));
+  }
+
+  // Create chat page
+  try {
+    const chatDir = path.join(process.cwd(), 'app', 'chat');
+    if (!fs.existsSync(chatDir)) {
+      fs.mkdirSync(chatDir, { recursive: true });
+    }
+
+    const chatTemplate = fs.readFileSync(
+      path.join(__dirname, '..', 'templates', 'chat-page.template.tsx'),
+      'utf8'
+    );
+
+    const chatPath = path.join(chatDir, 'page.tsx');
+    fs.writeFileSync(chatPath, chatTemplate);
+    spinner.text = 'Created chat page: app/chat/page.tsx';
+  } catch (error) {
+    spinner.warn('Could not create chat page automatically');
+    console.log(chalk.yellow('\nℹ️  You can manually create the chat page later'));
+  }
+
+  // Success message
+  console.log(chalk.green.bold('\n✅ Setup Complete!\n'));
+  console.log(chalk.white('Files created:'));
+  console.log(chalk.gray('  • .env.chatbot (API keys & database config)'));
+  console.log(chalk.gray('  • chatbot-config.json (settings)'));
+  console.log(chalk.gray('  • .gitignore (updated)\n'));
+
+  console.log(chalk.white('Next steps:\n'));
+  console.log(chalk.yellow('1. Add the widget to your Next.js app:\n'));
+  console.log(chalk.cyan('   import { ChatbotWidget } from "agenticaichat";'));
+  console.log(chalk.cyan('   \n   <ChatbotWidget />\n'));
+  
+  console.log(chalk.yellow('2. Or create a full-page chat route:\n'));
+  console.log(chalk.cyan('   // app/chat/page.tsx'));
+  console.log(chalk.cyan('   <ChatbotWidget fullScreen />\n'));
+
+  console.log(chalk.yellow('3. Start your development server:\n'));
+  console.log(chalk.cyan('   npm run dev\n'));
+
+  console.log(chalk.white('Need help? Visit: ') + chalk.blue('https://github.com/yourusername/agenticaichat\n'));
+}
+
+// Run CLI
+main().catch((error) => {
+  console.error(chalk.red('\n❌ Setup failed:'), error.message);
+  process.exit(1);
+});

package/dist/core/ChatbotEngine.d.ts

@@ -0,0 +1,28 @@
+import { ChatbotConfig, QueryRequest, QueryResponse, DatabaseSchema } from '../types';
+export declare class ChatbotEngine {
+    private dbConnector;
+    private nlConverter;
+    private schema;
+    private initialized;
+    constructor(config: ChatbotConfig);
+    /**
+     * Initialize chatbot (connect to DB and load schema)
+     */
+    initialize(): Promise<void>;
+    /**
+     * Process user query
+     */
+    processQuery(request: QueryRequest): Promise<QueryResponse>;
+    /**
+     * Disconnect from database
+     */
+    shutdown(): Promise<void>;
+    /**
+     * Check if initialized
+     */
+    isInitialized(): boolean;
+    /**
+     * Get current schema
+     */
+    getSchema(): DatabaseSchema | null;
+}

package/dist/core/ChatbotEngine.js

@@ -0,0 +1,95 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ChatbotEngine = void 0;
+const DatabaseConnector_1 = require("./DatabaseConnector");
+const NLToSQLConverter_1 = require("./NLToSQLConverter");
+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);
+        if (config.debug) {
+            logger_1.logger.info('ChatbotEngine initialized in DEBUG mode');
+        }
+    }
+    /**
+     * Initialize chatbot (connect to DB and load schema)
+     */
+    async initialize() {
+        try {
+            logger_1.logger.info('Initializing ChatbotEngine...');
+            // Connect to database
+            await this.dbConnector.connect();
+            // Load schema
+            this.schema = await this.dbConnector.getSchema();
+            logger_1.logger.info(`Schema loaded: ${this.schema.tables.length} tables found`);
+            this.initialized = true;
+            logger_1.logger.info('ChatbotEngine initialized successfully');
+        }
+        catch (error) {
+            logger_1.logger.error('Initialization failed', error);
+            throw error;
+        }
+    }
+    /**
+     * Process user query
+     */
+    async processQuery(request) {
+        if (!this.initialized || !this.schema) {
+            throw new Error('ChatbotEngine not initialized. Call initialize() first.');
+        }
+        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)) {
+                return {
+                    answer: 'Sorry, I cannot execute this query for security reasons.',
+                    error: 'SQL validation failed'
+                };
+            }
+            // Step 3: Execute SQL
+            const queryResult = await this.dbConnector.executeQuery(sqlQuery);
+            // Step 4: Generate human response
+            const humanAnswer = await this.nlConverter.generateHumanResponse(request.query, queryResult);
+            return {
+                answer: humanAnswer,
+                sql: sqlQuery,
+                data: queryResult
+            };
+        }
+        catch (error) {
+            logger_1.logger.error('Query processing failed', error);
+            return {
+                answer: 'Sorry, I encountered an error while processing your question. Please try again.',
+                error: error.message
+            };
+        }
+    }
+    /**
+     * Disconnect from database
+     */
+    async shutdown() {
+        if (this.dbConnector.isConnected()) {
+            await this.dbConnector.disconnect();
+        }
+        this.initialized = false;
+        logger_1.logger.info('ChatbotEngine shut down');
+    }
+    /**
+     * Check if initialized
+     */
+    isInitialized() {
+        return this.initialized;
+    }
+    /**
+     * Get current schema
+     */
+    getSchema() {
+        return this.schema;
+    }
+}
+exports.ChatbotEngine = ChatbotEngine;

package/dist/core/DatabaseConnector.d.ts

@@ -0,0 +1,55 @@
+import { DatabaseConfig, DatabaseSchema } from '../types';
+export declare class DatabaseConnector {
+    private config;
+    private connection;
+    private connected;
+    constructor(config: DatabaseConfig);
+    /**
+     * Connect to database
+     */
+    connect(): Promise<void>;
+    /**
+     * PostgreSQL connection
+     */
+    private connectPostgreSQL;
+    /**
+     * MySQL connection
+     */
+    private connectMySQL;
+    /**
+     * MongoDB connection
+     */
+    private connectMongoDB;
+    /**
+     * Get database schema
+     */
+    getSchema(): Promise<DatabaseSchema>;
+    /**
+     * PostgreSQL schema extraction
+     */
+    private getPostgreSQLSchema;
+    /**
+     * MySQL schema extraction
+     */
+    private getMySQLSchema;
+    /**
+     * MongoDB schema extraction (basic)
+     */
+    private getMongoDBSchema;
+    /**
+     * Format schema from raw data
+     */
+    private formatSchema;
+    /**
+     * Execute SQL query
+     */
+    executeQuery(sql: string): Promise<any>;
+    /**
+     * Disconnect from database
+     */
+    disconnect(): Promise<void>;
+    /**
+     * Check if connected
+     */
+    isConnected(): boolean;
+}

package/dist/core/DatabaseConnector.js

@@ -0,0 +1,229 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.DatabaseConnector = void 0;
+const pg_1 = require("pg");
+const promise_1 = __importDefault(require("mysql2/promise"));
+const mongodb_1 = require("mongodb");
+const logger_1 = require("../utils/logger");
+class DatabaseConnector {
+    constructor(config) {
+        this.connection = null;
+        this.connected = false;
+        this.config = config;
+    }
+    /**
+     * Connect to database
+     */
+    async connect() {
+        try {
+            logger_1.logger.info(`Connecting to ${this.config.type} database...`);
+            if (this.config.type === 'postgresql') {
+                await this.connectPostgreSQL();
+            }
+            else if (this.config.type === 'mysql') {
+                await this.connectMySQL();
+            }
+            else if (this.config.type === 'mongodb') {
+                await this.connectMongoDB();
+            }
+            else {
+                throw new Error(`Unsupported database type: ${this.config.type}`);
+            }
+            this.connected = true;
+            logger_1.logger.info('Database connected successfully');
+        }
+        catch (error) {
+            logger_1.logger.error('Database connection failed', error);
+            throw error;
+        }
+    }
+    /**
+     * PostgreSQL connection
+     */
+    async connectPostgreSQL() {
+        this.connection = new pg_1.Client({
+            connectionString: this.config.url
+        });
+        await this.connection.connect();
+    }
+    /**
+     * MySQL connection
+     */
+    async connectMySQL() {
+        this.connection = await promise_1.default.createConnection(this.config.url);
+    }
+    /**
+     * MongoDB connection
+     */
+    async connectMongoDB() {
+        const client = new mongodb_1.MongoClient(this.config.url);
+        await client.connect();
+        this.connection = client;
+    }
+    /**
+     * Get database schema
+     */
+    async getSchema() {
+        if (!this.connected) {
+            throw new Error('Database not connected');
+        }
+        try {
+            if (this.config.type === 'postgresql') {
+                return await this.getPostgreSQLSchema();
+            }
+            else if (this.config.type === 'mysql') {
+                return await this.getMySQLSchema();
+            }
+            else if (this.config.type === 'mongodb') {
+                return await this.getMongoDBSchema();
+            }
+            throw new Error('Unsupported database type');
+        }
+        catch (error) {
+            logger_1.logger.error('Failed to get schema', error);
+            throw error;
+        }
+    }
+    /**
+     * PostgreSQL schema extraction
+     */
+    async getPostgreSQLSchema() {
+        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.connection.query(query);
+        return this.formatSchema(result.rows);
+    }
+    /**
+     * MySQL schema extraction
+     */
+    async getMySQLSchema() {
+        const [rows] = await this.connection.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;
+    `);
+        return this.formatSchema(rows);
+    }
+    /**
+     * MongoDB schema extraction (basic)
+     */
+    async getMongoDBSchema() {
+        const db = this.connection.db();
+        const collections = await db.listCollections().toArray();
+        const tables = [];
+        for (const collection of collections) {
+            const sampleDoc = await db.collection(collection.name).findOne({});
+            const columns = [];
+            if (sampleDoc) {
+                for (const [key, value] of Object.entries(sampleDoc)) {
+                    columns.push({
+                        name: key,
+                        type: typeof value,
+                        nullable: true
+                    });
+                }
+            }
+            tables.push({
+                name: collection.name,
+                columns
+            });
+        }
+        return { tables };
+    }
+    /**
+     * Format schema from raw data
+     */
+    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' || row.is_nullable === 'true'
+            };
+            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 };
+    }
+    /**
+     * Execute SQL query
+     */
+    async executeQuery(sql) {
+        if (!this.connected) {
+            throw new Error('Database not connected');
+        }
+        try {
+            logger_1.logger.debug_log('Executing query:', sql);
+            if (this.config.type === 'postgresql') {
+                const result = await this.connection.query(sql);
+                return result.rows;
+            }
+            else if (this.config.type === 'mysql') {
+                const [rows] = await this.connection.query(sql);
+                return rows;
+            }
+            else if (this.config.type === 'mongodb') {
+                throw new Error('MongoDB query execution not yet implemented');
+            }
+            throw new Error('Unsupported database type');
+        }
+        catch (error) {
+            logger_1.logger.error('Query execution failed', error);
+            throw error;
+        }
+    }
+    /**
+     * Disconnect from database
+     */
+    async disconnect() {
+        if (!this.connected)
+            return;
+        try {
+            if (this.config.type === 'postgresql') {
+                await this.connection.end();
+            }
+            else if (this.config.type === 'mysql') {
+                await this.connection.end();
+            }
+            else if (this.config.type === 'mongodb') {
+                await this.connection.close();
+            }
+            this.connected = false;
+            logger_1.logger.info('Database disconnected');
+        }
+        catch (error) {
+            logger_1.logger.error('Disconnect failed', error);
+        }
+    }
+    /**
+     * Check if connected
+     */
+    isConnected() {
+        return this.connected;
+    }
+}
+exports.DatabaseConnector = DatabaseConnector;