cloving 0.3.4 → 0.3.6

package/dist/managers/BlockManager.js

@@ -0,0 +1,121 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const events_1 = require("events");
+// Passes through string chunks, looking for code blocks, when it finds one, it starts buffering until it finds the end of the block
+// Then it emits the code block and clears the buffer and continues
+class BlockManager extends events_1.EventEmitter {
+    constructor() {
+        super(...arguments);
+        this.buffer = '';
+        this.codeBuffer = '';
+        this.isBufferingCode = false;
+        this.isWaitingForContent = false;
+    }
+    // add content to the buffer, watching for code blocks along the way
+    addContent(content) {
+        // when getting ` , just add it to the buffer until we get a char that isn't `
+        if (content.includes('`')) {
+            this.isWaitingForContent = true;
+            this.buffer += content;
+            return;
+        }
+        else if (this.isWaitingForContent) {
+            content = this.buffer + content;
+            this.buffer = '';
+        }
+        const codeBlockMarker = '\n```';
+        let markerIndex = content.indexOf(codeBlockMarker);
+        if (content.startsWith('```'))
+            markerIndex = 0;
+        if (markerIndex !== -1) {
+            if (this.isBufferingCode) {
+                // End of code block
+                this.codeBuffer += content.slice(0, markerIndex + codeBlockMarker.length);
+                const rest = content.slice(markerIndex + codeBlockMarker.length);
+                this.emit('endGeneratingCode');
+                this.emitCodeBlock();
+                this.emit('content', rest);
+            }
+            else {
+                // Start of code block
+                this.emit('startGeneratingCode');
+                this.emitBuffer(content.slice(0, markerIndex));
+                this.codeBuffer = content.slice(markerIndex);
+                this.isBufferingCode = true;
+            }
+        }
+        else {
+            // No code block marker found
+            if (this.isBufferingCode) {
+                this.codeBuffer += content;
+            }
+            else {
+                this.buffer += content;
+            }
+        }
+        if (!this.isBufferingCode && this.buffer) {
+            this.emitBuffer();
+        }
+    }
+    emitBuffer(additionalContent = '') {
+        const contentToEmit = this.buffer + additionalContent;
+        if (contentToEmit) {
+            this.emit('content', contentToEmit);
+            this.clearBuffer();
+        }
+    }
+    emitCodeBlock() {
+        if (this.codeBuffer) {
+            const codeParts = this.parseCodeBuffer();
+            if (codeParts) {
+                const { language, currentStart, newEnd, currentCode, newCode } = codeParts;
+                this.emit('codeBlock', {
+                    language,
+                    currentStart,
+                    newEnd,
+                    currentCode,
+                    newCode,
+                    raw: this.codeBuffer,
+                });
+                this.emit('content', this.buffer);
+                this.clearBuffer();
+            }
+        }
+    }
+    /**
+     * Parses a code buffer into its constituent parts.
+     *
+     * This function takes a code buffer as a string, splits it into lines, and identifies the language,
+     * current start index, divider index, and new end index. It then extracts the current code and new code
+     * from the buffer based on these indices.
+     *
+     * @return {{ language: string, currentStart: string, newEnd: string, current: string, newCode: string, afterCode: string }}
+     *   An object containing the language, current start, new end, current code, and new code.
+     */
+    parseCodeBuffer() {
+        const lines = this.codeBuffer.split('\n');
+        const language = lines[0].trim().slice(3); // Remove '```' from the language line
+        const currentStartIndex = lines.findIndex((line) => line.startsWith('<<<<<<< CURRENT'));
+        const dividerIndex = lines.findIndex((line) => line === '=======');
+        const newEndIndex = lines.findIndex((line) => line.startsWith('>>>>>>> NEW'));
+        if (currentStartIndex === -1 || dividerIndex === -1 || newEndIndex === -1) {
+            return null;
+        }
+        const currentCode = lines.slice(currentStartIndex + 1, dividerIndex).join('\n');
+        const newCode = lines.slice(dividerIndex + 1, newEndIndex).join('\n');
+        return {
+            language,
+            currentStart: lines[currentStartIndex],
+            newEnd: lines[newEndIndex],
+            currentCode,
+            newCode,
+        };
+    }
+    clearBuffer() {
+        this.buffer = '';
+        this.codeBuffer = '';
+        this.isBufferingCode = false;
+        this.isWaitingForContent = false;
+    }
+}
+exports.default = BlockManager;

package/dist/managers/ChatManager.js

