* feat(launch.json): add launch configuration for vscode-jest-tests.v2.insert-file-tag

* feat(calltree-snippet.txt): add call tree generation prompt
* feat(source.txt): add source file with "Hello World!" content
* feat(isValidPath.test.js): add test for isValidPath function
* feat(processAdnSaveFileWithTags.test.js): add tests for processAndSaveFileWithTags function
* fix(source-processor.js): fix typo in function name
* feat(source-processor.js): add processAndSaveFileWithTags function
* feat(source-processor.js): add updateInsertTagsSafely function
* feat(source-processor.js): add isValidPath function
* feat(source-processor.js): export all functions in source-processor module
* feat(target.txt): add target file with "Hello World!" content
* feat(test.txt): add test file with "Hello World!" content

Author: ioncakephper

.vscode/launch.json

@@ -0,0 +1,30 @@
+{
+    // Use IntelliSense to learn about possible attributes.
+    // Hover to view descriptions of existing attributes.
+    // For more information, visit: https://go.microsoft.com/fwlink/?linkid=830387
+    "version": "0.2.0",
+    "configurations": [
+        
+        {
+            "type": "node",
+            "name": "vscode-jest-tests.v2.insert-file-tag",
+            "request": "launch",
+            "args": [
+                "--runInBand",
+                "--watchAll=false",
+                "--testNamePattern",
+                "${jest.testNamePattern}",
+                "--runTestsByPath",
+                "${jest.testFile}"
+            ],
+            "cwd": "${workspaceFolder}",
+            "console": "integratedTerminal",
+            "internalConsoleOptions": "neverOpen",
+            "disableOptimisticBPs": true,
+            "program": "${workspaceFolder}/node_modules/.bin/jest",
+            "windows": {
+                "program": "${workspaceFolder}/node_modules/jest/bin/jest"
+            }
+        }
+    ]
+}

calltree-snippet.txt

@@ -0,0 +1,4 @@
+Generate a call tree for the JavaScript file, showing the dependencies between functions. The root node should be the filename, followed by functions that don't call other functions within the file, and then their descendants based on function calls. Format the output as a tree using indentation and└─ to indicate parent-child relationships. Enclose the output within a JavaScript block comment.
+
+
+What mechanism of retrieving this prompt do you recommend? I want to give this prompt a name, and later I give you the prompt name and you will execute the prompt.

source.txt

@@ -0,0 +1 @@
+Hello World!

src/isValidPath.test.js

@@ -0,0 +1,48 @@
+const fs = require('fs');
+const path = require('path');
+const { processAndSaveFileWithTags } = require('./source-processor');
+
+describe('processAndSaveFileWithTags', () => {
+  it('throws Error when sourceFilename is not provided', () => {
+    expect(() => processAndSaveFileWithTags()).toThrow(Error);
+  });
+
+  it('throws TypeError when sourceFilename is not a string', () => {
+    expect(() => processAndSaveFileWithTags(123)).toThrow(TypeError);
+  });
+
+  it('throws Error when targetFilename is not provided', () => {
+    expect(() => processAndSaveFileWithTags('source.txt')).toThrow(Error);
+  });
+
+  it('throws TypeError when targetFilename is not a string', () => {
+    expect(() => processAndSaveFileWithTags('source.txt', 123)).toThrow(TypeError);
+  });
+
+//   it('throws Error when file path is invalid', () => {
+//     expect(() => processAndSaveFileWithTags('source.txt', '../invalid/path.txt')).toThrow(Error);
+//   });
+
+//   it('processes and saves file correctly', () => {
+//     const sourceFilename = 'source.txt';
+//     const targetFilename = 'target.txt';
+//     const sourceContent = 'Hello World!';
+//     fs.writeFileSync(sourceFilename, sourceContent, 'utf8');
+//     processAndSaveFileWithTags(sourceFilename, targetFilename);
+//     const targetContent = fs.readFileSync(targetFilename, 'utf8');
+//     expect(targetContent).toContain(sourceContent);
+//     fs.unlinkSync(sourceFilename);
+//     fs.unlinkSync(targetFilename);
+//   });
+
+//   it('handles error while reading or writing file', () => {
+//     const sourceFilename = 'source.txt';
+//     const targetFilename = 'target.txt';
+//     const sourceContent = 'Hello World!';
+//     fs.writeFileSync(sourceFilename, sourceContent, 'utf8');
+//     fs.chmodSync(sourceFilename, 0o000); // make the file unreadable
+//     expect(() => processAndSaveFileWithTags(sourceFilename, targetFilename)).toThrow(Error);
+//     fs.chmodSync(sourceFilename, 0o644); // restore the file permissions
+//     fs.unlinkSync(sourceFilename);
+//   });
+});

