cloving 0.3.3 → 0.3.4

package/dist/utils/string_utils.js

@@ -3,7 +3,7 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
     return (mod && mod.__esModule) ? mod : { "default": mod };
 };
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.applyAndSaveCurrentNewBlocks = exports.extractCurrentNewBlocks = exports.parseMarkdownInstructions = exports.extractMarkdown = exports.extractJsonMetadata = exports.estimateTokens = void 0;
+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;
 const fs_1 = __importDefault(require("fs"));
 const path_1 = __importDefault(require("path"));
 const colors_1 = __importDefault(require("colors"));
@@ -35,13 +35,13 @@ exports.estimateTokens = estimateTokens;
  *                   or a partial JSON string.
  *
  * @example
- * const aiResponse = '```json\n{"key": "value"}\n```\nOther text';
- * const jsonMetadata = extractJsonMetadata(aiResponse);
+ * const aiResponse = '```json\n{"key": "value"}\n```\nOther text'
+ * const jsonMetadata = extractJsonMetadata(aiResponse)
  * // jsonMetadata will be '{"key": "value"}'
  *
  * @example
- * const plainResponse = 'Some text {"key": "value"} more text';
- * const jsonMetadata = extractJsonMetadata(plainResponse);
+ * const plainResponse = 'Some text {"key": "value"} more text'
+ * const jsonMetadata = extractJsonMetadata(plainResponse)
  * // jsonMetadata will be '{"key": "value"}'
  */
 const extractJsonMetadata = (response) => {
@@ -145,12 +145,14 @@ const findBlockIndices = (input, startIndex) => {
         end: blockEnd
     };
 };
+exports.findBlockIndices = findBlockIndices;
 const extractBlock = (input, indices) => {
     const filePath = input.slice(indices.start + BLOCK_START.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 };
 };
