berget 1.0.0 → 1.2.0

package/src/commands/chat.ts

@@ -0,0 +1,445 @@
+import { Command } from 'commander'
+import chalk from 'chalk'
+import readline from 'readline'
+import { COMMAND_GROUPS, SUBCOMMANDS } from '../constants/command-structure'
+import { ChatService, ChatMessage, ChatCompletionOptions } from '../services/chat-service'
+import { ApiKeyService } from '../services/api-key-service'
+import { AuthService } from '../services/auth-service'
+import { handleError } from '../utils/error-handler'
+import { DefaultApiKeyManager } from '../utils/default-api-key'
+
+/**
+ * Helper function to get user confirmation
+ */
+async function confirm(question: string): Promise<boolean> {
+  const rl = readline.createInterface({
+    input: process.stdin,
+    output: process.stdout,
+  })
+
+  return new Promise<boolean>((resolve) => {
+    rl.question(question, (answer) => {
+      rl.close()
+      resolve(answer.toLowerCase() === 'y' || answer.toLowerCase() === 'yes')
+    })
+  })
+}
+
+/**
+ * Register chat commands
+ */
+export function registerChatCommands(program: Command): void {
+  const chat = program
+    .command(COMMAND_GROUPS.CHAT)
+    .description('Interact with AI chat models')
+
+  chat
+    .command(SUBCOMMANDS.CHAT.RUN)
+    .description('Run a chat session with a specified model')
+    .argument('[model]', 'Model to use (default: google/gemma-3-27b-it)')
+    .option('-s, --system <message>', 'System message')
+    .option('-t, --temperature <temp>', 'Temperature (0-1)', parseFloat)
+    .option('-m, --max-tokens <tokens>', 'Maximum tokens to generate', parseInt)
+    .option('-k, --api-key <key>', 'API key to use for this chat session')
+    .option(
+      '--api-key-id <id>',
+      'ID of the API key to use from your saved keys'
+    )
+    .action(async (options) => {
+      try {
+        const chatService = ChatService.getInstance()
+
+        // Check if we have an API key or need to get one
+        let apiKey = options.apiKey
+        let apiKeyId = options.apiKeyId
+        
+        // Check for environment variable first
+        const envApiKey = process.env.BERGET_API_KEY;
+        if (envApiKey) {
+          console.log(
+            chalk.dim(`Using API key from BERGET_API_KEY environment variable`)
+          )
+          apiKey = envApiKey;
+        }
+        // If no API key or API key ID provided and no env var, check for default API key
+        else if (!apiKey && !apiKeyId) {
+          try {
+            const defaultApiKeyManager = DefaultApiKeyManager.getInstance()
+            const defaultApiKeyData = defaultApiKeyManager.getDefaultApiKeyData()
+
+            if (defaultApiKeyData) {
+              apiKeyId = defaultApiKeyData.id
+              apiKey = defaultApiKeyData.key
+              
+              if (apiKey) {
+                console.log(
+                  chalk.dim(`Using default API key: ${defaultApiKeyData.name}`)
+                )
+              } else {
+                console.log(
+                  chalk.yellow(`Default API key "${defaultApiKeyData.name}" exists but the key value is missing.`)
+                )
+                console.log(
+                  chalk.yellow(`Try rotating the key with: berget api-keys rotate ${defaultApiKeyData.id}`)
+                )
+              }
+            } else {
+              // No default API key, prompt the user to create one
+              console.log(chalk.yellow('No default API key set.'))
+
+              // Try to prompt for a default API key
+              apiKey = await defaultApiKeyManager.promptForDefaultApiKey()
+
+              if (!apiKey) {
+                console.log(
+                  chalk.red(
+                    'Error: An API key is required to use the chat command.'
+                  )
+                )
+                console.log(chalk.yellow('You can:'))
+                console.log(
+                  chalk.yellow(
+                    '1. Create an API key with: berget api-keys create --name "My Key"'
+                  )
+                )
+                console.log(
+                  chalk.yellow(
+                    '2. Set a default API key with: berget api-keys set-default <id>'
+                  )
+                )
+                console.log(
+                  chalk.yellow(
+                    '3. Provide an API key with the --api-key option'
+                  )
+                )
+                return
+              }
+            }
+          } catch (error) {
+            if (process.argv.includes('--debug')) {
+              console.log(
+                chalk.yellow('DEBUG: Error checking default API key:')
+              )
+              console.log(chalk.yellow(String(error)))
+            }
+          }
+        }
+
+        // If no direct API key, try to get one from API key ID
+        if (!apiKey && apiKeyId) {
+          try {
+            const apiKeyService = ApiKeyService.getInstance()
+            const keys = await apiKeyService.list()
+            const selectedKey = keys.find(
+              (key) => key.id.toString() === options.apiKeyId
+            )
+
+            if (!selectedKey) {
+              console.log(
+                chalk.yellow(
+                  `API key with ID ${options.apiKeyId} not found. Using default authentication.`
+                )
+              )
+            } else {
+              console.log(chalk.dim(`Using API key: ${selectedKey.name}`))
+
+              // We need to rotate the key to get the actual key value
+              if (
+                await confirm(
+                  chalk.yellow(
+                    `To use API key "${selectedKey.name}", it needs to be rotated. This will invalidate the current key. Continue? (y/n)`
+                  )
+                )
+              ) {
+                const rotatedKey = await apiKeyService.rotate(options.apiKeyId)
+                apiKey = rotatedKey.key
+                console.log(
+                  chalk.green(
+                    `API key "${selectedKey.name}" rotated successfully.`
+                  )
+                )
+              } else {
+                console.log(
+                  chalk.yellow('Using default authentication instead.')
+                )
+              }
+            }
+          } catch (error) {
+            // Check if this is an authentication error
+            const errorMessage = error instanceof Error ? error.message : String(error);
+            const isAuthError = errorMessage.includes('Unauthorized') || 
+                               errorMessage.includes('Authentication failed') ||
+                               errorMessage.includes('AUTH_FAILED');
+            
+            if (isAuthError) {
+              console.log(chalk.yellow('Authentication required. Please run `berget auth login` first.'));
+            } else {
+              console.error(chalk.red('Error fetching API key:'));
+              console.error(error);
+            }
+            console.log(chalk.yellow('Using default authentication instead.'));
+          }
+        }
+
+        // Verify we have authentication before starting chat
+        if (!apiKey) {
+          try {
+            AuthService.getInstance()
+          } catch (error) {
+            console.log(chalk.red('Error: Authentication required for chat'))
+            console.log(chalk.yellow('Please either:'))
+            console.log(chalk.yellow('1. Log in with `berget auth login`'))
+            console.log(chalk.yellow('2. Provide an API key with `--api-key`'))
+            console.log(
+              chalk.yellow('3. Provide an API key ID with `--api-key-id`')
+            )
+            console.log(
+              chalk.yellow(
+                '4. Set a default API key with `berget api-keys set-default <id>`'
+              )
+            )
+            return
+          }
+        }
+
+        // Set up readline interface for user input
+        const rl = readline.createInterface({
+          input: process.stdin,
+          output: process.stdout,
+        })
+
+        // Prepare messages array
+        const messages: ChatMessage[] = []
+
+        // Add system message if provided
+        if (options.system) {
+          messages.push({
+            role: 'system',
+            content: options.system,
+          })
+        }
+
+        console.log(chalk.cyan('Chat with Berget AI (type "exit" to quit)'))
+        console.log(chalk.cyan('----------------------------------------'))
+
+        // Start the conversation loop
+        const askQuestion = () => {
+          rl.question(chalk.green('You: '), async (input) => {
+            // Check if user wants to exit
+            if (input.toLowerCase() === 'exit') {
+              console.log(chalk.cyan('Goodbye!'))
+              rl.close()
+              return
+            }
+
+            // Add user message
+            messages.push({
+              role: 'user',
+              content: input,
+            })
+
+            try {
+              // Call the API
+              console.log(chalk.yellow('DEBUG: Preparing completion options'))
+              
+              const completionOptions: ChatCompletionOptions = {
+                model: options.args?.[0] || 'google/gemma-3-27b-it',
+                messages: messages,
+                temperature:
+                  options.temperature !== undefined ? options.temperature : 0.7,
+                max_tokens: options.maxTokens || 4096,
+              }
+
+              // Only add apiKey if it actually exists
+              if (apiKey) {
+                completionOptions.apiKey = apiKey
+                console.log(chalk.yellow('DEBUG: Using API key from command options or default'))
+              } else {
+                console.log(chalk.yellow('DEBUG: No API key available in chat command'))
+                // If we got this far with defaultApiKeyData but no apiKey, there's a problem
+                const defaultApiKeyManager = DefaultApiKeyManager.getInstance();
+                if (defaultApiKeyManager.getDefaultApiKeyData()) {
+                  console.log(chalk.yellow('DEBUG: Default API key data exists but key is missing'))
+                }
+              }
+
+              // Debug output
+              console.log(chalk.yellow('DEBUG: Completion options:'))
+              console.log(chalk.yellow(JSON.stringify({
+                ...completionOptions,
+                apiKey: completionOptions.apiKey ? '***' : undefined,
+                messages: completionOptions.messages.map((m: any) => ({
+                  role: m.role,
+                  content: m.content.length > 50 ? m.content.substring(0, 50) + '...' : m.content
+                }))
+              }, null, 2)))
+
+              console.log(chalk.yellow('DEBUG: Calling chatService.createCompletion'))
+              
+              const response = await chatService.createCompletion(
+                completionOptions
+              )
+
+              // Debug output
+              if (program.opts().debug) {
+                console.log(chalk.yellow('DEBUG: Full response:'))
+                console.log(chalk.yellow(JSON.stringify(response, null, 2)))
+              }
+
+              // Check if response has the expected structure
+              if (
+                !response ||
+                !response.choices ||
+                !response.choices[0] ||
+                !response.choices[0].message
+              ) {
+                console.error(
+                  chalk.red('Error: Unexpected response format from API')
+                )
+                console.error(
+                  chalk.red('Response:', JSON.stringify(response, null, 2))
+                )
+                throw new Error('Unexpected response format from API')
+              }
+
+              // Get assistant's response
+              const assistantMessage = response.choices[0].message.content
+
+              // Add to messages array
+              messages.push({
+                role: 'assistant',
+                content: assistantMessage,
+              })
+
+              // Display the response
+              console.log(chalk.blue('Assistant: ') + assistantMessage)
+              console.log() // Empty line for better readability
+
+              // Continue the conversation
+              askQuestion()
+            } catch (error) {
+              console.error(chalk.red('Error: Failed to get response'))
+              if (error instanceof Error) {
+                console.error(chalk.red(error.message))
+              }
+              // Continue despite error
+              askQuestion()
+            }
+          })
+        }
+
+        // Start the conversation
+        askQuestion()
+      } catch (error) {
+        handleError('Failed to create chat completion', error)
+      }
+    })
+
+  chat
+    .command(SUBCOMMANDS.CHAT.LIST)
+    .description('List available chat models')
+    .option('-k, --api-key <key>', 'API key to use for this request')
+    .option(
+      '--api-key-id <id>',
+      'ID of the API key to use from your saved keys'
+    )
+    .action(async (options) => {
+      try {
+        // If API key ID is provided, fetch the actual key
+        let apiKey = options.apiKey
+        let apiKeyId = options.apiKeyId
+
+        // If no API key or API key ID provided, check for default API key
+        if (!apiKey && !apiKeyId) {
+          const defaultApiKeyManager = DefaultApiKeyManager.getInstance()
+          const defaultApiKeyData = defaultApiKeyManager.getDefaultApiKeyData()
+
+          if (defaultApiKeyData) {
+            apiKeyId = defaultApiKeyData.id
+            console.log(
+              chalk.dim(`Using default API key: ${defaultApiKeyData.name}`)
+            )
+          }
+        }
+
+        if (apiKeyId && !apiKey) {
+          try {
+            const apiKeyService = ApiKeyService.getInstance()
+            const keys = await apiKeyService.list()
+            const selectedKey = keys.find(
+              (key) => key.id.toString() === options.apiKeyId
+            )
+
+            if (!selectedKey) {
+              console.log(
+                chalk.yellow(
+                  `API key with ID ${options.apiKeyId} not found. Using default authentication.`
+                )
+              )
+            } else {
+              console.log(chalk.dim(`Using API key: ${selectedKey.name}`))
+
+              // We need to rotate the key to get the actual key value
+              if (
+                await confirm(
+                  chalk.yellow(
+                    `To use API key "${selectedKey.name}", it needs to be rotated. This will invalidate the current key. Continue? (y/n)`
+                  )
+                )
+              ) {
+                const rotatedKey = await apiKeyService.rotate(options.apiKeyId)
+                apiKey = rotatedKey.key
+                console.log(
+                  chalk.green(
+                    `API key "${selectedKey.name}" rotated successfully.`
+                  )
+                )
+              } else {
+                console.log(
+                  chalk.yellow('Using default authentication instead.')
+                )
+              }
+            }
+          } catch (error) {
+            console.error(chalk.red('Error fetching API key:'))
+            console.error(error)
+            console.log(chalk.yellow('Using default authentication instead.'))
+          }
+        }
+
+        const chatService = ChatService.getInstance()
+        const models = await chatService.listModels(apiKey)
+
+        // Debug output
+        if (program.opts().debug) {
+          console.log(chalk.yellow('DEBUG: Models response:'))
+          console.log(chalk.yellow(JSON.stringify(models, null, 2)))
+        }
+
+        console.log(chalk.bold('Available Chat Models:'))
+        console.log(chalk.dim('─'.repeat(70)))
+        console.log(
+          chalk.dim('MODEL ID'.padEnd(30)) +
+            chalk.dim('OWNER'.padEnd(25)) +
+            chalk.dim('CAPABILITIES')
+        )
+        console.log(chalk.dim('─'.repeat(70)))
+
+        models.data.forEach((model: any) => {
+          const capabilities = []
+          if (model.capabilities.vision) capabilities.push('vision')
+          if (model.capabilities.function_calling)
+            capabilities.push('function_calling')
+          if (model.capabilities.json_mode) capabilities.push('json_mode')
+
+          console.log(
+            model.id.padEnd(30) +
+              model.owned_by.padEnd(25) +
+              capabilities.join(', ')
+          )
+        })
+      } catch (error) {
+        handleError('Failed to list chat models', error)
+      }
+    })
+}

