berget 2.2.6 → 2.2.8

package/src/commands/chat.ts

@@ -1,42 +1,20 @@
-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'
-import { renderMarkdown, containsMarkdown } from '../utils/markdown-renderer'
-
-/**
- * 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')
-    })
-  })
-}
+import chalk from 'chalk';
+import { Command } from 'commander';
+import readline from 'node:readline';
+
+import { COMMAND_GROUPS, SUBCOMMANDS } from '../constants/command-structure';
+import { ApiKeyService } from '../services/api-key-service';
+import { AuthService } from '../services/auth-service';
+import { ChatCompletionOptions, ChatMessage, ChatService } from '../services/chat-service';
+import { DefaultApiKeyManager } from '../utils/default-api-key';
+import { handleError } from '../utils/error-handler';
+import { containsMarkdown, renderMarkdown } from '../utils/markdown-renderer';
 
 /**
  * Register chat commands
  */
 export function registerChatCommands(program: Command): void {
-  const chat = program
-    .command(COMMAND_GROUPS.CHAT)
-    .description('Interact with AI chat models')
+  const chat = program.command(COMMAND_GROUPS.CHAT).description('Interact with AI chat models');
 
   chat
     .command(SUBCOMMANDS.CHAT.RUN)
@@ -44,115 +22,87 @@ export function registerChatCommands(program: Command): void {
     .argument('[message]', 'Message to send directly (skips interactive mode)')
     .option('-m, --model <model>', 'Model to use (default: glm-4.7)')
 
-    .option('-t, --temperature <temp>', 'Temperature (0-1)', parseFloat)
-    .option('--max-tokens <tokens>', 'Maximum tokens to generate', parseInt)
+    .option('-t, --temperature <temp>', 'Temperature (0-1)', Number.parseFloat)
+    .option('--max-tokens <tokens>', 'Maximum tokens to generate', Number.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'
-    )
-    .option(
-      '--no-stream',
-      'Disable streaming (streaming is enabled by default)'
-    )
+    .option('--api-key-id <id>', 'ID of the API key to use from your saved keys')
+    .option('--no-stream', 'Disable streaming (streaming is enabled by default)')
     .action(async (message, options) => {
       try {
-        const chatService = ChatService.getInstance()
+        const chatService = ChatService.getInstance();
 
         // Check if we have an API key or need to get one
-        let apiKey = options.apiKey
-        let apiKeyId = options.apiKeyId
+        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
+        const environmentApiKey = process.env.BERGET_API_KEY;
+        if (environmentApiKey) {
+          console.log(chalk.dim(`Using API key from BERGET_API_KEY environment variable`));
+          apiKey = environmentApiKey;
 
           // Debug the API key (first few characters only)
           if (process.argv.includes('--debug')) {
             console.log(
               chalk.yellow(
-                `DEBUG: API key from env starts with: ${envApiKey.substring(
-                  0,
-                  4
-                )}...`
-              )
-            )
+                `DEBUG: API key from env starts with: ${environmentApiKey.slice(0, 4)}...`,
+              ),
+            );
           }
         }
         // If API key is already provided via command line, use it
         else if (options.apiKey) {
-          console.log(chalk.dim(`Using API key from command line argument`))
-          apiKey = options.apiKey
+          console.log(chalk.dim(`Using API key from command line argument`));
+          apiKey = options.apiKey;
         }
         // 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()
+            const defaultApiKeyManager = DefaultApiKeyManager.getInstance();
+            const defaultApiKeyData = defaultApiKeyManager.getDefaultApiKeyData();
 
             if (defaultApiKeyData) {
-              apiKeyId = defaultApiKeyData.id
-              apiKey = defaultApiKeyData.key
+              apiKeyId = defaultApiKeyData.id;
+              apiKey = defaultApiKeyData.key;
 
               if (apiKey) {
-                console.log(
-                  chalk.dim(`Using default API key: ${defaultApiKeyData.name}`)
-                )
+                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.`
-                  )
-                )
+                    `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}`
-                  )
-                )
+                    `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.'))
+              console.log(chalk.yellow('No default API key set.'));
 
               // Try to prompt for a default API key
-              apiKey = await defaultApiKeyManager.promptForDefaultApiKey()
+              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.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>'
-                  )
-                )
+                  chalk.yellow('1. Create an API key with: berget api-keys create --name "My Key"'),
+                );
                 console.log(
-                  chalk.yellow(
-                    '3. Provide an API key with the --api-key option'
-                  )
-                )
-                return
+                  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)))
+              console.log(chalk.yellow('DEBUG: Error checking default API key:'));
+              console.log(chalk.yellow(String(error)));
             }
           }
         }
