cloving 0.3.19 → 0.3.20

package/src/managers/ChunkManager.ts

@@ -1,31 +0,0 @@
-import { EventEmitter } from 'events'
-
-// A chunk is a JSON object with different keys depending on the AI service provider
-//
-// Some providers produce single response in a single chunk
-//
-// Others produce multiple responses in a single chunk
-//
-// This Chunk Manager's job is to buffer the chunks and emit them as a single string
-// without automatically clearing the buffer until clearBuffer is called.
-// That way, the consumer of the chunk can process it and clear the buffer after
-// they have received enough data.
-class ChunkManager extends EventEmitter {
-  private buffer: string = ''
-
-  addChunk(chunk: string | undefined) {
-    if (!chunk) return
-    this.buffer += chunk
-    this.emit('content', this.buffer)
-  }
-
-  clearBuffer(lastChar: number) {
-    this.buffer = this.buffer.substring(lastChar)
-  }
-
-  getBuffer() {
-    return this.buffer
-  }
-}
-
-export default ChunkManager

package/src/managers/CodeManager.ts

@@ -1,226 +0,0 @@
-import { select, input, confirm } from '@inquirer/prompts'
-import { AxiosError } from 'axios'
-import highlight from 'cli-highlight'
-import colors from 'colors'
-
-import ClovingGPT from '../cloving_gpt'
-
-import { getConfig } from '../utils/config_utils'
-import { generateCodegenPrompt, addFileOrDirectoryToContext } from '../utils/prompt_utils'
-import {
-  checkBlocksApplicability,
-  extractCurrentNewBlocks,
-  applyAndSaveCurrentNewBlocks,
-} from '../utils/string_utils'
-import { CODEGEN_COULDNT_APPLY } from '../utils/prompts'
-import type { ClovingGPTOptions } from '../utils/types'
-import StreamManager from './StreamManager'
-
-class CodeManager extends StreamManager {
-  constructor(options: ClovingGPTOptions) {
-    super(options)
-    options.silent = getConfig(options).globalSilent || false
-    options.stream = true
-    this.gpt = new ClovingGPT(options)
-  }
-
-  public async initialize(): Promise<void> {
-    try {
-      if (this.options.files) {
-        for (const file of this.options.files) {
-          this.contextFiles = await addFileOrDirectoryToContext(
-            file,
-            this.contextFiles,
-            this.options,
-          )
-        }
-      } else {
-        let includeMoreFiles = true
-
-        while (includeMoreFiles) {
-          const contextFile = await input({
-            message: `Enter the relative path of a file or directory you would like to include as context (or press enter to continue): `,
-          })
-
-          if (contextFile) {
-            this.contextFiles = await addFileOrDirectoryToContext(
-              contextFile,
-              this.contextFiles,
-              this.options,
-            )
-          } else {
-            includeMoreFiles = false
-          }
-        }
-      }
-
-      if (!this.options.prompt) {
-        const userPrompt = await input({
-          message: 'What would you like the code to do:',
-        })
-        this.options.prompt = userPrompt
-      }
-
-      await this.generateCode(this.options.prompt)
-    } catch (err) {
-      const error = err as AxiosError
-      console.error('Could not generate code', error.message)
-    }
-  }
-
-  public async generateCode(userPrompt: string): Promise<void> {
-    await this.checkForLatestVersion()
-    await this.loadContextFiles()
-
-    if (this.chatHistory.length === 0) {
-      this.addUserPrompt(generateCodegenPrompt(this.contextFiles))
-      this.addAssistantResponse('What would you like to do?')
-    }
-
-    this.addUserPrompt(userPrompt)
-
-    try {
-      const responseStream = await this.gpt.streamText({
-        prompt: userPrompt,
-        messages: this.chatHistory,
-      })
-
-      this.handleResponseStream(responseStream)
-    } catch (err) {
-      const error = err as AxiosError
-      console.error('Error streaming response:', error.message)
-    }
-  }
-
-  private async handleUserAction(response: string): Promise<void> {
-    const currentNewBlocks = extractCurrentNewBlocks(response)
-    const files = Array.from(new Set(currentNewBlocks.map((block) => block.filePath)))
-
-    if (this.options.save) {
-      await applyAndSaveCurrentNewBlocks(currentNewBlocks)
-      return
-    }
-
-    const action = await select({
-      message: 'What would you like to do?',
-      choices: [
-        { name: 'Revise', value: 'revise' },
-        { name: 'Explain', value: 'explain' },
-        { name: 'Save a Source Code File', value: 'save' },
-        { name: 'Save All Source Code Files', value: 'saveAll' },
-        { name: 'Copy Source Code to Clipboard', value: 'copySource' },
-        { name: 'Copy Entire Response to Clipboard', value: 'copyAll' },
-        { name: 'Done', value: 'done' },
-      ],
-    })
-
-    switch (action) {
-      case 'revise':
-        const newPrompt = await input({
-          message: 'How would you like to modify the output:',
-        })
-        let includeMoreFiles = true
-        while (includeMoreFiles) {
-          const contextFile = await input({
-            message:
-              'Enter the relative path of a file or directory you would like to include as context (or press enter to continue):',
-          })
-
-          if (contextFile) {
-            this.contextFiles = await addFileOrDirectoryToContext(
-              contextFile,
-              this.contextFiles,
-              this.options,
-            )
-          } else {
-            includeMoreFiles = false
-          }
-        }
-        await this.generateCode(newPrompt)
-        break
-      case 'explain':
-        const explainPrompt = this.generateExplainCodePrompt(response)
-        this.chatHistory.push({ role: 'user', content: explainPrompt })
-        const explainCodeCommand = await this.gpt.generateText({
-          prompt: explainPrompt,
-          messages: this.chatHistory,
-        })
-        console.log(highlight(explainCodeCommand, { language: 'markdown' }))
-        break
-      case 'save':
-        let saveAnother = true
-        while (saveAnother) {
-          const fileToSave = await select({
-            message: 'Which file do you want to save?',
-            choices: files.map((file) => ({ name: file, value: file })),
-          })
-
-          await applyAndSaveCurrentNewBlocks(
-            currentNewBlocks.filter((block) => block.filePath === fileToSave),
-          )
-
-          const saveMore = await confirm({
-            message: 'Do you want to save another file?',
-            default: true,
-          })
-
-          saveAnother = saveMore
-        }
-        break
-      case 'saveAll':
-        await applyAndSaveCurrentNewBlocks(currentNewBlocks)
-        console.log(colors.green('\nAll files have been saved.'))
-        break
-      case 'done':
-        break
-    }
-  }
-
-  private generateExplainCodePrompt(prompt: string): string {
-    return `${prompt}
-
-# Task
-
-Please briefly explain how the code works in this.`
-  }
-
-  /**
-   * Finalizes the response processing.
-   * This method should be overridden to provide specific finalization behavior.
-   * @protected
-   */
-  protected async finalizeResponse(): Promise<void> {
-    this.addAssistantResponse(this.responseString)
-    this.isProcessing = false
-
-    if (this.responseString !== '') {
-      const currentNewBlocks = extractCurrentNewBlocks(this.responseString)
-      const [canApply, summary] = await checkBlocksApplicability(currentNewBlocks)
-      if (!canApply) {
-        await this.handleUnapplicableBlocks(summary)
-      } else {
-        this.retryCount = 0 // Reset the retry count on successful application
-      }
-    }
-
-    await this.handleUserAction(this.responseString)
-  }
-
-  private async handleUnapplicableBlocks(summary: string): Promise<void> {
-    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++
-      await this.generateCode(`${CODEGEN_COULDNT_APPLY}\n\n${summary}`)
-    } 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
-    }
-  }
-}
-
-export default CodeManager