package/src/commands/clusters.ts

@@ -0,0 +1,65 @@
+import { Command } from 'commander'
+import { ClusterService, Cluster } from '../services/cluster-service'
+import { handleError } from '../utils/error-handler'
+
+/**
+ * Register cluster commands
+ */
+export function registerClusterCommands(program: Command): void {
+  const cluster = program
+    .command(ClusterService.COMMAND_GROUP)
+    .description('Manage Berget clusters')
+
+  cluster
+    .command(ClusterService.COMMANDS.LIST)
+    .description('List all Berget clusters')
+    .action(async () => {
+      try {
+        const clusterService = ClusterService.getInstance()
+        const clusters = await clusterService.list()
+
+        console.log('NAME                   STATUS    NODES    CREATED')
+        clusters.forEach((cluster: Cluster) => {
+          console.log(
+            `${cluster.name.padEnd(22)} ${cluster.status.padEnd(9)} ${String(
+              cluster.nodes
+            ).padEnd(8)} ${cluster.created}`
+          )
+        })
+      } catch (error) {
+        handleError('Failed to list clusters', error)
+      }
+    })
+
+  cluster
+    .command(ClusterService.COMMANDS.GET_USAGE)
+    .description('Get usage metrics for a specific cluster')
+    .argument('<clusterId>', 'Cluster ID')
+    .action(async (clusterId) => {
+      try {
+        const clusterService = ClusterService.getInstance()
+        const usage = await clusterService.getUsage(clusterId)
+
+        console.log('Cluster Usage:')
+        console.log(JSON.stringify(usage, null, 2))
+      } catch (error) {
+        handleError('Failed to get cluster usage', error)
+      }
+    })
+
+  cluster
+    .command(ClusterService.COMMANDS.DESCRIBE)
+    .description('Get detailed information about a cluster')
+    .argument('<clusterId>', 'Cluster ID')
+    .action(async (clusterId) => {
+      try {
+        const clusterService = ClusterService.getInstance()
+        const clusterInfo = await clusterService.describe(clusterId)
+
+        console.log('Cluster Details:')
+        console.log(JSON.stringify(clusterInfo, null, 2))
+      } catch (error) {
+        handleError('Failed to describe cluster', error)
+      }
+    })
+}

