cloving 0.3.17 → 0.3.19

package/src/managers/ProxyManager.ts

@@ -0,0 +1,240 @@
+import express, { Request, Response } from 'express'
+import bodyParser from 'body-parser'
+import fs from 'fs'
+import path from 'path'
+
+import ClovingGPT from '../cloving_gpt'
+import ChunkManager from './ChunkManager'
+import { getNearestClovingConfig } from '../utils/config_utils'
+import { getAllFilesInDirectory } from '../utils/prompt_utils'
+import type { ClovingGPTOptions } from '../utils/types'
+
+class ProxyManager {
+  private gpt: ClovingGPT
+  private app: express.Application
+  private contextFiles: Record<string, string> = {}
+  private chunkManager: ChunkManager
+
+  /**
+   * Creates an instance of ProxyManager.
+   * @param {ClovingGPTOptions} options - Configuration options for the ProxyManager.
+   * @description
+   * Initializes the ProxyManager with the given options. It sets up:
+   * - A ClovingGPT instance with silent and stream options enabled
+   * - An Express application with JSON body parsing
+   * - A ChunkManager for handling streaming responses
+   */
+  constructor(private options: ClovingGPTOptions) {
+    this.options.silent = true
+    this.options.stream = true
+    this.gpt = new ClovingGPT(this.options)
+    this.app = express()
+    this.app.use(bodyParser.json())
+    this.chunkManager = new ChunkManager()
+  }
+
+  async initialize() {
+    await this.setupRoutes()
+    await this.loadContextFiles()
+    this.startServer()
+  }
+
+  private async setupRoutes() {
+    this.app.get('/', (_req: Request, res: Response) => {
+      res.json({ message: 'ClovingGPT proxy server running' })
+    })
+
+    this.app.post('/v1/chat/completions', async (req, res, next) => {
+      try {
+        await this.handleChatCompletions(req, res)
+      } catch (error) {
+        next(error)
+      }
+    })
+  }
+
+  private async loadContextFiles() {
+    let files = this.options.files || '.'
+
+    let expandedFiles: string[] = []
+    for (const file of files) {
+      const filePath = path.resolve(file)
+      if (
+        await fs.promises
+          .stat(filePath)
+          .then((stat) => stat.isDirectory())
+          .catch(() => false)
+      ) {
+        const dirFiles = await getAllFilesInDirectory(filePath)
+        expandedFiles = expandedFiles.concat(dirFiles.map((f) => path.relative(process.cwd(), f)))
+      } else {
+        expandedFiles.push(path.relative(process.cwd(), filePath))
+      }
+    }
+    files = expandedFiles
+
+    for (const file of files) {
+      const filePath = path.resolve(file)
+      if (
+        await fs.promises
+          .stat(filePath)
+          .then((stat) => stat.isFile())
+          .catch(() => false)
+      ) {
+        const content = await fs.promises.readFile(filePath, 'utf-8')
+        this.contextFiles[file] = content
+      }
+    }
+  }
+
+  private async handleChatCompletions(req: Request, res: Response) {
+    try {
+      const { messages, stream } = req.body
+
+      if (!Array.isArray(messages)) {
+        return res.status(400).json({ error: 'Invalid request body: messages must be an array' })
+      }
+
+      const content = messages
+        .map((message: any) => {
+          if (typeof message !== 'object' || typeof message.content !== 'string') {
+            throw new Error('Invalid message format')
+          }
+          return message.content
+        })
+        .join('\n\n')
+
+      const contextFileContents = Object.keys(this.contextFiles)
+        .map((file) => `### Contents of ${file}\n\n${this.contextFiles[file]}\n\n`)
+        .join('\n')
+      const prompt = `# Task
+
+${content}
+
+### Description of App
+
+${JSON.stringify(getNearestClovingConfig().config, null, 2)}
+
+${contextFileContents}
+
+# Task
+
+${content}`
+
+      if (stream) {
+        await this.handleStreamResponse(prompt, res)
+      } else {
+        await this.handleNonStreamResponse(prompt, res)
+      }
+    } catch (error) {
+      console.error('Error processing request:', error)
+      if (error instanceof Error && error.message === 'Invalid message format') {
+        res.status(400).json({
+          error: 'Invalid request body: each message must have a content property of type string',
+        })
+      } else {
+        res.status(500).json({ error: 'Internal server error' })
+      }
+    }
+  }
+
+  private async handleStreamResponse(prompt: string, res: Response) {
+    const shortPrompt = prompt.replace('### Task', '').trim().slice(0, 50).replace(/\n/g, ' ')
+    const promptTokens = Math.ceil(prompt.length / 4).toLocaleString()
+    console.log(`> sending ${promptTokens} token prompt:`, shortPrompt)
+    const responseStream = await this.gpt.streamText({ prompt })
+
+    res.setHeader('Content-Type', 'application/json')
+    res.setHeader('Transfer-Encoding', 'chunked')
+
+    let convertedStreams: string[] = []
+    // Add initial stream to indicate the start of the response
+    convertedStreams.push(
+      '{"id":"chatcmpl-9tLvSuRQaYzQIiKRAwI5a7WqdJspq","object":"chat.completion.chunk","created":1722979349,"model":"cloving","system_fingerprint":"fp_3aa7262c27","choices":[{"index":0,"delta":{"role":"assistant","content":"","refusal":null},"logprobs":null,"finish_reason":null}]}',
+    )
+
+    this.chunkManager.on('content', (buffer: string) => {
+      let convertedStream = this.gpt.convertStream(buffer)
+
+      while (convertedStream !== null) {
+        const { output, lastChar } = convertedStream
+        const content = JSON.stringify({
+          id: 'chatcmpl-9tLvSuRQaYzQIiKRAwI5a7WqdJspq',
+          object: 'chat.completion.chunk',
+          created: 1722979350,
+          model: 'cloving',
+          system_fingerprint: 'fp_3aa7262c27',
+          choices: [{ index: 0, delta: { content: output }, logprobs: null, finish_reason: null }],
+        })
+
+        convertedStreams.push(content)
+
+        if (convertedStreams.length >= 2) {
+          const dataToSend = convertedStreams.map((c) => `data: ${c}`).join('\n\n')
+          res.write(`${dataToSend}\n\n`)
+          convertedStreams = []
+        }
+
+        buffer = buffer.slice(lastChar)
+        convertedStream = this.gpt.convertStream(buffer)
+      }
+    })
+
+    responseStream.data.on('data', (chunk: Buffer) => {
+      const chunkString = chunk.toString()
+      this.chunkManager.addChunk(chunkString)
+    })
+
+    responseStream.data.on('end', () => {
+      // Send any remaining converted streams
+      const dataToSend = convertedStreams.map((c) => `data: ${c}`).join('\n\n')
+      res.write(`${dataToSend}\n\ndata: [DONE]\n\n`)
+      res.end()
+    })
+
+    responseStream.data.on('error', (error: Error) => {
+      console.error('Error streaming response:', error)
+      res.status(500).json({ error: 'Internal server error' })
+    })
+  }
+
+  private async handleNonStreamResponse(prompt: string, res: Response) {
+    const content = await this.gpt.generateText({ prompt })
+
+    const response = {
+      id: 'chatcmpl-' + Date.now(),
+      object: 'chat.completion',
+      created: Math.floor(Date.now() / 1000),
+      model: 'cloving',
+      choices: [
+        {
+          index: 0,
+          message: {
+            role: 'assistant',
+            content,
+          },
+          logprobs: null,
+          finish_reason: 'stop',
+        },
+      ],
+      usage: {
+        prompt_tokens: Math.ceil(prompt.length / 4),
+        completion_tokens: Math.ceil(content.length / 4),
+        total_tokens: Math.ceil(prompt.length / 4) + Math.ceil(content.length / 4),
+      },
+      system_fingerprint: 'fp_3cd8b62c3b',
+    }
+
+    res.json(response)
+  }
+
+  private startServer() {
+    const port = parseInt(`${process.env.PORT || this.options.port || 3000}`, 10)
+
+    this.app.listen(port, () => {
+      console.log(`ClovingGPT proxy server running on port ${port}`)
+    })
+  }
+}
+
+export default ProxyManager

