claude-git-hooks 2.34.0 → 2.35.0

package/CHANGELOG.md

@@ -5,6 +5,21 @@ 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.35.0] - 2026-03-27
+
+### ✨ Added
+- Prettier formatting support — auto-formats JS/TS/CSS/HTML/JSON/YAML/MD files before linting (format first, then lint)
+- Remote formatter configuration — preset-to-tools mapping fetched from centralized git-hooks-config repo, allowing team-wide control without releasing new versions
+- New `parsePrettierOutput()` function for parsing Prettier --check output into structured issues
+
+### 🔧 Changed
+- Linting pipeline now runs formatters (Prettier) before linters (ESLint) for consistent code style
+- Updated preset-to-tools mapping: frontend, fullstack, ai, and default presets now include Prettier
+- `getLinterToolsForPreset()` now fetches remote config with local fallback instead of using hardcoded mapping only
+- `runLinters()` and `checkLinterAvailability()` converted to async functions to support remote config fetching
+- Unfixable linting issues are now forwarded to the Claude judge for semantic resolution instead of blocking directly
+
+
 ## [2.34.0] - 2026-03-27
 
 ### ✨ Added

package/CLAUDE.md

@@ -6,14 +6,14 @@
 
 **Main use cases:**
 
-1. **Pre-commit linting**: Runs linters (ESLint, Spotless, sqlfluff) on staged files before Claude analysis — fast, deterministic, auto-fix enabled by default
+1. **Pre-commit linting**: Runs formatters and linters (Prettier, ESLint, Spotless, sqlfluff) on staged files before Claude analysis — fast, deterministic, auto-fix enabled by default
 2. **Pre-commit analysis**: Detects security issues, bugs, and code smells before each commit (blocks on CRITICAL/BLOCKER only)
 3. **Interactive analysis**: `claude-hooks analyze` - review all issues (INFO to BLOCKER) interactively before committing
 4. **Automatic messages**: Write `git commit -m "auto"` and Claude generates the message in Conventional Commits format with task-id extracted from branch
 5. **PR analysis**: `claude-hooks analyze-diff [branch]` generates title, description, and test plan for PRs
 6. **PR review**: `claude-hooks analyze-pr <url>` analyzes a GitHub PR with preset guidelines, Linear ticket enrichment, and posts review comments
 7. **PR creation**: `claude-hooks create-pr [branch]` creates the PR on GitHub with automatic metadata (reviewers from CODEOWNERS, labels by preset, merge strategy auto-detected from branch naming)
-8. **Linting**: `claude-hooks lint [paths...]` runs linters on staged files, directories, or specific files — supports ESLint, Spotless, sqlfluff per preset
+8. **Linting**: `claude-hooks lint [paths...]` runs formatters and linters on staged files, directories, or specific files — supports Prettier, ESLint, Spotless, sqlfluff per preset (remote config priority with local fallback)
 9. **Coupling detection**: `claude-hooks check-coupling` scans open PRs targeting a base branch, computes file overlap, and reports which features are coupled (share modified files) — helps TL make informed decisions before cutting a release
 10. **Shadow management**: `claude-hooks shadow <analyze|reset|sync>` manages the shadow branch lifecycle — analyze divergence vs main and active RC, reset shadow to a clean copy of main, or sync shadow with a source branch (RC, develop, feature)
 11. **Release creation**: `claude-hooks create-release <major|minor|patch>` creates a release-candidate branch from develop, bumps version files, commits, pushes, and deploys to shadow — replaces the 8 manual steps executed every Tuesday by the Tech Lead
@@ -86,7 +86,7 @@ claude-git-hooks/
 │   │   └── prepare-commit-msg.js     # Message generation - auto commit messages
 │   └── utils/                        # Reusable modules - shared logic
 │       ├── tool-runner.js            # Generic tool executor - resolve, spawn, parse, auto-fix (v2.34.0)
