cloving 0.3.7 → 0.3.9

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,7 +37,6 @@ class BlockManager extends events_1.EventEmitter {
                 this.emit('content', rest);
             }
             else {
-                // Start of code block
                 this.emitBuffer(content.slice(0, markerIndex));
                 this.codeBuffer = content.slice(markerIndex);
                 this.emit('startGeneratingCode');
@@ -45,7 +44,6 @@ class BlockManager extends events_1.EventEmitter {
             }
         }
         else {
-            // No code block marker found
             if (this.isBufferingCode) {
                 this.codeBuffer += content;
             }
@@ -66,22 +64,17 @@ class BlockManager extends events_1.EventEmitter {
     }
     emitCodeBlock() {
         if (this.codeBuffer.length > 0) {
-            const codeParts = this.parseCodeBuffer();
-            if (codeParts) {
-                const { language, currentStart, newEnd, currentCode, newCode } = codeParts;
+            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('content', this.codeBuffer);
+                this.emit('codeBlock', this.codeBuffer);
                 this.clearBuffer();
             }
         }
@@ -93,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

@@ -621,12 +621,26 @@ class ChatManager {
             accumulatedContent += content;
         });
         this.blockManager.on('codeBlock', (codeBlock) => {
-            process.stdout.write(colors_1.default.gray.bold(`\`\`\`${codeBlock.language}                                       \n`));
-            process.stdout.write(colors_1.default.gray.bold(`${codeBlock.currentStart}\n`));
-            process.stdout.write((0, cli_highlight_1.default)(codeBlock.currentCode, { language: codeBlock.language }));
-            process.stdout.write(colors_1.default.gray.bold('\n=======\n'));
-            process.stdout.write((0, cli_highlight_1.default)(codeBlock.newCode, { language: codeBlock.language }));
-            process.stdout.write(colors_1.default.gray.bold('\n>>>>>>> NEW\n```'));
+            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

package/dist/package.json

@@ -1,6 +1,6 @@
 {
   "name": "cloving",
-  "version": "0.3.6",
+  "version": "0.3.9",
   "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

@@ -7,9 +7,10 @@ exports.checkBlocksApplicability = exports.applyAndSaveCurrentNewBlocks = export
 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;
 /**
@@ -211,22 +226,25 @@ exports.extractBlock = extractBlock;
  * Each block contains information about file paths, current content, and new content.
  *
  * The blocks are defined by specific delimiters:
+ * - Setup: '```lang'
  * - Start: '<<<<<<< CURRENT'
  * - Divider: '======='
  * - End: '>>>>>>> NEW'
+ * - Finish: '```'
  *
  * @param {string} [input] - The input string containing CURRENT/NEW blocks.
  * @returns {CurrentNewBlock[]} An array of CurrentNewBlock objects, each representing a parsed block.
  *                              If the input is undefined or empty, an empty array is returned.
  *
  * @example
- * const input = `
+ * const input = "
+ * ```typescript
  * <<<<<<< CURRENT path/to/file.ts
  * const oldCode = 'old'
  * =======
  * const newCode = 'new'
  * >>>>>>> NEW
- * `
+ * ```"
  * const blocks = extractCurrentNewBlocks(input)
  * // blocks will contain one CurrentNewBlock object with the parsed information
  */
@@ -297,6 +315,10 @@ const searchReplaceString = (currentContent, block) => {
     if (block.currentContent.trim() === '') {
         return block.newContent;
     }
+    // check if you can replace the entire block without changing indentation
+    if (currentContent.includes(block.currentContent)) {
+        return currentContent.replace(block.currentContent, block.newContent);
+    }
     // 2) split currentContent and block.currentContent into new lines and trim() all the lines, then put back the new lines
     const currentLines = currentContent.split('\n').map((line) => line.trim());
     const blockLines = block.currentContent.split('\n').map((line) => line.trim());

package/package.json

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