intentiai 0.1.0

package/README.md

@@ -0,0 +1,156 @@
+# IntentiAI
+
+Intent-aware LLM routing that saves 60-90% on API costs while maintaining quality.
+
+## Installation
+
+```bash
+npm install -g intentiai
+```
+
+## Quick Start
+
+```bash
+# Login (opens browser for authentication)
+intentiai auth login
+
+# Create a project
+intentiai project create "My Chatbot"
+
+# Add intents
+intentiai intent add "refund_request" -d "Customer wants a refund"
+intentiai intent add "order_status" -d "Customer checking order status"
+intentiai intent add "product_question" -d "Questions about products"
+
+# Set up routing (cheap models for easy queries, GPT-4 for hard ones)
+intentiai route add -i "order_status" -d easy -p groq -m "llama-3.1-8b-instant"
+intentiai route add -i "product_question" -d easy -p groq -m "llama-3.1-8b-instant"
+intentiai route add -i "refund_request" -d hard -p openai -m "gpt-4o"
+
+# Set system prompts
+intentiai prompt set -i "refund_request" -s "You are a helpful customer service agent. Help with refunds politely."
+
+# Train the intent classifier
+intentiai train start --samples 20 --watch
+
+# Test your chatbot
+intentiai test "Where is my order?"
+intentiai test "I want a refund for my purchase"
+
+# Get embed code for your website
+intentiai deploy
+```
+
+## How It Works
+
+1. **Intent Classification** - Queries are classified into intents (refund_request, order_status, etc.)
+2. **Difficulty Assessment** - Each query is rated as easy, medium, or hard
+3. **Smart Routing** - Easy queries → fast/cheap models (Groq Llama), Hard queries → powerful models (GPT-4)
+4. **Cost Savings** - 60-90% reduction in LLM API costs
+
+## Commands
+
+### Authentication
+
+```bash
+intentiai auth login              # Browser-based login (recommended)
+intentiai auth login --no-browser # Terminal login with email/password
+intentiai auth whoami             # Show current user
+intentiai auth logout             # Logout
+```
+
+### Project Management
+
+```bash
+intentiai project create "Name"   # Create a new project
+intentiai project list            # List all projects
+intentiai project select <id>     # Select a project to work with
+```
+
+### Intent Management
+
+```bash
+intentiai intent add "name" -d "description"   # Add an intent
+intentiai intent list                          # List all intents
+```
+
+### Routing Rules
+
+Route queries to different models based on intent and difficulty:
+- `easy` → Fast, cheap models (Groq Llama 3.1 8B)
+- `medium` → Balanced models (Groq Llama 3.3 70B)
+- `hard` → Powerful models (GPT-4o)
+
+```bash
+intentiai route add -i "intent_name" -d easy -p groq -m "llama-3.1-8b-instant"
+intentiai route add -i "intent_name" -d medium -p groq -m "llama-3.3-70b-versatile"
+intentiai route add -i "intent_name" -d hard -p openai -m "gpt-4o"
+intentiai route list
+```
+
+### System Prompts
+
+```bash
+intentiai prompt set -i "intent_name" -s "Your system prompt here"
+intentiai prompt get -i "intent_name"
+```
+
+### Training
+
+```bash
+intentiai train start --samples 20 --watch   # Train the classifier
+intentiai train status                        # Check training status
+```
+
+### Testing & Deployment
+
+```bash
+intentiai test "Your test message"   # Test a query
+intentiai deploy                     # Get embed code and API info
+```
+
+## API Integration
+
+### JavaScript/TypeScript
+```javascript
+const response = await fetch('https://api.intentiai.com/v1/chat/completions', {
+  method: 'POST',
+  headers: {
+    'Content-Type': 'application/json',
+    'X-Project-Key': 'your_project_key'
+  },
+  body: JSON.stringify({
+    messages: [{ role: 'user', content: 'I want a refund' }]
+  })
+});
+
+const data = await response.json();
+console.log(data.choices[0].message.content);
+```
+
+### Python (OpenAI SDK Compatible)
+```python
+from openai import OpenAI
+
+client = OpenAI(
+    base_url='https://api.intentiai.com/v1',
+    api_key='your_project_key'
+)
+
+response = client.chat.completions.create(
+    model='auto',  # IntentiAI routes automatically
+    messages=[{'role': 'user', 'content': 'I want a refund'}]
+)
+
+print(response.choices[0].message.content)
+```
+
+## Links
+
+- Website: https://www.intentiai.com
+- Documentation: https://www.intentiai.com/docs
+- Dashboard: https://www.intentiai.com/dashboard
+
+## License
+
+MIT