package/src/managers/CommitManager.ts

@@ -1,71 +0,0 @@
-import fs from 'fs'
-import path from 'path'
-import { execFileSync, execSync } from 'child_process'
-import { extractMarkdown } from '../utils/string_utils'
-import { generateCommitMessagePrompt } from '../utils/git_utils'
-import { getConfig } from '../utils/config_utils'
-import ClovingGPT from '../cloving_gpt'
-import type { ClovingGPTOptions } from '../utils/types'
-import type { AxiosError } from 'axios'
-
-class CommitManager {
-  private gpt: ClovingGPT
-
-  constructor(options: ClovingGPTOptions) {
-    options.silent = getConfig(options).globalSilent || false
-    this.gpt = new ClovingGPT(options)
-  }
-
-  private cleanCommitMessage(message: string): string {
-    // Remove markdown code block formatting if present, including any text before and after
-    const codeBlockRegex = /.*?```.*\n(.*?)\n```.*/m
-    const match = message.match(codeBlockRegex)
-    return match ? match[1].trim() : message.trim()
-  }
-
-  public async generateCommit(): Promise<void> {
-    try {
-      // Get the git diff
-      const diff = execSync('git diff HEAD').toString().trim()
-
-      // Check if the diff is blank
-      if (!diff) {
-        console.error('No changes to commit.')
-        return
-      }
-
-      // Generate the prompt for commit message
-      const prompt = generateCommitMessagePrompt(diff)
-
-      // Instantiate ClovingGPT and get the commit message
-      const rawCommitMessage = await this.gpt.generateText({ prompt })
-
-      // Clean the commit message using extractMarkdown and remove code blocks
-      const commitMessage = this.cleanCommitMessage(extractMarkdown(rawCommitMessage))
-
-      // Write the commit message to a temporary file
-      const tempCommitFilePath = path.join('.git', 'SUGGESTED_COMMIT_EDITMSG')
-      fs.writeFileSync(tempCommitFilePath, commitMessage)
-
-      // Commit the changes using the generated commit message
-      try {
-        execFileSync('git', ['commit', '-a', '--edit', '--file', tempCommitFilePath], {
-          stdio: 'inherit',
-        })
-      } catch (commitError) {
-        // If commit is canceled (non-zero exit), handle it here
-        console.log('Commit was canceled or failed.')
-      }
-
-      // Remove the temporary file using fs
-      fs.unlink(tempCommitFilePath, (err) => {
-        if (err) throw err
-      })
-    } catch (err) {
-      const error = err as AxiosError
-      console.error('Could not generate commit message:', error.message)
-    }
-  }
-}
-
-export default CommitManager

