agenticaichat 1.0.1 → 1.0.3

package/README.md

@@ -1,30 +1,55 @@
-# 🤖 AgenticAIChat
-
+# AgenticAIChat
 AI-powered chatbot for business analytics with natural language database queries.
 
-## ✨ Features
+## Highlights
+
+- Five-minute setup with an interactive CLI wizard
+- Natural language questions in English or Hindi
+- Works with PostgreSQL, MySQL, SQLite, Turso, and MongoDB
+- Ready-to-use React/Next.js widget for dashboards and full pages
+- Configuration files generated for you (`.env.chatbot`, `chatbot-config.json`)
+- Fully typed TypeScript package
+
+## Requirements
+
+- Node.js 18+ and npm 9+
+- React 18+ and Next.js 13+ (app router recommended)
 
-- 🚀 **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 and Setup
+
+The setup wizard now launches automatically right after installation. Choose your preferred package manager:
 
-## 📦 Installation
 ```bash
+# npm
 npm install agenticaichat
+
+# yarn
+yarn add agenticaichat
+
+# pnpm
+pnpm add agenticaichat
 ```
 
-## 🚀 Quick Start
+During install, the wizard will:
+
+- Ask for your database type and connection details
+- Collect your AI provider, model, and API key
+- Generate `.env.chatbot` and `chatbot-config.json`
+- Create starter files if they are missing (Next.js defaults):
+  - `app/api/chatbot/query/route.ts`
+  - `app/chat/page.tsx`
+  - Updates `.gitignore` to exclude generated secrets
+
+If you need to rerun the wizard later:
 
-### Step 1: Run Setup Wizard
 ```bash
 npx agenticai-setup
 ```
 
-### Step 2: Add Widget
+## Quick Start (Next.js)
+
+Add the widget to any page or component:
+
 ```tsx
 // app/dashboard/page.tsx
 import { ChatbotWidget } from 'agenticaichat';
@@ -39,7 +64,8 @@ export default function Dashboard() {
 }
 ```
 
-### Step 3: Full Page Chat (Optional)
+Create a full-page chat experience:
+
 ```tsx
 // app/chat/page.tsx
 import { ChatbotWidget } from 'agenticaichat';
@@ -49,23 +75,54 @@ export default function ChatPage() {
 }
 ```
 
-## 📖 Documentation
+Start your Next.js app:
 
-Coming soon!
+```bash
+npm run dev
+```
 
-## 🤝 Contributing
+## Using with Other React Frameworks
 
-Contributions welcome!
+The widget renders in any React 18+ app (CRA, Vite, Remix, etc.). You only need to supply a compatible backend endpoint.
 
-## 📄 License
+Backend requirements:
 
-MIT License
+- Create an HTTP POST endpoint (e.g., `/api/chatbot/query`) that follows `templates/api-route.template.ts`.
+- Load `.env.chatbot` on the server and wire `DATABASE_URL`, `DB_TYPE`, `LLM_PROVIDER`, `LLM_MODEL`, and `LLM_API_KEY` into the handler.
+- Return JSON responses in the same shape as the template handler.
+- Configure CORS/auth so the widget can call your endpoint from the browser.
 
-## 🙋‍♂️ Support
+Frontend usage stays the same:
 