package/src/managers/ReviewManager.ts

@@ -0,0 +1,154 @@
+import ncp from 'copy-paste'
+import colors from 'colors'
+import { select } from '@inquirer/prompts'
+import { AxiosError } from 'axios'
+
+import ClovingGPT from '../cloving_gpt'
+import { getGitDiff } from '../utils/git_utils'
+import { generateReviewPrompt } from '../utils/prompt_utils'
+import { getConfig } from '../utils/config_utils'
+import StreamManager from './StreamManager'
+import type { ClovingGPTOptions } from '../utils/types'
+
+class ReviewManager extends StreamManager {
+  constructor(options: ClovingGPTOptions) {
+    super(options)
+    options.silent = getConfig(options).globalSilent || false
+    options.stream = true
+    this.gpt = new ClovingGPT(options)
+  }
+
+  private async getGitDiffPrompt(): Promise<string> {
+    const gitDiff = await getGitDiff()
+    return `${generateReviewPrompt(this.options, this.contextFiles)}
+
+## Diff Content
+${gitDiff}
+
+# Task
+
+${this.options.prompt || 'Please provide a code review.'}`
+  }
+
+  private async handleUserAction(analysis: string) {
+    const extractSection = (section: string): string => {
+      const regex = new RegExp(
+        `## ${section}[\\s\\S]*?(?=\\n## Potential Bugs and Recommended Fixes|$)`,
+        'g',
+      )
+      const match = analysis.match(regex)
+      return match ? match[0].trim() : ''
+    }
+
+    const clipboardOption = await select({
+      message: 'What would you like to copy to the clipboard?',
+      choices: [
+        { name: 'Copy only the Changes Overview', value: 'Changes Overview' },
+        {
+          name: 'Copy only the Potential Bugs and Recommended Fixes',
+          value: 'Potential Bugs and Recommended Fixes',
+        },
+        { name: 'Copy everything', value: 'Everything' },
+        { name: 'Done', value: 'Done' },
+      ],
+    })
+
+    let contentToCopy = ''
+
+    switch (clipboardOption) {
+      case 'Changes Overview':
+        contentToCopy = extractSection('Changes Overview')
+        break
+      case 'Potential Bugs and Recommended Fixes':
+        contentToCopy = extractSection('Potential Bugs and Recommended Fixes')
+        break
+      case 'Everything':
+        contentToCopy = analysis
+        break
+      case 'Done':
+        console.log('No content copied to clipboard.')
+        return
+    }
+
+    if (contentToCopy) {
+      ncp.copy(contentToCopy, (err) => {
+        if (err) {
+          console.error(colors.red('Error: Unable to copy to clipboard.'), err)
+        } else {
+          console.log(colors.green('Selected content copied to clipboard'))
+        }
+      })
+    }
+  }
+
+  public async generateReview(extraPrompt?: string): Promise<void> {
+    try {
+      await this.checkForLatestVersion()
+      await this.loadContextFiles()
+
+      if (this.options.files) {
+        if (this.chatHistory.length === 0) {
+          this.addUserPrompt(`${generateReviewPrompt(this.options, this.contextFiles)}`)
+          this.addAssistantResponse('What would you like to do?')
+        }
+        this.addUserPrompt(
+          `${this.options.prompt || 'Please provide a code review.'}\n\n${extraPrompt || ''}`,
+        )
+      } else {
+        if (this.chatHistory.length === 0) {
+          this.addUserPrompt(await this.getGitDiffPrompt())
+          this.addAssistantResponse('What would you like to do?')
+        }
+        this.addUserPrompt(
+          `${this.options.prompt || 'Please provide a code review.'}\n\n${extraPrompt || ''}`,
+        )
+      }
+
+      const responseStream = await this.gpt.streamText({
+        prompt: this.prompt,
+        messages: this.chatHistory,
+      })
+
+      this.handleResponseStream(responseStream)
+    } catch (error) {
+      this.handleError(error as AxiosError)
+    }
+  }
+
+  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
+  }
+
+  protected async finalizeResponse(): Promise<void> {
+    this.addAssistantResponse(this.responseString)
+    this.isProcessing = false
+
+    await this.handleUserAction(this.responseString)
+  }
+}
+
+export default ReviewManager

