@veloxts/cli 0.6.52 → 0.6.55

package/CHANGELOG.md

@@ -1,5 +1,41 @@
 # @veloxts/cli
 
+## 0.6.55
+
+### Patch Changes
+
+- feat(mcp): add static TypeScript analyzer for procedure discovery
+- Updated dependencies
+  - @veloxts/auth@0.6.55
+  - @veloxts/core@0.6.55
+  - @veloxts/orm@0.6.55
+  - @veloxts/router@0.6.55
+  - @veloxts/validation@0.6.55
+
+## 0.6.54
+
+### Patch Changes
+
+- feat(cli): add velox mcp init command for Claude Desktop setup
+- Updated dependencies
+  - @veloxts/auth@0.6.54
+  - @veloxts/core@0.6.54
+  - @veloxts/orm@0.6.54
+  - @veloxts/router@0.6.54
+  - @veloxts/validation@0.6.54
+
+## 0.6.53
+
+### Patch Changes
+
+- feat(cli): add duplicate file detection to resource generator
+- Updated dependencies
+  - @veloxts/auth@0.6.53
+  - @veloxts/core@0.6.53
+  - @veloxts/orm@0.6.53
+  - @veloxts/router@0.6.53
+  - @veloxts/validation@0.6.53
+
 ## 0.6.52
 
 ### Patch Changes

package/GUIDE.md