package/bin/intentiai.js

@@ -0,0 +1,39 @@
+#!/usr/bin/env node
+
+const { program } = require('commander');
+const packageJson = require('../package.json');
+
+// Import command modules
+const authCommands = require('../commands/auth');
+const projectCommands = require('../commands/project');
+const intentCommands = require('../commands/intent');
+const routeCommands = require('../commands/route');
+const promptCommands = require('../commands/prompt');
+const docsCommands = require('../commands/docs');
+const trainCommands = require('../commands/train');
+const testCommands = require('../commands/test');
+const deployCommands = require('../commands/deploy');
+
+program
+  .name('intentiai')
+  .description('IntentiAI CLI - Intelligent LLM routing and orchestration')
+  .version(packageJson.version);
+
+// Register all commands
+authCommands(program);
+projectCommands(program);
+intentCommands(program);
+routeCommands(program);
+promptCommands(program);
+docsCommands(program);
+trainCommands(program);
+testCommands(program);
+deployCommands(program);
+
+// Parse arguments
+program.parse(process.argv);
+
+// Show help if no command provided
+if (!process.argv.slice(2).length) {
+  program.outputHelp();
+}

package/commands/auth.js

@@ -0,0 +1,242 @@
+const inquirer = require('inquirer');
+const chalk = require('chalk');
+const ora = require('ora');
+const api = require('../lib/api');
+const config = require('../lib/config');
+
+// Generate a random device code
+function generateDeviceCode() {
+  const chars = 'ABCDEFGHJKLMNPQRSTUVWXYZ23456789';
+  let code = '';
+  for (let i = 0; i < 8; i++) {
+    code += chars.charAt(Math.floor(Math.random() * chars.length));
+  }
+  return code;
+}
+
+// Open URL in browser
+async function openBrowser(url) {
+  const { exec } = require('child_process');
+  const platform = process.platform;
+
+  let command;
+  if (platform === 'win32') {
+    command = `start "" "${url}"`;
+  } else if (platform === 'darwin') {
+    command = `open "${url}"`;
+  } else {
+    command = `xdg-open "${url}"`;
+  }
+
+  return new Promise((resolve, reject) => {
+    exec(command, (error) => {
+      if (error) reject(error);
+      else resolve();
+    });
+  });
+}
+
+// Sleep helper
+function sleep(ms) {
+  return new Promise(resolve => setTimeout(resolve, ms));
+}
+
+module.exports = (program) => {
+  const auth = program.command('auth').description('Authentication commands');
+
+  // Login command - Browser-based by default
+  auth
+    .command('login')
+    .description('Login to IntentiAI via browser')
+    .option('--no-browser', 'Use email/password instead of browser')
+    .option('-u, --username <username>', 'Username (for --no-browser mode)')
+    .option('-p, --password <password>', 'Password (for --no-browser mode)')
+    .action(async (options) => {
+      try {
+        // If --no-browser flag is set, use traditional login
+        if (options.browser === false) {
+          await traditionalLogin(options);
+          return;
+        }
+
+        // Browser-based login flow
+        const deviceCode = generateDeviceCode();
+        const baseUrl = config.getWebUrl();
+        const loginUrl = `${baseUrl}/cli-auth?code=${deviceCode}`;
+
+        console.log();
+        console.log(chalk.bold('  IntentiAI CLI Login'));
+        console.log();
+        console.log('  Opening browser to complete authentication...');
+        console.log();
+        console.log(chalk.gray('  If browser doesn\'t open, visit:'));
+        console.log(chalk.cyan(`  ${loginUrl}`));
+        console.log();
+        console.log(chalk.gray('  Verification code:'), chalk.bold.white(deviceCode));
+        console.log();
+
+        // Try to open browser
+        try {
+          await openBrowser(loginUrl);
+        } catch (e) {
+          console.log(chalk.yellow('  Could not open browser automatically.'));
+          console.log(chalk.yellow('  Please open the URL above manually.'));
+        }
+
+        // Start polling for auth completion
+        const spinner = ora('Waiting for authentication...').start();
+
+        let attempts = 0;
+        const maxAttempts = 120; // 2 minutes timeout (polling every 1 second)
+
+        while (attempts < maxAttempts) {
+          try {
+            const result = await api.checkDeviceAuth(deviceCode);
+
+            if (result.authenticated) {
+              config.setAuth(result.username, result.access_token);
+              spinner.succeed(chalk.green('Successfully logged in!'));
+              console.log();
+              console.log(chalk.gray('  Logged in as:'), chalk.white(result.username));
+              console.log(chalk.gray('  Email:'), chalk.white(result.email));
+              console.log();
+              return;
+            }
+          } catch (e) {
+            // Device not authenticated yet, continue polling
+          }
+
+          await sleep(1000);
+          attempts++;
+        }
+
+        spinner.fail(chalk.red('Authentication timed out'));
+        console.log(chalk.gray('Please try again with'), chalk.cyan('intentiai auth login'));
+        process.exit(1);
+
+      } catch (error) {
+        console.error(chalk.red('Login failed:'), error.message);
+        process.exit(1);
+      }
+    });
+
+  // Traditional username/password login
+  async function traditionalLogin(options) {
+    let { username, password } = options;
+
+    // Prompt for credentials if not provided
+    if (!username || !password) {
+      const answers = await inquirer.prompt([
+        {
+          type: 'input',
+          name: 'username',
+          message: 'Email:',
+          when: !username
+        },
+        {
+          type: 'password',
+          name: 'password',
+          message: 'Password:',
+          when: !password
+        }
+      ]);
+
+      username = username || answers.username;
+      password = password || answers.password;
+    }
+
+    const spinner = ora('Logging in...').start();
+
+    const response = await api.login(username, password);
+
+    // Save credentials
+    config.setAuth(response.username || username, response.api_key || response.access_token);
+
+    spinner.succeed(chalk.green('Successfully logged in!'));
+    console.log(chalk.gray('Username:'), username);
+  }
+
+  // Register command
+  auth
+    .command('register')
+    .description('Register a new account')
+    .option('-u, --username <username>', 'Username')
+    .option('-e, --email <email>', 'Email')
+    .option('-p, --password <password>', 'Password')
+    .action(async (options) => {
+      try {
+        let { username, email, password } = options;
+
+        // Prompt for details if not provided
+        if (!username || !email || !password) {
+          const answers = await inquirer.prompt([
+            {
+              type: 'input',
+              name: 'username',
+              message: 'Username:',
+              when: !username
+            },
+            {
+              type: 'input',
+              name: 'email',
+              message: 'Email:',
+              when: !email,
+              validate: (input) => {
+                return /\S+@\S+\.\S+/.test(input) || 'Please enter a valid email';
+              }
+            },
+            {
+              type: 'password',
+              name: 'password',
+              message: 'Password:',
+              when: !password
+            }
+          ]);
+
+          username = username || answers.username;
+          email = email || answers.email;
+          password = password || answers.password;
+        }
+
+        const spinner = ora('Creating account...').start();
+
+        const response = await api.register(username, email, password);
+
+        // Auto-login after registration
+        config.setAuth(username, response.api_key || response.access_token);
+
+        spinner.succeed(chalk.green('Account created successfully!'));
+        console.log(chalk.gray('Username:'), username);
+        console.log(chalk.gray('Email:'), email);
+      } catch (error) {
+        console.error(chalk.red('Registration failed:'), error.message);
+        process.exit(1);
+      }
+    });
+
+  // Logout command
+  auth
+    .command('logout')
+    .description('Logout from IntentiAI')
+    .action(() => {
+      config.clearAuth();
+      console.log(chalk.green('Successfully logged out!'));
+    });
+
+  // Whoami command
+  auth
+    .command('whoami')
+    .description('Show current user')
+    .action(() => {
+      const username = config.getUsername();
+      const apiKey = config.getApiKey();
+
+      if (username) {
+        console.log(chalk.green('Logged in as:'), username);
+        console.log(chalk.gray('API Key:'), apiKey ? apiKey.substring(0, 20) + '...' : 'Not set');
+      } else {
+        console.log(chalk.yellow('Not logged in'));
+        console.log(chalk.gray('Run'), chalk.cyan('intentiai auth login'), chalk.gray('to login'));
+      }
+    });
+};