src/processAdnSaveFileWithTags.test.js

@@ -8,19 +8,24 @@ const fs = require('fs');
  */
 
 /**
- * Testing Order:
+ * source-processor.js
+ * └─ isValidPath
+ * └─ processSourceCode
+ *   └─ processFilename
+ *      └─ processAndSaveFileWithTags
+ *         └─ updateInsertTagsSafely
+ */
+
+/**
+ * The order of testing the functions in this file is as follows:
  *
- * 1. `processSourceCode`
+ * 1. `isValidPath`
  * 2. `processFilename`
- *
- * This order is important because `processFilename` depends on
- * `processMarkdown` and we want to make sure that all the dependant
- * functions are tested first.
+ * 3. `processSourceCode`
+ * 4. `processAndSaveFileWithTags`
+ * 5. `updateInsertTagsSafely`
  */
 
-
-
-
 /**
  * Processes the given source code by replacing insert/include tags with the content
  * of the specified files. The file paths are resolved relative to the provided base path.
@@ -69,7 +74,6 @@ ${fileContent}
     });
 }
 
-
 /**
  * Reads the content of a file and processes it by inserting content of other
  * files based on insert/include tags. If the file does not exist or is empty,
@@ -82,6 +86,9 @@ ${fileContent}
  * @throws {Error} If an error occurs while reading the file
  */
 function processFilename(filename) {
+    /*
+     * Validate the filename
+     */
     if (!filename) {
         throw new Error("File name is required");
     }
@@ -96,20 +103,152 @@ function processFilename(filename) {
         // Read the content of the file
         fileContent = fs.readFileSync(filename, 'utf8');
     } catch (error) {
+        // If the file does not exist, return null
         if (error.code !== 'ENOENT') {
             throw error;
         }
+
+        return null;
     }
 
     if (!fileContent || fileContent.trim() === '') {
+        // If the file is empty, return null
         return null;
     }
 
-    // Process the markdown content by inserting content of other files
+    // Process the source content by inserting content of other files
     return processSourceCode(fileContent, path.dirname(filename));
 }
 
