cloving 0.3.19 → 1.0.1

package/src/managers/ProxyManager.ts

@@ -1,240 +0,0 @@
-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

@@ -1,154 +0,0 @@
-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

@@ -1,172 +0,0 @@
-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