+exports.extractBlock = extractBlock;
 /**
  * Extracts CURRENT/NEW blocks from the given input string.
  *
@@ -169,12 +171,12 @@ const extractBlock = (input, indices) => {
  * @example
  * const input = `
  * <<<<<<< CURRENT path/to/file.ts
- * const oldCode = 'old';
+ * const oldCode = 'old'
  * =======
- * const newCode = 'new';
+ * const newCode = 'new'
  * >>>>>>> NEW
- * `;
- * const blocks = extractCurrentNewBlocks(input);
+ * `
+ * const blocks = extractCurrentNewBlocks(input)
  * // blocks will contain one CurrentNewBlock object with the parsed information
  */
 const extractCurrentNewBlocks = (input) => {
@@ -183,10 +185,10 @@ const extractCurrentNewBlocks = (input) => {
     const blocks = [];
     let currentIndex = 0;
     while (currentIndex < input.length) {
-        const indices = findBlockIndices(input, currentIndex);
+        const indices = (0, exports.findBlockIndices)(input, currentIndex);
         if (!indices)
             break;
-        blocks.push(extractBlock(input, indices));
+        blocks.push((0, exports.extractBlock)(input, indices));
         currentIndex = indices.end + BLOCK_END.length;
     }
     return blocks;
@@ -206,10 +208,12 @@ const readFileContent = async (filePath) => {
 const ensureDirectoryExists = async (filePath) => {
     await fs_1.default.promises.mkdir(path_1.default.dirname(filePath), { recursive: true });
 };
+exports.ensureDirectoryExists = ensureDirectoryExists;
 const writeFileContent = async (filePath, content) => {
-    await ensureDirectoryExists(filePath);
+    await (0, exports.ensureDirectoryExists)(filePath);
     await fs_1.default.promises.writeFile(filePath, content);
 };
+exports.writeFileContent = writeFileContent;
 /**
  * Updates the content of a file by replacing a specified block of current content with new content.
  *
@@ -224,61 +228,55 @@ const writeFileContent = async (filePath, content) => {
  * @example
  * const currentContent = `
  * function example() {
- *   console.log('Old content');
+ *   console.log('Old content')
  * }
- * `;
+ * `
  * const block = {
- *   currentContent: "console.log('Old content');",
- *   newContent: "console.log('New content');"
- * };
- * const updatedContent = updateFileContent(currentContent, block);
+ *   currentContent: "console.log('Old content')",
+ *   newContent: "console.log('New content')"
+ * }
+ * const updatedContent = updateFileContent(currentContent, block)
  * // updatedContent will be:
  * // function example() {
- * //   console.log('New content');
+ * //   console.log('New content')
  * // }
  */
 const updateFileContent = (currentContent, block) => {
+    // 1) if block.currentContent.trim() is empty then return block.newContent
     if (block.currentContent.trim() === '') {
         return block.newContent;
     }
-    // Normalize the current content for comparison
-    const normalizedCurrentContent = block.currentContent.trim();
-    const normalizedFileContent = currentContent.replace(/\r\n/g, '\n');
-    // Find the index of the normalized current content in the file content
-    const index = normalizedFileContent.indexOf(normalizedCurrentContent);
-    if (index === -1) {
-        return currentContent;
+    // 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());
+    // 3) see if the trimmed block.currentContent matches a section of code in the trimmed currentContent
+    const blockContent = blockLines.join('\n');
+    const currentContentTrimmed = currentLines.join('\n');
+    // 4) if so, make a variable named matchingLine with the line number of which line the block.currentContent starts on in currentContent
+    const matchingLine = currentContentTrimmed.indexOf(blockContent);
+    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*/);
+    // 6) add preceedingSpaces to the start of each line in both block.currentContent and block.newContent
+    if (precedingSpaces) {
+        const precedingSpacesValue = precedingSpaces[0];
+        const indentedNewContent = block.newContent.split('\n').map(line => precedingSpacesValue + 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);
+    }
+    else {
+        return currentContent.replace(block.currentContent, block.newContent);
     }
-    // Determine the indentation level of the current content in the file
-    const linesBefore = normalizedFileContent.substring(0, index).split('\n');
-    const lastLineBefore = linesBefore[linesBefore.length - 1];
-    const indentationMatch = lastLineBefore.match(/^\s*/);
-    const indentation = indentationMatch ? indentationMatch[0] : '';
-    // Calculate missing leading spaces in the current content
-    const currentContentLines = block.currentContent.split('\n');
-    const fileContentLines = normalizedFileContent.substring(index, index + normalizedCurrentContent.length).split('\n');
-    const missingSpaces = currentContentLines.map((line, i) => {
-        const fileLine = fileContentLines[i] || '';
-        const lineIndentationMatch = fileLine.match(/^\s*/);
-        const lineIndentation = lineIndentationMatch ? lineIndentationMatch[0] : '';
-        return Math.max(0, lineIndentation.length - line.length + line.trimStart().length);
-    });
-    // Apply the adjusted indentation to the new content
-    const indentedNewContent = block.newContent
-        .split('\n')
-        .map((line, i) => {
-        const additionalSpaces = ' '.repeat(missingSpaces[i] || 0);
-        return line.trim() ? indentation + additionalSpaces + line : line;
-    })
-        .join('\n');
-    // Replace the current content with the indented new content
-    return currentContent.replace(block.currentContent, indentedNewContent);
 };
+exports.updateFileContent = updateFileContent;
 const processBlock = async (block, index) => {
     const filePath = path_1.default.resolve(block.filePath);
     let fileContent = await readFileContent(filePath);
     if (fileContent === '') {
-        await writeFileContent(filePath, block.newContent);
+        await (0, exports.writeFileContent)(filePath, block.newContent);
         console.log(`[${index + 1}] ${colors_1.default.green.bold(block.filePath)} has been ${colors_1.default.green.bold('created')}`);
         return;
     }
@@ -286,10 +284,11 @@ const processBlock = async (block, index) => {
         console.log(`[${index + 1}] ${colors_1.default.green.bold(block.filePath)} ${colors_1.default.red.bold(`ERROR: Current content not found to replace in the file`)}`);
         return;
     }
-    const updatedContent = updateFileContent(fileContent, block);
-    await writeFileContent(filePath, updatedContent);
+    const updatedContent = (0, exports.updateFileContent)(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;
 /**
  * Applies and saves the changes specified in the CurrentNewBlock array.
  *
@@ -310,14 +309,14 @@ const processBlock = async (block, index) => {
  * const blocks = [
  *   { filePath: 'path/to/file.ts', currentContent: 'old code', newContent: 'new code' },
  *   { filePath: 'path/to/newfile.ts', currentContent: '', newContent: 'new file content' }
- * ];
- * await applyAndSaveCurrentNewBlocks(blocks);
+ * ]
+ * await applyAndSaveCurrentNewBlocks(blocks)
  */
 const applyAndSaveCurrentNewBlocks = async (blocks) => {
     console.log(`\nApplying and saving current/new blocks...\n`);
     for (const [index, block] of blocks.entries()) {
         try {
-            await processBlock(block, index);
+            await (0, exports.processBlock)(block, index);
         }
         catch (error) {
             console.error(`Error processing ${colors_1.default.red(block.filePath)}:`, error);
@@ -325,3 +324,42 @@ const applyAndSaveCurrentNewBlocks = async (blocks) => {
     }
 };
 exports.applyAndSaveCurrentNewBlocks = applyAndSaveCurrentNewBlocks;
+/**
+ * Checks if all the blocks can be applied without making any changes.
+ *
+ * This function iterates through an array of CurrentNewBlock objects and checks
+ * if each block can be applied to its respective file. It returns a tuple where
+ * the first element is a boolean indicating if all blocks can be applied, and
+ * the second element is a string summarizing the success or failure of each block.
+ *
+ * @param {CurrentNewBlock[]} blocks - An array of CurrentNewBlock objects to be checked.
+ * @returns {Promise<[boolean, string]>} A promise that resolves to a tuple containing
+ *                                       a boolean and a summary string.
+ *
+ * @example
+ * const blocks = [
+ *   { filePath: 'path/to/file.ts', currentContent: 'old code', newContent: 'new code' },
+ *   { filePath: 'path/to/newfile.ts', currentContent: '', newContent: 'new file content' }
+ * ]
+ * const [canApply, summary] = await checkBlocksApplicability(blocks)
+ */
+const checkBlocksApplicability = async (blocks) => {
+    let allApplicable = true;
+    const summary = [];
+    for (const [index, block] of blocks.entries()) {
+        const filePath = path_1.default.resolve(block.filePath);
+        let fileContent = await readFileContent(filePath);
+        if (fileContent === '') {
+            summary.push(`[${index + 1}] ${colors_1.default.green.bold(block.filePath)} can be ${colors_1.default.green.bold('created')}`);
+        }
+        else if (block.currentContent.trim() !== '' && !fileContent.includes(block.currentContent)) {
+            allApplicable = false;
+            summary.push(`[${index + 1}] ${colors_1.default.red.bold(block.filePath)} ${colors_1.default.red.bold('cannot be applied: Current content not found')}`);
+        }
+        else {
+            summary.push(`[${index + 1}] ${colors_1.default.green.bold(block.filePath)} can be ${colors_1.default.yellow.bold('updated')}`);
+        }
+    }
+    return [allApplicable, summary.join('\n')];
+};
+exports.checkBlocksApplicability = checkBlocksApplicability;

package/package.json

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