cloving 0.3.3 → 0.3.5

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) => {
@@ -68,7 +68,20 @@ const extractJsonMetadata = (response) => {
     return jsonString;
 };
 exports.extractJsonMetadata = extractJsonMetadata;
-// Function to extract markdown from the AI response
+/**
+ * Extracts markdown content from a given response string.
+ *
+ * This function attempts to extract markdown content from the input string,
+ * focusing on content within code blocks and removing any surrounding metadata.
+ *
+ * @param {string} response - The input string containing markdown and possibly other content.
+ * @returns {string} The extracted markdown content.
+ *
+ * @example
+ * const response = '```markdown\n# Title\nContent\n```\nOther text';
+ * const markdown = extractMarkdown(response);
+ * console.log(markdown); // Outputs: "# Title\nContent"
+ */
 const extractMarkdown = (response) => {
     let markdownString = response;
     // Regular expression to match any ```<word> block
@@ -91,12 +104,28 @@ const extractMarkdown = (response) => {
     return markdownString;
 };
 exports.extractMarkdown = extractMarkdown;
+/**
+ * Parses markdown instructions into separate blocks.
+ *
+ * This function takes a string input containing markdown instructions and
+ * separates it into an array of strings, where each string represents a
+ * distinct block of content (either a code block or a text block).
+ *
+ * @param {string} input - The input string containing markdown instructions.
+ * @returns {string[]} An array of strings, each representing a distinct block of content.
+ *
+ * @example
+ * const input = "# Title\n```js\nconst x = 1;\n```\nSome text";
+ * const blocks = parseMarkdownInstructions(input);
+ * console.log(blocks);
+ * // Outputs: ["# Title", "```js\nconst x = 1;\n```", "Some text"]
+ */
 const parseMarkdownInstructions = (input) => {
     const lines = input.split('\n');
     const result = [];
     let buffer = [];
     let inCodeBlock = false;
-    lines.forEach(line => {
+    lines.forEach((line) => {
         if (line.trim().startsWith('```')) {
             if (inCodeBlock) {
                 // End of code block
@@ -126,6 +155,18 @@ const parseMarkdownInstructions = (input) => {
     return result;
 };
 exports.parseMarkdownInstructions = parseMarkdownInstructions;
+/**
+ * Finds the indices of a CURRENT/NEW block within the input string.
+ *
+ * This function searches for the start, divider, and end markers of a CURRENT/NEW block
+ * in the input string, starting from the given index. It returns the indices of these
+ * markers if a complete block is found.
+ *
+ * @param {string} input - The input string to search for block indices.
+ * @param {number} startIndex - The index in the input string to start searching from.
+ * @returns {BlockIndices | null} An object containing the indices of the block components,
+ *                                or null if a complete block is not found.
+ */
 const findBlockIndices = (input, startIndex) => {
     const blockStart = input.indexOf(BLOCK_START, startIndex);
     if (blockStart === -1)
@@ -142,15 +183,27 @@ const findBlockIndices = (input, startIndex) => {
         start: blockStart,
         filePathEnd,
         divider: dividerIndex,
-        end: blockEnd
+        end: blockEnd,
     };
 };
+exports.findBlockIndices = findBlockIndices;
+/**
+ * Extracts the content of a CURRENT/NEW block using the provided indices.
+ *
+ * This function takes the input string and a set of block indices, and extracts
+ * the file path, current content, and new content from the block.
+ *
+ * @param {string} input - The input string containing the CURRENT/NEW block.
+ * @param {BlockIndices} indices - An object containing the indices of the block components.
+ * @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 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 +222,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 +236,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 +259,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,72 +279,113 @@ 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;
+/**
+ * Analyzes the content of a block against the file content to find matching lines.
+ *
+ * This function compares the trimmed content of a block with the trimmed content of a file
+ * to identify all occurrences of the block content within the file.
+ *
+ * @param {CurrentNewBlock} block - The block containing the content to be searched for.
+ * @param {string} fileContent - The content of the file to be analyzed.
+ * @returns {Promise<{ matchingLines: number[]; currentContentTrimmed: string }>} A promise that resolves to an object containing:
+ *   - matchingLines: An array of line numbers where the block content matches in the file.
+ *   - currentContentTrimmed: The trimmed content of the file.
+ */
+const analyzeBlockContent = async (block, fileContent) => {
+    const currentLines = fileContent.split('\n').map((line) => line.trim());
+    const blockLines = block.currentContent.split('\n').map((line) => line.trim());
+    const blockContent = blockLines.join('\n');
+    const currentContentTrimmed = currentLines.join('\n');
+    const matchingLines = [];
+    let matchingLine = -1;
+    while ((matchingLine = currentContentTrimmed.indexOf(blockContent, matchingLine + 1)) !== -1) {
+        matchingLines.push(matchingLine);
+    }
+    return { matchingLines, currentContentTrimmed };
+};
+/**
+ * Processes a single block by applying its changes to the corresponding file.
+ *
+ * This function handles the following scenarios:
+ * 1. Creating a new file if it doesn't exist.
+ * 2. Updating an existing file if the block's current content matches exactly once.
+ * 3. Logging errors if the current content is not found or matches multiple times.
+ *
+ * @param {CurrentNewBlock} block - The block containing the changes to be applied.
+ * @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 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;
     }
-    if (block.currentContent.trim() !== '' && !fileContent.includes(block.currentContent)) {
-        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`)}`);
+    const { matchingLines } = await analyzeBlockContent(block, fileContent);
+    if (matchingLines.length === 0) {
+        console.log(`[${index + 1}] ${colors_1.default.red.bold(block.filePath)} ${colors_1.default.red.bold('ERROR: Current content not found to replace in the file')}`);
+        return;
+    }
+    else if (matchingLines.length > 1) {
+        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 = 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 +406,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 +421,52 @@ 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() !== '') {
+            const { matchingLines } = await analyzeBlockContent(block, fileContent);
+            if (matchingLines.length === 0) {
+                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 if (matchingLines.length > 1) {
+                allApplicable = false;
+                summary.push(`[${index + 1}] ${colors_1.default.red.bold(block.filePath)} ${colors_1.default.red.bold(`cannot be applied: Current content matches multiple (${matchingLines.length}) parts in the file`)}`);
+            }
+            else {
+                summary.push(`[${index + 1}] ${colors_1.default.green.bold(block.filePath)} can be ${colors_1.default.yellow.bold('updated')}`);
+            }
+        }
+        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.5",
   "packageManager": "yarn@1.22.22",
   "main": "dist/index.js",
   "types": "dist/index.d.ts",
@@ -10,7 +10,8 @@
     "watch": "tsc -w",
     "check": "bash -c 'npx tsc --noEmit --skipLibCheck'",
     "test": "bash -c jest",
-    "prepare": "husky"
+    "prepare": "husky",
+    "format": "prettier --write \"src/**/*.ts\""
   },
   "bin": "./dist/index.js",
   "files": [
@@ -23,7 +24,8 @@
   "description": "",
   "lint-staged": {
     "*.ts": [
-      "yarn run check"
+      "yarn run check",
+      "prettier --write"
     ]
   },
   "lint-prepush": {
@@ -31,7 +33,8 @@
     "tasks": {
       "*.ts": [
         "yarn run check",
-        "yarn run test"
+        "yarn run test",
+        "yarn run format"
       ]
     }
   },
@@ -42,14 +45,14 @@
     "colors": "^1.4.0",
     "commander": "^12.1.0",
     "copy-paste": "^1.5.3",
-    "eslint": "^9.9.0",
+    "eslint": "^8.57.0",
     "eslint-config-prettier": "^9.1.0",
     "eslint-config-raine": "^0.5.0",
     "eslint-config-standard": "^17.1.0",
     "eslint-plugin-import": "^2.29.1",
     "eslint-plugin-jsdoc": "^50.1.0",
-    "eslint-plugin-n": "^17.10.2",
-    "eslint-plugin-promise": "^7.1.0",
+    "eslint-plugin-n": "^16.6.2",
+    "eslint-plugin-promise": "^6.6.0",
     "express": "^4.19.2",
     "ignore": "^5.3.2",
     "ini": "^4.1.3",
@@ -70,12 +73,14 @@
     "jest": "^29.7.0",
     "lint-prepush": "^2.2.2",
     "lint-staged": "^15.2.9",
+    "prettier": "^3.2.5",
     "ts-jest": "^29.2.4",
     "typescript": "^5.5.4"
   },
   "resolutions": {
     "eslint": "8.57.0",
     "eslint-plugin-n": "16.6.2",
-    "eslint-plugin-import": "2.29.1"
+    "eslint-plugin-import": "2.29.1",
+    "eslint-plugin-promise": "6.6.0"
   }
 }