cloving 0.3.6 → 0.3.8

package/dist/index.js

@@ -71,6 +71,7 @@ generate
     .command('shell')
     .alias('sh')
     .description('Generate a shell command based on a prompt')
+    .option('-e, --exec', 'Automatically execute the generated shell command')
     .option('-s, --silent', 'Run the command without asking for confirmation of submitting prompts')
     .option('-m, --model <model>', 'Select the model to use (e.g., openai, claude, ollama, ollama:llama3, claude:claude-3-5-sonnet-20240620)')
     .option('-p, --prompt <prompt>', 'Specify the prompt to use')

package/dist/managers/BlockManager.js

@@ -1,6 +1,7 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 const events_1 = require("events");
+const string_utils_1 = require("../utils/string_utils");
 // 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 {
@@ -13,8 +14,7 @@ class BlockManager extends events_1.EventEmitter {
     }
     // 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('`')) {
+        if (content.includes('`') || content.includes('\n')) {
             this.isWaitingForContent = true;
             this.buffer += content;
             return;
@@ -23,13 +23,13 @@ class BlockManager extends events_1.EventEmitter {
             content = this.buffer + content;
             this.buffer = '';
         }
+        this.processCodeBlocks(content);
+    }
+    processCodeBlocks(content) {
         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');
@@ -37,15 +37,13 @@ class BlockManager extends events_1.EventEmitter {
                 this.emit('content', rest);
             }
             else {
-                // Start of code block
-                this.emit('startGeneratingCode');
                 this.emitBuffer(content.slice(0, markerIndex));
                 this.codeBuffer = content.slice(markerIndex);
+                this.emit('startGeneratingCode');
                 this.isBufferingCode = true;
             }
         }
         else {
-            // No code block marker found
             if (this.isBufferingCode) {
                 this.codeBuffer += content;
             }
@@ -65,21 +63,20 @@ class BlockManager extends events_1.EventEmitter {
         }
     }
     emitCodeBlock() {
-        if (this.codeBuffer) {
-            const codeParts = this.parseCodeBuffer();
-            if (codeParts) {
-                const { language, currentStart, newEnd, currentCode, newCode } = codeParts;
+        if (this.codeBuffer.length > 0) {
+            const currentNewBlock = this.parseCodeBuffer();
+            if (currentNewBlock) {
                 this.emit('codeBlock', {
-                    language,
-                    currentStart,
-                    newEnd,
-                    currentCode,
-                    newCode,
+                    currentNewBlock,
                     raw: this.codeBuffer,
                 });
                 this.emit('content', this.buffer);
                 this.clearBuffer();
             }
+            else {
+                this.emit('codeBlock', this.codeBuffer);
+                this.clearBuffer();
+            }
         }
     }
     /**
@@ -89,27 +86,12 @@ class BlockManager extends events_1.EventEmitter {
      * 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 }}
+     * @return {CurrentNewBlock | null}
      *   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,
-        };
+        const results = (0, string_utils_1.extractCurrentNewBlocks)(this.codeBuffer);
+        return results[0];
     }
     clearBuffer() {
         this.buffer = '';

package/dist/managers/ChatManager.js

@@ -48,6 +48,8 @@ class ChatManager {
         this.prompt = '';
         this.isProcessing = false;
         this.isSilent = false;
+        this.retryCount = 0;
+        this.maxRetries = 3;
         this.isSilent = options.silent || false;
         options.stream = true;
         options.silent = true;
@@ -597,22 +599,48 @@ class ChatManager {
      * @param accumulatedContent - A string to accumulate the complete response content.
      */
     handleResponseStream(responseStream, accumulatedContent) {
+        let animationInterval;
+        this.blockManager = new BlockManager_1.default();
+        this.chunkManager = new ChunkManager_1.default();
+        this.blockManager.on('startGeneratingCode', () => {
+            process.stdout.write(colors_1.default.gray.bold('\nGenerating code...  '));
+            let animationIndex = 0;
+            const animationChars = ['/', '|', '\\', '-'];
+            animationInterval = setInterval(() => {
+                process.stdout.write('\b'.repeat(1));
+                process.stdout.write(colors_1.default.gray.bold(animationChars[animationIndex]));
+                animationIndex = (animationIndex + 1) % animationChars.length;
+            }, 100);
+        });
+        this.blockManager.on('endGeneratingCode', () => {
+            clearInterval(animationInterval);
+            process.stdout.write('\b'.repeat(100));
+        });
         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);
+            const { currentNewBlock } = codeBlock;
+            if (currentNewBlock?.currentContent && currentNewBlock?.newContent) {
+                // Current/New format
+                process.stdout.write(colors_1.default.gray.bold(`\`\`\`${currentNewBlock.language}                                       \n`));
+                process.stdout.write(colors_1.default.gray.bold(`<<<<<<< CURRENT ${currentNewBlock.filePath}\n`));
+                process.stdout.write((0, cli_highlight_1.default)(currentNewBlock.currentContent, { language: currentNewBlock.language }));
+                process.stdout.write(colors_1.default.gray.bold('\n=======\n'));
+                process.stdout.write((0, cli_highlight_1.default)(currentNewBlock.newContent, { language: currentNewBlock.language }));
+                process.stdout.write(colors_1.default.gray.bold('\n>>>>>>> NEW\n```'));
+            }
+            else {
+                if (codeBlock.raw) {
+                    // Raw format
+                    process.stdout.write(`                                       \n`);
+                    process.stdout.write((0, cli_highlight_1.default)(codeBlock.raw));
+                }
+                else {
+                    process.stdout.write(`                                       \n`);
+                }
+            }
             accumulatedContent += codeBlock.raw;
         });
         // Handle content chunks from the ChunkManager
