sizuku 0.2.1 → 0.3.1

package/README.md

@@ -70,24 +70,30 @@ export const postRelations = relations(post, ({ one }) => ({
 }))
 ```
 
-Prepare sizuku.json:
-
-```json
-{
-  "input": "db/schema.ts",
-  "zod": {
-    "output": "zod/index.ts",
-    "comment": true,
-    "type": true
+Prepare sizuku.config.ts:
+
+```ts
+import defineConfig from 'sizuku/config'
+
+export default defineConfig({
+  input: 'db/schema.ts',
+  zod: {
+    output: 'zod/index.ts',
+    comment: true,
+    type: true,
+    zod: 'v4',
+    relation: true,
   },
-  "valibot": {
-    "output": "valibot/index.ts",
-    "comment": true
+  valibot: {
+    output: 'valibot/index.ts',
+    comment: true,
+    type: true,
+    relation: true,
   },
-  "mermaid": {
-    "output": "mermaid-er/ER.md"
-  }
-}
+  mermaid: {
+    output: 'mermaid-er/ER.md',
+  },
+})
 ```
 
 Run Sizuku:
@@ -160,6 +166,8 @@ export const UserSchema = v.object({
   name: v.pipe(v.string(), v.minLength(1), v.maxLength(50)),
 })
 
+export type User = v.InferInput<typeof UserSchema>
+
 export const PostSchema = v.object({
   /**
    * Primary key
@@ -179,9 +187,15 @@ export const PostSchema = v.object({
   userId: v.pipe(v.string(), v.uuid()),
 })
 
+export type Post = v.InferInput<typeof PostSchema>
+
 export const UserRelationsSchema = v.object({ ...UserSchema.entries, posts: v.array(PostSchema) })
 
+export type UserRelations = v.InferInput<typeof UserRelationsSchema>
+
 export const PostRelationsSchema = v.object({ ...PostSchema.entries, user: UserSchema })
+
+export type PostRelations = v.InferInput<typeof PostRelationsSchema>
 ```
 
 ### Mermaid ER

package/dist/config/index.d.ts

@@ -1,18 +1,27 @@
 export type Config = {
-    input?: `${string}.ts`;
-    zod?: {
-        output?: `${string}.ts`;
-        comment?: boolean;
-        type?: boolean;
-        zod?: 'v4' | 'mini' | '@hono/zod-openapi';
+    readonly input: `${string}.ts`;
+    readonly zod?: {
+        readonly output: `${string}.ts`;
+        readonly comment?: boolean;
+        readonly type?: boolean;
+        readonly zod?: 'v4' | 'mini' | '@hono/zod-openapi';
+        readonly relation?: boolean;
     };
-    valibot?: {
-        output?: `${string}.ts`;
-        comment?: boolean;
-        type?: boolean;
+    readonly valibot?: {
+        readonly output: `${string}.ts`;
+        readonly comment?: boolean;
+        readonly type?: boolean;
+        readonly relation?: boolean;
     };
-    mermaid?: {
-        output?: string;
+    readonly mermaid?: {
+        readonly output: string;
     };
 };
-export declare function getConfig(): Config;
+export declare function config(): Promise<{
+    readonly ok: true;
+    readonly value: Config;
+} | {
+    readonly ok: false;
+    readonly error: string;
+}>;
+export default function defineConfig(config: Config): Config;

package/dist/config/index.js

@@ -1,13 +1,85 @@
-import fs from 'node:fs';
-export function getConfig() {
-    if (!fs.existsSync('sizuku.json')) {
-        throw new Error('sizuku.json not found');
+import { existsSync } from 'node:fs';
+import { resolve } from 'node:path';
+import { pathToFileURL } from 'node:url';
+import { register } from 'tsx/esm/api';
+export async function config() {
+    const isTs = (o) => o.endsWith('.ts');
+    const abs = resolve(process.cwd(), 'sizuku.config.ts');
+    if (!existsSync(abs)) {
+        return { ok: false, error: `Config not found: ${abs}` };
     }
-    const parsed = JSON.parse(fs.readFileSync('sizuku.json', 'utf-8'));
-    return {
-        input: parsed.input,
-        zod: parsed.zod,
-        valibot: parsed.valibot,
-        mermaid: parsed.mermaid,
-    };
+    try {
+        register();
+        const mod = await import(pathToFileURL(abs).href);
+        if (!('default' in mod)) {
+            return { ok: false, error: 'Config must export default object' };
+        }
+        if (mod.default !== undefined) {
+            if (!isTs(mod.default.input)) {
+                return { ok: false, error: 'Input must be a .ts file' };
+            }
+            // zod
+            if (mod.default.zod !== undefined) {
+                if (!isTs(mod.default.zod.output)) {
+                    return { ok: false, error: 'Zod output must be a .ts file' };
+                }
+                if (mod.default.zod.comment !== undefined) {
+                    if (typeof mod.default.zod.comment !== 'boolean') {
+                        return { ok: false, error: 'Zod comment must be a boolean' };
+                    }
+                }
+                if (mod.default.zod.type !== undefined) {
+                    if (typeof mod.default.zod.type !== 'boolean') {
+                        return { ok: false, error: 'Zod type must be a boolean' };
+                    }
+                }
+                if (mod.default.zod.zod !== undefined) {
+                    if (mod.default.zod.zod !== 'v4' &&
+                        mod.default.zod.zod !== 'mini' &&
+                        mod.default.zod.zod !== '@hono/zod-openapi') {
+                        return { ok: false, error: 'zod must be v4, mini, or @hono/zod-openapi' };
+                    }
+                }
+                if (mod.default.zod.relation !== undefined) {
+                    if (typeof mod.default.zod.relation !== 'boolean') {
+                        return { ok: false, error: 'Zod relation must be a boolean' };
+                    }
+                }
+            }
+        }
+        // valibot
+        if (mod.default.valibot !== undefined) {
+            if (!isTs(mod.default.valibot.output)) {
+                return { ok: false, error: 'Valibot output must be a .ts file' };
+            }
+            if (mod.default.valibot.comment !== undefined) {
+                if (typeof mod.default.valibot.comment !== 'boolean') {
+                    return { ok: false, error: 'Valibot comment must be a boolean' };
+                }
+            }
+            if (mod.default.valibot.type !== undefined) {
+                if (typeof mod.default.valibot.type !== 'boolean') {
+                    return { ok: false, error: 'Valibot type must be a boolean' };
+                }
+            }
+            if (mod.default.valibot.relation !== undefined) {
+                if (typeof mod.default.valibot.relation !== 'boolean') {
+                    return { ok: false, error: 'Valibot relation must be a boolean' };
+                }
+            }
+        }
+        // mermaid
+        if (mod.default.mermaid !== undefined) {
+            if (typeof mod.default.mermaid.output !== 'string') {
+                return { ok: false, error: 'Mermaid output must be a string' };
+            }
+        }
+        return { ok: true, value: mod.default };
+    }
+    catch (e) {
+        return { ok: false, error: e instanceof Error ? e.message : String(e) };
+    }
+}
+export default function defineConfig(config) {
+    return config;
 }

package/dist/generator/mermaid-er/generator/er-content.js

@@ -14,7 +14,7 @@ export function erContent(relations, tables) {
         // Generate per-table definitions
         ...tables.flatMap((table) => [
             `    ${table.name} {`,
-            ...table.fields.map((field) => `        ${field.type} ${field.name} ${field.description ? `"${field.description}"` : ''}`),
+            ...table.fields.map((field) => `        ${field.type} ${field.name}${field.description ? ` "${field.description}"` : ''}`),
             '    }',
         ]),
         ...ER_FOOTER,

package/dist/generator/mermaid-er/validator/index.js

@@ -43,7 +43,8 @@ export function parseTableInfo(code) {
             const fieldType = baseBuilderName(initExpr);
             const initText = initExpr.getText();
             const lineIdx = prop.getStartLineNumber() - 1;
-            const baseDesc = code
+            // Find the immediate comment above this field
+            const immediateComment = code
                 .slice(0, lineIdx)
                 .reverse()
                 .find((line) => {
@@ -59,10 +60,12 @@ export function parseTableInfo(code) {
                 : initText.includes('.references(')
                     ? '(FK) '
                     : '';
+            // Only include description if there's a comment
+            const description = immediateComment ? `${prefix}${immediateComment}`.trim() : null;
             return {
                 name: fieldName,
                 type: fieldType,
-                description: `${prefix}${baseDesc}`.trim(),
+                description,
             };
         })
             .filter(isFieldInfo);

package/dist/generator/valibot/index.d.ts

@@ -5,7 +5,7 @@
  * @param comment - Whether to include comments in the generated code
  * @param type - Whether to include type information in the generated code
  */
-export declare function sizukuValibot(code: string[], output: `${string}.ts`, comment?: boolean, type?: boolean, relations?: boolean): Promise<{
+export declare function sizukuValibot(code: string[], output: `${string}.ts`, comment?: boolean, type?: boolean, relation?: boolean): Promise<{
     ok: true;
     value: undefined;
 } | {

package/dist/generator/valibot/index.js

@@ -11,14 +11,14 @@ import { valibotCode } from './generator/valibot-code.js';
  * @param comment - Whether to include comments in the generated code
  * @param type - Whether to include type information in the generated code
  */
-export async function sizukuValibot(code, output, comment, type, relations) {
+export async function sizukuValibot(code, output, comment, type, relation) {
     const baseSchemas = extractSchemas(code, 'valibot');
     const relationSchemas = extractRelationSchemas(code, 'valibot');
     const valibotGeneratedCode = [
         "import * as v from 'valibot'",
         '',
         ...baseSchemas.map((schema) => valibotCode(schema, comment ?? false, type ?? false)),
-        ...(relations
+        ...(relation
             ? relationSchemas.map((schema) => relationValibotCode(schema, type ?? false))
             : []),
     ].join('\n');

package/dist/generator/zod/index.d.ts

@@ -6,10 +6,10 @@
  * @param type - Whether to include type information in the generated code
  * @param zod - The Zod version to use
  */
-export declare function sizukuZod(code: string[], output: `${string}.ts`, comment?: boolean, type?: boolean, zod?: 'v4' | 'mini' | '@hono/zod-openapi', relations?: boolean): Promise<{
-    ok: true;
-    value: undefined;
+export declare function sizukuZod(code: string[], output: `${string}.ts`, comment?: boolean, type?: boolean, zod?: 'v4' | 'mini' | '@hono/zod-openapi', relation?: boolean): Promise<{
+    readonly ok: true;
+    readonly value: undefined;
 } | {
-    ok: false;
-    error: string;
+    readonly ok: false;
+    readonly error: string;
 }>;

package/dist/generator/zod/index.js

@@ -12,7 +12,7 @@ import { zodCode } from './generator/zod-code.js';
  * @param type - Whether to include type information in the generated code
  * @param zod - The Zod version to use
  */
-export async function sizukuZod(code, output, comment, type, zod, relations) {
+export async function sizukuZod(code, output, comment, type, zod, relation) {
     const importLine = zod === 'mini'
         ? `import * as z from 'zod/mini'`
         : zod === '@hono/zod-openapi'
@@ -24,7 +24,7 @@ export async function sizukuZod(code, output, comment, type, zod, relations) {
         importLine,
         '',
         ...baseSchemas.map((schema) => zodCode(schema, comment ?? false, type ?? false)),
-        ...(relations ? relationSchemas.map((schema) => relationZodCode(schema, type ?? false)) : []),
+        ...(relation ? relationSchemas.map((schema) => relationZodCode(schema, type ?? false)) : []),
     ].join('\n');
     const mkdirResult = await mkdir(path.dirname(output));
     if (!mkdirResult.ok) {

package/dist/index.d.ts

@@ -1,8 +1,7 @@
-import type { Config } from './config/index.js';
-export declare function main(config?: Config): Promise<{
-    ok: true;
-    value: string;
+export declare function main(): Promise<{
+    readonly ok: true;
+    readonly value: string;
 } | {
-    ok: false;
-    error: string;
+    readonly ok: false;
+    readonly error: string;
 }>;

package/dist/index.js

@@ -1,17 +1,19 @@
 // #!/usr/bin/env node
-import { getConfig } from './config/index.js';
+import { config } from './config/index.js';
 import { sizukuMermaidER } from './generator/mermaid-er/index.js';
 import { sizukuValibot } from './generator/valibot/index.js';
 import { sizukuZod } from './generator/zod/index.js';
 import { readFileSync } from './shared/fs/index.js';
-export async function main(config = getConfig()) {
-    if (!config.input) {
+export async function main() {
+    const configResult = await config();
+    if (!configResult.ok) {
         return {
             ok: false,
-            error: 'input is not found',
+            error: configResult.error,
         };
     }
-    const contentResult = readFileSync(config.input);
+    const c = configResult.value;
+    const contentResult = readFileSync(c.input);
     if (!contentResult.ok) {
         return {
             ok: false,
@@ -24,37 +26,37 @@ export async function main(config = getConfig()) {
     const code = lines.slice(codeStart);
     const results = [];
     /* zod */
-    if (config.zod?.output) {
-        const zodResult = await sizukuZod(code, config.zod.output, config.zod.comment, config.zod.type, config.zod.zod, true);
+    if (c.zod?.output) {
+        const zodResult = await sizukuZod(code, c.zod.output, c.zod.comment, c.zod.type, c.zod.zod, c.zod.relation);
         if (!zodResult.ok) {
             return {
                 ok: false,
                 error: zodResult.error,
             };
         }
-        results.push(`Generated Zod schema at: ${config.zod?.output}`);
+        results.push(`Generated Zod schema at: ${c.zod?.output}`);
     }
     /* valibot */
-    if (config.valibot?.output) {
-        const valibotResult = await sizukuValibot(code, config.valibot.output, config.valibot.comment, config.valibot.type, true);
+    if (c.valibot?.output) {
+        const valibotResult = await sizukuValibot(code, c.valibot.output, c.valibot.comment, c.valibot.type, c.valibot.relation);
         if (!valibotResult.ok) {
             return {
                 ok: false,
                 error: valibotResult.error,
             };
         }
-        results.push(`Generated Valibot schema at: ${config.valibot?.output}`);
+        results.push(`Generated Valibot schema at: ${c.valibot?.output}`);
     }
     /* mermaid */
-    if (config.mermaid?.output) {
-        const mermaidResult = await sizukuMermaidER(code, config.mermaid.output);
+    if (c.mermaid?.output) {
+        const mermaidResult = await sizukuMermaidER(code, c.mermaid.output);
         if (!mermaidResult.ok) {
             return {
                 ok: false,
                 error: mermaidResult.error,
             };
         }
-        results.push(`Generated Mermaid ER at: ${config.mermaid?.output}`);
+        results.push(`Generated Mermaid ER at: ${c.mermaid?.output}`);
     }
     return {
         ok: true,

package/dist/shared/format/index.d.ts

@@ -5,11 +5,9 @@
  * @returns A `Result` containing the formatted code or an error message.
  */
 export declare function fmt(code: string): Promise<{
-    ok: true;
-    value: string;
-    error?: undefined;
+    readonly ok: true;
+    readonly value: string;
 } | {
-    ok: false;
-    error: string;
-    value?: undefined;
+    readonly ok: false;
+    readonly error: string;
 }>;

package/dist/shared/format/index.js

@@ -7,13 +7,13 @@ import { format } from 'prettier';
  */
 export async function fmt(code) {
     try {
-        const formatted = await format(code, {
+        const result = await format(code, {
             parser: 'typescript',
             printWidth: 100,
             singleQuote: true,
             semi: false,
         });
-        return { ok: true, value: formatted };
+        return { ok: true, value: result };
     }
     catch (e) {
         return {

package/dist/shared/fs/index.d.ts

@@ -1,7 +1,7 @@
 export declare function readFileSync(path: string): {
-    ok: true;
-    value: string;
+    readonly ok: true;
+    readonly value: string;
 } | {
-    ok: false;
-    error: string;
+    readonly ok: false;
+    readonly error: string;
 };

package/dist/shared/fsp/index.d.ts

@@ -5,11 +5,11 @@
  * @returns A `Result` that is `ok` on success, otherwise an error message.
  */
 export declare function mkdir(dir: string): Promise<{
-    ok: false;
-    error: string;
+    readonly ok: false;
+    readonly error: string;
 } | {
-    ok: true;
-    value: undefined;
+    readonly ok: true;
+    readonly value: undefined;
 }>;
 /**
  * Writes UTF-8 text to a file, creating it if necessary.

package/dist/utils/index.d.ts

@@ -48,14 +48,14 @@ export declare function removeAtSign(str: string): string;
  * @param arr - Array of strings to join.
  * @returns Joined string with spaces.
  */
-export declare function joinWithSpace(arr: string[]): string;
+export declare function joinWithSpace(arr: readonly string[]): string;
 /**
  * Split string by newline character.
  *
  * @param str - The input string.
  * @returns Array of strings split by newline.
  */
-export declare function splitByNewline(str: string): string[];
+export declare function splitByNewline(str: string): readonly string[];
 /**
  * Trim whitespace from string.
  *
@@ -96,14 +96,14 @@ export declare function removeOptionalSuffix(str: string): string;
  * @param str - The input string.
  * @returns Array of strings split by whitespace.
  */
-export declare function splitByWhitespace(str: string): string[];
+export declare function splitByWhitespace(str: string): readonly string[];
 /**
  * Split string by dot character.
  *
  * @param str - The input string.
  * @returns Array of strings split by dot.
  */
-export declare function splitByDot(str: string): string[];
+export declare function splitByDot(str: string): readonly string[];
 /**
  * Parse field comments and extract definition line and description.
  *
@@ -135,10 +135,10 @@ export declare function inferInput(name: string): string;
  * @returns
  */
 export declare function fieldDefinitions(schema: {
-    name: string;
-    fields: {
-        name: string;
-        definition: string;
-        description?: string;
+    readonly name: string;
+    readonly fields: {
+        readonly name: string;
+        readonly definition: string;
+        readonly description?: string;
     }[];
 }, comment: boolean): string;

package/dist/utils/index.js

@@ -73,19 +73,7 @@ export function joinWithSpace(arr) {
  * @returns Array of strings split by newline.
  */
 export function splitByNewline(str) {
-    const result = [];
-    let current = '';
-    for (let i = 0; i < str.length; i++) {
-        if (str[i] === '\n') {
-            result.push(current);
-            current = '';
-        }
-        else {
-            current += str[i];
-        }
-    }
-    result.push(current);
-    return result;
+    return str.split('\n');
 }
 /**
  * Trim whitespace from string.
@@ -94,17 +82,7 @@ export function splitByNewline(str) {
  * @returns Trimmed string.
  */
 export function trimString(str) {
-    let start = 0;
-    let end = str.length - 1;
-    while (start <= end &&
-        (str[start] === ' ' || str[start] === '\t' || str[start] === '\r' || str[start] === '\n')) {
-        start++;
-    }
-    while (end >= start &&
-        (str[end] === ' ' || str[end] === '\t' || str[end] === '\r' || str[end] === '\n')) {
-        end--;
-    }
-    return str.substring(start, end + 1);
+    return str.trim();
 }
 /**
  * Parse relation line and extract components.
@@ -113,13 +91,13 @@ export function trimString(str) {
  * @returns Parsed relation or null if not a relation line.
  */
 export function parseRelationLine(line) {
-    if (!startsWith(line, '@relation'))
+    if (!line.startsWith('@relation'))
         return null;
-    const parts = splitByWhitespace(line);
+    const parts = line.trim().split(/\s+/);
     if (parts.length < 5)
         return null;
-    const fromParts = splitByDot(parts[1]);
-    const toParts = splitByDot(parts[2]);
+    const fromParts = parts[1].split('.');
+    const toParts = parts[2].split('.');
     if (fromParts.length !== 2 || toParts.length !== 2)
         return null;
     return {
@@ -159,28 +137,10 @@ export function removeOptionalSuffix(str) {
  * @returns Array of strings split by whitespace.
  */
 export function splitByWhitespace(str) {
-    const result = [];
-    let current = '';
-    let inWord = false;
-    for (let i = 0; i < str.length; i++) {
-        const char = str[i];
-        const isWhitespace = char === ' ' || char === '\t' || char === '\r' || char === '\n';
-        if (isWhitespace) {
-            if (inWord) {
-                result.push(current);
-                current = '';
-                inWord = false;
-            }
-        }
-        else {
-            current += char;
-            inWord = true;
-        }
-    }
-    if (inWord) {
-        result.push(current);
-    }
-    return result;
+    return str
+        .trim()
+        .split(/\s+/)
+        .filter((s) => s.length > 0);
 }
 /**
  * Split string by dot character.
@@ -189,19 +149,7 @@ export function splitByWhitespace(str) {
  * @returns Array of strings split by dot.
  */
 export function splitByDot(str) {
-    const result = [];
-    let current = '';
-    for (let i = 0; i < str.length; i++) {
-        if (str[i] === '.') {
-            result.push(current);
-            current = '';
-        }
-        else {
-            current += str[i];
-        }
-    }
-    result.push(current);
-    return result;
+    return str.split('.');
 }
 /* ========================================================================== *
  *  parse
@@ -214,24 +162,25 @@ export function splitByDot(str) {
  * @returns Parsed definition and description
  */
 export function parseFieldComments(commentLines, tag) {
-    const cleaned = commentLines.map((line) => removeTripleSlash(line).trim()).filter(isNonEmpty);
-    // Extract object type from strictObject/looseObject tags
-    const objectTypeLine = cleaned.find((line) => containsSubstring(line, `${tag.slice(1)}strictObject`) ||
-        containsSubstring(line, `${tag.slice(1)}looseObject`));
-    const objectType = objectTypeLine && containsSubstring(objectTypeLine, 'strictObject')
-        ? 'strict'
-        : objectTypeLine && containsSubstring(objectTypeLine, 'looseObject')
-            ? 'loose'
-            : undefined;
-    // Extract definition (excluding strictObject/looseObject tags)
-    const definitionLine = cleaned.find((line) => startsWith(line, tag) &&
-        !containsSubstring(line, 'strictObject') &&
-        !containsSubstring(line, 'looseObject'));
-    const definition = definitionLine ? removeAtSign(definitionLine) : '';
-    const descriptionLines = cleaned.filter((line) => !(containsSubstring(line, '@z.') ||
-        containsSubstring(line, '@v.') ||
-        containsSubstring(line, '@relation.')));
-    const description = descriptionLines.length > 0 ? joinWithSpace(descriptionLines) : undefined;
+    const cleaned = commentLines
+        .map((line) => (line.startsWith('///') ? line.substring(3) : line).trim())
+        .filter((line) => line.length > 0);
+    const objectTypeLine = cleaned.find((line) => line.includes(`${tag.slice(1)}strictObject`) || line.includes(`${tag.slice(1)}looseObject`));
+    const objectType = objectTypeLine
+        ? objectTypeLine.includes('strictObject')
+            ? 'strict'
+            : objectTypeLine.includes('looseObject')
+                ? 'loose'
+                : undefined
+        : undefined;
+    const definitionLine = cleaned.find((line) => line.startsWith(tag) && !line.includes('strictObject') && !line.includes('looseObject'));
+    const definition = definitionLine
+        ? definitionLine.startsWith('@')
+            ? definitionLine.substring(1)
+            : definitionLine
+        : '';
+    const descriptionLines = cleaned.filter((line) => !(line.includes('@z.') || line.includes('@v.') || line.includes('@relation.')));
+    const description = descriptionLines.length > 0 ? descriptionLines.join(' ') : undefined;
     return { definition, description, objectType };
 }
 /* ========================================================================== *
@@ -246,14 +195,14 @@ export function parseFieldComments(commentLines, tag) {
  */
 export function extractFieldComments(sourceText, fieldStartPos) {
     const beforeField = sourceText.substring(0, fieldStartPos);
-    const lines = splitByNewline(beforeField);
+    const lines = beforeField.split('\n');
     const reverseIndex = lines
-        .map((line, index) => ({ line: trimString(line), index }))
+        .map((line, index) => ({ line: line.trim(), index }))
         .reverse()
         .reduce((acc, { line }) => {
         if (acc.shouldStop)
             return acc;
-        if (startsWith(line, '///')) {
+        if (line.startsWith('///')) {
             return {
                 commentLines: [line, ...acc.commentLines],
                 shouldStop: false,

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "sizuku",
   "type": "module",
-  "version": "0.2.1",
+  "version": "0.3.1",
   "description": "Sizuku is a tool that generates validation schemas for Zod and Valibot, as well as ER diagrams, from Drizzle schemas annotated with comments.",
   "license": "MIT",
   "keywords": [
@@ -29,6 +29,12 @@
   "bin": {
     "sizuku": "dist/index.js"
   },
+  "exports": {
+    "./config": {
+      "types": "./dist/config/index.d.ts",
+      "import": "./dist/config/index.js"
+    }
+  },
   "scripts": {
     "deps": "rm -rf node_modules && pnpm install",
     "build": "tsc",
@@ -48,6 +54,7 @@
   },
   "dependencies": {
     "prettier": "^3.6.2",
-    "ts-morph": "^26.0.0"
+    "ts-morph": "^26.0.0",
+    "tsx": "^4.20.5"
   }
 }