+/**
+ * Processes the source file by replacing insert/include tags with the content
+ * of the specified files, and then saves the processed content to the target
+ * file.
+ *
+ * @param {string} sourceFilename - The name of the source file to process.
+ * @param {string} targetFilename - The name of the target file to save the
+ *        processed content to.
+ * @throws {Error} If the file name is not provided or is not a string.
+ * @throws {TypeError} If the file name is not a string.
+ * @throws {Error} If an error occurs while reading or writing the file.
+ */
+function processAndSaveFileWithTags(sourceFilename, targetFilename) {
+    // if (!isValidPath(sourceFilename) || !isValidPath(targetFilename)) {
+    //     throw new TypeError('Invalid file path');
+    // }
+    if (!sourceFilename) {
+        throw new Error("Source file name is required");
+    }
+
+    if (typeof sourceFilename !== 'string') {
+        throw new TypeError("Source file name must be a string");
+    }
+
+    if (!targetFilename) {
+        throw new Error("Target file name is required");
+    }
+
+    if (typeof targetFilename !== 'string') {
+        throw new TypeError("Target file name must be a string");
+    }
+
+    // Read the source file content and process it
+    // const processedSource = processFilename(path.basename(sourceFilename));
+    const processedSource = processFilename(sourceFilename);
+    if (!processedSource) {
+        throw new Error('Filename processing failed.');
+    }
+
+    // Save the processed content to the target file
+    try {
+        fs.mkdirSync(path.dirname(targetFilename), { recursive: true });
+        fs.writeFileSync(targetFilename, processedSource, 'utf8');
+    } catch (error) {
+        console.error(`Error processing file: ${error.message}`);
+    }
+}
+
+/**
+ * Processes the file by replacing insert/include tags with the content of
+ * other files, and saves the processed content to the same file. This
+ * function is safe to call concurrently because it uses a temporary file to
+ * avoid overwriting the original file during processing.
+ *
+ * @param {string} filename - The name of the file to process.
+ * @throws {Error} If the file name is not provided or is not a string.
+ * @throws {TypeError} If the file name is not a string.
+ * @throws {Error} If an error occurs while reading or writing the file.
+ */
+function updateInsertTagsSafely(filename) {
+    if (!filename) {
+        throw new Error("File name is required");
+    }
+
+    if (typeof filename !== 'string') {
+        throw new TypeError("File name must be a string");
+    }
+
+    const tempFilename = filename + '.tmp';
+
+    try {
+        // Process the file and save to a temporary file
+        processAndSaveFileWithTags(filename, tempFilename);
+
+        // Rename the temporary file to the original filename
+        fs.renameSync(tempFilename, filename);
+    } catch (error) {
+        console.error(`Error processing file with temp: ${error.message}`);
+        // Cleanup: remove the temporary file if it exists
+        if (fs.existsSync(tempFilename)) {
+            fs.unlinkSync(tempFilename);
+        }
+    }
+}
+
+/**
+ * Checks if the given file path is valid and not maliciously trying to escape
+ * the base directory.
+ *
+ * @param {string} filePath - The file path to check.
+ * @param {string} [baseDir=process.cwd()] - The base directory to check against.
+ * @returns {boolean} True if the path is valid, false otherwise.
+ */
+function isValidPath(filePath, baseDir = process.cwd()) {
+    const pathRegex = /^[a-zA-Z0-9_\-\/\\]+$/;
+    if (typeof filePath !== 'string' || !pathRegex.test(filePath)) {
+        return false
+    }
+
+    // Make sure the base directory exists and is a directory
+    if (!fs.existsSync(baseDir) || !fs.lstatSync(baseDir).isDirectory()) {
+        console.error(`Invalid base directory: ${baseDir}`);
+        return false;
+    }
+
+    // Sanitize the file path and base directory by removing any .. and . references
+    const sanitizedFilePath = path.normalize(filePath).replace(/(\.\.(\/|\\|$))+/, '');
+    const sanitizedBaseDir = path.normalize(baseDir).replace(/(\.\.(\/|\\|$))+/, '');
+
+    // Make sure the file path is absolute
+    if (!path.isAbsolute(sanitizedFilePath)) {
+        return false;
+    }
+
+    try {
+        // Resolve the file path and check if it's inside the base directory
+        const resolvedPath = path.join(sanitizedBaseDir, sanitizedFilePath);
+        const realPath = fs.realpathSync(resolvedPath);
+        return realPath.startsWith(sanitizedBaseDir);
+    } catch (error) {
+        console.error(`Error resolving path: ${error.message}`);
+        return false;
+    }
+}
+
 module.exports = {
     processFilename,
-    processSourceCode
-}
+    processSourceCode,
+    processAndSaveFileWithTags,
+    isValidPath,
+    updateInsertTagsSafely,
+};

src/source-processor.js

@@ -0,0 +1 @@
+Hello World!

target.txt

@@ -0,0 +1 @@
+Hello World!