@withone/mcp 1.2.4 → 1.3.1

package/build/knowledge-sections.test.js

@@ -0,0 +1,359 @@
+import { describe, it } from 'node:test';
+import assert from 'node:assert/strict';
+import fs from 'node:fs';
+import path from 'node:path';
+import { fileURLToPath } from 'node:url';
+import { parseSections, buildDigest, renderWhole, renderDigestNotice, renderDigestBanner, collapseSections, omittedSections, findSections, selectSections, parseSectionFlag, classifyHeading, flattenSections, sectionText, slugify, } from './knowledge-sections.js';
+// Pure string-in/structure-out module: no home-directory access, no sandbox needed.
+const fixturesDir = path.join(path.dirname(fileURLToPath(import.meta.url)), 'test-support', 'fixtures');
+const fixture = (name) => fs.readFileSync(path.join(fixturesDir, name), 'utf-8');
+const GITHUB = fixture('knowledge-github-create-issue.md'); // ~25k, canonical template
+const STRIPE = fixture('knowledge-stripe-create-customer.md'); // ~10k, canonical template
+const GMAIL = fixture('knowledge-gmail-send-email.md'); // ~10k, custom-action template
+describe('parseSections', () => {
+    it('takes the first H1 as the title and promotes its H2s to top level', () => {
+        const doc = parseSections(GITHUB);
+        assert.equal(doc.title, 'Create an Issue for a Repository');
+        assert.equal(doc.preface, '');
+        assert.deepEqual(doc.sections.map((s) => s.heading).slice(0, 6), ['Prerequisites', 'Method', 'URL', 'Headers', 'Description', 'Enforcement Rules']);
+        assert.ok(doc.sections.every((s) => s.level === 2));
+    });
+    it('parses a CRLF document identically to LF (Windows checkouts, scraped docs)', () => {
+        const lf = GITHUB.replace(/\r\n?/g, '\n');
+        const crlf = lf.replace(/\n/g, '\r\n');
+        // Without normalisation the trailing \r defeats the heading regex, so the
+        // title is empty and nothing is sectioned.
+        assert.equal(parseSections(crlf).title, 'Create an Issue for a Repository');
+        assert.deepEqual(parseSections(crlf), parseSections(lf));
+    });
+    it('nests H3s under their H2', () => {
+        const doc = parseSections(GITHUB);
+        const response = doc.sections.find((s) => s.heading === 'Response');
+        assert.equal(response.children.length, 7);
+        assert.equal(response.children[0].heading, 'Success Response (201 Created)');
+        assert.ok(response.children.slice(1).every((c) => c.heading.startsWith('Error Response')));
+    });
+    it('handles the custom-action template (Endpoint + Request Body with H3 children)', () => {
+        const doc = parseSections(GMAIL);
+        assert.equal(doc.title, 'Send Email');
+        const body = doc.sections.find((s) => s.heading === 'Request Body');
+        assert.deepEqual(body.children.map((c) => c.heading), ['Required Request Body Fields', 'Optional Request Body Fields']);
+    });
+    it('round-trips: rendering the whole tree reproduces the source text', () => {
+        for (const src of [GITHUB, STRIPE, GMAIL]) {
+            const doc = parseSections(src);
+            // Rendering joins blocks with a blank line and parseSections normalises
+            // CRLF to LF, so compare modulo blank-line runs and line-ending style.
+            const norm = (s) => s.replace(/\r\n?/g, '\n').replace(/\n{2,}/g, '\n').trim();
+            assert.equal(norm(renderWhole(doc)), norm(src));
+        }
+    });
+    it('ignores # lines inside fenced code blocks', () => {
+        const md = ['# T', '', '## Real', '```bash', '# not a heading', '~~~ still inside', '```', 'after', '## Next', ''].join('\n');
+        const doc = parseSections(md);
+        assert.deepEqual(doc.sections.map((s) => s.heading), ['Real', 'Next']);
+        assert.ok(doc.sections[0].text.includes('# not a heading'));
+    });
+    it('keeps a second H1 as a top-level section rather than a new title', () => {
+        const md = '# One\n\n## A\ntext\n\n# Two\n\n## B\nmore\n';
+        const doc = parseSections(md);
+        assert.equal(doc.title, 'One');
+        assert.deepEqual(doc.sections.map((s) => `${s.level}:${s.heading}`), ['2:A', '1:Two']);
+        assert.equal(doc.sections[1].children[0].heading, 'B');
+    });
+    it('returns no sections and an empty title for text without headings', () => {
+        const doc = parseSections('just prose\nno headings');
+        assert.equal(doc.title, '');
+        assert.equal(doc.sections.length, 0);
+        assert.equal(doc.preface, 'just prose\nno headings');
+    });
+    it('de-duplicates ids and slugs headings predictably', () => {
+        assert.equal(slugify('Success Response (201 Created)'), 'success-response-201-created');
+        assert.equal(slugify('Optional Request Body Fields (application/x-www-form-urlencoded)'), 'optional-request-body-fields-application-x-www-form-urlencoded');
+        const doc = parseSections('# T\n## Notes\n## Notes\n## Notes\n');
+        assert.deepEqual(doc.sections.map((s) => s.id), ['notes', 'notes-2', 'notes-3']);
+    });
+    it('measures chars including children', () => {
+        const doc = parseSections(GITHUB);
+        const response = doc.sections.find((s) => s.heading === 'Response');
+        assert.equal(response.chars, sectionText(response).length + 0 || response.chars);
+        assert.ok(response.chars > 15_000, `response subtree is ${response.chars}`);
+        const total = doc.sections.reduce((n, s) => n + s.chars, 0);
+        assert.ok(total <= GITHUB.length && total > GITHUB.length * 0.95);
+    });
+});
+describe('classifyHeading', () => {
+    it('marks request-building sections essential and the size drivers deferred', () => {
+        const essential = ['Method', 'URL', 'Endpoint', 'Headers', 'Description', 'Prerequisites', 'Enforcement Rules',
+            'Required Path Parameters', 'Required Request Body Fields', 'Required Query Parameters', 'Request Body',
+            'Sample Request', 'Gotchas', 'Error Handling'];
+        const deferred = ['Response', 'Success Response (201 Created)', 'Error Response (404 Not Found)', 'Response Fields',
+            'Optional Request Body Fields', 'Optional Request Body Fields (application/x-www-form-urlencoded)',
+            'Optional Query Parameters', 'Example Usage', 'Example 1: Simple Message', 'Behavior', 'Notes', 'Document.footnotes'];
+        for (const h of essential)
+            assert.equal(classifyHeading(h), 'essential', h);
+        for (const h of deferred)
+            assert.equal(classifyHeading(h), 'deferred', h);
+    });
+});
+describe('buildDigest', () => {
+    it('returns small documents whole, untruncated, with every section flagged included', () => {
+        const doc = parseSections(STRIPE);
+        const d = buildDigest(doc, { wholeDocThreshold: 20_000 });
+        assert.equal(d.truncated, false);
+        assert.equal(d.omitted, 0);
+        assert.equal(d.omittedChars, 0);
+        assert.ok(d.sections.every((s) => s.included === true));
+        assert.equal(d.sections.length, flattenSections(doc.sections).length);
+        assert.ok(d.markdown.includes('## Optional Request Body Fields'));
+    });
+    it('returns a document with no headings whole', () => {
+        const d = buildDigest(parseSections('a'.repeat(50_000)));
+        assert.equal(d.truncated, false);
+        assert.equal(d.markdown.length, 50_000);
+    });
+    it('keeps essentials, defers the big Response block, and lists everything omitted', () => {
+        const doc = parseSections(GITHUB);
+        const d = buildDigest(doc);
+        assert.equal(d.truncated, true);
+        assert.ok(d.markdown.length < GITHUB.length / 2, `digest is ${d.markdown.length} of ${GITHUB.length}`);
+        const status = Object.fromEntries(d.sections.map((s) => [s.heading, s.included]));
+        for (const h of ['Prerequisites', 'Method', 'URL', 'Headers', 'Description', 'Enforcement Rules',
+            'Required Path Parameters', 'Required Request Body Fields', 'Sample Request', 'Gotchas', 'Error Handling']) {
+            assert.equal(status[h], true, h);
+        }
+        assert.equal(status['Success Response (201 Created)'], false);
+        assert.equal(status['Response Fields'], false);
+        assert.ok(!d.markdown.includes('### Success Response (201 Created)'));
+        assert.ok(d.markdown.includes('## Required Request Body Fields'));
+        // The TOC covers every section, not just the omitted ones.
+        assert.equal(d.sections.length, flattenSections(doc.sections).length);
+        assert.ok(d.omitted > 0);
+        assert.ok(d.omittedChars > 15_000);
+    });
+    it('back-fills deferred sections in priority order while they fit the budget', () => {
+        const doc = parseSections(GITHUB);
+        const d = buildDigest(doc, { wholeDocThreshold: 0, budget: 8_000 });
+        const status = Object.fromEntries(d.sections.map((s) => [s.heading, s.included]));
+        // Optional fields (~1k) fit and are the first to be pulled back in.
+        assert.equal(status['Optional Request Body Fields'], true);
+        // The 15k success response never fits an 8k budget.
+        assert.equal(status['Success Response (201 Created)'], false);
+        const tight = buildDigest(doc, { wholeDocThreshold: 0, budget: 0 });
+        const tightStatus = Object.fromEntries(tight.sections.map((s) => [s.heading, s.included]));
+        assert.equal(tightStatus['Optional Request Body Fields'], false);
+        assert.equal(tightStatus['Method'], true, 'essentials survive a zero budget');
+    });
+    it('cuts an oversized essential section and marks it partial', () => {
+        const big = '# T\n\n## Method\nPOST\n\n## Required Request Body Fields\n' + '| a | b |\n'.repeat(2_000) + '\n## Notes\nn\n';
+        const doc = parseSections(big);
+        const d = buildDigest(doc, { wholeDocThreshold: 0, sectionCap: 500, budget: 0 });
+        const req = d.sections.find((s) => s.heading === 'Required Request Body Fields');
+        assert.equal(req.included, 'partial');
+        assert.ok(d.markdown.includes('_[truncated'));
+        assert.ok(d.markdown.includes('section: "required-request-body-fields"'));
+        assert.ok(d.truncated);
+        assert.ok(d.omittedChars > 15_000);
+    });
+    it('keeps essential children of an essential parent but defers deferred children (custom template)', () => {
+        const doc = parseSections(GMAIL);
+        const d = buildDigest(doc, { wholeDocThreshold: 0, budget: 0 });
+        const status = Object.fromEntries(d.sections.map((s) => [s.heading, s.included]));
+        assert.equal(status['Request Body'], true);
+        assert.equal(status['Required Request Body Fields'], true);
+        assert.equal(status['Optional Request Body Fields'], false);
+        assert.ok(d.markdown.includes('### Required Request Body Fields'));
+        assert.ok(!d.markdown.includes('### Optional Request Body Fields'));
+    });
+    it('keeps required fields nested under a deferred sub-heading (Notion option layout)', () => {
+        const md = [
+            '# Update Page', '', '## Method', 'PATCH', '', '## Request Body', 'Pick one option.', '',
+            '### Option A: Replace everything', '#### Required Request Body Fields (Replace)', '| a |', '#### Optional Fields (Replace)', '| opt |',
+            '### Option B: Search and replace', 'intro b', '#### Required Fields inside `update_content`', '| b |', '#### Examples for B', 'ex',
+            '## Response', 'x'.repeat(9_000), '',
+        ].join('\n');
+        const d = buildDigest(parseSections(md), { wholeDocThreshold: 0, budget: 0 });
+        const st = Object.fromEntries(d.sections.map((s) => [s.heading, s.included]));
+        assert.equal(st['Option A: Replace everything'], true, 'scaffolding kept');
+        assert.equal(st['Required Request Body Fields (Replace)'], true);
+        assert.equal(st['Optional Fields (Replace)'], false);
+        assert.equal(st['Option B: Search and replace'], true);
+        assert.equal(st['Required Fields inside `update_content`'], true);
+        assert.equal(st['Examples for B'], false);
+        assert.equal(st['Response'], false);
+        assert.ok(d.markdown.includes('intro b'));
+        assert.ok(!d.markdown.includes('| opt |'));
+    });
+    it('never back-fills appended H1 chunks even when they would fit the budget', () => {
+        const md = [
+            '# Action', '', '## Method', 'POST', '', '## Response', 'r'.repeat(9_000), '',
+            '# Data Models — Chunk 2/7', '', '# TinyType', '## Description', 'small', '## Fields', '| f |', '',
+        ].join('\n');
+        const d = buildDigest(parseSections(md), { wholeDocThreshold: 0, budget: 100_000 });
+        const st = Object.fromEntries(d.sections.map((s) => [s.heading, s.included]));
+        assert.equal(st['Response'], true, 'H2 deferred sections are back-filled');
+        assert.equal(st['TinyType'], false, 'appendix H1s are not');
+        assert.equal(st['Data Models — Chunk 2/7'], false);
+        assert.ok(d.truncated);
+    });
+    it('treats GraphQL request-building headings as essential', () => {
+        for (const h of ['GraphQL Operation', 'Request Variables', 'Path Parameters', 'Query Parameters']) {
+            assert.equal(classifyHeading(h), 'essential', h);
+        }
+        assert.equal(classifyHeading('Type'), 'deferred');
+    });
+    it('falls back to the whole document when the digest would include everything anyway', () => {
+        const doc = parseSections(STRIPE);
+        const d = buildDigest(doc, { wholeDocThreshold: 0, budget: 1_000_000 });
+        assert.equal(d.truncated, false);
+        assert.equal(d.markdown, renderWhole(doc));
+    });
+});
+describe('renderDigestNotice', () => {
+    it('is empty for an untruncated digest', () => {
+        const d = buildDigest(parseSections(STRIPE), { wholeDocThreshold: 1_000_000 });
+        assert.equal(renderDigestNotice(d, 'stripe', 'id'), '');
+    });
+    it('names only top-most omitted sections and shows both load commands', () => {
+        const d = buildDigest(parseSections(GITHUB), { wholeDocThreshold: 0, budget: 0 });
+        const notice = renderDigestNotice(d, 'github', 'conn_mod_def::X::Y');
+        assert.match(notice, /This is a digest, not the full document/);
+        assert.match(notice, /get_one_action_knowledge again for github \/ conn_mod_def::X::Y with section: "/);
+        assert.match(notice, /full: true/);
+        assert.ok(notice.includes('Response,') || notice.includes('Response.'), 'lists the omitted Response parent');
+        assert.ok(!notice.includes('Success Response (201 Created)'), 'children of an omitted parent are implied');
+        assert.ok(notice.includes('Response Fields'));
+    });
+});
+describe('renderDigestBanner', () => {
+    it('is empty when nothing was omitted and one line otherwise', () => {
+        assert.equal(renderDigestBanner(buildDigest(parseSections(STRIPE), { wholeDocThreshold: 1_000_000 })), '');
+        const b = renderDigestBanner(buildDigest(parseSections(GITHUB), { wholeDocThreshold: 0, budget: 0 }));
+        assert.match(b, /^> \*\*Digest\.\*\* \d+ sections \([\d,]+ chars\) omitted/);
+        assert.ok(!b.includes('\n'));
+    });
+});
+describe('collapseSections', () => {
+    const mk = (level, i) => ({ id: `s${i}`, heading: `H${i}`, level, chars: 10, included: false });
+    it('leaves a short list alone', () => {
+        const list = [mk(2, 1), mk(3, 2), mk(2, 3)];
+        const r = collapseSections(list, 60);
+        assert.equal(r.collapsed, false);
+        assert.equal(r.sections, list);
+    });
+    it('drops the deepest levels first and counts hidden descendants on the surviving ancestor', () => {
+        // 5 H2s, each with 20 H3s = 105 entries
+        const list = [];
+        let i = 0;
+        for (let a = 0; a < 5; a++) {
+            list.push(mk(2, i++));
+            for (let b = 0; b < 20; b++)
+                list.push(mk(3, i++));
+        }
+        const r = collapseSections(list, 60);
+        assert.equal(r.collapsed, true);
+        assert.equal(r.sections.length, 5);
+        assert.ok(r.sections.every((s) => s.level === 2 && s.children === 20));
+    });
+    it('collapses the real 400-heading Notion-style tree to a manageable size', () => {
+        // Synthesise: canonical doc + 40 appended H1 chunks each with 10 H2s.
+        const parts = ['# Big', '## Method', 'POST', '## Response', 'r'];
+        for (let c = 0; c < 40; c++) {
+            parts.push(`# Chunk ${c}`);
+            for (let h = 0; h < 10; h++)
+                parts.push(`## Type ${c}-${h}`, 'x');
+        }
+        const d = buildDigest(parseSections(parts.join('\n')), { wholeDocThreshold: 0 });
+        assert.equal(d.sections.length, 442);
+        const r = collapseSections(d.sections);
+        assert.ok(r.collapsed);
+        assert.equal(r.sections.length, 42, 'title-level H2s and the 40 chunk H1s');
+        const chunk = r.sections.find((s) => s.heading === 'Chunk 3');
+        assert.equal(chunk.children, 10);
+    });
+});
+describe('omittedSections', () => {
+    it('lists only what the digest left out', () => {
+        const d = buildDigest(parseSections(GITHUB), { wholeDocThreshold: 0, budget: 0 });
+        const o = omittedSections(d);
+        assert.equal(o.collapsed, false);
+        assert.ok(o.sections.length > 0 && o.sections.length < d.sections.length);
+        assert.ok(o.sections.every((s) => s.included !== true));
+        assert.ok(o.sections.some((s) => s.id === 'response-fields'));
+        assert.ok(!o.sections.some((s) => s.id === 'method'));
+    });
+    it('is empty for an untruncated digest', () => {
+        assert.deepEqual(omittedSections(buildDigest(parseSections(STRIPE), { wholeDocThreshold: 1_000_000 })).sections, []);
+    });
+});
+describe('findSections / selectSections', () => {
+    const doc = parseSections(GITHUB);
+    const headings = (r) => (r.ok ? r.sections.map((s) => s.heading) : r);
+    it('matches by id, exact heading, and case-insensitive heading', () => {
+        assert.deepEqual(headings(findSections(doc, 'response-fields')), ['Response Fields']);
+        assert.deepEqual(headings(findSections(doc, 'Response Fields')), ['Response Fields']);
+        assert.deepEqual(headings(findSections(doc, '"response fields"')), ['Response Fields']);
+        assert.deepEqual(headings(findSections(doc, 'success response')), ['Success Response (201 Created)']);
+    });
+    it('resolves aliases to groups', () => {
+        assert.deepEqual(headings(findSections(doc, 'optional')), ['Optional Request Body Fields']);
+        assert.deepEqual(headings(findSections(doc, 'required')), ['Required Path Parameters', 'Required Request Body Fields']);
+        assert.deepEqual(headings(findSections(doc, 'examples')), ['Example Usage']);
+        const errors = headings(findSections(doc, 'errors'));
+        assert.ok(errors.length >= 6 && errors.includes('Error Handling'));
+    });
+    it('returns every copy when a heading is duplicated', () => {
+        const dup = parseSections('# T\n## Response\nnot included\n## Notes\nn\n# T again\n## Response\nthe real one\n');
+        const r = findSections(dup, 'Response');
+        assert.ok(r.ok);
+        assert.deepEqual(r.sections.map((s) => s.id), ['response', 'response-2']);
+        const byId = findSections(dup, 'response-2');
+        assert.ok(byId.ok && byId.sections.length === 1);
+    });
+    it('labels appended H1 chunks as appendix in the notice', () => {
+        const d = buildDigest(parseSections('# T\n## Method\nPOST\n## Response\n' + 'x'.repeat(9000) + '\n# T\n## Response\nagain\n'), { wholeDocThreshold: 0, budget: 0 });
+        const n = renderDigestNotice(d, 'p', 'id');
+        assert.ok(n.includes('T (appendix)'), n);
+    });
+    it('a parent match carries its children', () => {
+        const r = selectSections(doc, ['response']);
+        assert.ok(r.ok);
+        assert.ok(r.markdown.includes('### Success Response (201 Created)'));
+        assert.ok(r.markdown.includes('### Error Response (404 Resource not found)'));
+        assert.ok(r.markdown.startsWith('# Create an Issue for a Repository'));
+    });
+    it('prefix matches that all share a canonical name return the group', () => {
+        const r = findSections(doc, 'error response');
+        assert.ok(r.ok);
+        assert.equal(r.sections.length, 6);
+    });
+    it('an ambiguous prefix returns candidates rather than guessing', () => {
+        const r = findSections(doc, 'e');
+        assert.ok(!r.ok);
+        assert.equal(r.reason, 'ambiguous');
+        assert.ok(r.candidates.length > 1);
+    });
+    it('an unknown name returns not-found with the full section list', () => {
+        const r = findSections(doc, 'pricing');
+        assert.ok(!r.ok);
+        assert.equal(r.reason, 'not-found');
+        assert.equal(r.candidates.length, flattenSections(doc.sections).length);
+    });
+    it('selectSections accepts several names, dedupes, and orders by document position', () => {
+        const r = selectSections(doc, ['notes', 'Method', 'success-response-201-created', 'response']);
+        assert.ok(r.ok);
+        assert.deepEqual(r.sections.map((s) => s.heading), ['Method', 'Response', 'Notes']);
+    });
+    it('selectSections reports the first bad name', () => {
+        const r = selectSections(doc, ['method', 'nope']);
+        assert.ok(!r.ok);
+        assert.equal(r.query, 'nope');
+    });
+});
+describe('parseSectionFlag', () => {
+    it('splits repeated flags and comma lists', () => {
+        assert.deepEqual(parseSectionFlag(undefined), []);
+        assert.deepEqual(parseSectionFlag('a, b'), ['a', 'b']);
+        assert.deepEqual(parseSectionFlag(['a,b', ' c ', '']), ['a', 'b', 'c']);
+    });
+});

package/build/schemas.js

@@ -25,7 +25,10 @@ export const searchOnePlatformActionsInputSchema = {
  */
 export const getOneActionKnowledgeInputSchema = {
     actionId: z.string().describe("The action ID to get knowledge for (from the actions list returned by search_one_platform_actions). REQUIRED: This tool must be called before execute_one_action to load the action's documentation into context."),
-    platform: z.string().describe("The platform name to get knowledge for (e.g., 'ship-station', 'shopify'). This is the kebab-case version of the platform name that comes from the list_one_integrations tool AVAILABLE PLATFORMS section.")
+    platform: z.string().describe("The platform name to get knowledge for (e.g., 'ship-station', 'shopify'). This is the kebab-case version of the platform name that comes from the list_one_integrations tool AVAILABLE PLATFORMS section."),
+    section: z.string().optional().describe("Load specific section(s) of the documentation by name (e.g. 'Response Fields', or comma-separated 'Response Fields, Optional Request Body Fields'). Large docs return a digest first; use this on a follow-up call to pull a section the digest omitted."),
+    full: z.boolean().optional().describe("Return the entire documentation verbatim instead of the token-saving digest. Ignored when `section` is set. Leave unset by default; only set it when you genuinely need every section."),
+    toc: z.boolean().optional().describe("Return only the table of contents (every section's id, heading, and size), no bodies. Use it to see everything available when the digest collapsed its list. Ignored when `section` is set.")
 };
 /**
  * Schema for executing One actions
@@ -111,7 +114,7 @@ export const searchOnePlatformActionsToolConfig = {
 };
 export const getOneActionKnowledgeToolConfig = {
     title: "Get Action Knowledge",
-    description: "Get comprehensive documentation for a specific action including parameters, requirements, and usage examples. MANDATORY: You MUST call this tool before execute_one_action to understand the action's requirements, parameter structure, caveats, and proper usage. This loads the action documentation into context and is required for successful execution.",
+    description: "Get comprehensive documentation for a specific action including parameters, requirements, and usage examples. MANDATORY: You MUST call this tool before execute_one_action to understand the action's requirements, parameter structure, caveats, and proper usage. This loads the action documentation into context and is required for successful execution. Large documents come back as a digest (the sections needed to build a correct request, plus a list of what was omitted); request an omitted section by name with `section`, or the whole document with `full: true`.",
     inputSchema: getOneActionKnowledgeInputSchema
 };
 export const executeOneActionToolConfig = {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@withone/mcp",
-  "version": "1.2.4",
+  "version": "1.3.1",
   "description": "A Model Context Protocol Server for One",
   "type": "module",
   "bin": {
@@ -11,6 +11,7 @@
   ],
   "scripts": {
     "build": "tsc && node -e \"require('fs').chmodSync('build/index.js', '755')\"",
+    "test": "node scripts/run-tests.mjs",
     "prepare": "npm run build",
     "watch": "tsc --watch",
     "inspector": "npx @modelcontextprotocol/inspector build/index.js",
@@ -31,6 +32,7 @@
     "@types/express": "^5.0.3",
     "@types/node": "^22.0.0",
     "nodemon": "^3.1.10",
+    "tsx": "^4.23.13",
     "typescript": "^5.6.0"
   },
   "author": {