cloving 0.3.18 → 0.3.19

package/src/managers/ChunkManager.ts

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

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

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

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

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