intentiai 0.1.0

package/commands/prompt.js

@@ -0,0 +1,164 @@
+const inquirer = require('inquirer');
+const chalk = require('chalk');
+const ora = require('ora');
+const Table = require('cli-table3');
+const fs = require('fs');
+const path = require('path');
+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) => {
+  const prompt = program.command('prompt').description('System prompt management');
+
+  // Set prompt
+  prompt
+    .command('set')
+    .description('Set system prompt for an intent')
+    .option('-i, --intent <intent>', 'Intent name')
+    .option('-s, --system <message>', 'System message')
+    .option('-f, --file <file>', 'Load system message from file')
+    .option('-m, --modifier <modifier>', 'High difficulty modifier')
+    .action(async (options) => {
+      requireProject();
+
+      try {
+        let { intent, system, file, modifier } = options;
+
+        // Get intents
+        const intents = await api.listIntents();
+
+        if (intents.length === 0) {
+          console.error(chalk.red('No intents found'));
+          console.log(chalk.gray('Create an intent first:'), chalk.cyan('gatellm intent add <name>'));
+          process.exit(1);
+        }
+
+        // Prompt for intent if not provided
+        if (!intent) {
+          const answers = await inquirer.prompt([
+            {
+              type: 'list',
+              name: 'intent',
+              message: 'Select intent:',
+              choices: intents.map(i => i.name)
+            }
+          ]);
+          intent = answers.intent;
+        }
+
+        // Load from file if specified
+        if (file) {
+          const filePath = path.resolve(file);
+          if (!fs.existsSync(filePath)) {
+            console.error(chalk.red('File not found:'), filePath);
+            process.exit(1);
+          }
+          system = fs.readFileSync(filePath, 'utf8');
+        }
+
+        // Prompt for system message if not provided
+        if (!system) {
+          const answers = await inquirer.prompt([
+            {
+              type: 'editor',
+              name: 'system',
+              message: 'Enter system prompt (opens in editor):',
+              default: 'You are a helpful AI assistant.'
+            }
+          ]);
+          system = answers.system;
+        }
+
+        const spinner = ora('Setting prompt...').start();
+
+        await api.setPrompt(intent, system, modifier);
+
+        spinner.succeed(chalk.green('Prompt set successfully!'));
+        console.log(chalk.gray('Intent:'), intent);
+        console.log(chalk.gray('System message:'), system.substring(0, 100) + (system.length > 100 ? '...' : ''));
+        if (modifier) {
+          console.log(chalk.gray('Difficulty modifier:'), modifier);
+        }
+      } catch (error) {
+        console.error(chalk.red('Failed to set prompt:'), error.message);
+        process.exit(1);
+      }
+    });
+
+  // Get prompt
+  prompt
+    .command('get <intent>')
+    .description('Get system prompt for an intent')
+    .action(async (intent) => {
+      requireProject();
+
+      try {
+        const spinner = ora('Fetching prompt...').start();
+        const promptData = await api.getPrompt(intent);
+        spinner.stop();
+
+        console.log(chalk.green('System Prompt:'));
+        console.log(chalk.gray('Intent:'), intent);
+        console.log(chalk.gray('Message:'));
+        console.log(chalk.cyan(promptData.system_message));
+
+        if (promptData.high_difficulty_modifier) {
+          console.log(chalk.gray('\nHigh Difficulty Modifier:'));
+          console.log(chalk.yellow(promptData.high_difficulty_modifier));
+        }
+      } catch (error) {
+        console.error(chalk.red('Failed to get prompt:'), error.message);
+        process.exit(1);
+      }
+    });
+
+  // List all prompts
+  prompt
+    .command('list')
+    .alias('ls')
+    .description('List all prompts')
+    .action(async () => {
+      requireProject();
+
+      try {
+        const spinner = ora('Fetching prompts...').start();
+        const prompts = await api.listPrompts();
+        spinner.stop();
+
+        if (prompts.length === 0) {
+          console.log(chalk.yellow('No prompts configured'));
+          console.log(chalk.gray('Set one with:'), chalk.cyan('gatellm prompt set'));
+          return;
+        }
+
+        const table = new Table({
+          head: [chalk.cyan('Intent'), chalk.cyan('System Message'), chalk.cyan('Has Modifier')],
+          colWidths: [25, 50, 15]
+        });
+
+        prompts.forEach(p => {
+          table.push([
+            p.intent_name,
+            p.system_message.substring(0, 45) + (p.system_message.length > 45 ? '...' : ''),
+            p.high_difficulty_modifier ? chalk.green('Yes') : chalk.gray('No')
+          ]);
+        });
+
+        console.log(table.toString());
+        console.log(chalk.gray(`\nTotal: ${prompts.length} prompt(s)`));
+      } catch (error) {
+        console.error(chalk.red('Failed to list prompts:'), error.message);
+        process.exit(1);
+      }
+    });
+};