@@ -9,13 +9,16 @@ const child_process_1 = require("child_process");
 const colors_1 = __importDefault(require("colors"));
 const axios_1 = __importDefault(require("axios"));
 const cli_highlight_1 = __importDefault(require("cli-highlight"));
+const fs_1 = __importDefault(require("fs"));
+const path_1 = __importDefault(require("path"));
 const CommitManager_1 = __importDefault(require("./CommitManager"));
 const ChunkManager_1 = __importDefault(require("./ChunkManager"));
+const BlockManager_1 = __importDefault(require("./BlockManager"));
 const ReviewManager_1 = __importDefault(require("./ReviewManager"));
 const cloving_gpt_1 = __importDefault(require("../cloving_gpt"));
 const string_utils_1 = require("../utils/string_utils");
 const config_utils_1 = require("../utils/config_utils");
-const command_utils_1 = require("../utils/command_utils");
+const prompt_utils_1 = require("../utils/prompt_utils");
 const specialCommands = [
     'save',
     'commit',
@@ -27,7 +30,7 @@ const specialCommands = [
     'ls <pattern>',
     'git <command>',
     'help',
-    'exit'
+    'exit',
 ];
 class ChatManager {
     /**
@@ -56,6 +59,7 @@ class ChatManager {
             historySize: 1000,
         });
         this.chunkManager = new ChunkManager_1.default();
+        this.blockManager = new BlockManager_1.default();
     }
     /**
      * Initializes the ChatManager by loading context files, displaying a welcome message,
@@ -87,16 +91,16 @@ class ChatManager {
         console.log(` - ${colors_1.default.yellow(colors_1.default.bold('exit'))}             Quit this session`);
     }
     /**
-    * Checks for the latest version of the app from GitHub and compares it with the current version.
-    * If a new version is available, it notifies the user.
-    * @private
-    * @returns {Promise<void>}
-    */
+     * Checks for the latest version of the app from GitHub and compares it with the current version.
+     * If a new version is available, it notifies the user.
+     * @private
+     * @returns {Promise<void>}
+     */
     async checkForLatestVersion() {
         try {
             const response = await axios_1.default.get('https://api.github.com/repos/cloving-ai/cloving-cli/releases/latest');
             const latestVersion = response.data.tag_name;
-            const currentVersion = `v${(0, command_utils_1.getPackageVersion)()}`;
+            const currentVersion = `v${(0, prompt_utils_1.getPackageVersion)()}`;
             if (latestVersion !== currentVersion) {
                 console.log(colors_1.default.bgWhite.black(`\n 🚀 A new version of Cloving is available: ${latestVersion}    `));
                 console.log(colors_1.default.bgWhite.black(`    You are currently using version: ${currentVersion}          `));
@@ -123,9 +127,9 @@ class ChatManager {
      */
     async loadContextFiles() {
         const config = (0, config_utils_1.getClovingConfig)();
-        const primaryLanguage = config.languages.find(lang => lang.primary);
+        const primaryLanguage = config.languages.find((lang) => lang.primary);
         const defaultDirectory = primaryLanguage ? primaryLanguage.directory : '.';
-        const testingDirectories = config.testingFrameworks?.map(framework => framework.directory) || [];
+        const testingDirectories = config.testingFrameworks?.map((framework) => framework.directory) || [];
         const testingDirectory = testingDirectories[0];
         let files = this.options.files || [defaultDirectory, testingDirectory].filter(Boolean);
         if (files.length > 0) {
@@ -136,7 +140,7 @@ class ChatManager {
             if (!file)
                 continue;
             const previousCount = Object.keys(this.contextFiles).length;
-            this.contextFiles = await (0, command_utils_1.addFileOrDirectoryToContext)(file, this.contextFiles, this.options);
+            this.contextFiles = await (0, prompt_utils_1.addFileOrDirectoryToContext)(file, this.contextFiles, this.options);
             const newCount = Object.keys(this.contextFiles).length;
             const addedCount = newCount - previousCount;
             const totalTokens = this.calculateTotalTokens();
@@ -235,6 +239,13 @@ class ChatManager {
      * - Any other input is processed as a user query to the AI.
      */
     async handleCommand(command) {
+        // 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
+            }
+        }
         switch (command) {
             case 'help':
                 this.displayHelp();
@@ -249,10 +260,10 @@ class ChatManager {
                 await this.handleCommit();
                 break;
             case 'ls':
-                this.handleList("ls *");
+                this.handleList('ls *');
                 break;
             case 'rm':
-                await this.handleRemove("rm *");
+                await this.handleRemove('rm *');
                 break;
             case 'review':
                 await this.handleReview();
@@ -292,7 +303,7 @@ class ChatManager {
                 }
                 else {
                     for (const filePath of foundFiles) {
-                        this.contextFiles = await (0, command_utils_1.addFileOrDirectoryToContext)(filePath, this.contextFiles, this.options);
+                        this.contextFiles = await (0, prompt_utils_1.addFileOrDirectoryToContext)(filePath, this.contextFiles, this.options);
                         const content = this.contextFiles[filePath];
                         const tokenEstimate = this.estimateTokens(content);
                         console.log(`\nAdded ${colors_1.default.bold(colors_1.default.green(filePath))} to this chat session's context (${colors_1.default.yellow(`~${tokenEstimate.toLocaleString()} tokens`)})`);
@@ -317,8 +328,10 @@ class ChatManager {
                 if (error) {
                     return reject(error);
                 }
-                const files = stdout.split('\n').filter((filePath) => filePath.trim() !== '')
-                    .map((filePath) => filePath.startsWith('./') ? filePath.slice(2) : filePath);
+                const files = stdout
+                    .split('\n')
+                    .filter((filePath) => filePath.trim() !== '')
+                    .map((filePath) => (filePath.startsWith('./') ? filePath.slice(2) : filePath));
                 resolve(files);
             });
         });
@@ -337,7 +350,7 @@ class ChatManager {
         const filePath = command.slice(4).trim();
         if (filePath) {
             try {
-                this.contextFiles = await (0, command_utils_1.addFileOrDirectoryToContext)(filePath, this.contextFiles, this.options);
+                this.contextFiles = await (0, prompt_utils_1.addFileOrDirectoryToContext)(filePath, this.contextFiles, this.options);
                 console.log(`\nAdded ${colors_1.default.bold(colors_1.default.green(filePath))} to this chat session's context`);
                 this.refreshContext();
             }
@@ -350,11 +363,23 @@ class ChatManager {
         }
         this.rl.prompt();
     }
-    refreshContext() {
-        const updatedSystemPrompt = (0, command_utils_1.generateCodegenPrompt)(this.contextFiles);
+    async refreshContext() {
+        await this.reloadContextFiles();
+        const updatedSystemPrompt = (0, prompt_utils_1.generateCodegenPrompt)(this.contextFiles);
         this.chatHistory[0] = { role: 'user', content: updatedSystemPrompt };
         this.chatHistory[1] = { role: 'assistant', content: 'What would you like to do?' };
     }
+    async reloadContextFiles() {
+        for (const filePath in this.contextFiles) {
+            try {
+                const content = await fs_1.default.promises.readFile(path_1.default.resolve(filePath), 'utf8');
+                this.contextFiles[filePath] = content;
+            }
+            catch (error) {
+                console.error(`Error reading file ${filePath}:`, error);
+            }
+        }
+    }
     isRemoveCommand(command) {
         return command.startsWith('rm ');
     }
@@ -367,14 +392,14 @@ class ChatManager {
     // Function to filter paths using the pattern
     filterPaths(paths, pattern) {
         const regex = this.globToRegExp(pattern);
-        return paths.filter(path => regex.test(path));
+        return paths.filter((path) => regex.test(path));
     }
     async handleRemove(command) {
         const pattern = command.slice(3).trim();
         if (pattern) {
             const matchedFiles = this.filterPaths(Object.keys(this.contextFiles), pattern);
             if (matchedFiles.length > 0) {
-                matchedFiles.forEach(filePath => {
+                matchedFiles.forEach((filePath) => {
                     delete this.contextFiles[filePath];
                     console.log(`Removed ${colors_1.default.bold(colors_1.default.green(filePath))} from this chat session's context files`);
                 });
@@ -402,7 +427,7 @@ class ChatManager {
         if (matchedFiles.length > 0) {
             console.log(`\nFiles in the current chat session context:`);
             let totalTokens = 0;
-            matchedFiles.forEach(fileName => {
+            matchedFiles.forEach((fileName) => {
                 const content = this.contextFiles[fileName];
                 const tokenEstimate = this.estimateTokens(content);
                 totalTokens += tokenEstimate;
@@ -417,7 +442,7 @@ class ChatManager {
         this.rl.prompt();
     }
     async handleCopy() {
-        const lastResponse = this.chatHistory.filter(msg => msg.role === 'assistant').pop();
+        const lastResponse = this.chatHistory.filter((msg) => msg.role === 'assistant').pop();
         if (lastResponse) {
             copy_paste_1.default.copy(lastResponse.content, () => {
                 console.info('Last response copied to clipboard.');
@@ -443,7 +468,10 @@ class ChatManager {
         this.rl.prompt();
     }
     async handleSave() {
-        const lastResponse = this.chatHistory.slice().reverse().find(msg => msg.role === 'assistant');
+        const lastResponse = this.chatHistory
+            .slice()
+            .reverse()
+            .find((msg) => msg.role === 'assistant');
         if (lastResponse) {
             const currentNewBlocks = (0, string_utils_1.extractCurrentNewBlocks)(lastResponse.content);
             if (Object.keys(currentNewBlocks).length > 0) {
@@ -493,12 +521,15 @@ class ChatManager {
         this.isProcessing = true;
         this.chunkManager = new ChunkManager_1.default();
         try {
-            this.refreshContext();
+            await this.refreshContext();
             this.prompt = this.generatePrompt(input);
             this.addChatHistory(this.prompt);
             if (!this.isSilent) {
-                const fullPrompt = this.chatHistory.map(m => {
-                    const content = m.content.split('\n').map(line => {
+                const fullPrompt = this.chatHistory
+                    .map((m) => {
+                    const content = m.content
+                        .split('\n')
+                        .map((line) => {
                         if (line.startsWith('###')) {
                             return colors_1.default.red.bold(line);
                         }
@@ -506,21 +537,27 @@ class ChatManager {
                             return colors_1.default.yellow.bold(line);
                         }
                         return line;
-                    }).join('\n');
-                    return m.role === 'user' ? `${colors_1.default.yellow.bold('## User Prompt')}\n\n${content}` : `${colors_1.default.green.bold('## 🍀 Cloving\'s Response 🍀')}\n\n${content}`;
-                }).join('\n\n');
+                    })
+                        .join('\n');
+                    return m.role === 'user'
+                        ? `${colors_1.default.yellow.bold('## User Prompt')}\n\n${content}`
+                        : `${colors_1.default.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(`The generated prompt is approximately ${tokenCount} tokens long. Would you like to review the prompt before sending it? ${colors_1.default.gray('(Y/n)')}`);
+                console.log(`${colors_1.default.yellow.bold('INFORMATION')} The generated prompt is approximately ${tokenCount} tokens long. Would you like to review the prompt before sending it? ${colors_1.default.gray('(Y/n)')}`);
                 const reviewPrompt = await new Promise((resolve) => {
                     this.rl.question(colors_1.default.green.bold('cloving> '), (answer) => {
                         resolve(answer.trim().toLowerCase());
                     });
                 });
-                if (reviewPrompt === 'y' || reviewPrompt === '') {
+                if (reviewPrompt.startsWith('y') || reviewPrompt === '') {
                     console.log(colors_1.default.gray.bold('\n---------------------- PROMPT START ----------------------\n'));
                     const promptParts = fullPrompt.split('\n```');
-                    const highlightedPrompt = promptParts.map((part, index) => index % 2 === 1 ? (0, cli_highlight_1.default)(part, { language: 'typescript' }) : part).join('\n```');
+                    const highlightedPrompt = promptParts
+                        .map((part, index) => index % 2 === 1 ? (0, cli_highlight_1.default)(part, { language: 'typescript' }) : part)
+                        .join('\n```');
                     console.log(highlightedPrompt);
                     console.log(colors_1.default.gray.bold('\n---------------------- PROMPT END ----------------------\n'));
                     console.log(`Do you want to proceed with this prompt? ${colors_1.default.gray('(Y/n)')}`);
@@ -529,7 +566,7 @@ class ChatManager {
                             resolve(answer.trim().toLowerCase());
                         });
                     });
-                    if (confirmPrompt !== 'y' && confirmPrompt !== '') {
+                    if (!confirmPrompt.startsWith('y') && confirmPrompt !== '') {
                         console.log('Operation cancelled by user.');
                         this.isProcessing = false;
                         this.rl.prompt();
@@ -537,7 +574,10 @@ class ChatManager {
                     }
                 }
             }
-            const responseStream = await this.gpt.streamText({ prompt: this.prompt, messages: this.chatHistory });
+            const responseStream = await this.gpt.streamText({
+                prompt: this.prompt,
+                messages: this.chatHistory,
+            });
             let accumulatedContent = '';
             this.handleResponseStream(responseStream, accumulatedContent);
         }
@@ -548,25 +588,69 @@ class ChatManager {
     addChatHistory(input) {
         this.chatHistory.push({ role: 'user', content: input });
     }
+    /**
+     * Handles the streaming response from the AI model.
+     * This method processes the incoming data chunks, converts them to readable output,
+     * and manages the accumulated content.
+     *
+     * @param responseStream - The stream of response data from the AI model.
+     * @param accumulatedContent - A string to accumulate the complete response content.
+     */
     handleResponseStream(responseStream, accumulatedContent) {
+        this.blockManager.on('content', (content) => {
+            process.stdout.write('\n------ beginning of blockManager content ------\n');
+            process.stdout.write(content);
+            process.stdout.write('\n------ end of blockManager content ------\n');
+            accumulatedContent += content;
+        });
+        this.blockManager.on('codeBlock', (codeBlock) => {
+            process.stdout.write(codeBlock.language);
+            process.stdout.write('\n');
+            process.stdout.write(codeBlock.currentStart);
+            process.stdout.write('\n');
+            process.stdout.write((0, cli_highlight_1.default)(codeBlock.currentCode, { language: codeBlock.language }));
+            process.stdout.write('\n=======\n');
+            process.stdout.write((0, cli_highlight_1.default)(codeBlock.newCode, { language: codeBlock.language }));
+            process.stdout.write('\n');
+            process.stdout.write(codeBlock.newEnd);
+            accumulatedContent += codeBlock.raw;
+        });
+        // Handle content chunks from the ChunkManager
         this.chunkManager.on('content', (buffer) => {
             let convertedStream = this.gpt.convertStream(buffer);
             while (convertedStream !== null) {
                 const { output, lastChar } = convertedStream;
+                process.stdout.write('\n------ beginning of chunk ------\n');
                 process.stdout.write(output);
-                accumulatedContent += output;
+                process.stdout.write(`lastChar: ${lastChar}\n`);
+                process.stdout.write('\n------ end of chunk ------\n');
+                // buffer the output to the BlockManager
+                this.blockManager.addContent(output);
+                // clear the buffer from the ChunkManager
                 this.chunkManager.clearBuffer(lastChar);
+                // Try to convert the rest of the buffer to a string
                 buffer = buffer.slice(lastChar);
                 convertedStream = this.gpt.convertStream(buffer);
             }
         });
+        // Handle incoming data chunks from the response stream
         responseStream.data.on('data', (chunk) => {
+            // Convert the chunk to a string and add it to the ChunkManager
+            if (!chunk)
+                return;
+            // a chunk is a JSON object with different keys depending on the AI service provider
             const chunkString = chunk.toString();
+            process.stdout.write('\n------ beginning of chunk string ------\n');
+            process.stdout.write(chunkString);
+            process.stdout.write('\n------ end of chunk string ------\n');
             this.chunkManager.addChunk(chunkString);
         });
+        // Handle the end of the response stream
         responseStream.data.on('end', () => {
+            // Finalize the response when the stream ends
             this.finalizeResponse(accumulatedContent);
         });
+        // Handle any errors in the response stream
         responseStream.data.on('error', (error) => {
             console.error('Error streaming response:', error);
             this.isProcessing = false;
@@ -574,9 +658,84 @@ class ChatManager {
             this.rl.prompt();
         });
     }
-    finalizeResponse(accumulatedContent) {
+    processOutput(output, accumulatedContent, codeBuffer, isBufferingCode) {
+        const codeBlockMarker = '\n```';
+        let currentIndex = 0;
+        while (currentIndex < output.length) {
+            let markerIndex = output.indexOf(codeBlockMarker, currentIndex);
+            if (output.startsWith('```'))
+                markerIndex = 0;
+            // Check if the code block marker is found
+            if (markerIndex !== -1) {
+                if (isBufferingCode) {
+                    // End of code block
+                    codeBuffer += output.slice(currentIndex, markerIndex + codeBlockMarker.length);
+                    const { language, currentStart, newEnd, current: currentCode, new: newCode } = this.parseCodeBuffer(codeBuffer);
+                    if (language)
+                        process.stdout.write(language);
+                    if (currentStart)
+                        process.stdout.write(currentStart);
+                    if (currentCode)
+                        process.stdout.write((0, cli_highlight_1.default)(currentCode, { language }));
+                    process.stdout.write('=======');
+                    if (newCode)
+                        process.stdout.write((0, cli_highlight_1.default)(newCode, { language }));
+                    if (newEnd)
+                        process.stdout.write(newEnd);
+                    accumulatedContent += codeBuffer;
+                    codeBuffer = '';
+                    isBufferingCode = false;
+                    currentIndex = markerIndex + codeBlockMarker.length;
+                }
+                else {
+                    // Start of code block
+                    process.stdout.write(output.slice(currentIndex, markerIndex + codeBlockMarker.length));
+                    accumulatedContent += output.slice(currentIndex, markerIndex + codeBlockMarker.length);
+                    codeBuffer = '';
+                    isBufferingCode = true;
+                    currentIndex = markerIndex + codeBlockMarker.length;
+                }
+            }
+            else {
+                // No code block marker found
+                if (isBufferingCode) {
+                    // buffering code
+                    codeBuffer += output.slice(currentIndex);
+                }
+                else {
+                    process.stdout.write(output.slice(currentIndex));
+                    accumulatedContent += output.slice(currentIndex);
+                }
+                break;
+            }
+        }
+        return [isBufferingCode, codeBuffer, accumulatedContent];
+    }
+    parseCodeBuffer(codeBuffer) {
+        const lines = codeBuffer.split('\n');
+        const language = lines[0].trim();
+        const currentStartIndex = lines.findIndex(line => line.startsWith('<<<<<<< CURRENT'));
+        const dividerIndex = lines.findIndex(line => line === '=======');
+        const newEndIndex = lines.findIndex(line => line.startsWith('>>>>>>> NEW'));
+        const current = lines.slice(currentStartIndex + 1, dividerIndex).join('\n');
+        const newCode = lines.slice(dividerIndex + 1, newEndIndex).join('\n');
+        return { language, currentStart: lines[currentStartIndex], newEnd: lines[newEndIndex], current, new: newCode };
+    }
+    async finalizeResponse(accumulatedContent) {
         this.chatHistory.push({ role: 'assistant', content: accumulatedContent.trim() });
         this.isProcessing = false;
+        if (accumulatedContent) {
+            const currentNewBlocks = (0, string_utils_1.extractCurrentNewBlocks)(accumulatedContent);
+            const [canApply, summary] = await (0, string_utils_1.checkBlocksApplicability)(currentNewBlocks);
+            if (!canApply) {
+                console.log(`\n\n${summary}\n\n${colors_1.default.yellow.bold('WARNING')} Some of the provided code blocks could not be automatically applied, prompting the AI to try again with more detail.\n`);
+                this.processUserInput(`Some of the provided code blocks could not be applied,
+please match the existing code with a few more lines of context and make sure it is a character for character exact match.
+
+${summary}`);
+                return;
+            }
+        }
         process.stdout.write(`
 
 You can follow up with another request or:
@@ -598,20 +757,21 @@ You can follow up with another request or:
         const errorNumber = error.response?.status || 'unknown';
         switch (errorNumber) {
             case 400:
-                errorMessage = "Invalid model or prompt size too large. Try specifying fewer files.";
+                errorMessage = 'Invalid model or prompt size too large. Try specifying fewer files.';
                 break;
             case 403:
-                errorMessage = "Inactive subscription or usage limit reached";
+                errorMessage = 'Inactive subscription or usage limit reached';
                 break;
             case 429:
-                errorMessage = "Rate limit error";
+                errorMessage = 'Rate limit error';
                 break;
             case 500:
-                errorMessage = "Internal server error";
+                errorMessage = 'Internal server error';
                 break;
         }
         const promptTokens = Math.ceil(this.prompt.length / 4).toLocaleString();
-        console.error(`Error processing a ${promptTokens} token prompt: `, errorMessage, `(${errorNumber}) \n`);
+        const statusMessage = error.response?.data?.statusMessage;
+        console.error(colors_1.default.red(`\nError (${errorNumber}) while submitting the prompt to the AI API\n\n${statusMessage}\n`));
         this.isProcessing = false;
         this.rl.prompt();
     }

package/dist/managers/ChunkManager.js

@@ -1,12 +1,24 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 const events_1 = require("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 events_1.EventEmitter {
     constructor() {
         super(...arguments);
         this.buffer = '';
     }
     addChunk(chunk) {
+        if (!chunk)
+            return;
         this.buffer += chunk;
         this.emit('content', this.buffer);
     }