claude-git-hooks 2.18.0 → 2.18.1

package/CHANGELOG.md

@@ -5,6 +5,20 @@ Todos los cambios notables en este proyecto se documentarán en este archivo.
 El formato está basado en [Keep a Changelog](https://keepachangelog.com/en/1.0.0/),
 y este proyecto adhiere a [Semantic Versioning](https://semver.org/spec/v2.0.0.html).
 
+## [2.18.1] - 2026-03-04
+
+### ✨ Added
+- Monorepo support for CHANGELOG discovery - discovers all CHANGELOG.md files and prompts to select when multiple are found (#77)
+- AI-powered help and issue creation system (#79)
+
+### 🔧 Changed
+- Enhanced `walkDirectoryTree` utility function in file-utils.js for reusable directory traversal
+- Updated documentation to reflect monorepo CHANGELOG discovery capabilities
+
+### 🐛 Fixed
+- Cross-platform path handling in git hooks directory resolution (normalized path separators)
+
+
 ## [2.18.0] - 2026-03-03
 
 ### ✨ Added

package/CLAUDE.md

@@ -240,10 +240,11 @@ Wait for both → consolidate results
 | `claude-client.js`       | Claude CLI wrapper    | `analyzeCode()`, `analyzeCodeParallel()`, `executeClaudeWithRetry()`                                                                                                           |
 | `prompt-builder.js`      | Prompt construction   | `buildAnalysisPrompt()`, `loadPrompt()`                                                                                                                                        |
 | `git-operations.js`      | Git abstractions      | `getStagedFiles()`, `getUnstagedFiles()`, `getAllTrackedFiles()`, `getDiff()`, `getRepoRoot()`, `getBranchPushStatus()`, `pushBranch()`, `createCommit()`, `fetchRemote()`, `branchExists()`, `getRemoteBranches()`, `resolveBaseBranch()`, `getChangedFilesBetweenRefs()`, `getDiffBetweenRefs()`, `getCommitsBetweenRefs()` |
+| `file-utils.js`          | File operations       | `ensureDir()`, `ensureOutputDir()`, `writeOutputFile()`, `walkDirectoryTree()`                                                                                                                                                                                                                                                |
 | `pr-metadata-engine.js`  | PR metadata generation | `getBranchContext()`, `buildDiffPayload()`, `generatePRMetadata()`, `analyzeBranchForPR()` (v2.14.0) |
 | `git-tag-manager.js`     | Git tag operations    | `createTag()`, `pushTags()`, `getLocalTags()`, `getRemoteTags()`, `compareLocalAndRemoteTags()`, `tagExists()` (v2.12.0)                                                       |
 | `version-manager.js`     | Version management    | `discoverVersionFiles()`, `getDiscoveryResult()`, `readVersionFromFile()`, `writeVersionToFile()`, `updateVersionFiles()`, `modifySuffix()`, `incrementVersion()`, `parseVersion()`, `validateVersionFormat()`, `compareVersions()`, `validateVersionAlignment()` (v2.15.5)                             |
-| `changelog-generator.js` | CHANGELOG generation  | `generateChangelogEntry()`, `updateChangelogFile()`, `getLastFinalVersionTag()`, `getCommitsSinceTag()` (v2.12.0)                                                              |
+| `changelog-generator.js` | CHANGELOG generation  | `generateChangelogEntry()`, `updateChangelogFile()`, `getLastFinalVersionTag()`, `getCommitsSinceTag()`, `discoverChangelogFiles()`, `selectChangelogFile()` (v2.12.0)         |
 | `github-api.js`          | Octokit integration   | `createPullRequest()`, `validateToken()`, `saveGitHubToken()`, `fetchFileContent()`, `fetchDirectoryListing()`, `createIssue()`                                                |
 | `github-client.js`       | GitHub helpers        | `getReviewersForFiles()`, `parseGitHubRepo()`                                                                                                                                  |
 | `preset-loader.js`       | Preset system         | `loadPreset()`, `listPresets()`                                                                                                                                                |

package/README.md

@@ -157,7 +157,8 @@ claude-hooks generate-changelog --base-branch develop
 - Analyzes commits since last tag using Claude
 - Categorizes by Conventional Commits types (feat, fix, refactor, etc.)
 - Generates Keep a Changelog format entries
-- Updates CHANGELOG.md automatically
+- Discovers all CHANGELOG.md files (monorepo aware); prompts to select when multiple found
+- Updates the selected CHANGELOG.md automatically
 - Useful when `bump-version --update-changelog` fails
 
 ### Disable/Enable Hooks

package/lib/commands/bump-version.js

@@ -35,7 +35,8 @@ import {
 } from '../utils/git-tag-manager.js';
 import {
     generateChangelogEntry,
-    updateChangelogFile
+    updateChangelogFile,
+    selectChangelogFile
 } from '../utils/changelog-generator.js';
 import {
     getRepoRoot,
@@ -582,6 +583,10 @@ export async function runBumpVersion(args) {
             process.exit(1);
         }
 
+        // selectedChangelogPath: set in Step 9 when multiple CHANGELOGs found;
+        // used in Step 10 to stage the correct file.
+        let selectedChangelogPath = null;
+
         // Step 9: Generate CHANGELOG (if requested)
         if (options.updateChangelog) {
             logger.debug('bump-version', 'Step 9: Generating CHANGELOG');
@@ -597,7 +602,9 @@ export async function runBumpVersion(args) {
             });
 
             if (changelogResult.content) {
-                const updated = updateChangelogFile(changelogResult.content);
+                selectedChangelogPath = await selectChangelogFile();
+
+                const updated = updateChangelogFile(changelogResult.content, selectedChangelogPath);
                 if (updated) {
                     showSuccess('✓ CHANGELOG.md updated');
                 } else {
@@ -620,9 +627,9 @@ export async function runBumpVersion(args) {
             // Collect files to stage
             const filesToStage = selectedFiles.map(f => f.path);
 
-            // Add CHANGELOG if it was updated
+            // Add CHANGELOG if it was updated (use selected path from Step 9, or default root)
             if (options.updateChangelog) {
-                const changelogPath = path.join(getRepoRoot(), 'CHANGELOG.md');
+                const changelogPath = selectedChangelogPath || path.join(getRepoRoot(), 'CHANGELOG.md');
                 if (fs.existsSync(changelogPath)) {
                     filesToStage.push(changelogPath);
                 }

package/lib/commands/generate-changelog.js

@@ -7,7 +7,11 @@
  */
 
 import { discoverVersionFiles } from '../utils/version-manager.js';
-import { generateChangelogEntry, updateChangelogFile } from '../utils/changelog-generator.js';
+import {
+    generateChangelogEntry,
+    updateChangelogFile,
+    selectChangelogFile
+} from '../utils/changelog-generator.js';
 import { getConfig } from '../config.js';
 import { showInfo, showSuccess, showWarning, showError } from '../utils/interactive-ui.js';
 import logger from '../utils/logger.js';
@@ -116,7 +120,9 @@ export async function runGenerateChangelog(args) {
         });
 
         if (changelogResult.content) {
-            const updated = updateChangelogFile(changelogResult.content);
+            const selectedPath = await selectChangelogFile();
+
+            const updated = updateChangelogFile(changelogResult.content, selectedPath);
             if (updated) {
                 showSuccess('✓ CHANGELOG.md updated');
             } else {

package/lib/utils/changelog-generator.js

@@ -13,6 +13,8 @@ import { getRepoRoot } from './git-operations.js';
 import { executeClaudeWithRetry, extractJSON } from './claude-client.js';
 import { loadPrompt } from './prompt-builder.js';
 import logger from './logger.js';
+import { walkDirectoryTree } from './file-utils.js';
+import { showInfo, promptMenu } from './interactive-ui.js';
 
 /**
  * Gets the last final version tag (without suffix)
@@ -256,13 +258,30 @@ export async function generateChangelogEntry(options) {
             .map(c => `${c.sha.substring(0, 7)} - ${c.message} (${c.author}, ${c.date})`)
             .join('\n');
 
+        if (!fromTag) {
+            logger.debug(
+                'changelog-generator - generateChangelogEntry',
+                'No version tags found — using full commit history for first CHANGELOG entry'
+            );
+        }
+
         // Get diff for context
         const compareWith = fromTag ? `${fromTag}..HEAD` : `origin/${baseBranch}...HEAD`;
         let fullDiff;
         try {
             fullDiff = execSync(`git diff ${compareWith}`, { encoding: 'utf8' });
         } catch (error) {
-            logger.warning('changelog-generator - generateChangelogEntry', 'Could not get diff', error);
+            if (fromTag) {
+                // Unexpected: a tag exists but diff failed
+                logger.warning('changelog-generator - generateChangelogEntry', 'Could not get diff', error);
+            } else {
+                // Expected: no remote or remote branch not yet pushed — commit messages are primary context
+                logger.debug(
+                    'changelog-generator - generateChangelogEntry',
+                    'Diff not available — no remote or no version tags yet, using commit messages as primary context',
+                    { error: error.message }
+                );
+            }
             fullDiff = '(diff not available)';
         }
 
@@ -322,18 +341,20 @@ export async function generateChangelogEntry(options) {
  * Why: Inserts new version section at the top
  *
  * @param {string} newContent - New CHANGELOG section
+ * @param {string|null} changelogPath - Absolute path to target CHANGELOG file.
+ *   If null, defaults to CHANGELOG.md at repo root (backward compatible).
  * @returns {boolean} True if updated successfully
  */
-export function updateChangelogFile(newContent) {
+export function updateChangelogFile(newContent, changelogPath = null) {
     logger.debug('changelog-generator - updateChangelogFile', 'Updating CHANGELOG.md');
 
     try {
         const repoRoot = getRepoRoot();
-        const changelogPath = path.join(repoRoot, 'CHANGELOG.md');
+        const targetPath = changelogPath || path.join(repoRoot, 'CHANGELOG.md');
 
         let existingContent = '';
-        if (fs.existsSync(changelogPath)) {
-            existingContent = fs.readFileSync(changelogPath, 'utf8');
+        if (fs.existsSync(targetPath)) {
+            existingContent = fs.readFileSync(targetPath, 'utf8');
         } else {
             // Create new CHANGELOG with header
             existingContent = `# Changelog
@@ -367,7 +388,7 @@ y este proyecto adhiere a [Semantic Versioning](https://semver.org/spec/v2.0.0.h
             updatedContent = `${newContent  }\n${  existingContent}`;
         }
 
-        fs.writeFileSync(changelogPath, updatedContent, 'utf8');
+        fs.writeFileSync(targetPath, updatedContent, 'utf8');
 
         logger.debug('changelog-generator - updateChangelogFile', 'CHANGELOG.md updated successfully');
 
@@ -378,3 +399,84 @@ y este proyecto adhiere a [Semantic Versioning](https://semver.org/spec/v2.0.0.h
         return false;
     }
 }
+
+/**
+ * Discovers all CHANGELOG.md files in the repository
+ * Why: Support monorepos where each module has its own changelog
+ *
+ * Reuses the same maxDepth and ignoreSet patterns as discoverVersionFiles()
+ * in version-manager.js for consistency.
+ *
+ * @param {Object} options - Discovery options
+ * @param {number} options.maxDepth - Maximum directory depth to search (default: 3)
+ * @param {string[]} options.ignoreDirs - Additional directories to ignore
+ * @returns {string[]} Absolute paths to discovered CHANGELOG.md files, root-first
+ */
+export function discoverChangelogFiles(options = {}) {
+    const { maxDepth = 3, ignoreDirs = [] } = options;
+
+    logger.debug('changelog-generator - discoverChangelogFiles', 'Starting discovery', { maxDepth });
+
+    const repoRoot = getRepoRoot();
+
+    const defaultIgnore = [
+        'node_modules', 'dist', 'build', 'target', 'vendor',
+        '.next', '.nuxt', 'coverage'
+    ];
+    const ignoreSet = new Set([...defaultIgnore, ...ignoreDirs]);
+
+    const found = [];
+
+    walkDirectoryTree(repoRoot, {
+        maxDepth,
+        ignoreSet,
+        onFile: (entry, fullPath) => {
+            if (entry.name.toLowerCase() === 'changelog.md') found.push(fullPath);
+        },
+        onError: (dir, error) => {
+            logger.debug('changelog-generator - discoverChangelogFiles', 'Error reading directory', {
+                dir,
+                error: error.message
+            });
+        }
+    });
+
+    // Sort: root-level first, then by depth, then alphabetically
+    found.sort((a, b) => {
+        const depthA = path.relative(repoRoot, a).split(path.sep).length;
+        const depthB = path.relative(repoRoot, b).split(path.sep).length;
+        if (depthA !== depthB) return depthA - depthB;
+        return a.localeCompare(b);
+    });
+
+    logger.debug('changelog-generator - discoverChangelogFiles', 'Discovery complete', {
+        count: found.length,
+        files: found.map(f => path.relative(repoRoot, f))
+    });
+
+    return found;
+}
+
+/**
+ * Discovers CHANGELOG files and prompts the user to select one if multiple exist
+ * Why: Shared interactive selection used by both generate-changelog and bump-version
+ *
+ * @returns {Promise<string|null>} Absolute path to selected CHANGELOG, or null if none found
+ *   (null → updateChangelogFile falls back to repo-root CHANGELOG.md)
+ */
+export async function selectChangelogFile() {
+    const files = discoverChangelogFiles();
+
+    if (files.length > 1) {
+        const repoRoot = getRepoRoot();
+        const menuOptions = files.map((f, i) => ({
+            key: String(i + 1),
+            label: path.relative(repoRoot, f)
+        }));
+        showInfo('Multiple CHANGELOG files detected:');
+        const selected = await promptMenu('Select CHANGELOG to update:', menuOptions, '1');
+        return files[parseInt(selected) - 1];
+    }
+
+    return files[0] || null;
+}

package/lib/utils/file-utils.js

@@ -3,7 +3,8 @@
  * Purpose: Utility functions for file system operations
  */
 
-import fs from 'fs/promises';
+import fsPromises from 'fs/promises';
+import fs from 'fs';
 import path from 'path';
 import { getRepoRoot } from './git-operations.js';
 import logger from './logger.js';
@@ -20,7 +21,7 @@ export const ensureDir = async (dirPath) => {
         : path.join(getRepoRoot(), dirPath);
 
     try {
-        await fs.mkdir(absolutePath, { recursive: true });
+        await fsPromises.mkdir(absolutePath, { recursive: true });
         logger.debug('file-utils - ensureDir', 'Directory ensured', { path: absolutePath });
     } catch (error) {
         logger.error('file-utils - ensureDir', 'Failed to create directory', error);
@@ -55,10 +56,47 @@ export const writeOutputFile = async (filePath, content, config) => {
         ? filePath
         : path.join(getRepoRoot(), filePath);
 
-    await fs.writeFile(absolutePath, content, 'utf8');
+    await fsPromises.writeFile(absolutePath, content, 'utf8');
 
     logger.debug('file-utils - writeOutputFile', 'File written', {
         path: absolutePath,
         size: content.length
     });
 };
+
+/**
+ * Walks a directory tree recursively, invoking callbacks for each file
+ * Why: Shared traversal logic for discoverVersionFiles and discoverChangelogFiles
+ *
+ * @param {string} rootDir - Starting directory path
+ * @param {Object} options
+ * @param {number} options.maxDepth - Maximum recursion depth (default: 3)
+ * @param {Set<string>} options.ignoreSet - Directory names to skip
+ * @param {Function} options.onFile - Called as onFile(entry, fullPath) for each file entry
+ * @param {Function} options.onError - Called as onError(dir, error) on readdirSync failures
+ */
+export function walkDirectoryTree(rootDir, { maxDepth = 3, ignoreSet = new Set(), onFile, onError } = {}) {
+    function walk(dir, depth) {
+        if (depth > maxDepth) return;
+
+        try {
+            const entries = fs.readdirSync(dir, { withFileTypes: true });
+
+            for (const entry of entries) {
+                if (entry.name.startsWith('.') || ignoreSet.has(entry.name)) continue;
+
+                const fullPath = path.join(dir, entry.name);
+
+                if (entry.isDirectory()) {
+                    walk(fullPath, depth + 1);
+                } else if (entry.isFile()) {
+                    onFile?.(entry, fullPath);
+                }
+            }
+        } catch (error) {
+            onError?.(dir, error);
+        }
+    }
+
+    walk(rootDir, 0);
+}

package/lib/utils/version-manager.js

@@ -14,6 +14,7 @@ import fs from 'fs';
 import path from 'path';
 import { getRepoRoot } from './git-operations.js';
 import logger from './logger.js';
+import { walkDirectoryTree } from './file-utils.js';
 
 /**
  * Cache for discovery result
@@ -232,69 +233,38 @@ export function discoverVersionFiles(options = {}) {
     ];
     const ignoreSet = new Set([...defaultIgnore, ...ignoreDirs]);
 
-    /**
-     * Recursively walks directory tree
-     * @param {string} dir - Current directory path
-     * @param {number} depth - Current depth level
-     */
-    function walkDirectory(dir, depth) {
-        if (depth > maxDepth) {
-            return;
-        }
-
-        try {
-            const entries = fs.readdirSync(dir, { withFileTypes: true });
-
-            for (const entry of entries) {
-                // Skip hidden directories and ignored patterns
-                if (entry.name.startsWith('.') || ignoreSet.has(entry.name)) {
-                    continue;
-                }
-
-                const fullPath = path.join(dir, entry.name);
-
-                if (entry.isDirectory()) {
-                    // Recurse into subdirectory
-                    walkDirectory(fullPath, depth + 1);
-                } else if (entry.isFile()) {
-                    // Check if this file matches any registered type
-                    for (const fileType of fileTypes) {
-                        const registry = VERSION_FILE_TYPES[fileType];
-                        if (registry && entry.name === registry.filename) {
-                            // Read version from file
-                            const version = registry.readVersion(fullPath);
-
-                            // Create descriptor
-                            const descriptor = {
-                                path: fullPath,
-                                relativePath: path.relative(repoRoot, fullPath),
-                                type: fileType,
-                                projectLabel: registry.projectLabel,
-                                version,
-                                selected: true // Default: all files selected
-                            };
-
-                            discoveredFiles.push(descriptor);
-
-                            logger.debug('version-manager - discoverVersionFiles', 'Found version file', {
-                                relativePath: descriptor.relativePath,
-                                type: fileType,
-                                version
-                            });
-                        }
-                    }
+    walkDirectoryTree(repoRoot, {
+        maxDepth,
+        ignoreSet,
+        onFile: (entry, fullPath) => {
+            for (const fileType of fileTypes) {
+                const registry = VERSION_FILE_TYPES[fileType];
+                if (registry && entry.name === registry.filename) {
+                    const version = registry.readVersion(fullPath);
+                    const descriptor = {
+                        path: fullPath,
+                        relativePath: path.relative(repoRoot, fullPath),
+                        type: fileType,
+                        projectLabel: registry.projectLabel,
+                        version,
+                        selected: true
+                    };
+                    discoveredFiles.push(descriptor);
+                    logger.debug('version-manager - discoverVersionFiles', 'Found version file', {
+                        relativePath: descriptor.relativePath,
+                        type: fileType,
+                        version
+                    });
                 }
             }
-        } catch (error) {
+        },
+        onError: (dir, error) => {
             logger.debug('version-manager - discoverVersionFiles', 'Error reading directory', {
                 dir,
                 error: error.message
             });
         }
-    }
-
-    // Start walking from repo root at depth 0
-    walkDirectory(repoRoot, 0);
+    });
 
     // Sort results: root files first, then by depth, then alphabetically
     discoveredFiles.sort((a, b) => {

package/package.json

@@ -1,69 +1,69 @@
-{
-    "name": "claude-git-hooks",
-    "version": "2.18.0",
-    "description": "Git hooks with Claude CLI for code analysis and automatic commit messages",
-    "type": "module",
-    "bin": {
-        "claude-hooks": "./bin/claude-hooks"
-    },
-    "scripts": {
-        "test": "npm run test:all",
-        "test:all": "npm run lint && npm run test:smoke && npm run test:unit && npm run test:integration",
-        "test:smoke": "node --experimental-vm-modules node_modules/jest/bin/jest.js test/smoke --maxWorkers=1",
-        "test:unit": "node --experimental-vm-modules node_modules/jest/bin/jest.js test/unit --forceExit",
-        "test:integration": "node --experimental-vm-modules node_modules/jest/bin/jest.js test/integration --maxWorkers=1 --testTimeout=30000 --forceExit",
-        "test:integration:ci": "node --experimental-vm-modules node_modules/jest/bin/jest.js test/integration/ci-safe.test.js --maxWorkers=1 --testTimeout=30000 --forceExit",
-        "test:changed": "node --experimental-vm-modules node_modules/jest/bin/jest.js test/unit --changedSince=main --forceExit",
-        "test:watch": "node --experimental-vm-modules node_modules/jest/bin/jest.js --watch",
-        "test:coverage": "node --experimental-vm-modules node_modules/jest/bin/jest.js --coverage",
-        "lint": "eslint lib/ bin/claude-hooks",
-        "lint:fix": "eslint lib/ bin/claude-hooks --fix",
-        "format": "prettier --write \"lib/**/*.js\" \"bin/**\" \"test/**/*.js\"",
-        "precommit": "npm run lint && npm run test:smoke",
-        "prepublishOnly": "npm run test:all"
-    },
-    "keywords": [
-        "git",
-        "hooks",
-        "claude",
-        "ai",
-        "code-review",
-        "commit-messages",
-        "pre-commit",
-        "automation"
-    ],
-    "author": "Pablo Rovito",
-    "license": "MIT",
-    "repository": {
-        "type": "git",
-        "url": "https://github.com/mscope-S-L/git-hooks.git"
-    },
-    "engines": {
-        "node": ">=16.9.0"
-    },
-    "engineStrict": false,
-    "os": [
-        "darwin",
-        "linux",
-        "win32"
-    ],
-    "preferGlobal": true,
-    "files": [
-        "bin/",
-        "lib/",
-        "templates/",
-        "README.md",
-        "CHANGELOG.md",
-        "CLAUDE.md",
-        "LICENSE"
-    ],
-    "dependencies": {
-        "@octokit/rest": "^21.0.0"
-    },
-    "devDependencies": {
-        "@types/jest": "^29.5.0",
-        "eslint": "^8.57.0",
-        "jest": "^29.7.0",
-        "prettier": "^3.2.0"
-    }
-}
+{
+    "name": "claude-git-hooks",
+    "version": "2.18.1",
+    "description": "Git hooks with Claude CLI for code analysis and automatic commit messages",
+    "type": "module",
+    "bin": {
+        "claude-hooks": "./bin/claude-hooks"
+    },
+    "scripts": {
+        "test": "npm run test:all",
+        "test:all": "npm run lint && npm run test:smoke && npm run test:unit && npm run test:integration",
+        "test:smoke": "node --experimental-vm-modules node_modules/jest/bin/jest.js test/smoke --maxWorkers=1",
+        "test:unit": "node --experimental-vm-modules node_modules/jest/bin/jest.js test/unit --forceExit",
+        "test:integration": "node --experimental-vm-modules node_modules/jest/bin/jest.js test/integration --maxWorkers=1 --testTimeout=30000 --forceExit",
+        "test:integration:ci": "node --experimental-vm-modules node_modules/jest/bin/jest.js test/integration/ci-safe.test.js --maxWorkers=1 --testTimeout=30000 --forceExit",
+        "test:changed": "node --experimental-vm-modules node_modules/jest/bin/jest.js test/unit --changedSince=main --forceExit",
+        "test:watch": "node --experimental-vm-modules node_modules/jest/bin/jest.js --watch",
+        "test:coverage": "node --experimental-vm-modules node_modules/jest/bin/jest.js --coverage",
+        "lint": "eslint lib/ bin/claude-hooks",
+        "lint:fix": "eslint lib/ bin/claude-hooks --fix",
+        "format": "prettier --write \"lib/**/*.js\" \"bin/**\" \"test/**/*.js\"",
+        "precommit": "npm run lint && npm run test:smoke",
+        "prepublishOnly": "npm run test:all"
+    },
+    "keywords": [
+        "git",
+        "hooks",
+        "claude",
+        "ai",
+        "code-review",
+        "commit-messages",
+        "pre-commit",
+        "automation"
+    ],
+    "author": "Pablo Rovito",
+    "license": "MIT",
+    "repository": {
+        "type": "git",
+        "url": "https://github.com/mscope-S-L/git-hooks.git"
+    },
+    "engines": {
+        "node": ">=16.9.0"
+    },
+    "engineStrict": false,
+    "os": [
+        "darwin",
+        "linux",
+        "win32"
+    ],
+    "preferGlobal": true,
+    "files": [
+        "bin/",
+        "lib/",
+        "templates/",
+        "README.md",
+        "CHANGELOG.md",
+        "CLAUDE.md",
+        "LICENSE"
+    ],
+    "dependencies": {
+        "@octokit/rest": "^21.0.0"
+    },
+    "devDependencies": {
+        "@types/jest": "^29.5.0",
+        "eslint": "^8.57.0",
+        "jest": "^29.7.0",
+        "prettier": "^3.2.0"
+    }
+}