package/commands/route.js

@@ -0,0 +1,187 @@
+const inquirer = require('inquirer');
+const chalk = require('chalk');
+const ora = require('ora');
+const Table = require('cli-table3');
+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;
+}
+
+const DIFFICULTY_LEVELS = ['easy', 'medium', 'hard'];
+const PROVIDERS = {
+  openai: ['gpt-4o', 'gpt-4o-mini', 'gpt-4-turbo', 'gpt-3.5-turbo'],
+  groq: ['llama-3.1-8b-instant', 'llama-3.3-70b-versatile', 'mixtral-8x7b-32768'],
+  anthropic: ['claude-3-5-sonnet-20241022', 'claude-3-haiku-20240307'],
+  gemini: ['gemini-2.0-flash-exp', 'gemini-1.5-flash']
+};
+
+module.exports = (program) => {
+  const route = program.command('route').description('Routing rule management');
+
+  // Add route
+  route
+    .command('add')
+    .description('Add a routing rule')
+    .option('-i, --intent <intent>', 'Intent name')
+    .option('-d, --difficulty <level>', 'Difficulty level (easy/medium/hard)')
+    .option('-m, --model <model>', 'Model name')
+    .option('-p, --provider <provider>', 'Provider (openai/groq/anthropic/gemini)')
+    .action(async (options) => {
+      requireProject();
+
+      try {
+        let { intent, difficulty, model, provider } = options;
+
+        // Interactive prompts for missing options
+        const intents = await api.listIntents();
+
+        if (intents.length === 0) {
+          console.error(chalk.red('No intents found'));
+          console.log(chalk.gray('Create an intent first:'), chalk.cyan('gatellm intent add <name>'));
+          process.exit(1);
+        }
+
+        if (!intent || !difficulty || !model || !provider) {
+          const answers = await inquirer.prompt([
+            {
+              type: 'list',
+              name: 'intent',
+              message: 'Select intent:',
+              choices: intents.map(i => i.name),
+              when: !intent
+            },
+            {
+              type: 'list',
+              name: 'difficulty',
+              message: 'Difficulty level:',
+              choices: DIFFICULTY_LEVELS,
+              when: !difficulty
+            },
+            {
+              type: 'list',
+              name: 'provider',
+              message: 'Select provider:',
+              choices: Object.keys(PROVIDERS),
+              when: !provider
+            },
+            {
+              type: 'list',
+              name: 'model',
+              message: 'Select model:',
+              choices: (answers) => PROVIDERS[answers.provider || provider],
+              when: !model
+            }
+          ]);
+
+          intent = intent || answers.intent;
+          difficulty = difficulty || answers.difficulty;
+          provider = provider || answers.provider;
+          model = model || answers.model;
+        }
+
+        const spinner = ora('Creating routing rule...').start();
+
+        await api.createRoute(intent, difficulty, model, provider);
+
+        spinner.succeed(chalk.green('Routing rule created successfully!'));
+        console.log(chalk.gray('Intent:'), intent);
+        console.log(chalk.gray('Difficulty:'), difficulty);
+        console.log(chalk.gray('Model:'), `${provider}/${model}`);
+      } catch (error) {
+        console.error(chalk.red('Failed to create route:'), error.message);
+        process.exit(1);
+      }
+    });
+
+  // List routes
+  route
+    .command('list')
+    .alias('ls')
+    .description('List all routing rules')
+    .action(async () => {
+      requireProject();
+
+      try {
+        const spinner = ora('Fetching routes...').start();
+
+        const routes = await api.listRoutes();
+
+        spinner.stop();
+
+        if (routes.length === 0) {
+          console.log(chalk.yellow('No routing rules found'));
+          console.log(chalk.gray('Create one with:'), chalk.cyan('gatellm route add'));
+          return;
+        }
+
+        const table = new Table({
+          head: [chalk.cyan('ID'), chalk.cyan('Intent'), chalk.cyan('Difficulty'), chalk.cyan('Provider'), chalk.cyan('Model')],
+          colWidths: [8, 25, 15, 15, 35]
+        });
+
+        routes.forEach(route => {
+          const difficultyColor =
+            route.difficulty_level === 'easy' ? chalk.green :
+            route.difficulty_level === 'medium' ? chalk.yellow :
+            chalk.red;
+
+          table.push([
+            route.id,
+            route.intent_name,
+            difficultyColor(route.difficulty_level),
+            route.provider,
+            route.model_name
+          ]);
+        });
+
+        console.log(table.toString());
+        console.log(chalk.gray(`\nTotal: ${routes.length} route(s)`));
+      } catch (error) {
+        console.error(chalk.red('Failed to list routes:'), error.message);
+        process.exit(1);
+      }
+    });
+
+  // Delete route
+  route
+    .command('delete <id>')
+    .alias('rm')
+    .description('Delete a routing rule')
+    .option('-y, --yes', 'Skip confirmation')
+    .action(async (id, options) => {
+      requireProject();
+
+      try {
+        if (!options.yes) {
+          const answers = await inquirer.prompt([
+            {
+              type: 'confirm',
+              name: 'confirm',
+              message: `Are you sure you want to delete route ${id}?`,
+              default: false
+            }
+          ]);
+
+          if (!answers.confirm) {
+            console.log(chalk.yellow('Cancelled'));
+            return;
+          }
+        }
+
+        const spinner = ora('Deleting route...').start();
+        await api.deleteRoute(id);
+        spinner.succeed(chalk.green('Route deleted successfully'));
+      } catch (error) {
+        console.error(chalk.red('Failed to delete route:'), error.message);
+        process.exit(1);
+      }
+    });
+};

