berget 1.3.0 → 1.4.0

package/src/services/chat-service.ts

@@ -1,4 +1,4 @@
-import { createAuthenticatedClient, API_BASE_URL } from '../client'
+import { createAuthenticatedClient } from '../client'
 import { logger } from '../utils/logger'
 
 export interface ChatMessage {
@@ -323,28 +323,15 @@ export class ChatService {
     options: any,
     headers: Record<string, string>
   ): Promise<any> {
-    logger.debug('Handling streaming response')
-
-    // Create URL with query parameters
-    const url = new URL(`${API_BASE_URL}/v1/chat/completions`)
-
-    // Debug the headers and options
-    logger.debug('Streaming headers:')
-    logger.debug(JSON.stringify(headers, null, 2))
-
-    logger.debug('Streaming options:')
-    logger.debug(
-      JSON.stringify(
-        {
-          ...options,
-          onChunk: options.onChunk ? 'function present' : 'no function',
-        },
-        null,
-        2
-      )
-    )
+    // Use the same base URL as the client
+    const baseUrl = process.env.API_BASE_URL || 'https://api.berget.ai'
+    const url = new URL(`${baseUrl}/v1/chat/completions`)
 
     try {
+      logger.debug(`Making streaming request to: ${url.toString()}`)
+      logger.debug(`Headers:`, JSON.stringify(headers, null, 2))
+      logger.debug(`Body:`, JSON.stringify(options, null, 2))
+
       // Make fetch request directly to handle streaming
       const response = await fetch(url.toString(), {
         method: 'POST',
@@ -356,14 +343,17 @@ export class ChatService {
         body: JSON.stringify(options),
       })
 
+      logger.debug(`Response status: ${response.status}`)
+      logger.debug(`Response headers:`, JSON.stringify(Object.fromEntries(response.headers.entries()), null, 2))
+
       if (!response.ok) {
         const errorText = await response.text()
         logger.error(
           `Stream request failed: ${response.status} ${response.statusText}`
         )
-        logger.debug(`Error response: ${errorText}`)
+        logger.error(`Error response: ${errorText}`)
         throw new Error(
-          `Stream request failed: ${response.status} ${response.statusText}`
+          `Stream request failed: ${response.status} ${response.statusText} - ${errorText}`
         )
       }
 

package/src/utils/markdown-renderer.ts

@@ -0,0 +1,68 @@
+import { marked } from 'marked'
+import TerminalRenderer from 'marked-terminal'
+import chalk from 'chalk'
+
+// Configure marked to use the terminal renderer
+marked.setOptions({
+  renderer: new TerminalRenderer({
+    // Customize the rendering options
+    code: chalk.cyan,
+    blockquote: chalk.gray.italic,
+    table: chalk.white,
+    listitem: chalk.yellow,
+    strong: chalk.bold,
+    em: chalk.italic,
+    heading: chalk.bold.blueBright,
+    hr: chalk.gray,
+    link: chalk.blue.underline,
+    // Adjust the width to fit the terminal
+    width: process.stdout.columns || 80,
+    // Customize code block rendering
+    codespan: chalk.cyan
+  })
+})
+
+/**
+ * Render markdown text to terminal-friendly formatted text
+ * @param markdown The markdown text to render
+ * @returns Formatted text for terminal display
+ */
+export function renderMarkdown(markdown: string): string {
+  if (!markdown) return ''
+  
+  try {
+    // Convert markdown to terminal-friendly text
+    return marked(markdown)
+  } catch (error) {
+    // If rendering fails, return the original text
+    console.error(`Error rendering markdown: ${error}`)
+    return markdown
+  }
+}
+
+/**
+ * Check if a string contains markdown formatting
+ * @param text The text to check
+ * @returns True if the text contains markdown formatting
+ */
+export function containsMarkdown(text: string): boolean {
+  if (!text) return false
+  
+  // Check for common markdown patterns
+  const markdownPatterns = [
+    /^#+\s+/m,                // Headers
+    /\*\*.*?\*\*/,            // Bold
+    /\*.*?\*/,                // Italic
+    /`.*?`/,                  // Inline code
+    /```[\s\S]*?```/,         // Code blocks
+    /\[.*?\]\(.*?\)/,         // Links
+    /^\s*[-*+]\s+/m,          // Lists
+    /^\s*\d+\.\s+/m,          // Numbered lists
+    /^\s*>\s+/m,              // Blockquotes
+    /\|.*\|.*\|/,             // Tables
+    /^---+$/m,                // Horizontal rules
+    /^===+$/m                 // Alternative headers
+  ]
+  
+  return markdownPatterns.some(pattern => pattern.test(text))
+}

package/tests/commands/chat.test.ts

@@ -0,0 +1,117 @@
+import { describe, it, expect, vi, beforeEach, afterEach } from 'vitest'
+import { Command } from 'commander'
+import { registerChatCommands } from '../../src/commands/chat'
+import { ChatService } from '../../src/services/chat-service'
+import { DefaultApiKeyManager } from '../../src/utils/default-api-key'
+
+// Mock dependencies
+vi.mock('../../src/services/chat-service')
+vi.mock('../../src/utils/default-api-key')
+vi.mock('readline', () => ({
+  createInterface: vi.fn(() => ({
+    question: vi.fn(),
+    close: vi.fn()
+  }))
+}))
+
+describe('Chat Commands', () => {
+  let program: Command
+  let mockChatService: any
+  let mockDefaultApiKeyManager: any
+
+  beforeEach(() => {
+    program = new Command()
+    
+    // Mock ChatService
+    mockChatService = {
+      createCompletion: vi.fn(),
+      listModels: vi.fn()
+    }
+    vi.mocked(ChatService.getInstance).mockReturnValue(mockChatService)
+    
+    // Mock DefaultApiKeyManager
+    mockDefaultApiKeyManager = {
+      getDefaultApiKeyData: vi.fn(),
+      promptForDefaultApiKey: vi.fn()
+    }
+    vi.mocked(DefaultApiKeyManager.getInstance).mockReturnValue(mockDefaultApiKeyManager)
+    
+    registerChatCommands(program)
+  })
+
+  afterEach(() => {
+    vi.clearAllMocks()
+  })
+
+  describe('chat run command', () => {
+    it('should use openai/gpt-oss as default model', () => {
+      const chatCommand = program.commands.find(cmd => cmd.name() === 'chat')
+      const runCommand = chatCommand?.commands.find(cmd => cmd.name() === 'run')
+      
+      expect(runCommand).toBeDefined()
+      
+      // Check the help text which contains the default model
+      const helpText = runCommand?.helpInformation()
+      expect(helpText).toContain('openai/gpt-oss')
+    })
+
+    it('should have streaming enabled by default', () => {
+      const chatCommand = program.commands.find(cmd => cmd.name() === 'chat')
+      const runCommand = chatCommand?.commands.find(cmd => cmd.name() === 'run')
+      
+      expect(runCommand).toBeDefined()
+      
+      // Check that the option is --no-stream (meaning streaming is default)
+      const streamOption = runCommand?.options.find(opt => opt.long === '--no-stream')
+      expect(streamOption).toBeDefined()
+      expect(streamOption?.description).toContain('Disable streaming')
+    })
+
+    it('should create completion with correct default options', async () => {
+      // Mock API key
+      process.env.BERGET_API_KEY = 'test-key'
+      
+      // Mock successful completion
+      mockChatService.createCompletion.mockResolvedValue({
+        choices: [{
+          message: { content: 'Test response' }
+        }]
+      })
+
+      // This would normally test the actual command execution
+      // but since it involves readline interaction, we just verify
+      // that the service would be called with correct defaults
+      expect(mockChatService.createCompletion).not.toHaveBeenCalled()
+      
+      // Clean up
+      delete process.env.BERGET_API_KEY
+    })
+  })
+
+  describe('chat list command', () => {
+    it('should list available models', async () => {
+      const mockModels = {
+        data: [
+          {
+            id: 'gpt-oss',
+            owned_by: 'openai',
+            active: true,
+            capabilities: {
+              vision: false,
+              function_calling: true,
+              json_mode: true
+            }
+          }
+        ]
+      }
+      
+      mockChatService.listModels.mockResolvedValue(mockModels)
+      
+      const chatCommand = program.commands.find(cmd => cmd.name() === 'chat')
+      const listCommand = chatCommand?.commands.find(cmd => cmd.name() === 'list')
+      
+      expect(listCommand).toBeDefined()
+      expect(listCommand?.description()).toBe('List available chat models')
+    })
+  })
+})

package/vitest.config.ts

@@ -0,0 +1,8 @@
+import { defineConfig } from 'vitest/config'
+
+export default defineConfig({
+  test: {
+    globals: true,
+    environment: 'node',
+  },
+})