package/commands/deploy.js

@@ -0,0 +1,153 @@
+const chalk = require('chalk');
+const ora = require('ora');
+const api = require('../lib/api');
+const config = require('../lib/config');
+
+function requireProject() {
+  const projectKey = config.getCurrentProject();
+  if (!projectKey) {
+    console.error(chalk.red('No project selected'));
+    console.log(chalk.gray('Select a project with:'), chalk.cyan('gatellm project select'));
+    process.exit(1);
+  }
+  return projectKey;
+}
+
+module.exports = (program) => {
+  // Deploy command
+  program
+    .command('deploy')
+    .description('Deploy your chatbot (show integration info)')
+    .action(async () => {
+      const projectKey = requireProject();
+
+      try {
+        const spinner = ora('Fetching project details...').start();
+
+        const project = await api.getProject(projectKey);
+        const apiUrl = config.getApiUrl();
+
+        spinner.stop();
+
+        console.log(chalk.green('\n✓ Your chatbot is ready to deploy!\n'));
+
+        console.log(chalk.cyan('=== Integration Details ===\n'));
+
+        console.log(chalk.gray('API Endpoint:'));
+        console.log(chalk.white(`  ${apiUrl}/v1/chat/completions\n`));
+
+        console.log(chalk.gray('Project Key (use as API key):'));
+        console.log(chalk.white(`  ${projectKey}\n`));
+
+        console.log(chalk.cyan('=== Example Usage ===\n'));
+
+        console.log(chalk.yellow('cURL:'));
+        console.log(chalk.gray(`
+curl ${apiUrl}/v1/chat/completions \\
+  -H "Content-Type: application/json" \\
+  -H "X-Project-Key: ${projectKey}" \\
+  -d '{
+    "messages": [
+      {"role": "user", "content": "Hello!"}
+    ]
+  }'
+`));
+
+        console.log(chalk.yellow('JavaScript/Node.js:'));
+        console.log(chalk.gray(`
+const response = await fetch('${apiUrl}/v1/chat/completions', {
+  method: 'POST',
+  headers: {
+    'Content-Type': 'application/json',
+    'X-Project-Key': '${projectKey}'
+  },
+  body: JSON.stringify({
+    messages: [
+      { role: 'user', content: 'Hello!' }
+    ]
+  })
+});
+
+const data = await response.json();
+console.log(data.choices[0].message.content);
+`));
+
+        console.log(chalk.yellow('Python:'));
+        console.log(chalk.gray(`
+import requests
+
+response = requests.post(
+    '${apiUrl}/v1/chat/completions',
+    headers={
+        'Content-Type': 'application/json',
+        'X-Project-Key': '${projectKey}'
+    },
+    json={
+        'messages': [
+            {'role': 'user', 'content': 'Hello!'}
+        ]
+    }
+)
+
+print(response.json()['choices'][0]['message']['content'])
+`));
+
+        console.log(chalk.yellow('OpenAI SDK (Python):'));
+        console.log(chalk.gray(`
+from openai import OpenAI
+
+client = OpenAI(
+    base_url='${apiUrl}/v1',
+    api_key='${projectKey}'
+)
+
+response = client.chat.completions.create(
+    model='gpt-4o',  # Will be routed by GateLLM
+    messages=[
+        {'role': 'user', 'content': 'Hello!'}
+    ]
+)
+
+print(response.choices[0].message.content)
+`));
+
+        console.log(chalk.cyan('\n=== Next Steps ===\n'));
+        console.log(chalk.gray('1. Test your deployment:'));
+        console.log(chalk.white(`   gatellm test "Hello, how are you?"\n`));
+        console.log(chalk.gray('2. View project details:'));
+        console.log(chalk.white(`   gatellm project current\n`));
+        console.log(chalk.gray('3. Monitor in production:'));
+        console.log(chalk.white(`   Check logs at: ${apiUrl}/logs (coming soon)\n`));
+
+      } catch (error) {
+        console.error(chalk.red('Failed to get deployment info:'), error.message);
+        process.exit(1);
+      }
+    });
+
+  // Status command
+  program
+    .command('status')
+    .description('Check API server status')
+    .action(async () => {
+      try {
+        const apiUrl = config.getApiUrl();
+        const spinner = ora(`Checking API status at ${apiUrl}...`).start();
+
+        const health = await api.health();
+
+        spinner.succeed(chalk.green('API server is healthy!'));
+        console.log(chalk.gray('Status:'), health.status);
+        console.log(chalk.gray('API URL:'), apiUrl);
+
+        if (health.version) {
+          console.log(chalk.gray('Version:'), health.version);
+        }
+      } catch (error) {
+        console.error(chalk.red('API server is not reachable:'), error.message);
+        console.log(chalk.gray('\nMake sure the GateLLM API server is running'));
+        console.log(chalk.gray('Default URL:'), 'http://localhost:8000');
+        process.exit(1);
+      }
+    });
+};