@@ -160,144 +110,128 @@ export function registerChatCommands(program: Command): void {
         // 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
-            )
+            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}`))
+            if (selectedKey) {
+              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)`
-                  )
+                    `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.`
-                  )
-                )
+                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.')
-                )
+                console.log(chalk.yellow('Using default authentication instead.'));
               }
+            } else {
+              console.log(
+                chalk.yellow(
+                  `API key with ID ${options.apiKeyId} not found. Using default authentication.`,
+                ),
+              );
             }
           } catch (error) {
             // Check if this is an authentication error
-            const errorMessage =
-              error instanceof Error ? error.message : String(error)
+            const errorMessage = error instanceof Error ? error.message : String(error);
             const isAuthError =
               errorMessage.includes('Unauthorized') ||
               errorMessage.includes('Authentication failed') ||
-              errorMessage.includes('AUTH_FAILED')
+              errorMessage.includes('AUTH_FAILED');
 
             if (isAuthError) {
               console.log(
-                chalk.yellow(
-                  'Authentication required. Please run `berget auth login` first.'
-                )
-              )
+                chalk.yellow('Authentication required. Please run `berget auth login` first.'),
+              );
             } else {
-              console.error(chalk.red('Error fetching API key:'))
-              console.error(error)
+              console.error(chalk.red('Error fetching API key:'));
+              console.error(error);
             }