package/src/commands/index.ts

@@ -0,0 +1,23 @@
+import { Command } from 'commander'
+import { registerAuthCommands } from './auth'
+import { registerApiKeyCommands } from './api-keys'
+import { registerClusterCommands } from './clusters'
+import { registerBillingCommands } from './billing'
+import { registerModelCommands } from './models'
+import { registerUserCommands } from './users'
+import { registerChatCommands } from './chat'
+import { registerAutocompleteCommands } from './autocomplete'
+
+/**
+ * Register all command groups with the program
+ */
+export function registerCommands(program: Command): void {
+  registerAuthCommands(program)
+  registerApiKeyCommands(program)
+  registerClusterCommands(program)
+  registerBillingCommands(program)
+  registerModelCommands(program)
+  registerUserCommands(program)
+  registerChatCommands(program)
+  registerAutocompleteCommands(program)
+}

package/src/commands/models.ts

@@ -0,0 +1,63 @@
+import { Command } from 'commander'
+import { COMMAND_GROUPS, SUBCOMMANDS } from '../constants/command-structure'
+import { createAuthenticatedClient } from '../client'
+import { handleError } from '../utils/error-handler'
+
+/**
+ * Register models commands
+ */
+export function registerModelCommands(program: Command): void {
+  const models = program
+    .command(COMMAND_GROUPS.MODELS)
+    .description('Manage AI models')
+
+  models
+    .command(SUBCOMMANDS.MODELS.LIST)
+    .description('List available AI models')
+    .option('--id <modelId>', 'Get details for a specific model')
+    .action(async (options) => {
+      try {
+        const client = createAuthenticatedClient()
+        let response
+
+        if (options.id) {
+          const { data, error } = await client.GET('/v1/models/{modelId}', {
+            params: { path: { modelId: options.id } },
+          })
+          if (error) throw new Error(JSON.stringify(error))
+          response = data
+
+          console.log('Model Details:')
+          console.log(JSON.stringify(response, null, 2))
+        } else {
+          const { data, error } = await client.GET('/v1/models')
+          if (error) throw new Error(JSON.stringify(error))
+          response = data
+
+          console.log('Available Models:')
+          console.log(
+            'ID                      OWNED BY                  CAPABILITIES'
+          )
+          // Ensure response has the expected structure
+          const modelData = response as { data?: any[] };
+          if (modelData.data) {
+            modelData.data.forEach((model: any) => {
+              const capabilities = []
+              if (model.capabilities.vision) capabilities.push('vision')
+              if (model.capabilities.function_calling)
+                capabilities.push('function_calling')
+              if (model.capabilities.json_mode) capabilities.push('json_mode')
+
+              console.log(
+                `${model.id.padEnd(24)} ${model.owned_by.padEnd(
+                  25
+                )} ${capabilities.join(', ')}`
+              )
+            })
+          }
+        }
+      } catch (error) {
+        handleError('Failed to get models', error)
+      }
+    })
+}