package/commands/test.js

@@ -0,0 +1,88 @@
+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) => {
+  // Test command
+  program
+    .command('test <query>')
+    .description('Test a query against your chatbot')
+    .option('-s, --stream', 'Stream the response')
+    .action(async (query, options) => {
+      requireProject();
+
+      try {
+        const spinner = ora('Processing query...').start();
+
+        const response = await api.testQuery(query, options.stream);
+
+        spinner.stop();
+
+        console.log(chalk.green('\n=== Response ===\n'));
+
+        if (response.choices && response.choices.length > 0) {
+          const message = response.choices[0].message;
+          console.log(chalk.cyan(message.content));
+
+          console.log(chalk.gray('\n=== Metadata ==='));
+
+          if (response.usage) {
+            console.log(chalk.gray('Tokens:'),
+              `${response.usage.prompt_tokens} prompt + ${response.usage.completion_tokens} completion = ${response.usage.total_tokens} total`
+            );
+          }
+
+          if (response.model) {
+            console.log(chalk.gray('Model:'), response.model);
+          }
+
+          // GateLLM specific metadata
+          if (response.gatellm_metadata) {
+            console.log(chalk.gray('\n=== GateLLM Routing ==='));
+            const meta = response.gatellm_metadata;
+
+            if (meta.intent) {
+              console.log(chalk.gray('Intent:'), chalk.green(meta.intent.name));
+              console.log(chalk.gray('Confidence:'), `${(meta.intent.confidence * 100).toFixed(2)}%`);
+            }
+
+            if (meta.difficulty) {
+              const diffColor =
+                meta.difficulty.level === 'easy' ? chalk.green :
+                meta.difficulty.level === 'medium' ? chalk.yellow :
+                chalk.red;
+
+              console.log(chalk.gray('Difficulty:'), diffColor(meta.difficulty.level));
+              console.log(chalk.gray('Difficulty Score:'), meta.difficulty.score?.toFixed(4) || 'N/A');
+            }
+
+            if (meta.routing) {
+              console.log(chalk.gray('Selected Model:'), meta.routing.model);
+              console.log(chalk.gray('Provider:'), meta.routing.provider);
+            }
+
+            if (meta.rag_used) {
+              console.log(chalk.gray('RAG Context:'), chalk.green('Used'));
+              console.log(chalk.gray('Documents Retrieved:'), meta.rag_docs_count || 0);
+            }
+          }
+        } else {
+          console.log(chalk.yellow('No response generated'));
+        }
+      } catch (error) {
+        console.error(chalk.red('Test failed:'), error.message);
+        process.exit(1);
+      }
+    });
+};

