cloving 0.3.17 → 0.3.19

package/src/managers/ChatManager.ts

@@ -0,0 +1,755 @@
+import ncp from 'copy-paste'
+import colors from 'colors'
+import highlight from 'cli-highlight'
+import readline from 'readline'
+import { execSync } from 'child_process'
+import type { AxiosError } from 'axios'
+
+import CommitManager from './CommitManager'
+import ReviewManager from './ReviewManager'
+import {
+  extractCurrentNewBlocks,
+  applyAndSaveCurrentNewBlocks,
+  checkBlocksApplicability,
+} from '../utils/string_utils'
+import { getConfig } from '../utils/config_utils'
+import { addFileOrDirectoryToContext } from '../utils/prompt_utils'
+import { CODEGEN_COULDNT_APPLY } from '../utils/prompts'
+import type { ClovingGPTOptions } from '../utils/types'
+import StreamManager from './StreamManager'
+
+const specialCommands = [
+  'save',
+  'commit',
+  'copy',
+  'review',
+  'add <file-path>',
+  'find <file-name>',
+  'rm <pattern>',
+  'ls <pattern>',
+  'git <command>',
+  'help',
+  'exit',
+]
+
+class ChatManager extends StreamManager {
+  private commandHistory: string[] = []
+  private historyIndex: number = -1
+  private multilineInput: string = ''
+  private isMultilineMode: boolean = false
+  private isSilent = false
+  private rl: readline.Interface
+
+  /**
+   * Creates an instance of ChatManager.
+   * @param {ClovingGPTOptions} options - Configuration options for the ChatManager.
+   */
+  constructor(options: ClovingGPTOptions) {
+    super(options)
+    this.isSilent = options.silent || getConfig(options).globalSilent || false
+    options.stream = true
+    options.silent = true
+    this.rl = readline.createInterface({
+      input: process.stdin,
+      output: process.stdout,
+      prompt: colors.green.bold('cloving> '),
+      historySize: 1000,
+    })
+  }
+
+  /**
+   * Initializes the ChatManager by loading context files, displaying a welcome message,
+   * and setting up event listeners.
+   * @returns {Promise<void>}
+   */
+  async initialize(): Promise<void> {
+    await this.checkForLatestVersion()
+    await this.loadContextFiles()
+    console.log(`\n🍀 🍀 🍀 ${colors.bold('Welcome to Cloving REPL')} 🍀 🍀 🍀\n`)
+    this.displayAvailableCommands()
+    console.log('\nWhat would you like to do?')
+    this.setupReadline()
+  }
+
+  private displayAvailableCommands(): void {
+    console.log(
+      `Type a freeform request or question to interact with your Cloving AI pair programmer.\n`,
+    )
+    console.log('Available special commands:')
+    console.log(
+      ` - ${colors.yellow(colors.bold('save'))}             Save all the changes from the last response to files`,
+    )
+    console.log(
+      ` - ${colors.yellow(colors.bold('commit'))}           Commit the changes to git with an AI-generated message that you can edit`,
+    )
+    console.log(
+      ` - ${colors.yellow(colors.bold('copy'))}             Copy the last response to clipboard`,
+    )
+    console.log(` - ${colors.yellow(colors.bold('review'))}           Start a code review`)
+    console.log(
+      ` - ${colors.yellow(colors.bold('find <file-name>'))} Find and add files matching the name to the chat context (supports * for glob matching)`,
+    )
+    console.log(
+      ` - ${colors.yellow(colors.bold('add <file-path>'))}  Add a file to the chat context (supports * for glob matching)`,
+    )
+    console.log(
+      ` - ${colors.yellow(colors.bold('rm <pattern>'))}     Remove files from the chat context (supports * for glob matching)`,
+    )
+    console.log(
+      ` - ${colors.yellow(colors.bold('ls <pattern>'))}     List files in the chat context (supports * for glob matching)`,
+    )
+    console.log(` - ${colors.yellow(colors.bold('git <command>'))}    Run a git command`)
+    console.log(` - ${colors.yellow(colors.bold('help'))}             Display this help message`)
+    console.log(` - ${colors.yellow(colors.bold('exit'))}             Quit this session`)
+  }
+
+  /**
+   * Sets up readline and event listeners for the readline interface and process input.
+   * @private
+   */
+  private setupReadline(): void {
+    this.rl.prompt()
+    this.rl.on('line', this.handleLine.bind(this))
+    this.rl.on('close', this.handleClose.bind(this))
+    process.stdin.on('keypress', this.handleKeypress.bind(this))
+  }
+
+  /**
+   * Handles each line of input from the user.
+   * @private
+   * @param {string} line - The input line from the user.
+   * @returns {Promise<void>}
+   */
+  private async handleLine(line: string): Promise<void> {
+    if (this.isProcessing) {
+      return
+    }
+
+    const trimmedLine = line.trim()
+
+    if (this.isPastedCode(trimmedLine)) {
+      this.multilineInput = trimmedLine
+      this.isMultilineMode = true
+      await this.handleCommand(this.multilineInput)
+      this.multilineInput = ''
+      this.isMultilineMode = false
+      return
+    }
+
+    if (this.handleMultilineInput(trimmedLine)) {
+      return
+    }
+
+    if (trimmedLine === '') {
+      this.displayPrompt()
+      return
+    }
+
+    this.updateCommandHistory(trimmedLine)
+
+    if (this.handleExitCommand(trimmedLine)) {
+      return
+    }
+
+    await this.handleCommand(trimmedLine)
+  }
+
+  private handleMultilineInput(line: string): boolean {
+    if (this.isMultilineMode) {
+      if (line === '```') {
+        this.isMultilineMode = false
+        this.handleCommand(this.multilineInput)
+        this.multilineInput = ''
+      } else {
+        this.multilineInput += line + '\n'
+        this.rl.prompt()
+      }
+      return true
+    } else if (line === '```') {
+      this.isMultilineMode = true
+      this.multilineInput = ''
+      console.log('Entering multiline mode. Type ``` on a new line to end.\n')
+      this.rl.prompt()
+      return true
+    }
+    return false
+  }
+
+  private isPastedCode(line: string): boolean {
+    // Check if the line contains multiple lines (indicating a paste)
+    return line.includes('\n') || line.length > 100
+  }
+
+  private handleExitCommand(command: string): boolean {
+    if (command.toLowerCase() === 'exit') {
+      this.rl.close()
+      return true
+    }
+    return false
+  }
+
+  private updateCommandHistory(command: string) {
+    if (this.commandHistory[0] !== command) {
+      this.commandHistory.unshift(command)
+      if (this.commandHistory.length > 1000) {
+        this.commandHistory.pop()
+      }
+    }
+    this.historyIndex = -1
+  }
+
+  /**
+   * Handles various commands entered by the user.
+   * This function acts as a command router, delegating to specific handlers based on the input.
+   *
+   * @private
+   * @param {string} command - The command entered by the user.
+   * @returns {Promise<void>}
+   *
+   * @description
+   * Supported commands:
+   * - 'copy': Copies the last response to clipboard.
+   * - 'save': Saves changes to files.
+   * - 'commit': Commits changes to git with an AI-generated message.
+   * - 'ls': Lists files in the context (equivalent to 'ls *').
+   * - 'rm': Removes all files from the context (equivalent to 'rm *').
+   * - 'review': Starts a code review.
+   * - 'add <file-path>': Adds a file to the context.
+   * - 'rm <pattern>': Removes files matching the pattern from the context.
+   * - 'ls <pattern>': Lists files in the context matching the pattern.
+   * - 'git <command>': Executes a git command.
+   * - Any other input is processed as a user query to the AI.
+   */
+  private async handleCommand(command: string): Promise<void> {
+    // Check if the command is a single character and map it to the first matching special command
+    if (command.length === 1) {
+      const matchingCommand = specialCommands.find((cmd) => cmd.startsWith(command))
+      if (matchingCommand) {
+        command = matchingCommand.split(' ')[0] // Use only the command part without arguments
+      } else {
+        console.log(`No matching command found for '${command}'. Processing as user input.`)
+        await this.processUserInput(command)
+        return
+      }
+    }
+
+    switch (command) {
+      case 'help':
+        this.displayHelp()
+        break
+      case 'copy':
+        await this.handleCopy()
+        break
+      case 'save':
+        await this.handleSave()
+        break
+      case 'commit':
+        await this.handleCommit()
+        break
+      case 'ls':
+        this.handleList('ls *')
+        break
+      case 'rm':
+        await this.handleRemove('rm *')
+        break
+      case 'review':
+        await this.handleReview()
+        break
+      default:
+        if (this.isAddCommand(command)) {
+          await this.handleAdd(command)
+        } else if (this.isFindCommand(command)) {
+          await this.handleFind(command)
+        } else if (this.isRemoveCommand(command)) {
+          await this.handleRemove(command)
+        } else if (this.isListCommand(command)) {
+          this.handleList(command)
+        } else if (this.isGitCommand(command)) {
+          this.executeGitCommand(command)
+        } else {
+          await this.processUserInput(command)
+        }
+    }
+  }
+
+  private isFindCommand(command: string): boolean {
+    const parts = command.trim().split(/\s+/)
+    return parts.length === 2 && parts[0] === 'find'
+  }
+
+  private async handleFind(command: string) {
+    const fileName = command.slice(5).trim()
+
+    if (fileName) {
+      try {
+        const foundFiles = await this.findFiles(fileName)
+        if (foundFiles.length === 0) {
+          console.log(`No files found matching ${colors.bold(colors.red(fileName))}.`)
+        } else {
+          for (const filePath of foundFiles) {
+            this.contextFiles = await addFileOrDirectoryToContext(
+              filePath,
+              this.contextFiles,
+              this.options,
+            )
+            const content = this.contextFiles[filePath]
+            const tokenEstimate = this.estimateTokens(content)
+            console.log(
+              `\nAdded ${colors.bold(colors.green(filePath))} to this chat session's context (${colors.yellow(`~${tokenEstimate.toLocaleString()} tokens`)})`,
+            )
+          }
+          const totalTokens = this.calculateTotalTokens()
+          console.log(
+            colors.yellow(`\n📊 Total tokens in context now: ${totalTokens.toLocaleString()}\n`),
+          )
+        }
+      } catch (error) {
+        console.error(
+          `Failed to find and add files matching ${colors.bold(colors.red(fileName))}:`,
+          error,
+        )
+      }
+    } else {
+      console.log('No file name provided.')
+    }
+
+    this.rl.prompt()
+  }
+
+  private async findFiles(fileName: string): Promise<string[]> {
+    const { exec } = require('child_process')
+    return new Promise((resolve, reject) => {
+      exec(`find . -name "${fileName}"`, (error: Error | null, stdout: string) => {
+        if (error) {
+          return reject(error)
+        }
+        const files = stdout
+          .split('\n')
+          .filter((filePath) => filePath.trim() !== '')
+          .map((filePath) => (filePath.startsWith('./') ? filePath.slice(2) : filePath))
+        resolve(files)
+      })
+    })
+  }
+
+  private displayHelp(): void {
+    console.log('')
+    this.displayAvailableCommands()
+    console.log('\nFor any other input, I will process it as a request or question.\n')
+    this.rl.prompt()
+  }
+
+  private isAddCommand(command: string): boolean {
+    const parts = command.trim().split(/\s+/)
+    return parts.length === 2 && parts[0] === 'add'
+  }
+
+  private async handleAdd(command: string) {
+    const filePath = command.slice(4).trim()
+
+    if (filePath) {
+      try {
+        this.contextFiles = await addFileOrDirectoryToContext(
+          filePath,
+          this.contextFiles,
+          this.options,
+        )
+        console.log(`\nAdded ${colors.bold(colors.green(filePath))} to this chat session's context`)
+        this.refreshContext()
+      } catch (error) {
+        console.error(
+          `Failed to add ${colors.bold(colors.red(filePath))} to this chat session's context:`,
+          error,
+        )
+      }
+    } else {
+      console.log('No file path provided.')
+    }
+
+    this.rl.prompt()
+  }
+
+  private isRemoveCommand(command: string): boolean {
+    return command.startsWith('rm ')
+  }
+
+  // Function to convert glob-like pattern to a regular expression
+  private globToRegExp(glob: string): RegExp {
+    const escapedGlob = glob.replace(/[-/\\^$+?.()|[\]{}]/g, '\\$&')
+    const regexString = escapedGlob.replace(/\*/g, '.*')
+    return new RegExp(`^${regexString}$`)
+  }
+
+  // Function to filter paths using the pattern
+  private filterPaths(paths: string[], pattern: string): string[] {
+    const regex = this.globToRegExp(pattern)
+    return paths.filter((path) => regex.test(path))
+  }
+
+  private async handleRemove(command: string) {
+    const pattern = command.slice(3).trim()
+
+    if (pattern) {
+      const matchedFiles = this.filterPaths(Object.keys(this.contextFiles), pattern)
+
+      if (matchedFiles.length > 0) {
+        matchedFiles.forEach((filePath) => {
+          delete this.contextFiles[filePath]
+          console.log(
+            `Removed ${colors.bold(colors.green(filePath))} from this chat session's context files`,
+          )
+        })
+      } else {
+        console.log(
+          `No files matching pattern "${colors.bold(pattern)}" found in this chat session's context files, try running ${colors.yellow('ls')} to see the list of files.`,
+        )
+      }
+    } else {
+      console.log('No pattern provided.')
+    }
+
+    this.rl.prompt()
+  }
+
+  private isListCommand(command: string): boolean {
+    return command.startsWith('ls ')
+  }
+
+  private estimateTokens(text: string): number {
+    // A simple estimation: 1 token ≈ 4 characters
+    return Math.ceil(text.length / 4)
+  }
+
+  private handleList(command: string) {
+    const pattern = command.slice(3).trim()
+    const fileNames = Object.keys(this.contextFiles)
+
+    const matchedFiles = pattern ? this.filterPaths(fileNames, pattern) : fileNames
+
+    if (matchedFiles.length > 0) {
+      console.log(`\nFiles in the current chat session context:`)
+      let totalTokens = 0
+      matchedFiles.forEach((fileName) => {
+        const content = this.contextFiles[fileName]
+        const tokenEstimate = this.estimateTokens(content)
+        totalTokens += tokenEstimate
+        console.log(
+          ` - ${colors.bold(colors.green(fileName))} (${colors.yellow(`~${tokenEstimate.toLocaleString()} tokens`)})`,
+        )
+      })
+      console.log(`\nTotal files: ${matchedFiles.length}`)
+      console.log(`Total estimated tokens: ${colors.yellow(totalTokens.toLocaleString())}\n`)
+    } else {
+      console.log('No files currently in context.')
+    }
+    this.rl.prompt()
+  }
+
+  private async handleCopy() {
+    const lastResponse = this.chatHistory.filter((msg) => msg.role === 'assistant').pop()
+    if (lastResponse) {
+      ncp.copy(lastResponse.content, () => {
+        console.info('Last response copied to clipboard.')
+        this.rl.prompt()
+      })
+    } else {
+      console.error('No response to copy.')
+    }
+  }
+
+  private async handleReview() {
+    this.options.stream = false
+    const reviewManager = new ReviewManager(this.options)
+    await reviewManager.generateReview()
+    this.options.stream = true
+    this.rl.prompt()
+  }
+
+  private async handleCommit() {
+    this.options.stream = false
+    const commitManager = new CommitManager(this.options)
+    await commitManager.generateCommit()
+    this.options.stream = true
+    this.rl.prompt()
+  }
+
+  private async handleSave() {
+    const lastResponse = this.chatHistory
+      .slice()
+      .reverse()
+      .find((msg) => msg.role === 'assistant')
+
+    if (lastResponse) {
+      const currentNewBlocks = extractCurrentNewBlocks(lastResponse.content)
+      if (Object.keys(currentNewBlocks).length > 0) {
+        await applyAndSaveCurrentNewBlocks(currentNewBlocks)
+        console.info(`\n${colors.bold('save')} has finished\n`)
+        this.rl.prompt()
+      } else {
+        console.info('No changes found to save in the last response.')
+        this.rl.prompt()
+      }
+    } else {
+      console.error('No response to save files from.')
+      this.rl.prompt()
+    }
+  }
+
+  private isGitCommand(command: string): boolean {
+    return command.split(' ').length <= 3 && command.startsWith('git ')
+  }
+
+  private executeGitCommand(command: string) {
+    try {
+      execSync(command, { stdio: 'inherit' })
+    } catch (error) {
+      console.error('Error running command:', error)
+    }
+    this.rl.prompt()
+  }
+
+  /**
+   * Processes user input by sending it to the AI model and handling the response.
+   *
+   * This method manages the interaction with the AI model by:
+   * 1. Checking if a request is already being processed.
+   * 2. Initializing the chat history and generating a prompt.
+   * 3. Streaming the response from the AI model.
+   * 4. Handling the response stream and updating the chat history.
+   *
+   * @param {string} input - The user's input or request to be processed.
+   * @returns {Promise<void>} - A promise that resolves when the processing is complete.
+   */
+  private async processUserInput(input: string): Promise<void> {
+    if (this.isProcessing) {
+      console.log('Please wait for the current request to complete.')
+      return
+    }
+
+    this.isProcessing = true
+
+    try {
+      await this.refreshContext()
+      this.addUserPrompt(this.generatePrompt(input))
+
+      if (!this.gpt.silent) {
+        const fullPrompt = this.chatHistory
+          .map((m) => {
+            const content = m.content
+              .split('\n')
+              .map((line) => {
+                if (line.startsWith('###')) {
+                  return colors.red.bold(line)
+                } else if (line.startsWith('##')) {
+                  return colors.yellow.bold(line)
+                }
+                return line
+              })
+              .join('\n')
+            return m.role === 'user'
+              ? `${colors.yellow.bold('## User Prompt')}\n\n${content}`
+              : `${colors.green.bold("## 🍀 Cloving's Response 🍀")}\n\n${content}`
+          })
+          .join('\n\n')
+
+        // Review the prompt using the REPL
+        const tokenCount = Math.ceil(fullPrompt.length / 4).toLocaleString()
+        console.log(
+          `${colors.yellow.bold('INFORMATION')} The generated prompt is approximately ${tokenCount} tokens long. Would you like to review the prompt before sending it? ${colors.gray('(Y/n)')}`,
+        )
+
+        const reviewPrompt = await this.askQuestion('cloving> ')
+
+        if (reviewPrompt.startsWith('y') || reviewPrompt === '') {
+          this.reviewPrompt(fullPrompt)
+          console.log(`Do you want to proceed with this prompt? ${colors.gray('(Y/n)')}`)
+
+          const confirmPrompt = await this.askQuestion('cloving> ')
+
+          if (!confirmPrompt.startsWith('y') && confirmPrompt !== '') {
+            console.log('Operation cancelled by user.')
+            this.isProcessing = false
+            this.rl.prompt()
+            return
+          }
+        }
+      }
+
+      const responseStream = await this.gpt.streamText({
+        prompt: this.prompt,
+        messages: this.chatHistory,
+      })
+
+      this.handleResponseStream(responseStream)
+    } catch (err) {
+      this.handleError(err as AxiosError)
+    }
+  }
+
+  private askQuestion(prompt: string): Promise<string> {
+    return new Promise<string>((resolve) => {
+      this.rl.question(colors.green.bold(prompt), (answer) => {
+        resolve(answer.trim().toLowerCase())
+      })
+    })
+  }
+
+  private reviewPrompt(fullPrompt: string) {
+    console.log(colors.gray.bold('\n---------------------- PROMPT START ----------------------\n'))
+    const promptParts = fullPrompt.split('\n```')
+    const highlightedPrompt = promptParts
+      .map((part, index) => (index % 2 === 1 ? highlight(part, { language: 'typescript' }) : part))
+      .join('\n```')
+    console.log(highlightedPrompt)
+    console.log(colors.gray.bold('\n---------------------- PROMPT END ----------------------\n'))
+  }
+
+  protected async finalizeResponse(): Promise<void> {
+    this.addAssistantResponse(this.responseString)
+    this.isProcessing = false
+    process.stdout.write('\b'.repeat(100))
+
+    if (this.responseString !== '') {
+      const currentNewBlocks = extractCurrentNewBlocks(this.responseString)
+      const [canApply, summary] = await checkBlocksApplicability(currentNewBlocks)
+      if (!canApply) {
+        if (this.retryCount < this.maxRetries) {
+          console.log(
+            `\n\n${summary}\n\n${colors.yellow.bold('WARNING')} Some of the provided code blocks could not be automatically applied. Retrying (Attempt ${this.retryCount + 1}/${this.maxRetries})...\n`,
+          )
+
+          this.retryCount++
+          this.processUserInput(`${CODEGEN_COULDNT_APPLY}\n\n${summary}`)
+
+          return
+        } else {
+          console.log(
+            `\n\n${colors.red.bold('ERROR')} Failed to generate a diff that could be cleanly applied after ${this.maxRetries} attempts. Please review the changes manually and try again.\n`,
+          )
+          this.retryCount = 0 // Reset the retry count for future attempts
+        }
+      } else {
+        this.retryCount = 0 // Reset the retry count on successful application
+      }
+    }
+
+    process.stdout.write(`
+
+You can follow up with another request or:
+  - type ${colors.yellow(colors.bold('"save"'))} to save all the changes to files
+  - type ${colors.yellow(colors.bold('"commit"'))} to commit the changes to git with a AI - generated message
+  - type ${colors.yellow(colors.bold('"copy"'))} to copy the last response to clipboard
+  - type ${colors.yellow(colors.bold('"review"'))} to start a code review
+  - type ${colors.yellow(colors.bold('"add <file-path>"'))} to add a file to the chat context
+  - type ${colors.yellow(colors.bold('"rm <pattern>"'))} to remove files from the chat context
+  - type ${colors.yellow(colors.bold('"ls <pattern>"'))} to list files in the chat context
+  - type ${colors.yellow(colors.bold('"git <command>"'))} to run a git command
+  - type ${colors.yellow(colors.bold('"exit"'))} to quit this session
+  `)
+    this.rl.prompt()
+  }
+
+  private handleError(error: AxiosError) {
+    let errorMessage = error.message || 'An error occurred.'
+    const errorNumber = error.response?.status || 'unknown'
+
+    switch (errorNumber) {
+      case 400:
+        errorMessage = 'Invalid model or prompt size too large. Try specifying fewer files.'
+        break
+      case 403:
+        errorMessage = 'Inactive subscription or usage limit reached'
+        break
+      case 429:
+        errorMessage = 'Rate limit error'
+        break
+      case 500:
+        errorMessage = 'Internal server error'
+        break
+    }
+
+    const statusMessage = (error.response?.data as any)?.statusMessage
+    console.error(
+      colors.red(
+        `\nError (${errorNumber}) while submitting the prompt to the AI API\n\n${statusMessage}\n`,
+      ),
+    )
+    this.isProcessing = false
+    this.rl.prompt()
+  }
+
+  /**
+   * Generates a comprehensive prompt for the AI model.
+   *
+   * This function constructs a detailed prompt that includes:
+   * 1. The user's current request
+   * 2. Contents of all context files
+   * 3. Full chat history (excluding the current request)
+   * 4. The current request repeated at the end
+   *
+   * @private
+   * @param {string} prompt - The user's current request or input.
+   * @returns {string} A formatted string containing the complete prompt for the AI.
+   *
+   * @description
+   * The generated prompt follows this structure:
+   * 1. "### Request" section with the current prompt
+   * 2. Contents of all context files, each prefixed with its file name
+   * 3. "### Full Chat History Context" section with all previous messages
+   * 4. "### Current Request" section repeating the current prompt
+   *
+   * This structure provides the AI with comprehensive context for generating
+   * accurate and relevant responses.
+   */
+  private generatePrompt(prompt: string): string {
+    return `### Request
+
+${prompt}
+
+### Note
+
+Whenever possible, break up the changes into pieces and make sure every change is in its own *CURRENT/NEW* Blocks.
+Do not allow empty CURRENT blocks in *CURRENT/NEW* Blocks and if you add content to the CURRENT block, you also have to add the same content to the NEW block.`
+  }
+
+  private handleClose() {
+    console.log('Goodbye!')
+    process.exit(0)
+  }
+
+  /**
+   * Displays the prompt in green and bold.
+   * This method should be used instead of directly calling this.rl.prompt().
+   * @private
+   */
+  private displayPrompt() {
+    this.rl.setPrompt(colors.green.bold('cloving> '))
+    this.rl.prompt()
+  }
+
+  private handleKeypress(_: any, key: { name: string }) {
+    if (key && (key.name === 'up' || key.name === 'down')) {
+      if (key.name === 'up' && this.historyIndex < this.commandHistory.length - 1) {
+        this.historyIndex++
+      } else if (key.name === 'down' && this.historyIndex > -1) {
+        this.historyIndex--
+      }
+
+      if (this.historyIndex >= 0) {
+        this.rl.write(null, { ctrl: true, name: 'u' })
+        this.rl.write(this.commandHistory[this.historyIndex])
+      } else if (this.historyIndex === -1) {
+        this.rl.write(null, { ctrl: true, name: 'u' })
+      }
+    } else if (key && key.name === 'tab') {
+      const line = this.rl.line.trim()
+      const hits = specialCommands.filter((command) => command.startsWith(line))
+      if (hits.length > 0) {
+        this.rl.write(null, { ctrl: true, name: 'u' })
+        this.rl.write(hits[0])
+      }
+    }
+  }
+}
+
+export default ChatManager