package/src/commands/users.ts

@@ -0,0 +1,37 @@
+import { Command } from 'commander'
+import { COMMAND_GROUPS, SUBCOMMANDS } from '../constants/command-structure'
+import { createAuthenticatedClient } from '../client'
+import { handleError } from '../utils/error-handler'
+import chalk from 'chalk'
+
+/**
+ * Register user commands
+ */
+export function registerUserCommands(program: Command): void {
+  const users = program
+    .command(COMMAND_GROUPS.USERS)
+    .description('Manage users')
+
+  users
+    .command(SUBCOMMANDS.USERS.LIST)
+    .description('List team members')
+    .action(async () => {
+      try {
+        const client = createAuthenticatedClient()
+        const { data, error } = await client.GET('/v1/users')
+        if (error) throw new Error(JSON.stringify(error))
+
+        console.log('Team Members:')
+        console.log(
+          'NAME                     EMAIL                           ROLE'
+        )
+        data.forEach((user: any) => {
+          console.log(
+            `${user.name.padEnd(24)} ${user.email.padEnd(30)} ${user.role}`
+          )
+        })
+      } catch (error) {
+        handleError('Failed to list team members', error)
+      }
+    })
+}

package/src/constants/command-structure.ts

@@ -15,6 +15,7 @@ export const COMMAND_GROUPS = {
   FLUX: 'flux',
   USERS: 'users',
   BILLING: 'billing',
+  CHAT: 'chat',
 }
 
 // Subcommands for each group