@@ -93,6 +93,24 @@ velox make seeder user      # Scaffold database seeder
 velox make factory user     # Scaffold model factory
 ```
 
+### velox mcp init
+
+Set up Model Context Protocol (MCP) server for Claude Desktop:
+
+```bash
+velox mcp init             # Configure Claude Desktop for VeloxTS
+velox mcp init --dry-run   # Preview configuration changes
+velox mcp init --force     # Overwrite existing configuration
+velox mcp init --json      # Output as JSON for scripting
+```
+
+The MCP server exposes your VeloxTS project's context to Claude Desktop and other AI assistants that support the Model Context Protocol. After running this command, restart Claude Desktop to activate the integration.
+
+Supported platforms:
+- macOS: `~/Library/Application Support/Claude/claude_desktop_config.json`
+- Windows: `%APPDATA%\Claude\claude_desktop_config.json`
+- Linux: `~/.config/Claude/claude_desktop_config.json`
+
 ## Database Seeding
 
 ### Creating Seeders

package/dist/cli.js

@@ -13,6 +13,7 @@ import { createDbCommand } from './commands/db.js';
 import { createDevCommand } from './commands/dev.js';
 import { createIntrospectCommand } from './commands/introspect.js';
 import { createMakeCommand } from './commands/make.js';
+import { createMcpCommand } from './commands/mcp.js';
 import { createMigrateCommand } from './commands/migrate.js';
 import { createProceduresCommand } from './commands/procedures.js';
 import { createScheduleCommand } from './commands/schedule.js';
@@ -33,6 +34,7 @@ function createCLI() {
     program.addCommand(createDevCommand(CLI_VERSION));
     program.addCommand(createIntrospectCommand());
     program.addCommand(createMakeCommand());
+    program.addCommand(createMcpCommand());
     program.addCommand(createMigrateCommand());
     program.addCommand(createProceduresCommand());
     program.addCommand(createScheduleCommand());

package/dist/commands/mcp.d.ts

@@ -0,0 +1,11 @@
+/**
+ * MCP command - Model Context Protocol configuration
+ *
+ * Provides subcommands for managing MCP server integration:
+ * - mcp:init - Set up Claude Desktop configuration for VeloxTS MCP server
+ */
+import { Command } from 'commander';
+/**
+ * Create the mcp command with subcommands
+ */
+export declare function createMcpCommand(): Command;

package/dist/commands/mcp.js

@@ -0,0 +1,344 @@
+/**
+ * MCP command - Model Context Protocol configuration
+ *
+ * Provides subcommands for managing MCP server integration:
+ * - mcp:init - Set up Claude Desktop configuration for VeloxTS MCP server
+ */
+import { homedir, platform } from 'node:os';
+import { join } from 'node:path';
+import * as p from '@clack/prompts';
+import { Command } from 'commander';
+import pc from 'picocolors';
+import { error, formatCommand, formatPath, info, success, warning } from '../utils/output.js';
+import { createDirectory, fileExists, readJsonFile, writeJsonFile } from '../utils/paths.js';
+// ============================================================================
+// Constants
+// ============================================================================
+const MCP_SERVER_NAME = 'veloxts';
+const MCP_SERVER_CONFIG = {
+    command: 'npx',
+    args: ['@veloxts/mcp'],
+};
+// ============================================================================
+// Command Factory
+// ============================================================================
+/**
+ * Create the mcp command with subcommands
+ */
+export function createMcpCommand() {
+    const mcp = new Command('mcp').description('Model Context Protocol server configuration');
+    mcp.addCommand(createMcpInitCommand());
+    return mcp;
+}
+/**
+ * Create the mcp:init subcommand
+ */
+function createMcpInitCommand() {
+    return new Command('init')
+        .description('Set up Claude Desktop configuration for VeloxTS MCP server')
+        .option('-d, --dry-run', 'Preview changes without writing files', false)
+        .option('-f, --force', 'Overwrite existing VeloxTS MCP configuration', false)
+        .option('--json', 'Output results as JSON', false)
+        .action(async (options) => {
+        await runMcpInit(options);
+    })
+        .addHelpText('after', `
+Examples:
+  ${formatCommand('velox mcp:init')}              Set up MCP server configuration
+  ${formatCommand('velox mcp:init --dry-run')}    Preview configuration changes
+  ${formatCommand('velox mcp:init --force')}      Overwrite existing configuration
+  ${formatCommand('velox mcp:init --json')}       Output as JSON for scripting
+
+About:
+  The MCP (Model Context Protocol) server exposes your VeloxTS project's
+  context to Claude Desktop and other AI assistants. This command automates
+  the configuration process.
+
+  After running this command, restart Claude Desktop to use the MCP server.
+`);
+}
+// ============================================================================
+// Platform Detection
+// ============================================================================
+/**
+ * Get the Claude Desktop configuration path for the current platform
+ */
+function getClaudeConfigPath() {
+    const platformName = platform();
+    switch (platformName) {
+        case 'darwin': // macOS
+            return join(homedir(), 'Library', 'Application Support', 'Claude', 'claude_desktop_config.json');
+        case 'win32': // Windows
+            return join(process.env.APPDATA || '', 'Claude', 'claude_desktop_config.json');
+        case 'linux':
+            return join(homedir(), '.config', 'Claude', 'claude_desktop_config.json');
+        default:
+            return null;
+    }
+}
+// ============================================================================
+// Configuration Management
+// ============================================================================
+/**
+ * Check if Claude Desktop is likely installed
+ */
+function isClaudeDesktopInstalled(configPath) {
+    // Check if parent directory exists (more reliable than checking for config file)
+    const configDir = join(configPath, '..');
+    return fileExists(configDir);
+}
+/**
+ * Read existing Claude Desktop configuration
+ */
+async function readClaudeConfig(configPath) {
+    if (!fileExists(configPath)) {
+        return null;
+    }
+    try {
+        const config = await readJsonFile(configPath);
+        return config;
+    }
+    catch (err) {
+        throw new Error(`Failed to parse Claude Desktop configuration: ${err instanceof Error ? err.message : String(err)}`);
+    }
+}
+/**
+ * Check if VeloxTS MCP server is already configured
+ */
+function isVeloxMcpConfigured(config) {
+    if (!config?.mcpServers) {
+        return false;
+    }
+    return MCP_SERVER_NAME in config.mcpServers;
+}
+/**
+ * Add or update VeloxTS MCP server configuration
+ */
+function addVeloxMcpConfig(config) {
+    const newConfig = config ?? {};
+    if (!newConfig.mcpServers) {
+        newConfig.mcpServers = {};
+    }
+    newConfig.mcpServers[MCP_SERVER_NAME] = MCP_SERVER_CONFIG;
+    return newConfig;
+}
+/**
+ * Write Claude Desktop configuration
+ */
+async function writeClaudeConfig(configPath, config) {
+    const configDir = join(configPath, '..');
+    // Ensure directory exists
+    if (!fileExists(configDir)) {
+        await createDirectory(configDir);
+    }
+    await writeJsonFile(configPath, config);
+}
+// ============================================================================
+// Command Implementation
+// ============================================================================
+/**
+ * Run the mcp:init command
+ */
+async function runMcpInit(options) {
+    const { dryRun, force, json } = options;
+    const isInteractive = !json;
+    try {
+        // Detect platform and config path
+        const configPath = getClaudeConfigPath();
+        if (!configPath) {
+            const result = {
+                success: false,
+                action: 'error',
+                configPath: 'unknown',
+                message: 'Unsupported platform',
+                error: `Platform '${platform()}' is not supported`,
+            };
+            if (json) {
+                console.log(JSON.stringify(result, null, 2));
+            }
+            else {
+                error('Unsupported platform.');
+                info(`This command supports macOS, Windows, and Linux.`);
+                info(`Your platform: ${platform()}`);
+            }
+            process.exit(1);
+        }
+        // Check if Claude Desktop is installed
+        if (!isClaudeDesktopInstalled(configPath) && isInteractive) {
+            warning('Claude Desktop may not be installed.');
+            console.log('');
+            console.log(`  ${pc.dim('Expected config directory:')} ${formatPath(join(configPath, '..'))}`);
+            console.log('');
+            const shouldContinue = await p.confirm({
+                message: 'Continue anyway?',
+                initialValue: false,
+            });
+            if (p.isCancel(shouldContinue) || !shouldContinue) {
+                info('Setup cancelled.');
+                return;
+            }
+        }
+        // Read existing configuration
+        let config = null;
+        let configExists = false;
+        try {
+            config = await readClaudeConfig(configPath);
+            configExists = config !== null;
+        }
+        catch (err) {
+            const result = {
+                success: false,
+                action: 'error',
+                configPath,
+                message: 'Failed to read configuration',
+                error: err instanceof Error ? err.message : String(err),
+            };
+            if (json) {
+                console.log(JSON.stringify(result, null, 2));
+            }
+            else {
+                error('Failed to read Claude Desktop configuration.');
+                console.log(`  ${pc.dim('Path:')} ${formatPath(configPath)}`);
+                console.log(`  ${pc.dim('Error:')} ${err instanceof Error ? err.message : String(err)}`);
+                console.log('');
+                info('The configuration file may be corrupted or have invalid JSON.');
+                info('You can manually delete it and run this command again.');
+            }
+            process.exit(1);
+        }
+        // Check if VeloxTS MCP is already configured
+        const isAlreadyConfigured = isVeloxMcpConfigured(config);
+        if (isAlreadyConfigured && !force) {
+            const result = {
+                success: true,
+                action: 'exists',
+                configPath,
+                message: 'VeloxTS MCP server is already configured',
+            };
+            if (json) {
+                console.log(JSON.stringify(result, null, 2));
+            }
+            else {
+                info('VeloxTS MCP server is already configured.');
+                console.log('');
+                console.log(`  ${pc.dim('Config path:')} ${formatPath(configPath)}`);
+                console.log('');
+                warning(`Use ${formatCommand('--force')} to overwrite the existing configuration.`);
+            }
+            return;
+        }
+        // Show what will be done
+        if (isInteractive && !dryRun) {
+            console.log('');
+            if (isAlreadyConfigured) {
+                info('Updating VeloxTS MCP server configuration:');
+            }
+            else if (configExists) {
+                info('Adding VeloxTS MCP server to existing configuration:');
+            }
+            else {
+                info('Creating Claude Desktop configuration:');
+            }
+            console.log('');
+            console.log(`  ${pc.dim('Path:')} ${formatPath(configPath)}`);
+            console.log(`  ${pc.dim('Server:')} ${MCP_SERVER_NAME}`);
+            console.log(`  ${pc.dim('Command:')} ${MCP_SERVER_CONFIG.command} ${MCP_SERVER_CONFIG.args.join(' ')}`);
+            console.log('');
+        }
+        // Add VeloxTS MCP configuration
+        const newConfig = addVeloxMcpConfig(config);
+        // Dry run mode
+        if (dryRun) {
+            const result = {
+                success: true,
+                action: configExists ? 'updated' : 'created',
+                configPath,
+                message: 'Dry run - no changes made',
+            };
+            if (json) {
+                console.log(JSON.stringify({
+                    ...result,
+                    dryRun: true,
+                    preview: newConfig,
+                }, null, 2));
+            }
+            else {
+                console.log('Configuration preview:');
+                console.log('');
+                console.log(JSON.stringify(newConfig, null, 2));
+                console.log('');
+                warning('Dry run mode - no changes made.');
+                console.log(`  ${pc.dim('Remove --dry-run to apply changes.')}`);
+            }
+            return;
+        }
+        // Write configuration
+        try {
+            await writeClaudeConfig(configPath, newConfig);
+        }
+        catch (err) {
+            const result = {
+                success: false,
+                action: 'error',
+                configPath,
+                message: 'Failed to write configuration',
+                error: err instanceof Error ? err.message : String(err),
+            };
+            if (json) {
+                console.log(JSON.stringify(result, null, 2));
+            }
+            else {
+                error('Failed to write Claude Desktop configuration.');
+                console.log(`  ${pc.dim('Path:')} ${formatPath(configPath)}`);
+                console.log(`  ${pc.dim('Error:')} ${err instanceof Error ? err.message : String(err)}`);
+                console.log('');
+                // Check for permission errors
+                if (err instanceof Error && err.message.includes('EACCES')) {
+                    info('You may not have write permission to this directory.');
+                    info('Try running this command with appropriate permissions.');
+                }
+            }
+            process.exit(1);
+        }
+        // Success!
+        const action = isAlreadyConfigured ? 'updated' : configExists ? 'updated' : 'created';
+        const result = {
+            success: true,
+            action,
+            configPath,
+            message: 'VeloxTS MCP server configured successfully',
+            instructions: 'Restart Claude Desktop to activate the MCP server',
+        };
+        if (json) {
+            console.log(JSON.stringify(result, null, 2));
+        }
+        else {
+            success('VeloxTS MCP server configured successfully!');
+            console.log('');
+            console.log(`  ${pc.dim('Config path:')} ${formatPath(configPath)}`);
+            console.log('');
+            info('Next steps:');
+            console.log(`  ${pc.dim('1.')} Restart Claude Desktop`);
+            console.log(`  ${pc.dim('2.')} Open Claude Desktop`);
+            console.log(`  ${pc.dim('3.')} The VeloxTS MCP server will provide project context automatically`);
+            console.log('');
+        }
+    }
+    catch (err) {
+        const result = {
+            success: false,
+            action: 'error',
+            configPath: 'unknown',
+            message: 'Unexpected error',
+            error: err instanceof Error ? err.message : String(err),
+        };
+        if (json) {
+            console.log(JSON.stringify(result, null, 2));
+        }
+        else {
+            error('An unexpected error occurred.');
+            console.log(`  ${pc.dim('Error:')} ${err instanceof Error ? err.message : String(err)}`);
+        }
+        process.exit(1);
+    }
+}

package/dist/generators/generators/resource.js

@@ -16,6 +16,7 @@ import pc from 'picocolors';
 import { BaseGenerator } from '../base.js';
 import { collectFields } from '../fields/index.js';
 import { generateInjectablePrismaContent, generateResourceFiles, } from '../templates/resource.js';
+import { findAllSimilarFiles, formatSimilarFilesWarning } from '../utils/filesystem.js';
 import { deriveEntityNames } from '../utils/naming.js';
 import { promptAndRunMigration } from '../utils/prisma-migration.js';
 import { analyzePrismaSchema, findPrismaSchema, hasModel, injectIntoSchema, } from '../utils/prisma-schema.js';
@@ -192,6 +193,40 @@ export class ResourceGenerator extends BaseGenerator {
             project: config.project,
             options: templateOptions,
         };
+        // Check for similar files (singular/plural variants) before generating
+        // This helps prevent accidental duplicate entities like user.ts vs users.ts
+        if (!config.force && !config.dryRun) {
+            const targetPaths = [
+                `src/procedures/${ctx.entity.kebab}.ts`,
+                `src/schemas/${ctx.entity.kebab}.schema.ts`,
+            ];
+            const similarResult = findAllSimilarFiles(config.cwd, targetPaths, ctx.entity.kebab);
+            if (similarResult.hasSimilar) {
+                const warningMessage = formatSimilarFilesWarning(similarResult, config.entityName);
+                p.log.warn(warningMessage);
+                // In interactive mode, ask user to confirm
+                if (interactive) {
+                    const shouldContinue = await p.confirm({
+                        message: 'Do you want to continue anyway?',
+                        initialValue: false,
+                    });
+                    if (p.isCancel(shouldContinue) || !shouldContinue) {
+                        return {
+                            files: [],
+                            postInstructions: 'Generation cancelled due to similar existing files.',
+                        };
+                    }
+                }
+                else {
+                    // In non-interactive mode, abort and suggest --force
+                    p.log.error('Use --force to generate anyway, or choose a different entity name.');
+                    return {
+                        files: [],
+                        postInstructions: 'Generation aborted: similar files already exist. Use --force to override.',
+                    };
+                }
+            }
+        }
         // Show spinner during actual file generation
         // Only show if we're in interactive mode (we collected fields or user opted to skip)
         const showSpinner = interactive && !skipFields && !config.dryRun;
@@ -274,12 +309,11 @@ export class ResourceGenerator extends BaseGenerator {
             }
             // Step 3: Run Prisma migration (if model was injected and migration not skipped)
             if (result.prismaInjected && !flags.skipMigration) {
-                const migResult = await promptAndRunMigration({
+                result.migrationRun = await promptAndRunMigration({
                     cwd: projectRoot,
                     autoRun: flags.autoMigrate,
                     skip: false,
                 });
-                result.migrationRun = migResult;
             }
             return result;
         }

package/dist/generators/utils/filesystem.d.ts

@@ -65,3 +65,47 @@ export declare function formatWriteResults(results: ReadonlyArray<WriteResult>,
  * Format write results as JSON for machine consumption
  */
 export declare function formatWriteResultsJson(results: ReadonlyArray<WriteResult>): string;
+/**
+ * Information about a similar file that was found
+ */
+export interface SimilarFile {
+    /** Path to the similar file */
+    path: string;
+    /** Why this is considered similar */
+    reason: 'singular' | 'plural' | 'different-suffix';
+    /** The file we were looking for when we found this */
+    targetPath: string;
+}
+/**
+ * Result of checking for similar files
+ */
+export interface SimilarFilesResult {
+    /** Whether any similar files were found */
+    hasSimilar: boolean;
+    /** List of similar files found */
+    files: SimilarFile[];
+}
+/**
+ * Find similar files that might conflict with intended generation.
+ *
+ * This checks for naming variations that could indicate duplicate entities:
+ * - Singular vs plural forms (user.ts vs users.ts)
+ * - Different file suffixes (user.ts vs user.schema.ts)
+ *
+ * @example
+ * findSimilarFiles('/project', 'src/procedures/user.ts', 'user')
+ * // Might find: src/procedures/users.ts
+ *
+ * @param projectRoot - Project root directory
+ * @param targetPath - Path we intend to create
+ * @param entityKebab - Entity name in kebab-case (e.g., 'user', 'blog-post')
+ */
+export declare function findSimilarFiles(projectRoot: string, targetPath: string, entityKebab: string): SimilarFilesResult;
+/**
+ * Check for similar files across multiple target paths
+ */
+export declare function findAllSimilarFiles(projectRoot: string, targetPaths: string[], entityKebab: string): SimilarFilesResult;
+/**
+ * Format similar files warning message
+ */
+export declare function formatSimilarFilesWarning(result: SimilarFilesResult, entityName: string): string;

package/dist/generators/utils/filesystem.js

@@ -4,11 +4,12 @@
  * Safe file operations with conflict detection, directory creation,
  * and interactive prompting support.
  */
-import { existsSync, mkdirSync, readFileSync, writeFileSync } from 'node:fs';
-import { dirname, relative } from 'node:path';
+import { existsSync, mkdirSync, readdirSync, readFileSync, writeFileSync } from 'node:fs';
+import { dirname, join, normalize, relative } from 'node:path';
 import * as p from '@clack/prompts';
 import pc from 'picocolors';
 import { GeneratorError, GeneratorErrorCode } from '../types.js';
+import { pluralize, singularize } from './naming.js';
 /**
  * Write a single file with conflict handling
  */
@@ -214,3 +215,122 @@ export function formatWriteResultsJson(results) {
         })),
     }, null, 2);
 }
+/**
+ * Find similar files that might conflict with intended generation.
+ *
+ * This checks for naming variations that could indicate duplicate entities:
+ * - Singular vs plural forms (user.ts vs users.ts)
+ * - Different file suffixes (user.ts vs user.schema.ts)
+ *
+ * @example
+ * findSimilarFiles('/project', 'src/procedures/user.ts', 'user')
+ * // Might find: src/procedures/users.ts
+ *
+ * @param projectRoot - Project root directory
+ * @param targetPath - Path we intend to create
+ * @param entityKebab - Entity name in kebab-case (e.g., 'user', 'blog-post')
+ */
+export function findSimilarFiles(projectRoot, targetPath, entityKebab) {
+    const result = {
+        hasSimilar: false,
+        files: [],
+    };
+    const dir = dirname(targetPath);
+    const fullDir = join(projectRoot, dir);
+    // If directory doesn't exist, no similar files
+    if (!existsSync(fullDir)) {
+        return result;
+    }
+    // Get all files in the directory
+    let filesInDir;
+    try {
+        filesInDir = readdirSync(fullDir);
+    }
+    catch {
+        return result;
+    }
+    // Generate variants to check
+    const singularName = singularize(entityKebab);
+    const pluralName = pluralize(entityKebab);
+    // Patterns to match (without extension)
+    const patterns = new Set([
+        singularName, // user
+        pluralName, // users
+        `${singularName}.schema`, // user.schema
+        `${pluralName}.schema`, // users.schema
+    ]);
+    // Normalize target path for consistent comparison across platforms
+    const normalizedTargetPath = normalize(targetPath);
+    for (const file of filesInDir) {
+        // Skip non-TS/JS files
+        if (!/\.(ts|js|tsx|jsx)$/.test(file)) {
+            continue;
+        }
+        // Get base name without extension
+        const fileBase = file.replace(/\.(ts|js|tsx|jsx)$/, '');
+        const filePath = normalize(join(dir, file));
+        // Skip the exact target (will be handled by normal conflict detection)
+        if (filePath === normalizedTargetPath) {
+            continue;
+        }
+        // Check if this file matches any of our patterns
+        if (patterns.has(fileBase)) {
+            // Determine the reason: singular/plural or different naming convention
+            const reason = fileBase === singularName
+                ? 'singular'
+                : fileBase === pluralName
+                    ? 'plural'
+                    : 'different-suffix';
+            // File exists since we got it from readdirSync
+            result.files.push({
+                path: filePath,
+                reason,
+                targetPath,
+            });
+            result.hasSimilar = true;
+        }
+    }
+    return result;
+}
+/**
+ * Check for similar files across multiple target paths
+ */
+export function findAllSimilarFiles(projectRoot, targetPaths, entityKebab) {
+    const allFiles = [];
+    for (const targetPath of targetPaths) {
+        const result = findSimilarFiles(projectRoot, targetPath, entityKebab);
+        allFiles.push(...result.files);
+    }
+    // Deduplicate by path
+    const uniqueFiles = Array.from(new Map(allFiles.map((f) => [f.path, f])).values());
+    return {
+        hasSimilar: uniqueFiles.length > 0,
+        files: uniqueFiles,
+    };
+}
+/**
+ * Format similar files warning message
+ */
+export function formatSimilarFilesWarning(result, entityName) {
+    if (!result.hasSimilar) {
+        return '';
+    }
+    const lines = [
+        pc.yellow(`⚠ Found existing files that may conflict with "${entityName}":`),
+        '',
+    ];
+    for (const file of result.files) {
+        const reasonText = file.reason === 'singular'
+            ? '(singular form)'
+            : file.reason === 'plural'
+                ? '(plural form)'
+                : '(different naming convention)';
+        lines.push(`  ${pc.cyan(file.path)} ${pc.dim(reasonText)}`);
+    }
+    lines.push('');
+    lines.push(pc.dim('This may indicate a duplicate entity. Options:'));
+    lines.push(pc.dim('  • Use --force to create anyway'));
+    lines.push(pc.dim('  • Rename your entity to avoid confusion'));
+    lines.push(pc.dim('  • Delete the existing files if they are unused'));
+    return lines.join('\n');
+}

package/dist/index.d.ts

@@ -24,6 +24,7 @@ export declare const CLI_VERSION: string;
 export { createDbCommand } from './commands/db.js';
 export { createDevCommand } from './commands/dev.js';
 export { createIntrospectCommand } from './commands/introspect.js';
+export { createMcpCommand } from './commands/mcp.js';
 export { createMigrateCommand } from './commands/migrate.js';
 /**
  * Export error system

package/dist/index.js

@@ -28,6 +28,7 @@ export const CLI_VERSION = packageJson.version ?? '0.0.0-unknown';
 export { createDbCommand } from './commands/db.js';
 export { createDevCommand } from './commands/dev.js';
 export { createIntrospectCommand } from './commands/introspect.js';
+export { createMcpCommand } from './commands/mcp.js';
 export { createMigrateCommand } from './commands/migrate.js';
 /**
  * Export error system

package/dist/utils/paths.d.ts

@@ -52,3 +52,15 @@ export interface ProjectType {
  * 2. app.config.ts or app.config.js (Vinxi configuration)
  */
 export declare function detectProjectType(cwd?: string): Promise<ProjectType>;
+/**
+ * Read and parse a JSON file
+ */
+export declare function readJsonFile<T = unknown>(filePath: string): Promise<T>;
+/**
+ * Write a JSON file with pretty formatting
+ */
+export declare function writeJsonFile(filePath: string, data: unknown): Promise<void>;
+/**
+ * Create a directory recursively
+ */
+export declare function createDirectory(dirPath: string): void;

package/dist/utils/paths.js

@@ -1,7 +1,8 @@
 /**
  * Path utilities for finding project files
  */
-import { existsSync } from 'node:fs';
+import { existsSync, mkdirSync } from 'node:fs';
+import { readFile, writeFile } from 'node:fs/promises';
 import path from 'node:path';
 /**
  * Find the project entry point
@@ -137,3 +138,23 @@ export async function detectProjectType(cwd = process.cwd()) {
         return result;
     }
 }
+/**
+ * Read and parse a JSON file
+ */
+export async function readJsonFile(filePath) {
+    const content = await readFile(filePath, 'utf-8');
+    return JSON.parse(content);
+}
+/**
+ * Write a JSON file with pretty formatting
+ */
+export async function writeJsonFile(filePath, data) {
+    const content = JSON.stringify(data, null, 2);
+    await writeFile(filePath, content, 'utf-8');
+}
+/**
+ * Create a directory recursively
+ */
+export function createDirectory(dirPath) {
+    mkdirSync(dirPath, { recursive: true });
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@veloxts/cli",
-  "version": "0.6.52",
+  "version": "0.6.55",
   "description": "Developer tooling and CLI commands for VeloxTS framework",
   "type": "module",
   "main": "dist/index.js",
@@ -40,11 +40,11 @@
     "picocolors": "1.1.1",
     "pluralize": "8.0.0",
     "tsx": "4.21.0",
-    "@veloxts/core": "0.6.52",
-    "@veloxts/auth": "0.6.52",
-    "@veloxts/orm": "0.6.52",
-    "@veloxts/router": "0.6.52",
-    "@veloxts/validation": "0.6.52"
+    "@veloxts/auth": "0.6.55",
+    "@veloxts/orm": "0.6.55",
+    "@veloxts/core": "0.6.55",
+    "@veloxts/validation": "0.6.55",
+    "@veloxts/router": "0.6.55"
   },
   "peerDependencies": {
     "@prisma/client": ">=7.0.0"