-- GitHub: [Issues](https://github.com/Bhaviraj2004/agenticaichat/issues)
-- Email: bhaviraj001@gmail.com
+```tsx
+import { ChatbotWidget } from 'agenticaichat';
+
+export default function Page() {
+  return <ChatbotWidget apiPath="/api/chatbot/query" />;
+}
+```
+
+## Configuration Files
+
+- `.env.chatbot` holds database connection, LLM provider, model, and API key.
+- `chatbot-config.json` stores non-secret metadata (database/LLM selection).
+- `.gitignore` is updated automatically to keep generated secrets out of version control.
+
+## Troubleshooting
 
----
+- CI environments skip the wizard; run `npx agenticai-setup` locally after install.
+- If the wizard cannot run (non-interactive terminal), rerun manually with the command above.
+- To switch databases or AI providers, rerun the wizard; existing files will be replaced.
 
-Made with ❤️ for developers
+## Contributing
+
+Contributions are welcome. Please open an issue or pull request with details and reproduction steps.
+
+## License
+
+MIT License
+
+## Support
+
+- GitHub: [Issues](https://github.com/Bhaviraj2004/agenticaichat/issues)
+- Email: bhaviraj001@gmail.com

package/bin/cli.js

@@ -17,68 +17,266 @@ async function main() {
 
   console.log(chalk.white('Let\'s set up your AI chatbot!\n'));
 
-  // Step 1: Database Configuration
+  // Step 1: Database Category
   console.log(chalk.bold.blue('📦 Step 1: Database Configuration\n'));
 
-  const dbAnswers = await inquirer.prompt([
+  const dbCategoryAnswer = await inquirer.prompt([
     {
       type: 'list',
-      name: 'dbType',
-      message: 'Select your database type:',
-      choices: ['PostgreSQL', 'MySQL', 'MongoDB'],
-      default: 'PostgreSQL'
+      name: 'category',
+      message: 'Select database category:',
+      choices: [
+        {
+          name: 'SQL Database (PostgreSQL, MySQL, SQLite, etc.)',
+          value: 'sql',
+          short: 'SQL'
+        },
+        {
+          name: 'NoSQL Database (MongoDB)',
+          value: 'nosql',
+          short: 'NoSQL'
+        }
+      ]
+    }
+  ]);
+
+  let dbType, databaseUrl;
+
+  // SQL Database Flow
+  if (dbCategoryAnswer.category === 'sql') {
+    const sqlAnswers = await inquirer.prompt([
+      {
+        type: 'list',
+        name: 'type',
+        message: 'Select SQL database:',
+        choices: [
+          {
+            name: 'PostgreSQL\n  ' + chalk.gray('Most popular, production-ready'),
+            value: 'postgresql',
+            short: 'PostgreSQL'
+          },
+          {
+            name: 'MySQL\n  ' + chalk.gray('Web standard, widely used'),
+            value: 'mysql',
+            short: 'MySQL'
+          },
+          {
+            name: 'SQLite\n  ' + chalk.gray('Local file, perfect for testing'),
+            value: 'sqlite',
+            short: 'SQLite'
+          },
+          {
+            name: 'Turso (LibSQL)\n  ' + chalk.gray('Modern SQLite, edge-ready'),
+            value: 'turso',
+            short: 'Turso'
+          }
+        ]
+      }
+    ]);
+
+    dbType = sqlAnswers.type;
+
+    // SQLite/Turso - File path based
+    if (dbType === 'sqlite' || dbType === 'turso') {
+      const fileAnswers = await inquirer.prompt([
+        {
+          type: 'input',
+          name: 'filepath',
+          message: 'Database file path:',
+          default: './database.db',
+          validate: (input) => {
+            if (!input || input.trim() === '') {
+              return 'File path is required!';
+            }
+            return true;
+          }
+        }
+      ]);
+
+      if (dbType === 'turso') {
+        const tursoAnswers = await inquirer.prompt([
+          {
+            type: 'input',
+            name: 'url',
+            message: 'Turso database URL (or leave empty for local):',
+            default: ''
+          },
+          {
+            type: 'password',
+            name: 'token',
+            message: 'Turso auth token (if using cloud):',
+            mask: '*',
+            when: (answers) => answers.url && answers.url.trim() !== ''
+          }
+        ]);
+
+        if (tursoAnswers.url && tursoAnswers.url.trim() !== '') {
+          databaseUrl = `${tursoAnswers.url}?authToken=${tursoAnswers.token || ''}`;
+        } else {
+          databaseUrl = `sqlite:///${fileAnswers.filepath}`;
+        }
+      } else {
+        databaseUrl = `sqlite:///${fileAnswers.filepath}`;
+      }
+    } 
+    // PostgreSQL/MySQL - Server based
+    else {
+      const serverAnswers = await inquirer.prompt([
+        {
+          type: 'input',
+          name: 'host',
+          message: 'Database host:',
+          default: 'localhost'
+        },
+        {
+          type: 'input',
+          name: 'port',
+          message: 'Port:',
+          default: dbType === 'postgresql' ? '5432' : '3306'
+        },
+        {
+          type: 'input',
+          name: 'user',
+          message: 'Username:',
+          default: dbType === 'postgresql' ? 'postgres' : 'root'
+        },
+        {
+          type: 'password',
+          name: 'password',
+          message: 'Password:',
+          mask: '*'
+        },
+        {
+          type: 'input',
+          name: 'database',
+          message: 'Database name:',
+          default: 'mydb'
+        }
+      ]);
+
+      if (dbType === 'postgresql') {
+        databaseUrl = `postgresql://${serverAnswers.user}:${serverAnswers.password}@${serverAnswers.host}:${serverAnswers.port}/${serverAnswers.database}`;
+      } else if (dbType === 'mysql') {
+        databaseUrl = `mysql://${serverAnswers.user}:${serverAnswers.password}@${serverAnswers.host}:${serverAnswers.port}/${serverAnswers.database}`;
+      }
+    }
+
+    console.log(chalk.green(`\n✅ ${dbType.toUpperCase()} configured!\n`));
+  } 
+  // NoSQL Database Flow
+  else {
+    const nosqlAnswers = await inquirer.prompt([
+      {
+        type: 'list',
+        name: 'type',
+        message: 'Select NoSQL database:',
+        choices: [
+          {
+            name: 'MongoDB\n  ' + chalk.gray('Document store, flexible schema'),
+            value: 'mongodb',
+            short: 'MongoDB'
+          }
+        ]
+      }
+    ]);
+
+    dbType = nosqlAnswers.type;
+
+    const mongoAnswers = await inquirer.prompt([
+      {
+        type: 'input',
+        name: 'url',
+        message: 'MongoDB connection URL:',
+        default: 'mongodb://localhost:27017',
+        validate: (input) => {
+          if (!input.startsWith('mongodb://') && !input.startsWith('mongodb+srv://')) {
+            return 'Invalid MongoDB URL format!';
+          }
+          return true;
+        }
+      },
+      {
+        type: 'input',
+        name: 'database',
+        message: 'Database name:',
+        default: 'mydb'
+      }
+    ]);
+
+    databaseUrl = `${mongoAnswers.url}/${mongoAnswers.database}`;
+    console.log(chalk.green(`\n✅ MongoDB configured!\n`));
+  }
+
+  // Step 2: AI Provider Configuration
+  console.log(chalk.bold.blue('🤖 Step 2: AI Provider Configuration\n'));
+
+  const llmProviders = [
+    {
+      name: 'OpenAI (GPT-3.5/GPT-4)',
+      value: 'openai',
+      description: 'Most popular, reliable, high quality',
+      models: ['gpt-3.5-turbo', 'gpt-4', 'gpt-4-turbo']
     },
     {
-      type: 'input',
-      name: 'host',
-      message: 'Database host:',
-      default: 'localhost'
+      name: 'Google Gemini (1.5 Pro/Flash)',
+      value: 'gemini',
+      description: 'Fast, affordable, multimodal',
+      models: ['gemini-1.5-pro', 'gemini-1.5-flash']
     },
     {
-      type: 'input',
-      name: 'port',
-      message: 'Database port:',
-      default: (answers) => {
-        if (answers.dbType === 'PostgreSQL') return '5432';
-        if (answers.dbType === 'MySQL') return '3306';
-        return '27017';
-      }
+      name: 'Anthropic Claude (Sonnet/Opus/Haiku)',
+      value: 'claude',
+      description: 'Best reasoning, longest context',
+      models: ['claude-3-sonnet-20240229', 'claude-3-opus-20240229', 'claude-3-haiku-20240307']
     },
     {
-      type: 'input',
-      name: 'user',
-      message: 'Database username:',
-      default: 'postgres'
+      name: 'xAI Grok',
+      value: 'grok',
+      description: 'Real-time data, Twitter integration',
+      models: ['grok-beta']
     },
     {
-      type: 'password',
-      name: 'password',
-      message: 'Database password:',
-      mask: '*'
+      name: 'Together AI',
+      value: 'together',
+      description: 'Open-source models, cost-effective',
+      models: ['mistralai/Mixtral-8x7B-Instruct-v0.1', 'meta-llama/Llama-3-70b-chat-hf']
+    },
+    {
+      name: 'DeepInfra',
+      value: 'deepinfra',
+      description: 'Multiple models, serverless',
+      models: ['meta-llama/Meta-Llama-3-70B-Instruct', 'mistralai/Mixtral-8x7B-Instruct-v0.1']
     },
     {
-      type: 'input',
-      name: 'database',
-      message: 'Database name:',
-      default: 'mydb'
+      name: 'Groq',
+      value: 'groq',
+      description: 'Ultra-fast inference',
+      models: ['llama3-70b-8192', 'mixtral-8x7b-32768']
     }
-  ]);
-
-  // Step 2: OpenAI Configuration
-  console.log(chalk.bold.blue('\n🔑 Step 2: OpenAI Configuration\n'));
+  ];
 
-  const aiAnswers = await inquirer.prompt([
+  const llmAnswers = await inquirer.prompt([
+    {
+      type: 'list',
+      name: 'provider',
+      message: 'Select AI Provider:',
+      choices: llmProviders.map(p => ({
+        name: `${p.name}\n  ${chalk.gray(p.description)}`,
+        value: p.value,
+        short: p.name
+      }))
+    },
     {
       type: 'password',
       name: 'apiKey',
-      message: 'Enter your OpenAI API key:',
+      message: (answers) => {
+        const provider = llmProviders.find(p => p.value === answers.provider);
+        return `Enter ${provider.name} 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!';
+        if (!input || input.trim() === '') {
+          return 'API key is required!';
         }
         return true;
       }
@@ -86,40 +284,43 @@ async function main() {
     {
       type: 'list',
       name: 'model',
-      message: 'Select GPT model:',
-      choices: ['gpt-3.5-turbo', 'gpt-4'],
-      default: 'gpt-3.5-turbo'
+      message: 'Select Model:',
+      choices: (answers) => {
+        const provider = llmProviders.find(p => p.value === answers.provider);
+        return provider.models.map(m => ({
+          name: m,
+          value: m
+        }));
+      }
     }
   ]);
 
-  // Step 3: Create configuration files
-  console.log(chalk.bold.blue('\n📝 Step 3: Generating Configuration Files\n'));
-  
-  const spinner = ora('Creating files...').start();
+  const selectedProvider = llmProviders.find(p => p.value === llmAnswers.provider);
+  console.log(chalk.green(`\n✅ ${selectedProvider.name} configured!\n`));
 
-  // Build database URL
-  let databaseUrl;
-  const dbType = dbAnswers.dbType.toLowerCase();
+  // Step 3: Generate configuration files
+  console.log(chalk.bold.blue('📝 Step 3: Generating Configuration Files\n'));
   
-  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}`;
-  }
+  const spinner = ora('Creating files...').start();
 
-  // Create .env.chatbot
+  // Create .env.chatbot file
   const envContent = `# AgenticAIChat Configuration
 # Generated on ${new Date().toISOString()}
 
-OPENAI_API_KEY=${aiAnswers.apiKey}
-DATABASE_URL=${databaseUrl}
+# Database Configuration
+DB_CATEGORY=${dbCategoryAnswer.category}
 DB_TYPE=${dbType}
-GPT_MODEL=${aiAnswers.model}
+DATABASE_URL=${databaseUrl}
+
+# LLM Provider Configuration
+LLM_PROVIDER=${llmAnswers.provider}
+LLM_API_KEY=${llmAnswers.apiKey}
+LLM_MODEL=${llmAnswers.model}
+
+# Other
 SECRET_KEY=${crypto.randomBytes(32).toString('hex')}
 CHATBOT_ENABLED=true
-`;
+  `.trim();
 
   const envPath = path.join(process.cwd(), '.env.chatbot');
   fs.writeFileSync(envPath, envContent);
@@ -127,32 +328,22 @@ CHATBOT_ENABLED=true
 
   // Create chatbot-config.json
   const configContent = {
-    dbType: dbType,
-    model: aiAnswers.model,
+    database: {
+      category: dbCategoryAnswer.category,
+      type: dbType
+    },
+    llm: {
+      provider: llmAnswers.provider,
+      model: llmAnswers.model
+    },
     setupDate: new Date().toISOString(),
-    version: '1.0.0'
+    version: '2.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');
@@ -161,7 +352,7 @@ CHATBOT_ENABLED=true
     }
 
     const apiTemplate = fs.readFileSync(
-      path.join(__dirname, '..', 'templates', 'api-route.template.ts'),
+      path.join(__dirname, '..', 'templates', 'api-route.txt'),
       'utf8'
     );
 
@@ -181,7 +372,7 @@ CHATBOT_ENABLED=true
     }
 
     const chatTemplate = fs.readFileSync(
-      path.join(__dirname, '..', 'templates', 'chat-page.template.tsx'),
+      path.join(__dirname, '..', 'templates', 'chat-page.txt'),
       'utf8'
     );
 
@@ -193,6 +384,22 @@ CHATBOT_ENABLED=true
     console.log(chalk.yellow('\nℹ️  You can manually create the chat page later'));
   }
 
+  // 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!');
+
   // Success message
   console.log(chalk.green.bold('\n✅ Setup Complete!\n'));
   console.log(chalk.white('Files created:'));
@@ -200,6 +407,16 @@ CHATBOT_ENABLED=true
   console.log(chalk.gray('  • chatbot-config.json (settings)'));
   console.log(chalk.gray('  • .gitignore (updated)\n'));
 
+  console.log(chalk.white('Database Configuration:'));
+  console.log(chalk.cyan(`  • Category: ${dbCategoryAnswer.category.toUpperCase()}`));
+  console.log(chalk.cyan(`  • Type: ${dbType}`));
+  console.log(chalk.gray(`  • URL: ${databaseUrl.substring(0, 50)}...\n`));
+
+  console.log(chalk.white('AI Provider Configuration:'));
+  console.log(chalk.cyan(`  • Provider: ${selectedProvider.name}`));
+  console.log(chalk.cyan(`  • Model: ${llmAnswers.model}`));
+  console.log(chalk.gray(`  • API Key: ${'*'.repeat(20)}\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";'));

package/dist/core/ChatbotEngine.d.ts

@@ -1,6 +1,6 @@
 import { ChatbotConfig, QueryRequest, QueryResponse, DatabaseSchema } from '../types';
 export declare class ChatbotEngine {
-    private dbConnector;
+    private dbEngine;
     private nlConverter;
     private schema;
     private initialized;
@@ -25,4 +25,12 @@ export declare class ChatbotEngine {
      * Get current schema
      */
     getSchema(): DatabaseSchema | null;
+    /**
+     * Get database engine status
+     */
+    getStatus(): {
+        initialized: boolean;
+        engine: import("../types").EngineStatus;
+        schema: string;
+    };
 }