@@ -26,6 +27,12 @@ export const SUBCOMMANDS = {
     WHOAMI: 'whoami',
   },
   
+  // Chat commands
+  CHAT: {
+    RUN: 'run',
+    LIST: 'list',
+  },
+  
   // API Keys commands
   API_KEYS: {
     LIST: 'list',
@@ -33,6 +40,8 @@ export const SUBCOMMANDS = {
     DELETE: 'delete',
     ROTATE: 'rotate',
     DESCRIBE: 'describe',
+    SET_DEFAULT: 'set-default',
+    GET_DEFAULT: 'get-default',
   },
   
   // Clusters commands
@@ -112,6 +121,8 @@ export const COMMAND_DESCRIPTIONS = {
   [`${COMMAND_GROUPS.API_KEYS} ${SUBCOMMANDS.API_KEYS.DELETE}`]: 'Delete an API key',
   [`${COMMAND_GROUPS.API_KEYS} ${SUBCOMMANDS.API_KEYS.ROTATE}`]: 'Rotate an API key',
   [`${COMMAND_GROUPS.API_KEYS} ${SUBCOMMANDS.API_KEYS.DESCRIBE}`]: 'Get usage statistics for an API key',
+  [`${COMMAND_GROUPS.API_KEYS} ${SUBCOMMANDS.API_KEYS.SET_DEFAULT}`]: 'Set an API key as the default for chat commands',
+  [`${COMMAND_GROUPS.API_KEYS} ${SUBCOMMANDS.API_KEYS.GET_DEFAULT}`]: 'Show the current default API key',
   
   // Clusters group
   [COMMAND_GROUPS.CLUSTERS]: 'Manage Kubernetes clusters',
@@ -165,4 +176,9 @@ export const COMMAND_DESCRIPTIONS = {
   [`${COMMAND_GROUPS.BILLING} ${SUBCOMMANDS.BILLING.ADD_PAYMENT_METHOD}`]: 'Add a new payment method',
   [`${COMMAND_GROUPS.BILLING} ${SUBCOMMANDS.BILLING.REMOVE_PAYMENT_METHOD}`]: 'Remove a payment method',
   [`${COMMAND_GROUPS.BILLING} ${SUBCOMMANDS.BILLING.UPDATE_SUBSCRIPTION}`]: 'Update subscription plan',
+  
+  // Chat group
+  [COMMAND_GROUPS.CHAT]: 'Interact with AI chat models',
+  [`${COMMAND_GROUPS.CHAT} ${SUBCOMMANDS.CHAT.RUN}`]: 'Run a chat session with a specified model',
+  [`${COMMAND_GROUPS.CHAT} ${SUBCOMMANDS.CHAT.LIST}`]: 'List available chat models',
 }