boe-eurlex-mcp 1.0.0

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2024
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -0,0 +1,120 @@
+<div align="center">
+  <img src="assets/boe_ai.gif" width="300" alt="BOE AI Demo">
+
+<h1>BOE & EUR-Lex MCP Server</h1>
+<h3>La Fuente de Verdad Jurídica Definitiva para tu Agente</h3>
+
+[![TypeScript](https://img.shields.io/badge/TypeScript-3178C6?style=for-the-badge&logo=typescript&logoColor=white)](https://www.typescriptlang.org/)
+[![MCP](https://img.shields.io/badge/MCP-Protocol-orange?style=for-the-badge)](https://modelcontextprotocol.io)
+[![NPM](https://img.shields.io/badge/NPM-red?style=for-the-badge&logo=npm&logoColor=white)](https://www.npmjs.com/package/boe-eurlex-mcp)
+
+<p align="center">
+  <a href="#-la-solución">Solución</a> •
+  <a href="#-instalación">Instalación</a> •
+  <a href="#-quick-start">Quick Start</a> •
+  <a href="#-garantía-de-verdad">Garantía</a>
+</p>
+
+</div>
+
+---
+
+## 🧐 La Solución
+
+Seamos honestos: los LLMs **alucinan leyes**. Se inventan artículos, mezclan normativas derogadas y te citan leyes que suenan muy convincentes pero que **no existen**.
+
+El **BOE & EUR-Lex MCP Server** es el "abogado en la sombra" que tu IA necesita. Conecta directamente a tu agente con la base de datos oficial del **Boletín Oficial del Estado (España)** y **EUR-Lex (Unión Europea)**.
+
+> **Tu agente ya no "cree saber". Ahora sabe buscar, leer y citar la fuente oficial.**
+
+---
+
+## 🚀 Instalación
+
+### Opción A: "Soy un usuario civilizado" (NPM Global)
+Instálalo una vez, úsalo siempre.
+
+```bash
+npm install -g boe-eurlex-mcp
+```
+
+### Opción B: "Me gusta vivir al límite" (NPX)
+Ejecútalo bajo demanda sin instalar nada.
+
+```bash
+npx -y boe-eurlex-mcp
+```
+
+---
+
+## ⚡ Quick Start
+
+Integra el poder del BOE en tu herramienta favorita en segundos.
+
+### 💎 Gemini CLI
+Dale superpoderes legales a tu terminal:
+
+```bash
+gemini mcp add boe_eurlex npx -y boe-eurlex-mcp --scope user
+```
+
+### 🤖 Claude Desktop
+Añade esto a tu `claude_desktop_config.json`:
+
+```json
+{
+  "mcpServers": {
+    "boe_eurlex": {
+      "command": "npx",
+      "args": ["-y", "boe-eurlex-mcp"]
+    }
+  }
+}
+```
+
+### 🌌 Antigravity / Cursor / Cline
+Simplemente busca la sección MCP en tu configuración y añade:
+
+**Comando:** `npx -y boe-eurlex-mcp`
+
+---
+
+## 🛠️ Arsenal Legal (Herramientas)
+
+Tu agente tendrá acceso a estas herramientas de precisión quirúrgica:
+
+### 🇪🇸 Jurisdicción Española (BOE)
+
+| Herramienta | Lo que hace (y lo que no) |
+| :--- | :--- |
+| **`boe.search`** | Busca en toda la legislación consolidada. *Nota: Ahora busca en título Y texto, porque sabemos que nadie se sabe el nombre oficial de la "Ley de Startups".* |
+| **`boe.get_article`** | Extrae un artículo específico con precisión láser. Nada de "resúmenes vagos". Texto literal. |
+| **`boe.get_daily_summary`** | ¿Qué ha pasado hoy en el BOE? Consúltalo con el café de la mañana. |
+
+### 🇪🇺 Jurisdicción Europea (EUR-Lex)
+
+| Herramienta | Misión |
+| :--- | :--- |
+| **`eurlex.search`** | Busca Directivas y Reglamentos en la "jungla" de Bruselas. |
+| **`eurlex.get_article`** | Saca ese artículo 5 del RGPD sin despeinarse. |
+
+---
+
+## 🔐 Garantía de Verdad (Anti-Alucinaciones)
+
+Para que duermas tranquilo, cada respuesta del servidor incluye una **Huella Digital Criptográfica (SHA-256)**.
+
+```json
+{
+  "source": "BOE",
+  "id": "BOE-A-1996-8930",
+  "mensaje": "Si el hash no coincide, alguien ha tocado el texto. (Spoiler: no hemos sido nosotros).",
+  "hash_value": "a591a6d40bf420404a011733cfb7b190d62c65bf0bcda32b57b277d9ad9f146e"
+}
+```
+
+---
+
+## 📜 Licencia
+
+**MIT**. Haz lo que quieras con el código. Solo no nos culpes si pierdes un juicio (esto es una herramienta, no un abogado colegiado).

package/dist/boe/api.js

@@ -0,0 +1,149 @@
+import axios from "axios";
+import * as cheerio from "cheerio";
+const BOE_API_BASE = "https://www.boe.es/datosabiertos/api";
+export async function searchBoe(query, limit = 5) {
+    try {
+        // Construct query JSON as per PDF
+        // If query does not contain field specifier, search in both titulo and texto
+        // This allows finding "Ley de startups" which mentions "startups" in text but not title
+        const queryString = query.includes(":") ? query : `(titulo:${query} OR texto:${query})`;
+        const queryObj = {
+            query: {
+                query_string: {
+                    query: queryString
+                }
+            }
+        };
+        // According to PDF: /datosabiertos/api/legislacion-consolidada?query={...}
+        const response = await axios.get(`${BOE_API_BASE}/legislacion-consolidada`, {
+            params: {
+                query: JSON.stringify(queryObj),
+                limit: limit
+            },
+            headers: {
+                Accept: "application/json"
+            }
+        });
+        if (response.data?.status?.code !== "200") {
+            console.error("BOE API Error:", response.data);
+            return [];
+        }
+        return response.data.data || [];
+    }
+    catch (error) {
+        console.error("Error searching BOE:", error);
+        throw error;
+    }
+}
+// Helper to extract text from a block
+function extractTextFromBlock(block) {
+    if (!block.version)
+        return "";
+    // Find latest version (usually last one? or check dates. For now assume request gives consolidated current/latest valid?)
+    // The PDF says "returns consolidated text complete with all versions". 
+    // We probably want the current valid version.
+    // If it's an array, we need to filter by date? Or usually the logic is complex.
+    // Simplification: Take the last version (often the current one).
+    let version = block.version;
+    if (Array.isArray(version)) {
+        version = version[version.length - 1];
+    }
+    if (!version)
+        return "";
+    // Content is in 'p', 'table', etc.
+    // In JSON, 'p' might be an array of objects or strings?
+    // PDF page 14: <p class="parrafo">Text</p>
+    // In JSON conversion, it typically becomes { "class": "parrafo", "$t": "Text" } or similar.
+    // Since exact JSON structure is not guaranteed to be clean, XML might be safer to parse with cheerio.
+    // But let's try JSON first.
+    let text = "";
+    if (version.p) {
+        const paragraphs = Array.isArray(version.p) ? version.p : [version.p];
+        text = paragraphs.map((p) => typeof p === 'string' ? p : p['$t'] || p['_text'] || JSON.stringify(p)).join("\n");
+    }
+    return text;
+}
+export async function getBoeArticle(id, articleNum) {
+    try {
+        const url = `${BOE_API_BASE}/legislacion-consolidada/id/${id}/texto`;
+        // We use XML because structure of text content in JSON can be messy (elements mixed).
+        // Cheerio is great for this.
+        const response = await axios.get(url, {
+            headers: { Accept: "application/xml" } // Explicitly ask for XML
+        });
+        const $ = cheerio.load(response.data, { xmlMode: true });
+        // Find block with type "precepto" (usually articles) and title matching "Artículo X"
+        // Title might be "Artículo 1", "Artículo 1.", "Art. 1", etc.
+        // We'll normalize.
+        const articleRegex = new RegExp(`^Art[ií]culo\\s+${articleNum}[^0-9]*$`, 'i');
+        let foundBlock = null;
+        $("bloque").each((i, el) => {
+            const tipo = $(el).attr("tipo");
+            const titulo = $(el).attr("titulo") || "";
+            // console.log(`Checking block: ${titulo} (${tipo})`);
+            // Check if title matches "Artículo {num}"
+            // Flexible match: "Artículo 10", "Artículo 10.", "Artículo 10: ..."
+            if ((tipo === "precepto" || tipo === "articulo") && titulo) {
+                // Exact number match is hard. "Artículo 10" vs "Artículo 10 bis".
+                // If user asks for "10", we probably want "Artículo 10" exactly, or "Artículo 10."
+                const normBooking = titulo.trim().replace(/\.$/, ""); // remove trailing dot
+                if (normBooking.toLowerCase() === `artículo ${articleNum.toLowerCase()}` || normBooking.toLowerCase() === `articulo ${articleNum.toLowerCase()}`) {
+                    foundBlock = el;
+                    return false; // break
+                }
+            }
+        });
+        if (!foundBlock) {
+            return null;
+        }
+        // Extract content from the block.
+        // We need the *content* of the latest version.
+        // Inside <bloque>, there are <version> tags.
+        // We want the one that is currently valid. 
+        // <version fecha_vigencia="..." fecha_derogacion="...">
+        // If multiple versions, pick the one with highest start date that isn't derogated? 
+        // Or usually the API returns them in order?
+        // Let's take the last version entry which usually represents the current state.
+        const lastVersion = $(foundBlock).find("version").last();
+        // Extract text content from <p> tags, maintaining order using Cheerio
+        // We want to preserve newlines.
+        let textContent = "";
+        lastVersion.children().each((i, el) => {
+            if (el.type === 'tag' && el.name === 'p') {
+                textContent += $(el).text() + "\n";
+            }
+        });
+        return {
+            source: "BOE",
+            id_or_celex: id,
+            article: articleNum,
+            text: textContent.trim(),
+            citation: {
+                url: `${BOE_API_BASE}/legislacion-consolidada/id/${id}`, // Or the web URL
+                retrieved_at: new Date().toISOString()
+            }
+        };
+    }
+    catch (error) {
+        console.error("Error getting BOE article:", error);
+        throw error;
+    }
+}
+export async function getDailySummary(date) {
+    try {
+        // Date format YYYYMMDD
+        const url = `${BOE_API_BASE}/boe/sumario/${date}`;
+        const response = await axios.get(url, {
+            headers: { Accept: "application/json" }
+        });
+        if (response.data?.status?.code !== "200") {
+            // Try XML if generic error or 404 in JSON wrapper (though axios throws on 404 usually)
+            return null;
+        }
+        return response.data;
+    }
+    catch (error) {
+        console.error("Error getting daily summary:", error);
+        throw error;
+    }
+}

package/dist/eurlex/api.js

@@ -0,0 +1,145 @@
+import axios from "axios";
+import * as cheerio from "cheerio";
+const EURLEX_SEARCH_BASE = "https://eur-lex.europa.eu/search.html";
+const EURLEX_CONTENT_BASE = "https://eur-lex.europa.eu/legal-content";
+export async function searchEurlex(query, lang = "ES", limit = 5) {
+    try {
+        // Construct search URL
+        // scope=EURLEX&text=...&lang=...&type=quick
+        const url = `${EURLEX_SEARCH_BASE}`;
+        const params = {
+            scope: "EURLEX",
+            text: query,
+            lang: lang,
+            type: "quick",
+            sortOne: "DD", // Date descending? Or default. Let's use default relevance.
+            sortOneOrder: "desc"
+        };
+        const response = await axios.get(url, { params });
+        const $ = cheerio.load(response.data);
+        const results = [];
+        // Selectors are tricky and might change.
+        // Usually results are in .SearchResult
+        $(".SearchResult").each((i, el) => {
+            if (i >= limit)
+                return false;
+            const titleEl = $(el).find("h2 > a, h4 > a").first(); // Typically h2 or h4
+            const title = titleEl.text().trim();
+            const href = titleEl.attr("href");
+            if (!title || !href)
+                return;
+            // Href usually starts with ./legal-content/... or absolute
+            // format: ./legal-content/ES/TXT/?uri=CELEX:32016R0679&qid=...
+            // We need to extract CELEX.
+            let celex = "";
+            const celexMatch = href.match(/CELEX:([A-Za-z0-9]+)/);
+            if (celexMatch) {
+                celex = celexMatch[1];
+            }
+            // Fix URL to absolute
+            const absoluteUrl = href.startsWith("http") ? href : `https://eur-lex.europa.eu${href.replace(/^\./, "")}`;
+            results.push({
+                title,
+                celex,
+                url: absoluteUrl
+            });
+        });
+        return results;
+    }
+    catch (error) {
+        console.error("Error searching EUR-Lex:", error);
+        throw error;
+    }
+}
+export async function getEurlexArticle(celex, articleNum, lang = "ES") {
+    try {
+        // Direct HTML content URL
+        // https://eur-lex.europa.eu/legal-content/ES/TXT/HTML/?uri=CELEX:32016R0679
+        const url = `${EURLEX_CONTENT_BASE}/${lang}/TXT/HTML/?uri=CELEX:${celex}`;
+        const response = await axios.get(url, {
+        // header 'User-Agent' might be needed to avoid bot detection?
+        // EUR-Lex is usually open but let's see.
+        });
+        const $ = cheerio.load(response.data);
+        // Find the article.
+        // Search for element with text matching "Artículo {num}" exactly or close to it.
+        // Structure is often: <p class="ti-art">Artículo 1</p>
+        let foundArticle = false;
+        let articleText = "";
+        let capture = false;
+        // Iterate over all elements in the body or standard container
+        // Accessing flattened list of elements can be hard.
+        // We can traverse body children.
+        const body = $("body");
+        // Helper to normalize text for comparison
+        const targetTitle = `Artículo ${articleNum}`;
+        const targetTitlePoints = `Artículo ${articleNum}.`; // Sometimes with dot
+        const targetTitleSpace = `Artículo ${articleNum} `; // With trailing space
+        // We will loop through ALL paragraph-like elements or headers.
+        // Or just traverse all children of the main container (usually div class="bbody" or similar, or just body)
+        // Let's try traversing all elements and detecting start/stop.
+        // In Cheerio, we can select all *relevant* tags in order.
+        // p, div, table...
+        // But hierarchy matters.
+        // Better: Find the Header element, then use .nextUntil() logic?
+        // Find the start element
+        let startElement = null;
+        $("*").each((i, el) => {
+            // Optimization: check tag type
+            if ('name' in el) {
+                const tag = el.name;
+                if (!['p', 'div', 'span', 'h1', 'h2', 'h3', 'h4', 'h5', 'h6'].includes(tag))
+                    return;
+                const text = $(el).text().trim().replace(/\s+/g, " ");
+                // Regex: ^Artículo 1(\.| |$) case insensitive
+                const regex = new RegExp(`^Art[ií]culo\\s+${articleNum}(\\.|\\s|$)`, 'i');
+                if (regex.test(text) && text.length < 50) {
+                    if (!startElement) {
+                        startElement = $(el);
+                    }
+                }
+            }
+        });
+        if (!startElement) {
+            return null;
+        }
+        // Now capture text from startElement until next Article
+        // We need to traverse siblings.
+        articleText += startElement.text() + "\n";
+        let next = startElement.next();
+        while (next.length > 0) {
+            const text = next.text().trim().replace(/\s+/g, " ");
+            // Check if next element is start of NEW article
+            // Regex for ANY article: ^Artículo \d+
+            if (/^Art[ií]culo\s+\d+/i.test(text) && text.length < 50) {
+                break; // Stop
+            }
+            // Append text
+            if (next.is('table')) {
+                // handle table parsing if needed, or just "Table content"
+                articleText += "[Tabla]\n";
+            }
+            else {
+                articleText += next.text().trim() + "\n";
+            }
+            next = next.next();
+        }
+        if (!articleText) {
+            return null;
+        }
+        return {
+            source: "EUR-Lex",
+            id_or_celex: celex,
+            article: articleNum,
+            text: articleText.trim(),
+            citation: {
+                url: `${EURLEX_CONTENT_BASE}/${lang}/TXT/HTML/?uri=CELEX:${celex}`,
+                retrieved_at: new Date().toISOString()
+            }
+        };
+    }
+    catch (error) {
+        console.error("Error getting EUR-Lex article:", error);
+        throw error;
+    }
+}

package/dist/index.js

@@ -0,0 +1,175 @@
+#!/usr/bin/env node
+import { Server } from "@modelcontextprotocol/sdk/server/index.js";
+import { StdioServerTransport } from "@modelcontextprotocol/sdk/server/stdio.js";
+import { CallToolRequestSchema, ListToolsRequestSchema, } from "@modelcontextprotocol/sdk/types.js";
+import { searchBoe, getBoeArticle, getDailySummary } from "./boe/api.js";
+import { searchEurlex, getEurlexArticle } from "./eurlex/api.js";
+import { calculateHash } from "./utils/hash.js";
+// Define the tools
+const BOE_SEARCH_TOOL = {
+    name: "boe_search",
+    description: "Busca normativa en la legislación consolidada del BOE.",
+    inputSchema: {
+        type: "object",
+        properties: {
+            q: { type: "string", description: "Término de búsqueda" },
+            limit: { type: "number", description: "Número máximo de resultados", default: 5 },
+        },
+        required: ["q"],
+    },
+};
+const BOE_GET_ARTICLE_TOOL = {
+    name: "boe_get_article",
+    description: "Obtiene un artículo concreto de una norma del BOE.",
+    inputSchema: {
+        type: "object",
+        properties: {
+            id: { type: "string", description: "Identificador de la norma (ej. BOE-A-1996-8930)" },
+            article: { type: "string", description: "Número del artículo" },
+        },
+        required: ["id", "article"],
+    },
+};
+const BOE_GET_DAILY_SUMMARY_TOOL = {
+    name: "boe_get_daily_summary",
+    description: "Obtiene el sumario del BOE de una fecha concreta.",
+    inputSchema: {
+        type: "object",
+        properties: {
+            date: { type: "string", description: "Fecha en formato YYYYMMDD" },
+        },
+        required: ["date"],
+    },
+};
+const EURLEX_SEARCH_TOOL = {
+    name: "eurlex_search",
+    description: "Busca normativa europea.",
+    inputSchema: {
+        type: "object",
+        properties: {
+            q: { type: "string", description: "Término de búsqueda" },
+            limit: { type: "number", description: "Número máximo de resultados", default: 5 },
+            lang: { type: "string", description: "Idioma (ej. ES)", default: "ES" },
+        },
+        required: ["q"],
+    },
+};
+const EURLEX_GET_ARTICLE_TOOL = {
+    name: "eurlex_get_article",
+    description: "Obtiene un artículo concreto de normativa europea.",
+    inputSchema: {
+        type: "object",
+        properties: {
+            celex: { type: "string", description: "Identificador CELEX" },
+            article: { type: "string", description: "Número del artículo" },
+            lang: { type: "string", description: "Idioma (ej. ES)", default: "ES" },
+        },
+        required: ["celex", "article"],
+    },
+};
+// Server implementation
+const server = new Server({
+    name: "boe-eurlex-mcp",
+    version: "1.0.0",
+}, {
+    capabilities: {
+        tools: {},
+    },
+});
+// List tools handler
+server.setRequestHandler(ListToolsRequestSchema, async () => {
+    return {
+        tools: [
+            BOE_SEARCH_TOOL,
+            BOE_GET_ARTICLE_TOOL,
+            BOE_GET_DAILY_SUMMARY_TOOL,
+            EURLEX_SEARCH_TOOL,
+            EURLEX_GET_ARTICLE_TOOL,
+        ],
+    };
+});
+// Call tool handler
+server.setRequestHandler(CallToolRequestSchema, async (request) => {
+    const { name, arguments: args } = request.params;
+    try {
+        switch (name) {
+            case "boe_search": {
+                const { q, limit = 5 } = args;
+                const results = await searchBoe(q, limit);
+                return {
+                    content: [{ type: "text", text: JSON.stringify(results, null, 2) }],
+                };
+            }
+            case "boe_get_article": {
+                const { id, article } = args;
+                const result = await getBoeArticle(id, article);
+                if (!result) {
+                    return {
+                        isError: true,
+                        content: [{ type: "text", text: `No se encontró el artículo ${article} en la norma ${id}` }]
+                    };
+                }
+                // Add Hash
+                result.hash_algo = "SHA-256";
+                result.hash_value = calculateHash(result.text);
+                return {
+                    content: [{ type: "text", text: JSON.stringify(result, null, 2) }],
+                };
+            }
+            case "boe_get_daily_summary": {
+                const { date } = args;
+                const result = await getDailySummary(date);
+                if (!result) {
+                    return {
+                        isError: true,
+                        content: [{ type: "text", text: `No se encontró sumario para la fecha ${date}` }]
+                    };
+                }
+                return {
+                    content: [{ type: "text", text: JSON.stringify(result, null, 2) }],
+                };
+            }
+            case "eurlex_search": {
+                const { q, limit = 5, lang = "ES" } = args;
+                const results = await searchEurlex(q, lang, limit);
+                return {
+                    content: [{ type: "text", text: JSON.stringify(results, null, 2) }],
+                };
+            }
+            case "eurlex_get_article": {
+                const { celex, article, lang = "ES" } = args;
+                const result = await getEurlexArticle(celex, article, lang);
+                if (!result) {
+                    return {
+                        isError: true,
+                        content: [{ type: "text", text: `No se encontró el artículo ${article} en la norma ${celex} (${lang})` }]
+                    };
+                }
+                // Add Hash
+                result.hash_algo = "SHA-256";
+                result.hash_value = calculateHash(result.text);
+                return {
+                    content: [{ type: "text", text: JSON.stringify(result, null, 2) }],
+                };
+            }
+            default:
+                throw new Error(`Tool unknown: ${name}`);
+        }
+    }
+    catch (error) {
+        return {
+            isError: true,
+            content: [{ type: "text", text: `Error executing tool ${name}: ${error.message}` }]
+        };
+    }
+});
+// Start server
+async function runServer() {
+    const transport = new StdioServerTransport();
+    await server.connect(transport);
+    console.error("BOE & EUR-Lex MCP Server running on stdio");
+}
+runServer().catch((error) => {
+    console.error("Fatal error running server:", error);
+    process.exit(1);
+});

package/dist/utils/hash.js

@@ -0,0 +1,4 @@
+import crypto from "crypto";
+export function calculateHash(text) {
+    return crypto.createHash("sha256").update(text).digest("hex");
+}

package/package.json

@@ -0,0 +1,37 @@
+{
+  "name": "boe-eurlex-mcp",
+  "version": "1.0.0",
+  "description": "MCP Server que permite a agentes de IA consultar directamente legislación oficial española (BOE) y europea (EUR-Lex)",
+  "type": "module",
+  "main": "dist/index.js",
+  "bin": {
+    "boe-eurlex-mcp": "./dist/index.js"
+  },
+  "scripts": {
+    "build": "tsc",
+    "start": "node dist/index.js",
+    "test": "npx tsx tests/manual_test.ts"
+  },
+  "keywords": [
+    "mcp",
+    "boe",
+    "eur-lex",
+    "legislation",
+    "ai",
+    "agent"
+  ],
+  "author": "",
+  "license": "MIT",
+  "dependencies": {
+    "@modelcontextprotocol/sdk": "^1.0.1",
+    "axios": "^1.6.0",
+    "cheerio": "^1.0.0-rc.12",
+    "zod": "^3.22.0"
+  },
+  "devDependencies": {
+    "@types/node": "^20.0.0",
+    "ts-node": "^10.9.2",
+    "tsx": "^4.7.0",
+    "typescript": "^5.3.0"
+  }
+}