-│       ├── linter-runner.js          # Linter orchestration - preset mapping, ESLint/Spotless/sqlfluff (v2.34.0)
+│       ├── linter-runner.js          # Linter orchestration - preset mapping, Prettier/ESLint/Spotless/sqlfluff, remote config (v2.34.0)
 │       ├── analysis-engine.js        # Shared analysis logic - file data, 3-tier routing, results (v2.13.0+)
 │       ├── diff-analysis-orchestrator.js  # Intelligent batch orchestration via Opus (v2.20.0)
 │       ├── claude-client.js          # Claude CLI wrapper - spawn, retry, model override
@@ -183,6 +183,7 @@ preset config (.claude/presets/{name}/config.json)  ← HIGHEST PRIORITY
 **Team-wide remote config** ([`mscope-S-L/git-hooks-config`](https://github.com/mscope-S-L/git-hooks-config)):
 
 - `labels.json` — PR label rules (fetched by `remote-config.js`, consumed by `label-resolver.js`)
+- `formatters.json` — preset-to-tools mapping for linting/formatting (fetched by `remote-config.js`, consumed by `linter-runner.js`)
 - `permissions.json` — role-based authorization (fetched directly by `authorization.js`, fail-closed)
 - Changes take effect immediately across all governed repos — no tool update needed
 
@@ -319,7 +320,7 @@ consolidateResults()
 | `lib/cli-metadata.js`           | Command registry                | `commands`, `buildCommandMap()`, `generateCompletionData()`, `PRESET_NAMES`, `HOOK_NAMES`, `BUMP_TYPES`                                                                                                                                                                                                                                                                                                                                                                                                                                                    |
 | `lib/config.js`                 | Config system                   | `getConfig()`                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              |
 | `tool-runner.js`                | Generic tool executor           | `isToolAvailable()`, `filterFilesByTool()`, `runTool()`, `runToolFix()`, `runToolWithAutoFix()`, `displayToolResult()` (v2.34.0)                                                                                                                                                                                                                                                                                                                                                                                                                           |
-| `linter-runner.js`              | Linter orchestration            | `runLinters()`, `displayLintResults()`, `checkLinterAvailability()`, `getLinterToolsForPreset()`, `LINTER_TOOLS`, `PRESET_LINTERS`, `parseEslintOutput()`, `parseSpotlessOutput()`, `parseSqlfluffOutput()`, `filesToSpotlessRegex()` (v2.34.0)                                                                                                                                                                                                                                                                                                            |
+| `linter-runner.js`              | Linter orchestration            | `runLinters()`, `displayLintResults()`, `checkLinterAvailability()`, `getLinterToolsForPreset()`, `LINTER_TOOLS`, `PRESET_LINTERS`, `parsePrettierOutput()`, `parseEslintOutput()`, `parseSpotlessOutput()`, `parseSqlfluffOutput()`, `filesToSpotlessRegex()` (v2.34.0)                                                                                                                                                                                                                                                                                   |
 | `analysis-engine.js`            | Shared analysis logic           | `buildFileData()`, `buildFilesData()`, `runAnalysis()`, `consolidateResults()`, `hasBlockingIssues()`, `hasAnyIssues()`, `displayResults()`, `displayIssueSummary()` (v2.13.0+)                                                                                                                                                                                                                                                                                                                                                                            |
 | `diff-analysis-orchestrator.js` | Intelligent batch orchestration | `orchestrateBatches()`, `buildFileOverview()`, `detectDependencies()` (v2.20.0)                                                                                                                                                                                                                                                                                                                                                                                                                                                                            |
 | `claude-client.js`              | Claude CLI wrapper              | `analyzeCode()`, `executeClaudeWithRetry()`, `extractJSON()` — spawn, retry, model override                                                                                                                                                                                                                                                                                                                                                                                                                                                                |
@@ -359,8 +360,8 @@ consolidateResults()
 7. **Adapter Pattern**: `git-operations.js` abstracts git commands into JS functions
 8. **Singleton Pattern**: `config.js` loads configuration once per execution
 9. **Guard Pattern**: `authorization.js` — fail-closed gate in `bin/claude-hooks` before command dispatch; static `PROTECTED_COMMANDS` set avoids API calls for unprotected commands; permissions sourced from `mscope-S-L/git-hooks-config/permissions.json`
-10. **Remote Config Pattern**: `remote-config.js` — fetches JSON from `mscope-S-L/git-hooks-config`, caches per-process (including nulls), graceful degradation (warn + return null); `label-resolver.js` — callers receive config via dependency injection and decide fallback
-11. **Pipeline Pattern**: `tool-runner.js` + `linter-runner.js` — generic tool execution infrastructure; linters (and future formatters) share the same resolve → spawn → parse → fix → re-stage pipeline. Tool definitions are data objects, not classes.
+10. **Remote Config Pattern**: `remote-config.js` — fetches JSON from `mscope-S-L/git-hooks-config`, caches per-process (including nulls), graceful degradation (warn + return null); `label-resolver.js` and `linter-runner.js` — callers fetch remote config and decide fallback (`labels.json` for PR labels, `formatters.json` for preset-to-tools mapping)
+11. **Pipeline Pattern**: `tool-runner.js` + `linter-runner.js` — generic tool execution infrastructure; formatters (Prettier) and linters (ESLint, Spotless, sqlfluff) share the same resolve → spawn → parse → fix → re-stage pipeline. Tool definitions are data objects, not classes. Preset-to-tools mapping fetched from `mscope-S-L/git-hooks-config/formatters.json` (remote config priority, local fallback).
 
 ### Key Data Flows
 
@@ -372,13 +373,14 @@ git commit
   → filters by preset extensions + size
   ↓
   → LINTING STEP (fast, deterministic)
-    → getLinterToolsForPreset(presetName) → applicable linters
-    → for each linter:
+    → getLinterToolsForPreset(presetName):
+        1. fetchRemoteConfig('formatters.json') → remote presetTools mapping
+        2. fallback to local PRESET_LINTERS if remote unavailable
+    → for each tool (formatters first, then linters):
         isToolAvailable() → not found? warn + install hint → skip
         filterFilesByTool() → matching files
         runToolWithAutoFix() → check → auto-fix → re-stage → re-check
-    → if failOnError && errors remain → exit 1 (COMMIT BLOCKED)
-    → if failOnWarning && warnings → exit 1 (COMMIT BLOCKED)
+    → unfixable issues forwarded to judge
   ↓
   → continues to Claude analysis
 ```

package/README.md

@@ -82,6 +82,43 @@ export GITHUB_TOKEN="ghp_..."
 
 Create token at https://github.com/settings/tokens with scopes: `repo`, `read:org`
 
+### Linting & Formatting
+
+Runs formatters and linters on staged files automatically during pre-commit, or on demand:
+
+```bash
+# Lint staged files (default)
+claude-hooks lint
+
+# Lint all files in a directory
+claude-hooks lint src/
+
+# Lint specific files
+claude-hooks lint file1.js file2.java
+
+# Mix of directories and files
+claude-hooks lint src/ lib/utils/ file.js
+```
+
+**Tools per preset** (configured via [remote config](https://github.com/mscope-S-L/git-hooks-config)):
+
+| Preset      | Tools                         |
+| ----------- | ----------------------------- |
+| `frontend`  | Prettier, ESLint              |
+| `backend`   | Spotless                      |
+| `fullstack` | Prettier, ESLint, Spotless    |
+| `database`  | sqlfluff                      |
+| `ai`        | Prettier, ESLint              |
+| `default`   | Prettier, ESLint              |
+
+**Behavior:**
+
+- Formatters run first (Prettier), then linters (ESLint) — format before lint
+- Auto-fix enabled by default — fixes and re-stages files automatically
+- Missing tools are skipped with install instructions (never blocks)
+- Unfixable issues are forwarded to the Claude judge for semantic resolution
+- Tool-to-preset mapping is fetched from remote config (team-controlled, no release needed)
+
 ### Analyze Code (Interactive Review)
 
 Run interactive code analysis before committing:

package/lib/commands/install.js

@@ -673,7 +673,7 @@ export async function runInstall(args) {
         const presetName = config.preset || 'default';
         if (config.linting?.enabled !== false) {
             const { checkLinterAvailability } = await import('../utils/linter-runner.js');
-            checkLinterAvailability(presetName);
+            await checkLinterAvailability(presetName);
         }
     } catch {
         // Non-fatal — linter check failure should not block installation

package/lib/commands/lint.js

@@ -170,7 +170,7 @@ export async function runLint(args = []) {
 
     info(`🎯 Linting ${filesToLint.length} file(s) with '${metadata.displayName}' preset`);
 
-    const lintResult = runLinters(filesToLint, config, presetName);
+    const lintResult = await runLinters(filesToLint, config, presetName);
     displayLintResults(lintResult);
 
     // Exit with error code if linting failed

package/lib/hooks/pre-commit.js

@@ -152,7 +152,7 @@ const main = async () => {
             logger.info('🔍 Running linters...');
             const lintStartTime = Date.now();
             const filePaths = validFiles.map((f) => (typeof f === 'string' ? f : f.path));
-            const lintResult = runLinters(filePaths, config, presetName);
+            const lintResult = await runLinters(filePaths, config, presetName);
             displayLintResults(lintResult);
 
             // Record lint metric

package/lib/utils/linter-runner.js

@@ -23,6 +23,7 @@ import {
     displayToolResult
 } from './tool-runner.js';
 import { getRepoRoot } from './git-operations.js';
+import { fetchRemoteConfig } from './remote-config.js';
 import logger from './logger.js';
 
 /**
@@ -157,6 +158,46 @@ export function parseSqlfluffOutput(stdout) {
     return { errors, warnings };
 }
 
+/**
+ * Parse Prettier --check output into structured issues
+ * Prettier outputs [warn] lines for files that need formatting
+ *
+ * @param {string} stdout - Prettier --check stdout
+ * @returns {{ errors: Array, warnings: Array }}
+ */
+export function parsePrettierOutput(stdout) {
+    const errors = [];
+    const warnings = [];
+
+    const lines = stdout.split('\n');
+
+    for (const line of lines) {
+        const trimmed = line.trim();
+
+        // Match [warn] <filepath> lines — skip summary lines
+        const match = trimmed.match(/^\[warn\]\s+(.+)$/);
+        if (!match) continue;
+
+        const content = match[1];
+
+        // Skip Prettier's summary lines (not file paths)
+        if (
+            content.includes('Code style issues') ||
+            content.includes('Forgot to run Prettier')
+        ) {
+            continue;
+        }
+
+        errors.push({
+            file: content,
+            severity: 'error',
+            message: 'File is not properly formatted'
+        });
+    }
+
+    return { errors, warnings };
+}
+
 /**
  * Convert file paths to Spotless-compatible regex pattern
  * Spotless -DspotlessFiles accepts a regex matching absolute file paths
@@ -176,6 +217,25 @@ export function filesToSpotlessRegex(files) {
  * @type {Object<string, import('./tool-runner.js').ToolDefinition>}
  */
 export const LINTER_TOOLS = {
+    prettier: {
+        name: 'prettier',
+        command: 'npx',
+        args: (files) => ['prettier', '--check', ...files],
+        fixArgs: (files) => ['prettier', '--write', ...files],
+        detectCommand: 'prettier',
+        detectInProjectFile: {
+            filename: 'package.json',
+            check: (content) => {
+                const pkg = JSON.parse(content);
+                const allDeps = { ...pkg.dependencies, ...pkg.devDependencies };
+                return 'prettier' in allDeps;
+            }
+        },
+        installHint: 'npm install --save-dev prettier',
+        extensions: ['.js', '.jsx', '.ts', '.tsx', '.css', '.scss', '.html', '.json', '.md', '.yaml', '.yml'],
+        parseOutput: parsePrettierOutput,
+        timeout: 30000
+    },
     eslint: {
         name: 'eslint',
         command: 'npx',
@@ -228,27 +288,56 @@ export const LINTER_TOOLS = {
 };
 
 /**
- * Preset-to-linter mapping
- * Each preset lists the linter tool names it uses
+ * Local fallback preset-to-tool mapping
+ * Used when remote formatters.json is unavailable
  * @type {Object<string, string[]>}
  */
 export const PRESET_LINTERS = {
-    frontend: ['eslint'],
+    frontend: ['prettier', 'eslint'],
     backend: ['spotless'],
-    fullstack: ['eslint', 'spotless'],
+    fullstack: ['prettier', 'eslint', 'spotless'],
     database: ['sqlfluff'],
-    ai: ['eslint'],
-    default: ['eslint']
+    ai: ['prettier', 'eslint'],
+    default: ['prettier', 'eslint']
 };
 
 /**
- * Get linter tool definitions for a preset
+ * Get linter/formatter tool definitions for a preset.
+ * Fetches preset-to-tools mapping from remote config (formatters.json),
+ * falls back to local PRESET_LINTERS when remote is unavailable.
  *
  * @param {string} presetName - Preset name
- * @returns {import('./tool-runner.js').ToolDefinition[]} Tool definitions
+ * @returns {Promise<import('./tool-runner.js').ToolDefinition[]>} Tool definitions
  */
-export function getLinterToolsForPreset(presetName) {
-    const toolNames = PRESET_LINTERS[presetName] || PRESET_LINTERS.default;
+export async function getLinterToolsForPreset(presetName) {
+    // Try remote config first
+    const remoteConfig = await fetchRemoteConfig('formatters.json');
+
+    let toolNames;
+
+    if (remoteConfig?.presetTools?.[presetName]) {
+        toolNames = remoteConfig.presetTools[presetName];
+        logger.debug('linter-runner - getLinterToolsForPreset', 'Using remote preset tools', {
+            preset: presetName,
+            tools: toolNames
+        });
+    } else if (remoteConfig?.presetTools?.default) {
+        toolNames = remoteConfig.presetTools.default;
+        logger.debug('linter-runner - getLinterToolsForPreset',
+            'Preset not in remote config, using remote default', {
+                preset: presetName,
+                tools: toolNames
+            });
+    } else {
+        // Fall back to local
+        toolNames = PRESET_LINTERS[presetName] || PRESET_LINTERS.default;
+        logger.debug('linter-runner - getLinterToolsForPreset', 'Using local fallback', {
+            preset: presetName,
+            tools: toolNames,
+            remoteAvailable: remoteConfig !== null
+        });
+    }
+
     return toolNames.map((name) => LINTER_TOOLS[name]).filter(Boolean);
 }
 
@@ -260,12 +349,12 @@ export function getLinterToolsForPreset(presetName) {
  * @param {string} [presetName] - Preset name (default: 'default')
  * @returns {{ results: ToolRunResult[], totalErrors: number, totalWarnings: number, totalFixed: number }}
  */
-export function runLinters(files, config, presetName = 'default') {
+export async function runLinters(files, config, presetName = 'default') {
     const lintConfig = config.linting || {};
     const autoFix = lintConfig.autoFix !== false;
     const timeout = lintConfig.timeout || 30000;
 
-    const tools = getLinterToolsForPreset(presetName);
+    const tools = await getLinterToolsForPreset(presetName);
     const results = [];
 
     logger.debug('linter-runner - runLinters', 'Starting linters', {
@@ -415,8 +504,8 @@ export function lintIssuesToAnalysisDetails(lintResult) {
  *
  * @param {string} presetName - Preset name
  */
-export function checkLinterAvailability(presetName) {
-    const tools = getLinterToolsForPreset(presetName);
+export async function checkLinterAvailability(presetName) {
+    const tools = await getLinterToolsForPreset(presetName);
 
     if (tools.length === 0) {
         return;

package/package.json

@@ -1,69 +1,69 @@
-{
-    "name": "claude-git-hooks",
-    "version": "2.34.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.1",
-        "jest": "^29.7.0",
-        "prettier": "^3.2.0"
-    }
-}
+{
+    "name": "claude-git-hooks",
+    "version": "2.35.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.1",
+        "jest": "^29.7.0",
+        "prettier": "^3.2.0"
+    }
+}