package/commands/train.js

@@ -0,0 +1,135 @@
+const inquirer = require('inquirer');
+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;
+}
+
+async function sleep(ms) {
+  return new Promise(resolve => setTimeout(resolve, ms));
+}
+
+module.exports = (program) => {
+  const train = program.command('train').description('Model training commands');
+
+  // Start training
+  train
+    .command('start')
+    .description('Start training the model')
+    .option('-i, --intents <intents...>', 'Specific intents to train (default: all)')
+    .option('-n, --samples <number>', 'Number of samples per intent', '100')
+    .option('-w, --watch', 'Watch training progress')
+    .action(async (options) => {
+      requireProject();
+
+      try {
+        const numSamples = parseInt(options.samples);
+
+        const spinner = ora('Starting training...').start();
+
+        const response = await api.startTraining(options.intents, numSamples);
+
+        spinner.succeed(chalk.green('Training started!'));
+        console.log(chalk.gray('Task ID:'), chalk.cyan(response.task_id));
+        console.log(chalk.gray('Status:'), response.status);
+
+        if (options.watch) {
+          console.log(chalk.gray('\nWatching training progress... (Ctrl+C to stop watching)\n'));
+
+          const progressSpinner = ora('Training in progress...').start();
+
+          let completed = false;
+
+          while (!completed) {
+            await sleep(3000); // Poll every 3 seconds
+
+            try {
+              const status = await api.getTrainingStatus(response.task_id);
+
+              if (status.status === 'completed') {
+                progressSpinner.succeed(chalk.green('Training completed!'));
+                completed = true;
+
+                if (status.result) {
+                  console.log(chalk.gray('\nResults:'));
+                  console.log(chalk.gray('  Intents trained:'), status.result.intents_trained || 'N/A');
+                  console.log(chalk.gray('  Samples generated:'), status.result.samples_generated || 'N/A');
+                  console.log(chalk.gray('  Model path:'), status.result.model_path || 'N/A');
+                }
+              } else if (status.status === 'failed') {
+                progressSpinner.fail(chalk.red('Training failed'));
+                completed = true;
+
+                if (status.error) {
+                  console.error(chalk.red('Error:'), status.error);
+                }
+              } else {
+                // Update progress message
+                progressSpinner.text = `Training in progress... (${status.status})`;
+              }
+            } catch (error) {
+              progressSpinner.warn(chalk.yellow('Could not fetch status'));
+              break;
+            }
+          }
+        } else {
+          console.log(chalk.gray('\nCheck training status with:'));
+          console.log(chalk.cyan(`  gatellm train status ${response.task_id}`));
+        }
+      } catch (error) {
+        console.error(chalk.red('Failed to start training:'), error.message);
+        process.exit(1);
+      }
+    });
+
+  // Check training status
+  train
+    .command('status <taskId>')
+    .description('Check training status')
+    .action(async (taskId) => {
+      requireProject();
+
+      try {
+        const spinner = ora('Fetching training status...').start();
+
+        const status = await api.getTrainingStatus(taskId);
+
+        spinner.stop();
+
+        console.log(chalk.green('Training Status:'));
+        console.log(chalk.gray('  Task ID:'), taskId);
+        console.log(chalk.gray('  Status:'),
+          status.status === 'completed' ? chalk.green(status.status) :
+          status.status === 'failed' ? chalk.red(status.status) :
+          chalk.yellow(status.status)
+        );
+
+        if (status.status === 'completed' && status.result) {
+          console.log(chalk.gray('\nResults:'));
+          console.log(chalk.gray('  Intents trained:'), status.result.intents_trained || 'N/A');
+          console.log(chalk.gray('  Samples generated:'), status.result.samples_generated || 'N/A');
+          console.log(chalk.gray('  Model path:'), status.result.model_path || 'N/A');
+        }
+
+        if (status.status === 'failed' && status.error) {
+          console.log(chalk.red('\nError:'), status.error);
+        }
+
+        if (status.progress) {
+          console.log(chalk.gray('\nProgress:'), `${status.progress}%`);
+        }
+      } catch (error) {
+        console.error(chalk.red('Failed to get training status:'), error.message);
+        process.exit(1);
+      }
+    });
+};