@@ -620,10 +648,6 @@ class ChatManager {
             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);
-                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
@@ -640,9 +664,6 @@ class ChatManager {
                 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
@@ -658,69 +679,6 @@ class ChatManager {
             this.rl.prompt();
         });
     }
-    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;
@@ -728,12 +686,23 @@ class ChatManager {
             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,
+                if (this.retryCount < this.maxRetries) {
+                    console.log(`\n\n${summary}\n\n${colors_1.default.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.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.
+Never use "rest of the existing code" or "rest of the code" in your response, instead break the code block into smaller blocks.
 
 ${summary}`);
-                return;
+                    return;
+                }
+                else {
+                    console.log(`\n\n${colors_1.default.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
+                }
+            }
+            else {
+                this.retryCount = 0; // Reset the retry count on successful application
             }
         }
         process.stdout.write(`

package/dist/managers/ShellManager.js

@@ -40,9 +40,14 @@ Please briefly explain how this shell script works.`;
         console.log((0, cli_highlight_1.default)(generatedShellWithoutShebang));
     }
     async handleUserAction(response, prompt) {
+        let { exec } = this.options;
         this.chatHistory.push({ role: 'assistant', content: response });
         const generatedShell = (0, string_utils_1.extractMarkdown)(response);
         const generatedShellWithoutShebang = generatedShell.replace(/^#!.*?\s/, '');
+        if (exec) {
+            (0, child_process_1.execSync)(generatedShellWithoutShebang, { stdio: 'inherit' });
+            return;
+        }
         const action = await (0, prompts_1.select)({
             message: 'What would you like to do?',
             choices: [

package/dist/package.json

@@ -1,6 +1,6 @@
 {
   "name": "cloving",
-  "version": "0.3.5",
+  "version": "0.3.8",
   "packageManager": "yarn@1.22.22",
   "main": "dist/index.js",
   "types": "dist/index.d.ts",

package/dist/utils/prompt_utils.js

@@ -36,7 +36,7 @@ exports.CODEGEN_INSTRUCTIONS = `## AI Code Generation Instructions
    \`\`\`typescript
 2. **Next line: seven <, CURRENT, and the file path.**
    <<<<<<< CURRENT path/to/file.ts
-3. **Include the exact existing code to be changed.**
+3. **Include the exact existing code to be changed, this section should never be just spaces or tabs unless it is a new file.**
 4. **Divide with seven =.**
    =======
 5. **Add the new code.**

package/dist/utils/string_utils.js

@@ -3,13 +3,14 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
     return (mod && mod.__esModule) ? mod : { "default": mod };
 };
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.checkBlocksApplicability = exports.applyAndSaveCurrentNewBlocks = exports.processBlock = exports.updateFileContent = exports.writeFileContent = exports.ensureDirectoryExists = exports.extractCurrentNewBlocks = exports.extractBlock = exports.findBlockIndices = exports.parseMarkdownInstructions = exports.extractMarkdown = exports.extractJsonMetadata = exports.estimateTokens = void 0;
+exports.checkBlocksApplicability = exports.applyAndSaveCurrentNewBlocks = exports.applyAndSaveBlock = exports.searchReplaceString = exports.writeFileContent = exports.ensureDirectoryExists = exports.extractCurrentNewBlocks = exports.extractBlock = exports.findBlockIndices = exports.parseMarkdownInstructions = exports.extractMarkdown = exports.extractJsonMetadata = exports.estimateTokens = void 0;
 const fs_1 = __importDefault(require("fs"));
 const path_1 = __importDefault(require("path"));
 const colors_1 = __importDefault(require("colors"));
-const BLOCK_START = '\n<<<<<<< CURRENT';
+const BLOCK_START = '\n```';
+const BLOCK_CURRENT = '\n<<<<<<< CURRENT';
 const BLOCK_DIVIDER = '\n=======';
-const BLOCK_END = '\n>>>>>>> NEW';
+const BLOCK_END = '\n>>>>>>> NEW\n```';
 // Function to estimate token count
 const estimateTokens = async (text) => {
     const charCount = text.length;
@@ -65,6 +66,13 @@ const extractJsonMetadata = (response) => {
     if (jsonEndIndex !== -1) {
         jsonString = jsonString.substring(0, jsonEndIndex + 1);
     }
+    // sanity check that the extracted string is valid JSON
+    try {
+        JSON.parse(jsonString);
+    }
+    catch (error) {
+        jsonString = '';
+    }
     return jsonString;
 };
 exports.extractJsonMetadata = extractJsonMetadata;
@@ -171,7 +179,12 @@ const findBlockIndices = (input, startIndex) => {
     const blockStart = input.indexOf(BLOCK_START, startIndex);
     if (blockStart === -1)
         return null;
-    const filePathStart = blockStart + BLOCK_START.length;
+    const languageStart = blockStart + BLOCK_START.length;
+    const languageEnd = input.indexOf('\n', languageStart);
+    if (languageEnd === -1)
+        return null;
+    const currentStart = input.indexOf(BLOCK_CURRENT, startIndex);
+    const filePathStart = currentStart + BLOCK_CURRENT.length;
     const filePathEnd = input.indexOf('\n', filePathStart);
     const dividerIndex = input.indexOf(BLOCK_DIVIDER, filePathEnd);
     if (dividerIndex === -1)
@@ -180,7 +193,8 @@ const findBlockIndices = (input, startIndex) => {
     if (blockEnd === -1)
         return null;
     return {
-        start: blockStart,
+        start: languageStart,
+        current: currentStart,
         filePathEnd,
         divider: dividerIndex,
         end: blockEnd,
@@ -198,10 +212,11 @@ exports.findBlockIndices = findBlockIndices;
  * @returns {CurrentNewBlock} An object containing the extracted file path, current content, and new content.
  */
 const extractBlock = (input, indices) => {
-    const filePath = input.slice(indices.start + BLOCK_START.length, indices.filePathEnd).trim();
+    const language = input.slice(indices.start, indices.current).trim();
+    const filePath = input.slice(indices.current + BLOCK_CURRENT.length, indices.filePathEnd).trim();
     const currentContent = input.slice(indices.filePathEnd + 1, indices.divider).trim();
     const newContent = input.slice(indices.divider + BLOCK_DIVIDER.length, indices.end).trim();
-    return { filePath, currentContent, newContent };
+    return { language, filePath, currentContent, newContent };
 };
 exports.extractBlock = extractBlock;
 /**
@@ -286,13 +301,13 @@ exports.writeFileContent = writeFileContent;
  *   currentContent: "console.log('Old content')",
  *   newContent: "console.log('New content')"
  * }
- * const updatedContent = updateFileContent(currentContent, block)
+ * const updatedContent = searchReplaceString(currentContent, block)
  * // updatedContent will be:
  * // function example() {
  * //   console.log('New content')
  * // }
  */
-const updateFileContent = (currentContent, block) => {
+const searchReplaceString = (currentContent, block) => {
     // 1) if block.currentContent.trim() is empty then return block.newContent
     if (block.currentContent.trim() === '') {
         return block.newContent;
@@ -308,26 +323,32 @@ const updateFileContent = (currentContent, block) => {
     if (matchingLine === -1) {
         return currentContent; // If no match is found, return the original content
     }
-    // 5) compare the first line of block.currentContent with the matchingLine line of currentContent, putting any preceeding spaces that are in currentContent but not in block.currentContent into a variable named preceedingSpaces
-    const firstLineIndex = currentContent.indexOf(blockLines[0]);
-    const precedingSpaces = currentContent
-        .substring(firstLineIndex, firstLineIndex + currentLines[0].length)
-        .match(/^\s*/);
+    // 5) compare the first line of block.currentContent with the startLine line of currentContent, putting any preceeding spaces that are in currentContent but not in block.currentContent into a variable named preceedingSpaces
+    const startLine = currentContent.split('\n').findIndex((line) => line.includes(blockLines[0]));
+    if (startLine === -1) {
+        return currentContent; // If no match is found, return the original content
+    }
+    const startLineContent = currentContent.split('\n')[startLine];
+    const blockLineContent = block.currentContent.split('\n')[0];
+    const precedingSpaces = startLineContent.replace(blockLineContent, '');
     // 6) add preceedingSpaces to the start of each line in both block.currentContent and block.newContent
     if (precedingSpaces) {
-        const precedingSpacesValue = precedingSpaces[0];
+        const indentedCurrentContent = block.currentContent
+            .split('\n')
+            .map((line) => precedingSpaces + line)
+            .join('\n');
         const indentedNewContent = block.newContent
             .split('\n')
-            .map((line) => precedingSpacesValue + line)
+            .map((line) => precedingSpaces + line)
             .join('\n');
         // 7) finally, do a simple currentContent.replace(block.currentContent, block.newContent) with the modified (added preceeding spaces to match) variables
-        return currentContent.replace(block.currentContent, indentedNewContent);
+        return currentContent.replace(indentedCurrentContent, indentedNewContent);
     }
     else {
         return currentContent.replace(block.currentContent, block.newContent);
     }
 };
-exports.updateFileContent = updateFileContent;
+exports.searchReplaceString = searchReplaceString;
 /**
  * Analyzes the content of a block against the file content to find matching lines.
  *
@@ -364,7 +385,7 @@ const analyzeBlockContent = async (block, fileContent) => {
  * @param {number} index - The index of the block being processed (used for logging).
  * @returns {Promise<void>} A promise that resolves when the block has been processed.
  */
-const processBlock = async (block, index) => {
+const applyAndSaveBlock = async (block, index) => {
     const filePath = path_1.default.resolve(block.filePath);
     let fileContent = await readFileContent(filePath);
     if (fileContent === '') {
@@ -381,11 +402,11 @@ const processBlock = async (block, index) => {
         console.log(`[${index + 1}] ${colors_1.default.red.bold(block.filePath)} ${colors_1.default.red.bold(`ERROR: Current content matches multiple (${matchingLines.length}) parts in the file`)}`);
         return;
     }
-    const updatedContent = (0, exports.updateFileContent)(fileContent, block);
+    const updatedContent = (0, exports.searchReplaceString)(fileContent, block);
     await (0, exports.writeFileContent)(filePath, updatedContent);
     console.log(`[${index + 1}] ${colors_1.default.green.bold(block.filePath)} has been ${colors_1.default.yellow.bold('updated')}`);
 };
-exports.processBlock = processBlock;
+exports.applyAndSaveBlock = applyAndSaveBlock;
 /**
  * Applies and saves the changes specified in the CurrentNewBlock array.
  *
@@ -413,7 +434,7 @@ const applyAndSaveCurrentNewBlocks = async (blocks) => {
     console.log(`\nApplying and saving current/new blocks...\n`);
     for (const [index, block] of blocks.entries()) {
         try {
-            await (0, exports.processBlock)(block, index);
+            await (0, exports.applyAndSaveBlock)(block, index);
         }
         catch (error) {
             console.error(`Error processing ${colors_1.default.red(block.filePath)}:`, error);

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "cloving",
-  "version": "0.3.6",
+  "version": "0.3.8",
   "packageManager": "yarn@1.22.22",
   "main": "dist/index.js",
   "types": "dist/index.d.ts",