cloving 0.2.1 → 0.3.0

package/dist/utils/command_utils.js

@@ -3,12 +3,13 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
     return (mod && mod.__esModule) ? mod : { "default": mod };
 };
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.addFileOrDirectoryToContext = exports.readFileContent = exports.fetchModels = exports.runCommand = exports.generateFileList = exports.getAllFilesInDirectory = exports.checkForSpecialFiles = exports.collectSpecialFileContents = exports.SPECIAL_FILES = void 0;
-const child_process_1 = require("child_process");
+exports.addFileOrDirectoryToContext = exports.readFileContent = exports.fetchModels = exports.runCommand = exports.generateFileList = exports.getAllFilesInDirectory = exports.checkForSpecialFiles = exports.collectSpecialFileContents = exports.generateShellPrompt = exports.generateCodegenPrompt = exports.SPECIAL_FILES = void 0;
 const fs_1 = __importDefault(require("fs"));
 const path_1 = __importDefault(require("path"));
-const config_utils_1 = require("./config_utils");
+const child_process_1 = require("child_process");
 const isbinaryfile_1 = require("isbinaryfile");
+const colors_1 = __importDefault(require("colors"));
+const config_utils_1 = require("./config_utils");
 exports.SPECIAL_FILES = [
     'package.json', 'Gemfile', 'requirements.txt', 'Pipfile', 'pyproject.toml', 'pom.xml', 'build.gradle',
     '.csproj', 'packages.config', 'composer.json', 'CMakeLists.txt', 'conanfile.txt', 'conanfile.py',
@@ -16,6 +17,164 @@ exports.SPECIAL_FILES = [
     'DESCRIPTION', 'mix.exs', 'build.sbt', 'pubspec.yaml', 'stack.yaml', 'cabal.project', 'Project.toml',
     'rockspec', 'rebar.config', 'project.clj', 'tsconfig.json'
 ];
+const generateCodegenPrompt = (contextFilesContent) => {
+    const instructions = `## AI Code Generation Instructions
+
+### General Guidelines
+
+1. **Respond as an expert software developer.**
+2. **Follow best practices and the latest standards found in the **Description of App** section.**
+3. **Adhere to existing conventions and libraries in the codebase.**
+
+### Request Handling
+
+1. **Try to understand the request, but if anything is unclear, ask questions.**
+2. **Decide if you need to propose edits to existing files not in the chat.**
+   - If yes, provide the full path names and ask the user to add them.
+   - Wait for user approval before proceeding.
+3. **Propose changes using *CURRENT/NEW* Blocks.**
+4. **Show the smallest possible *CURRENT* section that uniquely identifies the code.**
+5. **To move code, use two *CURRENT/NEW* blocks: one to remove and one to add.**
+6. **For new files or to replace an existing file, the *CURRENT* block is empty.**
+
+### *CURRENT/NEW* Block Format
+
+1. **Start a block with three backticks and the language name.**
+   \`\`\`typescript
+2. **Next line: seven <, CURRENT, and the file path.**
+   <<<<<<< CURRENT path/to/file.ts
+3. **Include the exact existing code to be changed.**
+4. **Divide with seven =.**
+   =======
+5. **Add the new code.**
+6. **End with seven > and NEW.**
+   >>>>>>> NEW
+7. **Close the block with three backticks.**
+   \`\`\``;
+    const specialFileContents = (0, exports.collectSpecialFileContents)();
+    const specialFiles = Object.keys(specialFileContents).map((file) => `### Contents of **${file}**\n\n\`\`\`\n${JSON.stringify(specialFileContents[file], null, 2)}\n\`\`\`\n\n`).join('\n');
+    const contextFileContents = Object.keys(contextFilesContent).map((file) => `### Contents of **${file}**\n\n\`\`\`\n${contextFilesContent[file]}\n\`\`\`\n\n`).join('\n');
+    const prompt = `${instructions}
+
+## Description of App
+
+${JSON.stringify((0, config_utils_1.getClovingConfig)(), null, 2)}
+
+## Special Files
+
+${specialFiles.length > 0 ? specialFiles : 'No special files provided.'}
+
+## Context Files
+
+${contextFileContents.length > 0 ? contextFileContents : 'No context files provided.'}
+
+## Directory structure
+
+${Object.keys(contextFilesContent).join('\n')}
+
+${instructions}
+
+### Example 1: Changing a Variable
+
+\`\`\`typescript
+<<<<<<< CURRENT path/to/file.ts
+const myVariable = 'exact'
+const oldVariable = 1
+=======
+const myVariable = 'exact'
+const newVariable = 2
+>>>>>>> NEW
+\`\`\`
+
+### Example 2: Create a New File
+
+\`\`\`ruby
+<<<<<<< CURRENT path/to/newfile.rb
+=======
+def new_function
+  puts 'Hello, world!'
+end
+>>>>>>> NEW
+\`\`\`
+
+### Example 3: Moving a Function
+
+Removing it from path/to/file.py
+
+\`\`\`python
+<<<<<<< CURRENT path/to/file.py
+def old_function():
+  return 'Old function'
+=======
+>>>>>>> NEW
+\`\`\`
+
+Adding it to path/to/newfile.py
+
+\`\`\`python
+<<<<<<< CURRENT path/to/newfile.py
+def existing_function():
+  return 'Existing function'
+
+=======
+def existing_function():
+  return 'Existing function'
+
+def old_function():
+  return 'Old function'
+>>>>>>> NEW
+\`\`\`
+
+### Example 4: Removing a Function
+
+\`\`\`java
+<<<<<<< CURRENT path/to/file.java
+public void oldFunction() {
+  System.out.println("Old function")
+}
+=======
+>>>>>>> NEW
+\`\`\`
+
+### Example 5: Replace a file
+
+This will replace the entire contents of **path/to/file.rb** with the new content:
+
+\`\`\`ruby
+<<<<<<< CURRENT path/to/file.rb
+=======
+def new_function
+  puts 'Hello, world!'
+end
+>>>>>>> NEW
+\`\`\`
+
+## Don't Invent Code That Isn't Provided in Context
+
+A file might be referenced by just the file name without the full path, but the code must be provided in the *Context Files* section.
+
+Unless you believe you are creating a whole new file, never ever under any circumstances make up code in the CURRENT block that was not provided to you in the *Context Files* section.
+
+If a required file hasn't been provided in the *Context Files* section, stop everything and ask the user to provide it in the context by adding -f path/to/file to the command or add path/to/file in the interactive chat.`;
+    return prompt;
+};
+exports.generateCodegenPrompt = generateCodegenPrompt;
+const generateShellPrompt = () => {
+    const shell = (0, child_process_1.execSync)('echo $SHELL').toString().trim();
+    const os = (0, child_process_1.execSync)('echo $OSTYPE').toString().trim();
+    return `Generate an executable ${shell} script that works on ${os}. Try to make it a single line if possible and as simple and straightforward as possible.
+
+Do not add any commentary or context to the message other than the commit message itself.
+
+An example of the output for this should look like the following:
+
+\`\`\`sh
+find . -type f -name "*.ts" -exec sed -i '' 's/old/new/g' {} +
+\`\`\`
+
+Don't use that script, it is only an example.`;
+};
+exports.generateShellPrompt = generateShellPrompt;
 const collectSpecialFileContents = () => {
     const specialFileContents = {};
     for (const file of exports.SPECIAL_FILES) {
@@ -110,27 +269,43 @@ const readFileContent = (file) => {
     }
 };
 exports.readFileContent = readFileContent;
-const addFileOrDirectoryToContext = async (contextFile, contextFiles, options) => {
-    const filePath = path_1.default.resolve(contextFile);
-    if (await fs_1.default.promises.stat(filePath).then(stat => stat.isDirectory()).catch(() => false)) {
-        // Add all files in the specified directory
-        const files = await (0, config_utils_1.getAllFiles)(options, false);
-        for (const file of files) {
-            // if the file is in the same directory as the context file, add it to the context
-            if (path_1.default.dirname(file) === path_1.default.dirname(filePath)) {
-                const content = await fs_1.default.promises.readFile(file, 'utf-8');
-                contextFiles[path_1.default.relative(process.cwd(), file)] = content;
+const addFileToContext = async (filePath, contextFiles, baseDir) => {
+    const relativePath = path_1.default.relative(baseDir, filePath);
+    if (await (0, isbinaryfile_1.isBinaryFile)(filePath)) {
+        return;
+    }
+    const content = await fs_1.default.promises.readFile(filePath, 'utf-8');
+    contextFiles[relativePath] = content;
+};
+const addDirectoryToContext = async (dirPath, contextFiles, baseDir) => {
+    const entries = await fs_1.default.promises.readdir(dirPath, { withFileTypes: true });
+    for (const entry of entries) {
+        const fullPath = path_1.default.join(dirPath, entry.name);
+        if (entry.isDirectory()) {
+            if (entry.name !== 'node_modules' && entry.name !== '.git') {
+                await addDirectoryToContext(fullPath, contextFiles, baseDir);
             }
         }
-        console.log(`Added contents of ${contextFile} to context.`);
+        else {
+            await addFileToContext(fullPath, contextFiles, baseDir);
+        }
     }
-    else if (await fs_1.default.promises.stat(filePath).then(stat => stat.isFile()).catch(() => false)) {
-        const content = await fs_1.default.promises.readFile(filePath, 'utf-8');
-        contextFiles[contextFile] = content;
-        console.log(`Added ${filePath} to context.`);
+};
+const addFileOrDirectoryToContext = async (contextFile, contextFiles, options) => {
+    const filePath = path_1.default.resolve(contextFile);
+    const baseDir = process.cwd();
+    try {
+        const stats = await fs_1.default.promises.stat(filePath);
+        if (stats.isDirectory()) {
+            await addDirectoryToContext(filePath, contextFiles, baseDir);
+        }
+        else if (stats.isFile()) {
+            await addFileToContext(filePath, contextFiles, baseDir);
+        }
     }
-    else {
-        console.log(`File or directory ${contextFile} does not exist.`);
+    catch (error) {
+        console.error(`${colors_1.default.bold('Error')}: File or directory "${contextFile}" does not exist`);
+        process.exit(1);
     }
     return contextFiles;
 };

package/dist/utils/string_utils.js

@@ -3,9 +3,13 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
     return (mod && mod.__esModule) ? mod : { "default": mod };
 };
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.saveGeneratedFiles = exports.extractFilesAndContent = exports.parseMarkdownInstructions = exports.extractMarkdown = exports.extractJsonMetadata = exports.estimateTokens = void 0;
+exports.applyAndSaveCurrentNewBlocks = exports.extractCurrentNewBlocks = 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_DIVIDER = '\n=======';
+const BLOCK_END = '\n>>>>>>> NEW';
 // Function to estimate token count
 const estimateTokens = async (text) => {
     const charCount = text.length;
@@ -13,7 +17,33 @@ const estimateTokens = async (text) => {
     return tokenCount;
 };
 exports.estimateTokens = estimateTokens;
-// Function to extract JSON metadata from the AI response
+/**
+ * Extracts JSON metadata from an AI response string.
+ *
+ * This function attempts to extract a valid JSON string from the given response.
+ * It handles responses that may contain the JSON within a code block or as plain text.
+ *
+ * The function performs the following steps:
+ * 1. Looks for a ```json code block and extracts its content if found.
+ * 2. If no code block is found, it treats the entire response as potential JSON.
+ * 3. Trims the extracted string to remove leading/trailing whitespace.
+ * 4. Removes any text before the first '{' and after the last '}'.
+ *
+ * @param {string} response - The AI response string that may contain JSON metadata.
+ * @returns {string} A string containing only the JSON part of the response.
+ *                   If no valid JSON structure is found, it may return an empty string
+ *                   or a partial JSON string.
+ *
+ * @example
+ * 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);
+ * // jsonMetadata will be '{"key": "value"}'
+ */
 const extractJsonMetadata = (response) => {
     let jsonString;
     // Extract the ```json block from the response
@@ -96,70 +126,202 @@ const parseMarkdownInstructions = (input) => {
     return result;
 };
 exports.parseMarkdownInstructions = parseMarkdownInstructions;
-const extractFilesAndContent = (rawCodeCommand) => {
-    if (!rawCodeCommand)
-        return {};
-    const files = [];
-    const fileContents = {};
+const findBlockIndices = (input, startIndex) => {
+    const blockStart = input.indexOf(BLOCK_START, startIndex);
+    if (blockStart === -1)
+        return null;
+    const filePathStart = blockStart + BLOCK_START.length;
+    const filePathEnd = input.indexOf('\n', filePathStart);
+    const dividerIndex = input.indexOf(BLOCK_DIVIDER, filePathEnd);
+    if (dividerIndex === -1)
+        return null;
+    const blockEnd = input.indexOf(BLOCK_END, dividerIndex);
+    if (blockEnd === -1)
+        return null;
+    return {
+        start: blockStart,
+        filePathEnd,
+        divider: dividerIndex,
+        end: blockEnd
+    };
+};
+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 };
+};
+/**
+ * Extracts CURRENT/NEW blocks from the given input string.
+ *
+ * This function parses the input string to find and extract all CURRENT/NEW blocks.
+ * Each block contains information about file paths, current content, and new content.
+ *
+ * The blocks are defined by specific delimiters:
+ * - Start: '<<<<<<< CURRENT'
+ * - Divider: '======='
+ * - End: '>>>>>>> NEW'
+ *
+ * @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 = `
+ * <<<<<<< 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
+ */
+const extractCurrentNewBlocks = (input) => {
+    if (!input)
+        return [];
+    const blocks = [];
     let currentIndex = 0;
-    const commandLength = rawCodeCommand.length;
-    while (currentIndex < commandLength) {
-        let fileNameStart = rawCodeCommand.indexOf('**', currentIndex);
-        if (fileNameStart === -1)
-            break;
-        let fileNameEnd = rawCodeCommand.indexOf('**', fileNameStart + 2);
-        if (fileNameEnd === -1)
-            break;
-        let nextBoldStart = rawCodeCommand.indexOf('**', fileNameEnd + 2);
-        let nextCodeStart = rawCodeCommand.indexOf('\n```', fileNameEnd + 2);
-        while (nextBoldStart !== -1 && nextCodeStart > nextBoldStart) {
-            fileNameStart = nextBoldStart;
-            fileNameEnd = rawCodeCommand.indexOf('**', fileNameStart + 2);
-            nextBoldStart = rawCodeCommand.indexOf('**', fileNameEnd + 2);
-            nextCodeStart = rawCodeCommand.indexOf('\n```', fileNameEnd + 2);
-        }
-        const fileName = rawCodeCommand.slice(fileNameStart + 2, fileNameEnd).trim();
-        files.push(fileName);
-        const codeBlockStart = rawCodeCommand.indexOf('\n```', fileNameEnd);
-        if (codeBlockStart === -1)
-            break;
-        let codeBlockEnd = codeBlockStart + 4;
-        while (codeBlockEnd < commandLength) {
-            if (rawCodeCommand.slice(codeBlockEnd, codeBlockEnd + 5) === '\n```\n') {
-                break;
-            }
-            else if (rawCodeCommand.slice(codeBlockEnd, codeBlockEnd + 4) === '\n```' && codeBlockEnd + 4 === commandLength) {
-                break;
-            }
-            codeBlockEnd++;
-        }
-        if (codeBlockEnd >= commandLength)
+    while (currentIndex < input.length) {
+        const indices = findBlockIndices(input, currentIndex);
+        if (!indices)
             break;
-        let content = rawCodeCommand.slice(codeBlockStart + 4, codeBlockEnd).trim();
-        const firstNewlineIndex = content.indexOf('\n');
-        if (firstNewlineIndex !== -1) {
-            content = content.slice(firstNewlineIndex + 1);
-        }
-        else {
-            content = content.replace(/^\w+\s*/, '');
+        blocks.push(extractBlock(input, indices));
+        currentIndex = indices.end + BLOCK_END.length;
+    }
+    return blocks;
+};
+exports.extractCurrentNewBlocks = extractCurrentNewBlocks;
+const readFileContent = async (filePath) => {
+    try {
+        return await fs_1.default.promises.readFile(filePath, 'utf-8');
+    }
+    catch (error) {
+        if (error.code === 'ENOENT') {
+            return '';
         }
-        fileContents[fileName] = content.trim();
-        currentIndex = codeBlockEnd + 5;
+        throw error;
+    }
+};
+const ensureDirectoryExists = async (filePath) => {
+    await fs_1.default.promises.mkdir(path_1.default.dirname(filePath), { recursive: true });
+};
+const writeFileContent = async (filePath, content) => {
+    await ensureDirectoryExists(filePath);
+    await fs_1.default.promises.writeFile(filePath, content);
+};
+/**
+ * Updates the content of a file by replacing a specified block of current content with new content.
+ *
+ * This function searches for the `currentContent` within the `currentContent` of the file.
+ * If found, it replaces it with the `newContent` from the `block`, preserving the indentation
+ * level of the original content.
+ *
+ * @param {string} currentContent - The existing content of the file.
+ * @param {CurrentNewBlock} block - An object containing the current and new content to be replaced.
+ * @returns {string} The updated file content with the specified block replaced.
+ *
+ * @example
+ * const currentContent = `
+ * function example() {
+ *   console.log('Old content');
+ * }
+ * `;
+ * const 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');
+ * // }
+ */
+const updateFileContent = (currentContent, block) => {
+    if (block.currentContent.trim() === '') {
+        return block.newContent;
     }
-    return fileContents;
+    // 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;
+    }
+    // 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);
+};
+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);
+        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`)}`);
+        return;
+    }
+    const updatedContent = updateFileContent(fileContent, block);
+    await writeFileContent(filePath, updatedContent);
+    console.log(`[${index + 1}] ${colors_1.default.green.bold(block.filePath)} has been ${colors_1.default.yellow.bold('updated')}`);
 };
-exports.extractFilesAndContent = extractFilesAndContent;
-const saveGeneratedFiles = async (fileContents) => {
-    for (const file of Object.keys(fileContents)) {
-        if (fileContents[file]) {
-            const filePath = path_1.default.resolve(file);
-            await fs_1.default.promises.mkdir(path_1.default.dirname(filePath), { recursive: true });
-            await fs_1.default.promises.writeFile(filePath, fileContents[file]);
-            console.log(`${file} has been saved.`);
+/**
+ * Applies and saves the changes specified in the CurrentNewBlock array.
+ *
+ * This function iterates through an array of CurrentNewBlock objects, each representing
+ * a change to be made to a file. For each block, it attempts to process the change
+ * by either creating a new file, updating an existing file, or reporting an error
+ * if the current content doesn't match.
+ *
+ * The function provides console output to inform the user about the status of each
+ * file operation (created, updated, or error).
+ *
+ * @param {CurrentNewBlock[]} blocks - An array of CurrentNewBlock objects representing the changes to be applied.
+ * @returns {Promise<void>} A promise that resolves when all blocks have been processed.
+ *
+ * @throws Will log errors to the console if any block processing fails, but won't stop execution for other blocks.
+ *
+ * @example
+ * 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);
+ */
+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);
         }
-        else {
-            console.log(`File content not found for ${file}.`);
+        catch (error) {
+            console.error(`Error processing ${colors_1.default.red(block.filePath)}:`, error);
         }
     }
 };
-exports.saveGeneratedFiles = saveGeneratedFiles;
+exports.applyAndSaveCurrentNewBlocks = applyAndSaveCurrentNewBlocks;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "cloving",
-  "version": "0.2.1",
+  "version": "0.3.0",
   "packageManager": "yarn@1.22.22",
   "main": "dist/index.js",
   "types": "dist/index.d.ts",
@@ -36,25 +36,26 @@
     }
   },
   "dependencies": {
-    "@inquirer/prompts": "^5.3.6",
+    "@inquirer/prompts": "^5.3.8",
     "axios": "^1.7.3",
     "cli-highlight": "^2.1.11",
+    "colors": "^1.4.0",
     "commander": "^12.1.0",
     "copy-paste": "^1.5.3",
-    "eslint": "^9.8.0",
+    "eslint": "^9.9.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": "^48.11.0",
-    "eslint-plugin-n": "^17.10.1",
-    "eslint-plugin-promise": "^7.0.0",
+    "eslint-plugin-jsdoc": "^50.1.0",
+    "eslint-plugin-n": "^17.10.2",
+    "eslint-plugin-promise": "^7.1.0",
     "express": "^4.19.2",
-    "ignore": "^5.3.1",
+    "ignore": "^5.3.2",
     "ini": "^4.1.3",
     "isbinaryfile": "^5.0.2",
     "nock": "^13.5.4",
-    "vite": "^5.3.5",
+    "vite": "^5.4.0",
     "vite-node": "^2.0.5"
   },
   "devDependencies": {
@@ -64,11 +65,11 @@
     "@types/ini": "^4.1.1",
     "@types/inquirer": "^9.0.7",
     "@types/jest": "^29.5.12",
-    "@types/node": "^22.1.0",
+    "@types/node": "^22.2.0",
     "husky": "^9.1.4",
     "jest": "^29.7.0",
     "lint-prepush": "^2.2.2",
-    "lint-staged": "^15.2.8",
+    "lint-staged": "^15.2.9",
     "ts-jest": "^29.2.4",
     "typescript": "^5.5.4"
   },