-            console.log(chalk.yellow('Using default authentication instead.'))
+            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`')
-            )
+            AuthService.getInstance();
+          } catch {
+            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
+              chalk.yellow('4. Set a default API key with `berget api-keys set-default <id>`'),
+            );
+            return;
           }
         }
 
         // Prepare messages array
-        const messages: ChatMessage[] = []
+        const messages: ChatMessage[] = [];
 
         // Add system message if provided
         if (options.system) {
           messages.push({
-            role: 'system',
             content: options.system,
-          })
+            role: 'system',
+          });
         }
 
         // Check if input is being piped in
-        let inputMessage = message
-        let stdinContent = ''
+        let inputMessage = message;
+        let stdinContent = '';
 
         if (!process.stdin.isTTY) {
           // Read from stdin (piped input)
-          const chunks = []
+          const chunks = [];
           for await (const chunk of process.stdin) {
-            chunks.push(chunk)
+            chunks.push(chunk);
           }
-          stdinContent = Buffer.concat(chunks).toString('utf8').trim()
+          stdinContent = Buffer.concat(chunks).toString('utf8').trim();
         }
 
         // Combine stdin content with message if both exist
         if (stdinContent && message) {
-          inputMessage = `${stdinContent}\n\n${message}`
+          inputMessage = `${stdinContent}\n\n${message}`;
         } else if (stdinContent && !message) {
-          inputMessage = stdinContent
+          inputMessage = stdinContent;
         }
 
         // If a message is provided (either as argument, from stdin, or both), send it directly and exit
         if (inputMessage) {
           // Add user message
           messages.push({
-            role: 'user',
             content: inputMessage,
-          })
+            role: 'user',
+          });
 
           try {
             // Call the API
             const completionOptions: ChatCompletionOptions = {
-              model: options.model || 'openai/gpt-oss',
-              messages: messages,
-              temperature:
-                options.temperature !== undefined ? options.temperature : 0.7,
               max_tokens: options.maxTokens || 4096,
+              messages: messages,
+              model: options.model || 'openai/gpt-oss',
               stream: options.stream !== false,
-            }
+              temperature: options.temperature === undefined ? 0.7 : options.temperature,
+            };
 
             // Only add apiKey if it actually exists
             if (apiKey) {
-              completionOptions.apiKey = apiKey
+              completionOptions.apiKey = apiKey;
             }
 
             // Add streaming support (now default)
             if (completionOptions.stream) {
-              let assistantResponse = ''
+              let assistantResponse = '';
 
               // Stream the response in real-time
               completionOptions.onChunk = (chunk: any) => {
@@ -307,36 +241,32 @@ export function registerChatCommands(program: Command): void {
                   chunk.choices[0].delta &&
                   chunk.choices[0].delta.content
                 ) {
-                  const content = chunk.choices[0].delta.content
+                  const content = chunk.choices[0].delta.content;
                   try {
-                    process.stdout.write(content)
+                    process.stdout.write(content);
                   } catch (error: any) {
                     // Handle EPIPE errors gracefully (when pipe is closed)
                     if (error.code === 'EPIPE') {
                       // Stop streaming if the pipe is closed
-                      return
+                      return;
                     }
-                    throw error
+                    throw error;
                   }
-                  assistantResponse += content
+                  assistantResponse += content;
                 }
-              }
+              };
 
               try {
-                await chatService.createCompletion(completionOptions)
+                await chatService.createCompletion(completionOptions);
               } catch (streamError) {
-                console.error(chalk.red('\nStreaming error:'), streamError)
+                console.error(chalk.red('\nStreaming error:'), streamError);
 
                 // Fallback to non-streaming if streaming fails
-                console.log(
-                  chalk.yellow('Falling back to non-streaming mode...')
-                )
-                completionOptions.stream = false
-                delete completionOptions.onChunk
+                console.log(chalk.yellow('Falling back to non-streaming mode...'));
+                completionOptions.stream = false;
+                delete completionOptions.onChunk;
 
-                const response = await chatService.createCompletion(
-                  completionOptions
-                )
+                const response = await chatService.createCompletion(completionOptions);
 
                 if (
                   response &&
@@ -344,17 +274,15 @@ export function registerChatCommands(program: Command): void {
                   response.choices[0] &&
                   response.choices[0].message
                 ) {
-                  assistantResponse = response.choices[0].message.content
-                  console.log(assistantResponse)
+                  assistantResponse = response.choices[0].message.content;
+                  console.log(assistantResponse);
                 }
               }
-              console.log() // Add newline at the end
-              return
+              console.log(); // Add newline at the end
+              return;
             }
 
-            const response = await chatService.createCompletion(
-              completionOptions
-            )
+            const response = await chatService.createCompletion(completionOptions);
 
             // Check if response has the expected structure
             if (
@@ -363,32 +291,28 @@ export function registerChatCommands(program: Command): void {
               !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')
+              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
+            const assistantMessage = response.choices[0].message.content;
 
             // Display the response
             if (containsMarkdown(assistantMessage)) {
-              console.log(renderMarkdown(assistantMessage))
+              console.log(renderMarkdown(assistantMessage));
             } else {
-              console.log(assistantMessage)
+              console.log(assistantMessage);
             }
 
-            return
+            return;
           } catch (error) {
-            console.error(chalk.red('Error: Failed to get response'))
+            console.error(chalk.red('Error: Failed to get response'));
             if (error instanceof Error) {
-              console.error(chalk.red(error.message))
+              console.error(chalk.red(error.message));
             }
-            process.exit(1)
+            process.exit(1);
           }
         }
 
@@ -396,47 +320,46 @@ export function registerChatCommands(program: Command): void {
         const rl = readline.createInterface({
           input: process.stdin,
           output: process.stdout,
-        })
+        });
 
-        console.log(chalk.cyan('Chat with Berget AI (type "exit" to quit)'))
-        console.log(chalk.cyan('----------------------------------------'))
+        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
+              console.log(chalk.cyan('Goodbye!'));
+              rl.close();
+              return;
             }
 
             // Add user message
             messages.push({
-              role: 'user',
               content: input,
-            })
+              role: 'user',
+            });
 
             try {
               // Call the API
               const completionOptions: ChatCompletionOptions = {
-                model: options.model || 'openai/gpt-oss',
-                messages: messages,
-                temperature:
-                  options.temperature !== undefined ? options.temperature : 0.7,
                 max_tokens: options.maxTokens || 4096,
+                messages: messages,
+                model: options.model || 'openai/gpt-oss',
                 stream: options.stream !== false,
-              }
+                temperature: options.temperature === undefined ? 0.7 : options.temperature,
+              };
 
               // Only add apiKey if it actually exists
               if (apiKey) {
-                completionOptions.apiKey = apiKey
+                completionOptions.apiKey = apiKey;
               }
 
               // Add streaming support (now default)
               if (completionOptions.stream) {
-                let assistantResponse = ''
-                console.log(chalk.blue('Assistant: '))
+                let assistantResponse = '';
+                console.log(chalk.blue('Assistant: '));
 
                 // Stream the response in real-time
                 completionOptions.onChunk = (chunk: any) => {
@@ -446,36 +369,32 @@ export function registerChatCommands(program: Command): void {
                     chunk.choices[0].delta &&
                     chunk.choices[0].delta.content
                   ) {
-                    const content = chunk.choices[0].delta.content
+                    const content = chunk.choices[0].delta.content;
                     try {
-                      process.stdout.write(content)
+                      process.stdout.write(content);
                     } catch (error: any) {
                       // Handle EPIPE errors gracefully (when pipe is closed)
                       if (error.code === 'EPIPE') {
                         // Stop streaming if the pipe is closed
-                        return
+                        return;
                       }
-                      throw error
+                      throw error;
                     }
-                    assistantResponse += content
+                    assistantResponse += content;
                   }
-                }
+                };
 
                 try {
-                  await chatService.createCompletion(completionOptions)
+                  await chatService.createCompletion(completionOptions);
                 } catch (streamError) {
-                  console.error(chalk.red('\nStreaming error:'), streamError)
+                  console.error(chalk.red('\nStreaming error:'), streamError);
 
                   // Fallback to non-streaming if streaming fails
-                  console.log(
-                    chalk.yellow('Falling back to non-streaming mode...')
-                  )
-                  completionOptions.stream = false
-                  delete completionOptions.onChunk
+                  console.log(chalk.yellow('Falling back to non-streaming mode...'));
+                  completionOptions.stream = false;
+                  delete completionOptions.onChunk;
 
-                  const response = await chatService.createCompletion(
-                    completionOptions
-                  )
+                  const response = await chatService.createCompletion(completionOptions);
 
                   if (
                     response &&
@@ -483,31 +402,29 @@ export function registerChatCommands(program: Command): void {
                     response.choices[0] &&
                     response.choices[0].message
                   ) {
-                    assistantResponse = response.choices[0].message.content
-                    console.log(assistantResponse)
+                    assistantResponse = response.choices[0].message.content;
+                    console.log(assistantResponse);
                   }
                 }
-                console.log('\n')
+                console.log('\n');
 
                 // Add assistant response to messages
                 messages.push({
-                  role: 'assistant',
                   content: assistantResponse,
-                })
+                  role: 'assistant',
+                });
 
                 // Continue the conversation
-                askQuestion()
-                return
+                askQuestion();
+                return;
               }
 
-              const response = await chatService.createCompletion(
-                completionOptions
-              )
+              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)))
+                console.log(chalk.yellow('DEBUG: Full response:'));
+                console.log(chalk.yellow(JSON.stringify(response, null, 2)));
               }
 
               // Check if response has the expected structure
@@ -517,165 +434,158 @@ export function registerChatCommands(program: Command): void {
                 !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')
+                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
+              const assistantMessage = response.choices[0].message.content;
 
               // Add to messages array
               messages.push({
-                role: 'assistant',
                 content: assistantMessage,
-              })
+                role: 'assistant',
+              });
 
               // Display the response
-              console.log(chalk.blue('Assistant: '))
+              console.log(chalk.blue('Assistant: '));
 
               // Check if the response contains markdown and render it if it does
               if (containsMarkdown(assistantMessage)) {
-                console.log(renderMarkdown(assistantMessage))
+                console.log(renderMarkdown(assistantMessage));
               } else {
-                console.log(assistantMessage)
+                console.log(assistantMessage);
               }
 
-              console.log() // Empty line for better readability
+              console.log(); // Empty line for better readability
 
               // Continue the conversation
-              askQuestion()
+              askQuestion();
             } catch (error) {
-              console.error(chalk.red('Error: Failed to get response'))
+              console.error(chalk.red('Error: Failed to get response'));
               if (error instanceof Error) {
-                console.error(chalk.red(error.message))
+                console.error(chalk.red(error.message));
               }
               // Continue despite error
-              askQuestion()
+              askQuestion();
             }
-          })
-        }
+          });
+        };
 
         // Start the conversation
-        askQuestion()
+        askQuestion();
       } catch (error) {
-        handleError('Failed to create chat completion', 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'
-    )
+    .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
+        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()
+          const defaultApiKeyManager = DefaultApiKeyManager.getInstance();
+          const defaultApiKeyData = defaultApiKeyManager.getDefaultApiKeyData();
 
           if (defaultApiKeyData) {
-            apiKeyId = defaultApiKeyData.id
-            console.log(
-              chalk.dim(`Using default API key: ${defaultApiKeyData.name}`)
-            )
+            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
-            )
+            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}`))
+            if (selectedKey) {
+              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)`
-                  )
+                    `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.`
-                  )
-                )
+                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.')
-                )
+                console.log(chalk.yellow('Using default authentication instead.'));
               }
+            } else {
+              console.log(
+                chalk.yellow(
+                  `API key with ID ${options.apiKeyId} not found. Using default authentication.`,
+                ),
+              );
             }
           } catch (error) {
-            console.error(chalk.red('Error fetching API key:'))
-            console.error(error)
-            console.log(chalk.yellow('Using default authentication instead.'))
+            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)
+        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.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(40)) + chalk.dim('CAPABILITIES')
-        )
-        console.log(chalk.dim('─'.repeat(70)))
+        console.log(chalk.bold('Available Chat Models:'));
+        console.log(chalk.dim('─'.repeat(70)));
+        console.log(chalk.dim('MODEL ID'.padEnd(40)) + chalk.dim('CAPABILITIES'));
+        console.log(chalk.dim('─'.repeat(70)));
 
         // Filter to only show active models
-        const activeModels = models.data.filter(
-          (model: any) => model.active === true
-        )
+        const activeModels = models.data.filter((model: any) => model.active === true);
 
         activeModels.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')
+          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');
 
           // Format model ID in Huggingface compatible format (owner/model)
-          const modelId = `${model.owned_by.toLowerCase()}/${model.id}`.padEnd(
-            40
-          )
+          const modelId = `${model.owned_by.toLowerCase()}/${model.id}`.padEnd(40);
 
-          console.log(modelId + capabilities.join(', '))
-        })
+          console.log(modelId + capabilities.join(', '));
+        });
       } catch (error) {
-        handleError('Failed to list chat models', error)
+        handleError('Failed to list chat models', error);
       }
-    })
+    });
+}
+
+/**
+ * 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');
+    });
+  });
 }