package/src/managers/DocsManager.ts

@@ -1,101 +0,0 @@
-import { confirm } from '@inquirer/prompts'
-import colors from 'colors'
-
-import ClovingGPT from '../cloving_gpt'
-import { getConfig } from '../utils/config_utils'
-import { CODEGEN_COULDNT_APPLY } from '../utils/prompts'
-import { generateDocsPrompt } from '../utils/prompt_utils'
-import {
-  applyAndSaveCurrentNewBlocks,
-  extractCurrentNewBlocks,
-  checkBlocksApplicability,
-} from '../utils/string_utils'
-import type { ClovingGPTOptions } from '../utils/types'
-import StreamManager from './StreamManager'
-
-/**
- * Manages the generation of documentation for specified files.
- */
-class DocsManager extends StreamManager {
-  /**
-   * Creates a new DocumentationManager instance.
-   * @param {ClovingGPTOptions} options - Configuration options for the DocumentationManager.
-   */
-  constructor(options: ClovingGPTOptions) {
-    super(options)
-    options.silent = getConfig(options).globalSilent || false
-    options.stream = true
-    this.gpt = new ClovingGPT(options)
-  }
-
-  /**
-   * Generates documentation for the specified files.
-   * @returns {Promise<void>}
-   */
-  public async generateDocs(extraPrompt?: string): Promise<void> {
-    try {
-      this.isProcessing = true
-      if (this.retryCount === 0) {
-        await this.checkForLatestVersion()
-      }
-      await this.loadContextFiles()
-      this.addUserPrompt(`${generateDocsPrompt(this.contextFiles)}\n\n${extraPrompt || ''}`)
-
-      const responseStream = await this.gpt.streamText({
-        prompt: this.prompt,
-        messages: this.chatHistory,
-      })
-
-      this.handleResponseStream(responseStream)
-    } catch (error) {
-      console.error(colors.red('Error generating documentation:'), error)
-    }
-  }
-
-  /**
-   * Finalizes the response processing.
-   * This method should be overridden to provide specific finalization behavior.
-   * @protected
-   */
-  protected async finalizeResponse(): Promise<void> {
-    this.addAssistantResponse(this.responseString)
-    this.isProcessing = false
-
-    if (this.responseString !== '') {
-      const currentNewBlocks = extractCurrentNewBlocks(this.responseString)
-      const [canApply, summary] = await checkBlocksApplicability(currentNewBlocks)
-      if (canApply && currentNewBlocks.length > 0) {
-        const shouldSave = await confirm({
-          message: '\n\nDo you want to save the generated documentation?',
-          default: true,
-        })
-
-        if (shouldSave) {
-          await applyAndSaveCurrentNewBlocks(currentNewBlocks)
-          console.log(colors.green('\nDocumentation has been saved to the respective files.'))
-        }
-      } else {
-        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.generateDocs(`\n\n${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
-        }
-      }
-    }
-
-    // Reset responseString after processing
-    this.responseString = ''
-  }
-}
-
-export default DocsManager

package/src/managers/InitManager.ts

@@ -1,263 +0,0 @@
-import fs from 'fs'
-import os from 'os'
-import path from 'path'
-import colors from 'colors'
-import ignore from 'ignore'
-import { promises as fsPromises } from 'fs'
-import { confirm } from '@inquirer/prompts'
-
-import ClovingGPT from '../cloving_gpt'
-import { extractJsonMetadata } from '../utils/string_utils'
-import { getConfig } from '../utils/config_utils'
-import {
-  generateFileList,
-  collectSpecialFileContents,
-  checkForSpecialFiles,
-} from '../utils/prompt_utils'
-import { INIT_INSTRUCTIONS } from '../utils/prompts'
-import type { ClovingGPTOptions, ChatMessage } from '../utils/types'
-
-class InitManager {
-  private gpt: ClovingGPT
-  private chatHistory: ChatMessage[] = []
-
-  constructor(private options: ClovingGPTOptions) {
-    this.options.silent = getConfig(this.options).globalSilent || false
-    this.gpt = new ClovingGPT(this.options)
-    this.chatHistory.push({
-      role: 'system',
-      content: INIT_INSTRUCTIONS,
-    })
-  }
-
-  /**
-   * Initializes the InitManager by collecting special file contents, checking for dependencies,
-   * and processing the AI response for the project details.
-   *
-   * @return {Promise<void>} A promise that resolves when the initialization is complete.
-   */
-  public async initialize(): Promise<void> {
-    const specialFileContents = collectSpecialFileContents()
-    const specialFileNames = Object.keys(specialFileContents).map((file) => ' - ' + file)
-
-    this.logInitializationMessage(specialFileNames)
-
-    const config = getConfig(this.options)
-    if (!config || !config?.models) {
-      console.error('No cloving configuration found. Please run `cloving config`')
-      return
-    }
-
-    if (!checkForSpecialFiles()) {
-      console.error(
-        'No dependencies files detected. Please add a dependency file (e.g. package.json, Gemfile, requirements.txt, etc.) to your project and run `cloving init` again.',
-      )
-      return
-    }
-
-    const tempFilePath = path.join(os.tmpdir(), `describe_${Date.now()}.tmp`)
-
-    try {
-      const limitedFileList = await this.getFilteredFileList()
-
-      const projectDetails = {
-        files: limitedFileList,
-        specialFiles: specialFileContents,
-      }
-
-      const [success, errorMessage] = await this.processAIResponse(projectDetails, tempFilePath)
-
-      if (!success) {
-        console.log(errorMessage)
-        return
-      }
-
-      await this.promptUserForReview()
-
-      // Clean up
-      await fsPromises.unlink(tempFilePath)
-    } catch (error) {
-      console.error('Error describing the project:', (error as Error).message)
-    }
-  }
-
-  /**
-   * Checks if a directory exists at the specified path.
-   *
-   * @param {string} directory - The path of the directory to check.
-   * @return {Promise<boolean>} A promise that resolves to true if the directory exists, false otherwise.
-   */
-  private async directoryExists(directory: string): Promise<boolean> {
-    try {
-      const stats = await fsPromises.stat(directory)
-      return stats.isDirectory()
-    } catch (error) {
-      return false
-    }
-  }
-
-  /**
-   * Returns a filtered list of files, excluding those ignored by the .gitignore file.
-   *
-   * @return {string[]} A list of file paths, limited to the first 100 files.
-   */
-  private async getFilteredFileList(): Promise<string[]> {
-    const gitignorePath = path.join(process.cwd(), '.gitignore')
-    const ig = ignore()
-    if (fs.existsSync(gitignorePath)) {
-      const gitignoreContent = fs.readFileSync(gitignorePath, 'utf-8')
-      ig.add(gitignoreContent)
-    }
-
-    const fileList = await generateFileList()
-    const filteredFileList = fileList.filter((file) => {
-      try {
-        return !ig.ignores(file)
-      } catch (error) {
-        return false
-      }
-    })
-
-    return filteredFileList.slice(0, 100)
-  }
-
-  /**
-   * Logs the initialization message based on the special file names and silent mode.
-   *
-   * @param {string[]} specialFileNames - A list of special file names to be analyzed.
-   * @return {void} No return value.
-   */
-  private logInitializationMessage(specialFileNames: string[]): void {
-    if (!this.options.silent) {
-      if (specialFileNames.length > 0) {
-        console.log(`Cloving will analyze the list of files and the contents of the following files:
-
-${specialFileNames.join('\n')}
-
-Cloving will send AI a request to summarize the technologies used in this project.
-
-This will provide better context for future Cloving requests.`)
-      } else {
-        console.log(`
-This script will analyze the list of files in the current directory using GPT to summarize the
-technologies used. This will provide better context for future Cloving requests.
-        `)
-      }
-    }
-  }
-
-  /**
-   * Processes the AI response by generating a prompt, sending it to the AI,
-   * and saving the response to a temporary file and cloving.json.
-   *
-   * @param {any} projectDetails - A JSON object describing the project.
-   * @param {string} tempFilePath - The path to the temporary file.
-   * @param {string} errorMessage - An error message if there was an error.
-   * @return {[boolean, string]} A promise that resolves with an array containing a boolean
-   *                             indicating whether the AI response was successfully processed,
-   *                             and a message explaining any errors.
-   */
-  private async processAIResponse(
-    projectDetails: any,
-    tempFilePath: string,
-    errorMessage: string = '',
-  ): Promise<[boolean, string]> {
-    const prompt =
-      errorMessage !== ''
-        ? errorMessage
-        : `Here is a JSON object describing my project:
-${JSON.stringify(projectDetails, null, 2)}`
-    this.chatHistory.push({ role: 'user', content: prompt })
-    const aiChatResponse = await this.gpt.generateText({ prompt, messages: this.chatHistory })
-    this.chatHistory.push({ role: 'assistant', content: aiChatResponse })
-    let cleanAiChatResponse = extractJsonMetadata(aiChatResponse)
-    const [validSyntax, syntaxErrorMessage] = this.checkClovingJsonSyntax(cleanAiChatResponse)
-
-    if (!validSyntax) {
-      console.log(syntaxErrorMessage)
-      console.log('Retrying...')
-      return this.processAIResponse(projectDetails, tempFilePath, syntaxErrorMessage)
-    } else {
-      await fsPromises.writeFile(tempFilePath, cleanAiChatResponse)
-
-      // Save the AI chat response to cloving.json
-      await fsPromises.writeFile('cloving.json', cleanAiChatResponse)
-      console.log(`Project data saved to ${colors.green.bold('cloving.json')}`)
-      return [true, '']
-    }
-  }
-
-  /**
-   * Checks the syntax of the generated cloving.json file.
-   *
-   * @param {string} cleanAiChatResponse - The cleaned AI chat response.
-   * @return {[boolean, string]} An array where the first element is a boolean indicating
-   *                             whether the syntax was valid, and the second element is a
-   *                             message explaining any errors.
-   */
-  private checkClovingJsonSyntax(cleanAiChatResponse: string): [boolean, string] {
-    try {
-      JSON.parse(cleanAiChatResponse)
-    } catch (error) {
-      return [
-        false,
-        `${colors.red.bold('ERROR:')} parsing cloving.json: ${colors.red.bold((error as Error).message)}`,
-      ]
-    }
-
-    const clovingJson = JSON.parse(cleanAiChatResponse)
-
-    const directoriesToCheck = [
-      ...clovingJson.languages.map((language: any) => ({
-        type: 'Language',
-        name: language.name,
-        directory: language.directory,
-      })),
-      ...clovingJson.frameworks.map((framework: any) => ({
-        type: 'Framework',
-        name: framework.name,
-        directory: framework.directory,
-      })),
-      ...clovingJson.testingFrameworks.map((testingFramework: any) => ({
-        type: 'Testing Framework',
-        name: testingFramework.name,
-        directory: testingFramework.directory,
-      })),
-    ]
-
-    const missingDirectories = directoriesToCheck.filter((item) => !fs.existsSync(item.directory))
-
-    if (missingDirectories.length > 0) {
-      const missingDirMessages = missingDirectories.map(
-        (item) => `${item.type} ${colors.bold(item.name)}: ${colors.red.bold(item.directory)}`,
-      )
-      return [
-        false,
-        `${colors.red.bold('ERROR:')} The following directories were not found:\n${missingDirMessages.join('\n')}`,
-      ]
-    }
-
-    return [true, '']
-  }
-
-  /**
-   * Prompts the user to review the generated data if the `silent` option is not set.
-   * If the user confirms, reads the content of 'cloving.json' and logs it to the console.
-   *
-   * @return {Promise<void>} A promise that resolves when the review is complete.
-   */
-  private async promptUserForReview(): Promise<void> {
-    if (!this.options.silent) {
-      const reviewAnswer = await confirm({
-        message: 'Do you want to review the generated data?',
-        default: true,
-      })
-      if (reviewAnswer) {
-        const clovingJsonContent = await fsPromises.readFile('cloving.json', 'utf-8')
-        console.log(clovingJsonContent)
-      }
-    }
-  }
-}
-
-export default InitManager