package/src/managers/ShellManager.ts

@@ -0,0 +1,172 @@
+import highlight from 'cli-highlight'
+import ncp from 'copy-paste'
+import { execSync } from 'child_process'
+import { select, input } from '@inquirer/prompts'
+
+import ClovingGPT from '../cloving_gpt'
+import { generateShellPrompt } from '../utils/prompt_utils'
+import { extractMarkdown } from '../utils/string_utils'
+import { getConfig } from '../utils/config_utils'
+
+import type { ClovingGPTOptions, ChatMessage } from '../utils/types'
+
+/**
+ * ShellManager class for handling shell script generation and execution.
+ */
+class ShellManager {
+  private gpt: ClovingGPT
+  private chatHistory: ChatMessage[] = []
+
+  /**
+   * Creates an instance of ShellManager.
+   * @param {ClovingGPTOptions} options - The options for ClovingGPT.
+   */
+  constructor(private options: ClovingGPTOptions) {
+    options.silent = getConfig(options).globalSilent || false
+    this.gpt = new ClovingGPT(options)
+  }
+
+  /**
+   * Generates a prompt to explain a shell script.
+   * @param {string} prompt - The original shell script prompt.
+   * @returns {string} The prompt for explaining the shell script.
+   * @private
+   */
+  private generateExplainShellPrompt(prompt: string): string {
+    return `${prompt}
+
+# Task
+
+Please briefly explain how this shell script works.`
+  }
+
+  /**
+   * Generates a shell script based on the given prompt.
+   * @param {string} prompt - The user's prompt for generating a shell script.
+   * @returns {Promise<string>} A promise that resolves to the generated shell script.
+   * @private
+   */
+  private async generateShell(prompt: string): Promise<string> {
+    if (this.chatHistory.length === 0) {
+      const systemPrompt = generateShellPrompt()
+      this.chatHistory.push({ role: 'user', content: systemPrompt })
+      this.chatHistory.push({ role: 'assistant', content: 'What would you like to do?' })
+    }
+    this.chatHistory.push({ role: 'user', content: prompt })
+    return await this.gpt.generateText({ prompt, messages: this.chatHistory })
+  }
+
+  /**
+   * Displays the generated shell script with syntax highlighting.
+   * @param {string} rawShellCommand - The raw shell command to display.
+   * @private
+   */
+  private displayGeneratedShell(rawShellCommand: string) {
+    const generatedShell = extractMarkdown(rawShellCommand)
+    const generatedShellWithoutShebang = generatedShell.replace(/^#!.*?\s/, '')
+    console.log(highlight(generatedShellWithoutShebang))
+  }
+
+  /**
+   * Handles user actions after generating a shell script.
+   * @param {string} response - The generated shell script.
+   * @param {string} prompt - The original user prompt.
+   * @returns {Promise<void>}
+   * @private
+   */
+  private async handleUserAction(response: string, prompt: string): Promise<void> {
+    let { exec } = this.options
+    this.chatHistory.push({ role: 'assistant', content: response })
+
+    const generatedShell = extractMarkdown(response)
+    const generatedShellWithoutShebang = generatedShell.replace(/^#!.*?\s/, '')
+
+    if (exec) {
+      execSync(generatedShellWithoutShebang, { stdio: 'inherit' })
+      return
+    }
+
+    const action = await select({
+      message: 'What would you like to do?',
+      choices: [
+        { name: 'Execute', value: 'execute' },
+        { name: 'Revise', value: 'revise' },
+        { name: 'Explain', value: 'explain' },
+        { name: 'Copy to Clipboard', value: 'copy' },
+        { name: 'Cancel', value: 'cancel' },
+      ],
+    })
+
+    switch (action) {
+      case 'execute':
+        execSync(generatedShellWithoutShebang, { stdio: 'inherit' })
+        break
+      case 'revise':
+        const newPrompt = await input({
+          message: 'How would you like to modify the output:',
+        })
+        const newRawShellCommand = await this.generateShell(newPrompt)
+        this.displayGeneratedShell(newRawShellCommand)
+        await this.handleUserAction(newRawShellCommand, newPrompt)
+        break
+      case 'explain':
+        const explainPrompt = this.generateExplainShellPrompt(generatedShellWithoutShebang)
+        this.chatHistory.push({ role: 'user', content: explainPrompt })
+        const explainShellCommand = await this.gpt.generateText({
+          prompt: explainPrompt,
+          messages: this.chatHistory,
+        })
+        console.log(highlight(explainShellCommand, { language: 'markdown' }))
+        break
+      case 'copy':
+        ncp.copy(generatedShellWithoutShebang, (err) => {
+          if (err) {
+            console.error('Error: Unable to copy to clipboard.', err)
+          } else {
+            console.log('Script copied to clipboard.')
+          }
+        })
+        break
+      case 'cancel':
+        console.log('Operation cancelled.')
+        break
+    }
+  }
+
+  /**
+   * Generates a shell script based on user input and handles subsequent user actions.
+   *
+   * This method is the main entry point for generating and interacting with shell scripts.
+   * It performs the following steps:
+   * 1. Obtains a user prompt (either from options or by asking the user).
+   * 2. Generates a shell script based on the prompt.
+   * 3. Displays the generated script with syntax highlighting.
+   * 4. Handles user actions (execute, revise, explain, copy, or cancel) for the generated script.
+   *
+   * @returns {Promise<void>} A promise that resolves when the generation and handling process is complete.
+   * @throws {Error} If there's an issue during the shell script generation process.
+   * @public
+   *
+   * @example
+   * const shellManager = new ShellManager(options);
+   * await shellManager.generateAndHandleShell();
+   */
+  public async generateAndHandleShell(): Promise<void> {
+    let { prompt: userPrompt } = this.options
+    try {
+      if (!userPrompt) {
+        userPrompt = await input({
+          message: 'What would you like to do: ',
+        })
+      }
+
+      const rawShellCommand = await this.generateShell(userPrompt)
+      this.displayGeneratedShell(rawShellCommand)
+      await this.handleUserAction(rawShellCommand, userPrompt)
+    } catch (error) {
+      console.error('Could not generate shell script', error)
+    }
+  }
+}
+
+export default ShellManager