@veloxts/mcp 0.7.1 → 0.7.3

package/CHANGELOG.md

@@ -1,5 +1,23 @@
 # @veloxts/mcp
 
+## 0.7.3
+
+### Patch Changes
+
+- feat(cli): auto-populate Zod schemas from Prisma model fields
+- Updated dependencies
+  - @veloxts/cli@0.7.3
+  - @veloxts/router@0.7.3
+  - @veloxts/validation@0.7.3
+
+## 0.7.2
+
+### Patch Changes
+
+- simplify code for clarity and maintainability
+- Updated dependencies
+  - @veloxts/core@0.7.2
+
 ## 0.7.1
 
 ### Patch Changes

package/dist/resources/errors.js

@@ -30,17 +30,23 @@ function getErrorCategory(code) {
     return category?.name ?? 'Unknown';
 }
 /**
- * Get all errors from the catalog
+ * Convert a catalog error definition to an ErrorInfo
  */
-export function getErrors() {
-    const errors = Object.values(ERROR_CATALOG).map((def) => ({
+function toErrorInfo(def) {
+    return {
         code: def.code,
         name: def.name,
         message: def.message,
         fix: def.fix,
         docsUrl: def.docsUrl,
         category: getErrorCategory(def.code),
-    }));
+    };
+}
+/**
+ * Get all errors from the catalog
+ */
+export function getErrors() {
+    const errors = Object.values(ERROR_CATALOG).map(toErrorInfo);
     const categories = ERROR_CATEGORIES.map((cat) => ({
         prefix: cat.prefix,
         name: cat.name,
@@ -56,15 +62,7 @@ export function getErrors() {
  * Get errors for a specific category
  */
 export function getErrorsByPrefix(prefix) {
-    const defs = getErrorsByCategory(prefix);
-    return defs.map((def) => ({
-        code: def.code,
-        name: def.name,
-        message: def.message,
-        fix: def.fix,
-        docsUrl: def.docsUrl,
-        category: getErrorCategory(def.code),
-    }));
+    return getErrorsByCategory(prefix).map(toErrorInfo);
 }
 /**
  * Search errors by keyword
@@ -76,14 +74,7 @@ export function searchErrors(query) {
         def.name.toLowerCase().includes(lowerQuery) ||
         def.message.toLowerCase().includes(lowerQuery) ||
         def.fix?.toLowerCase().includes(lowerQuery))
-        .map((def) => ({
-        code: def.code,
-        name: def.name,
-        message: def.message,
-        fix: def.fix,
-        docsUrl: def.docsUrl,
-        category: getErrorCategory(def.code),
-    }));
+        .map(toErrorInfo);
 }
 /**
  * Format errors response as text

package/dist/resources/static-analyzer.js

@@ -395,7 +395,17 @@ export function formatStaticAnalysisAsText(result) {
         lines.push(`## ${namespace}`);
         lines.push('');
         for (const proc of procs) {
-            const type = proc.type === 'query' ? 'Q' : proc.type === 'mutation' ? 'M' : '?';
+            let type;
+            switch (proc.type) {
+                case 'query':
+                    type = 'Q';
+                    break;
+                case 'mutation':
+                    type = 'M';
+                    break;
+                default:
+                    type = '?';
+            }
             const route = proc.route ? ` -> ${proc.route.method} ${proc.route.path}` : '';
             const guards = proc.hasGuards ? ' [guarded]' : '';
             lines.push(`- [${type}] ${proc.name}${route}${guards}`);

package/dist/server.js

@@ -105,57 +105,28 @@ export function createVeloxMCPServer(options = {}) {
             ],
         };
     });
+    // Helper to wrap text content as an MCP resource response
+    function textResource(uri, text) {
+        return { contents: [{ uri, mimeType: 'text/plain', text }] };
+    }
     server.setRequestHandler(ReadResourceRequestSchema, async (request) => {
         const uri = request.params.uri;
         log(`Reading resource: ${uri}`);
         switch (uri) {
             case 'velox://procedures': {
                 const data = await getProcedures(projectRoot);
-                return {
-                    contents: [
-                        {
-                            uri,
-                            mimeType: 'text/plain',
-                            text: formatProceduresAsText(data),
-                        },
-                    ],
-                };
+                return textResource(uri, formatProceduresAsText(data));
             }
             case 'velox://routes': {
                 const data = await getRoutes(projectRoot);
-                return {
-                    contents: [
-                        {
-                            uri,
-                            mimeType: 'text/plain',
-                            text: formatRoutesAsText(data),
-                        },
-                    ],
-                };
+                return textResource(uri, formatRoutesAsText(data));
             }
             case 'velox://schemas': {
                 const data = await getSchemas(projectRoot);
-                return {
-                    contents: [
-                        {
-                            uri,
-                            mimeType: 'text/plain',
-                            text: formatSchemasAsText(data),
-                        },
-                    ],
-                };
+                return textResource(uri, formatSchemasAsText(data));
             }
             case 'velox://errors': {
-                const data = getErrors();
-                return {
-                    contents: [
-                        {
-                            uri,
-                            mimeType: 'text/plain',
-                            text: formatErrorsAsText(data),
-                        },
-                    ],
-                };
+                return textResource(uri, formatErrorsAsText(getErrors()));
             }
             case 'velox://project': {
                 const info = await getProjectInfo(projectRoot);
@@ -177,15 +148,7 @@ export function createVeloxMCPServer(options = {}) {
                         .filter(Boolean)
                         .join('\n')
                     : 'No VeloxTS project detected in current directory.';
-                return {
-                    contents: [
-                        {
-                            uri,
-                            mimeType: 'text/plain',
-                            text,
-                        },
-                    ],
-                };
+                return textResource(uri, text);
             }
             case 'velox://auth-context': {
                 const text = `# Authentication Context (ctx.user)
@@ -277,15 +240,7 @@ const fullUser = await getFullUser(ctx);
 const orgId = fullUser.organizationId;
 \`\`\`
 `;
-                return {
-                    contents: [
-                        {
-                            uri,
-                            mimeType: 'text/plain',
-                            text,
-                        },
-                    ],
-                };
+                return textResource(uri, text);
             }
             default:
                 throw new Error(`Unknown resource: ${uri}`);
@@ -363,21 +318,20 @@ const orgId = fullUser.organizationId;
     server.setRequestHandler(CallToolRequestSchema, async (request) => {
         const { name, arguments: args } = request.params;
         log(`Calling tool: ${name}`);
+        // Helper to build a tool response
+        function toolResult(text, isError = false) {
+            return { content: [{ type: 'text', text }], isError };
+        }
+        // Helper to format Zod validation errors into a tool error response
+        function validationError(toolName, issues) {
+            const errors = issues.map((e) => `${e.path.join('.')}: ${e.message}`);
+            return toolResult(`Invalid arguments for ${toolName}:\n${errors.join('\n')}`, true);
+        }
         switch (name) {
             case 'velox_generate': {
-                // Validate arguments with Zod
                 const parsed = GenerateArgsSchema.safeParse(args);
                 if (!parsed.success) {
-                    const errors = parsed.error.issues.map((e) => `${e.path.join('.')}: ${e.message}`);
-                    return {
-                        content: [
-                            {
-                                type: 'text',
-                                text: `Invalid arguments for velox_generate:\n${errors.join('\n')}`,
-                            },
-                        ],
-                        isError: true,
-                    };
+                    return validationError('velox_generate', parsed.error.issues);
                 }
                 const result = await generate({
                     type: parsed.data.type,
@@ -386,30 +340,12 @@ const orgId = fullUser.organizationId;
                     dryRun: parsed.data.dryRun,
                     json: true,
                 }, projectRoot);
-                return {
-                    content: [
-                        {
-                            type: 'text',
-                            text: formatGenerateResult(result),
-                        },
-                    ],
-                    isError: !result.success,
-                };
+                return toolResult(formatGenerateResult(result), !result.success);
             }
             case 'velox_migrate': {
-                // Validate arguments with Zod
                 const parsed = MigrateArgsSchema.safeParse(args);
                 if (!parsed.success) {
-                    const errors = parsed.error.issues.map((e) => `${e.path.join('.')}: ${e.message}`);
-                    return {
-                        content: [
-                            {
-                                type: 'text',
-                                text: `Invalid arguments for velox_migrate:\n${errors.join('\n')}`,
-                            },
-                        ],
-                        isError: true,
-                    };
+                    return validationError('velox_migrate', parsed.error.issues);
                 }
                 const result = await migrate({
                     action: parsed.data.action,
@@ -417,15 +353,7 @@ const orgId = fullUser.organizationId;
                     dryRun: parsed.data.dryRun,
                     json: true,
                 }, projectRoot);
-                return {
-                    content: [
-                        {
-                            type: 'text',
-                            text: formatMigrateResult(result),
-                        },
-                    ],
-                    isError: !result.success,
-                };
+                return toolResult(formatMigrateResult(result), !result.success);
             }
             default:
                 throw new Error(`Unknown tool: ${name}`);
@@ -436,13 +364,7 @@ const orgId = fullUser.organizationId;
     // ===========================================================================
     server.setRequestHandler(ListPromptsRequestSchema, async () => {
         log('Listing prompts');
-        const prompts = listPromptTemplates();
-        return {
-            prompts: prompts.map((p) => ({
-                name: p.name,
-                description: p.description,
-            })),
-        };
+        return { prompts: listPromptTemplates() };
     });
     server.setRequestHandler(GetPromptRequestSchema, async (request) => {
         const { name } = request.params;

package/dist/tools/generate.js

@@ -3,9 +3,8 @@
  *
  * Wraps `velox make` commands for AI tool invocation.
  */
-import { spawn } from 'node:child_process';
 import { z } from 'zod';
-import { resolveVeloxCLI } from '../utils/cli.js';
+import { spawnCLI } from '../utils/cli.js';
 import { findProjectRoot } from '../utils/project.js';
 // ============================================================================
 // Output Validation Schemas
@@ -59,69 +58,40 @@ export async function generate(options, serverProjectRoot) {
         };
     }
     const args = buildArgs(options);
-    const resolved = resolveVeloxCLI(projectRoot, args);
-    return new Promise((resolve) => {
-        const child = spawn(resolved.command, resolved.args, {
-            cwd: projectRoot,
-            shell: resolved.isNpx, // Only use shell for npx fallback
-            stdio: ['pipe', 'pipe', 'pipe'],
-        });
-        let stdout = '';
-        let stderr = '';
-        child.stdout?.on('data', (data) => {
-            stdout += data.toString();
-        });
-        child.stderr?.on('data', (data) => {
-            stderr += data.toString();
-        });
-        child.on('close', (code) => {
-            if (code === 0) {
-                // Try to parse and validate JSON output if requested
-                if (options.json) {
-                    try {
-                        const jsonData = JSON.parse(stdout);
-                        const parsed = GenerateOutputSchema.safeParse(jsonData);
-                        if (parsed.success) {
-                            resolve({
-                                success: true,
-                                type: options.type,
-                                name: options.name,
-                                files: parsed.data.files,
-                                output: stdout,
-                            });
-                            return;
-                        }
-                        // Invalid JSON structure - fall through to plain output
-                    }
-                    catch {
-                        // JSON parse failed - fall through to plain output
-                    }
-                }
-                resolve({
+    const result = await spawnCLI(projectRoot, args);
+    if (!result.success) {
+        return {
+            success: false,
+            type: options.type,
+            name: options.name,
+            error: result.stderr || result.stdout || `Command failed with exit code ${result.code}`,
+        };
+    }
+    // Try to parse and validate JSON output if requested
+    if (options.json) {
+        try {
+            const jsonData = JSON.parse(result.stdout);
+            const parsed = GenerateOutputSchema.safeParse(jsonData);
+            if (parsed.success) {
+                return {
                     success: true,
                     type: options.type,
                     name: options.name,
-                    output: stdout,
-                });
+                    files: parsed.data.files,
+                    output: result.stdout,
+                };
             }
-            else {
-                resolve({
-                    success: false,
-                    type: options.type,
-                    name: options.name,
-                    error: stderr || stdout || `Command failed with exit code ${code}`,
-                });
-            }
-        });
-        child.on('error', (err) => {
-            resolve({
-                success: false,
-                type: options.type,
-                name: options.name,
-                error: err.message,
-            });
-        });
-    });
+        }
+        catch {
+            // JSON parse failed - fall through to plain output
+        }
+    }
+    return {
+        success: true,
+        type: options.type,
+        name: options.name,
+        output: result.stdout,
+    };
 }
 /**
  * Generate a procedure

package/dist/tools/migrate.js

@@ -3,9 +3,8 @@
  *
  * Wraps `velox migrate` commands for AI tool invocation.
  */
-import { spawn } from 'node:child_process';
 import { z } from 'zod';
-import { resolveVeloxCLI } from '../utils/cli.js';
+import { spawnCLI } from '../utils/cli.js';
 import { findProjectRoot } from '../utils/project.js';
 // ============================================================================
 // Output Validation Schemas
@@ -58,65 +57,37 @@ export async function migrate(options, serverProjectRoot) {
         };
     }
     const args = buildArgs(options);
-    const resolved = resolveVeloxCLI(projectRoot, args);
-    return new Promise((resolve) => {
-        const child = spawn(resolved.command, resolved.args, {
-            cwd: projectRoot,
-            shell: resolved.isNpx, // Only use shell for npx fallback
-            stdio: ['pipe', 'pipe', 'pipe'],
-        });
-        let stdout = '';
-        let stderr = '';
-        child.stdout?.on('data', (data) => {
-            stdout += data.toString();
-        });
-        child.stderr?.on('data', (data) => {
-            stderr += data.toString();
-        });
-        child.on('close', (code) => {
-            if (code === 0) {
-                // Try to parse and validate JSON output if requested
-                if (options.json) {
-                    try {
-                        const jsonData = JSON.parse(stdout);
-                        const parsed = MigrateOutputSchema.safeParse(jsonData);
-                        if (parsed.success) {
-                            resolve({
-                                success: true,
-                                action: options.action,
-                                migrations: parsed.data.migrations,
-                                output: stdout,
-                            });
-                            return;
-                        }
-                        // Invalid JSON structure - fall through to plain output
-                    }
-                    catch {
-                        // JSON parse failed - fall through to plain output
-                    }
-                }
-                resolve({
+    const result = await spawnCLI(projectRoot, args);
+    if (!result.success) {
+        return {
+            success: false,
+            action: options.action,
+            error: result.stderr || result.stdout || `Command failed with exit code ${result.code}`,
+        };
+    }
+    // Try to parse and validate JSON output if requested
+    if (options.json) {
+        try {
+            const jsonData = JSON.parse(result.stdout);
+            const parsed = MigrateOutputSchema.safeParse(jsonData);
+            if (parsed.success) {
+                return {
                     success: true,
                     action: options.action,
-                    output: stdout,
-                });
+                    migrations: parsed.data.migrations,
+                    output: result.stdout,
+                };
             }
-            else {
-                resolve({
-                    success: false,
-                    action: options.action,
-                    error: stderr || stdout || `Command failed with exit code ${code}`,
-                });
-            }
-        });
-        child.on('error', (err) => {
-            resolve({
-                success: false,
-                action: options.action,
-                error: err.message,
-            });
-        });
-    });
+        }
+        catch {
+            // JSON parse failed - fall through to plain output
+        }
+    }
+    return {
+        success: true,
+        action: options.action,
+        output: result.stdout,
+    };
 }
 /**
  * Get migration status

package/dist/utils/cli.d.ts

@@ -25,3 +25,19 @@ export interface ResolvedCLI {
  * 5. Fallback to npx @veloxts/cli (slowest, downloads if needed)
  */
 export declare function resolveVeloxCLI(projectRoot: string, args: string[]): ResolvedCLI;
+/**
+ * Result from spawning a CLI command
+ */
+export interface SpawnCLIResult {
+    success: boolean;
+    stdout: string;
+    stderr: string;
+    code: number | null;
+}
+/**
+ * Spawn a VeloxTS CLI command and collect its output.
+ *
+ * Resolves the CLI binary, spawns the process, and returns stdout/stderr.
+ * Never rejects - errors are returned in the result.
+ */
+export declare function spawnCLI(projectRoot: string, args: string[]): Promise<SpawnCLIResult>;

package/dist/utils/cli.js

@@ -3,6 +3,7 @@
  *
  * Utilities for finding and executing the VeloxTS CLI binary.
  */
+import { spawn } from 'node:child_process';
 import { existsSync, readFileSync } from 'node:fs';
 import { join } from 'node:path';
 /**
@@ -77,3 +78,33 @@ export function resolveVeloxCLI(projectRoot, args) {
         isNpx: true,
     };
 }
+/**
+ * Spawn a VeloxTS CLI command and collect its output.
+ *
+ * Resolves the CLI binary, spawns the process, and returns stdout/stderr.
+ * Never rejects - errors are returned in the result.
+ */
+export function spawnCLI(projectRoot, args) {
+    const resolved = resolveVeloxCLI(projectRoot, args);
+    return new Promise((resolve) => {
+        const child = spawn(resolved.command, resolved.args, {
+            cwd: projectRoot,
+            shell: resolved.isNpx,
+            stdio: ['pipe', 'pipe', 'pipe'],
+        });
+        let stdout = '';
+        let stderr = '';
+        child.stdout?.on('data', (data) => {
+            stdout += data.toString();
+        });
+        child.stderr?.on('data', (data) => {
+            stderr += data.toString();
+        });
+        child.on('close', (code) => {
+            resolve({ success: code === 0, stdout, stderr, code });
+        });
+        child.on('error', (err) => {
+            resolve({ success: false, stdout, stderr: err.message, code: null });
+        });
+    });
+}

package/dist/utils/project.js

@@ -99,34 +99,28 @@ export async function getProjectInfo(projectRoot) {
     }
 }
 /**
- * Get the procedures directory path for a project
+ * Resolve a source subdirectory, checking monorepo layout first, then single-package.
  */
-export function getProceduresPath(projectRoot) {
-    // Check monorepo structure first
-    const monorepoProcedures = join(projectRoot, 'apps', 'api', 'src', 'procedures');
-    if (existsSync(monorepoProcedures)) {
-        return monorepoProcedures;
+function resolveSourcePath(projectRoot, subdir) {
+    const monorepoPath = join(projectRoot, 'apps', 'api', 'src', subdir);
+    if (existsSync(monorepoPath)) {
+        return monorepoPath;
     }
-    // Check single package structure
-    const singleProcedures = join(projectRoot, 'src', 'procedures');
-    if (existsSync(singleProcedures)) {
-        return singleProcedures;
+    const singlePath = join(projectRoot, 'src', subdir);
+    if (existsSync(singlePath)) {
+        return singlePath;
     }
     return null;
 }
+/**
+ * Get the procedures directory path for a project
+ */
+export function getProceduresPath(projectRoot) {
+    return resolveSourcePath(projectRoot, 'procedures');
+}
 /**
  * Get the schemas directory path for a project
  */
 export function getSchemasPath(projectRoot) {
-    // Check monorepo structure first
-    const monorepoSchemas = join(projectRoot, 'apps', 'api', 'src', 'schemas');
-    if (existsSync(monorepoSchemas)) {
-        return monorepoSchemas;
-    }
-    // Check single package structure
-    const singleSchemas = join(projectRoot, 'src', 'schemas');
-    if (existsSync(singleSchemas)) {
-        return singleSchemas;
-    }
-    return null;
+    return resolveSourcePath(projectRoot, 'schemas');
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@veloxts/mcp",
-  "version": "0.7.1",
+  "version": "0.7.3",
   "description": "Model Context Protocol server for VeloxTS - expose project context to AI tools",
   "type": "module",
   "main": "dist/index.js",
@@ -24,9 +24,9 @@
   "dependencies": {
     "@modelcontextprotocol/sdk": "1.26.0",
     "typescript": "5.9.3",
-    "@veloxts/router": "0.7.1",
-    "@veloxts/validation": "0.7.1",
-    "@veloxts/cli": "0.7.1"
+    "@veloxts/cli": "0.7.3",
+    "@veloxts/router": "0.7.3",
+    "@veloxts/validation": "0.7.3"
   },
   "peerDependencies": {
     "zod": "^4.3.0"