veryfront 0.1.501 → 0.1.503

package/src/cli/mcp/tools/project-tools.ts

@@ -2,7 +2,8 @@
  * MCP tools for project discovery and analysis.
  */
 
-import { z } from "zod";
+import { defineSchema } from "../../../src/schemas/index.js";
+import type { InferSchema } from "../../../src/extensions/schema/index.js";
 import type { FileSystem } from "../../../src/platform/index.js";
 import { join } from "../../../src/platform/compat/path/index.js";
 import { cwd } from "../../../src/platform/index.js";
@@ -24,16 +25,19 @@ import {
 // Tool: vf_list_routes
 // ============================================================================
 
-const listRoutesInput = z.object({
-  type: z.enum(["all", "pages", "api", "layouts"]).optional().default("all").describe(
-    "Filter routes by type",
-  ),
-  projectPath: z.string().optional().describe(
-    "Project directory (defaults to current working directory)",
-  ),
-});
+const getListRoutesInput = defineSchema((v) =>
+  v.object({
+    type: v.enum(["all", "pages", "api", "layouts"]).optional().default("all").describe(
+      "Filter routes by type",
+    ),
+    projectPath: v.string().optional().describe(
+      "Project directory (defaults to current working directory)",
+    ),
+  })
+);
+const listRoutesInput = getListRoutesInput();
 
-type ListRoutesInput = z.infer<typeof listRoutesInput>;
+type ListRoutesInput = InferSchema<ReturnType<typeof getListRoutesInput>>;
 
 export const vfListRoutes: MCPTool<ListRoutesInput, RouteInfo[]> = {
   name: "vf_list_routes",
@@ -68,13 +72,16 @@ export const vfListRoutes: MCPTool<ListRoutesInput, RouteInfo[]> = {
 // Tool: vf_get_project_context
 // ============================================================================
 
-const getProjectContextInput = z.object({
-  projectPath: z.string().optional().describe(
-    "Project directory (defaults to current working directory)",
-  ),
-});
+const getGetProjectContextInput = defineSchema((v) =>
+  v.object({
+    projectPath: v.string().optional().describe(
+      "Project directory (defaults to current working directory)",
+    ),
+  })
+);
+const getProjectContextInput = getGetProjectContextInput();
 
-type GetProjectContextInput = z.infer<typeof getProjectContextInput>;
+type GetProjectContextInput = InferSchema<ReturnType<typeof getGetProjectContextInput>>;
 
 const STANDARD_DIRS = ["app", "pages", "components", "lib", "ai"] as const;
 
@@ -182,14 +189,17 @@ export const vfGetProjectContext: MCPTool<GetProjectContextInput, ProjectContext
 // Tool: vf_get_component_tree
 // ============================================================================
 
-const getComponentTreeInput = z.object({
-  route: z.string().describe("Route path to analyze (e.g., '/', '/dashboard')"),
-  projectPath: z.string().optional().describe(
-    "Project directory (defaults to current working directory)",
-  ),
-});
+const getGetComponentTreeInput = defineSchema((v) =>
+  v.object({
+    route: v.string().describe("Route path to analyze (e.g., '/', '/dashboard')"),
+    projectPath: v.string().optional().describe(
+      "Project directory (defaults to current working directory)",
+    ),
+  })
+);
+const getComponentTreeInput = getGetComponentTreeInput();
 
-type GetComponentTreeInput = z.infer<typeof getComponentTreeInput>;
+type GetComponentTreeInput = InferSchema<ReturnType<typeof getGetComponentTreeInput>>;
 
 interface ComponentNode {
   name: string;
@@ -283,16 +293,19 @@ export const vfGetComponentTree: MCPTool<GetComponentTreeInput, ComponentTreeRes
 // Tool: vf_list_local_projects
 // ============================================================================
 
-const listLocalProjectsInput = z.object({
-  directory: z.string().optional().describe(
-    "Directory to scan for projects (defaults to current directory and common locations)",
-  ),
-  depth: z.number().optional().default(2).describe(
-    "How deep to scan (1 = immediate children, 2 = grandchildren)",
-  ),
-});
+const getListLocalProjectsInput = defineSchema((v) =>
+  v.object({
+    directory: v.string().optional().describe(
+      "Directory to scan for projects (defaults to current directory and common locations)",
+    ),
+    depth: v.number().optional().default(2).describe(
+      "How deep to scan (1 = immediate children, 2 = grandchildren)",
+    ),
+  })
+);
+const listLocalProjectsInput = getListLocalProjectsInput();
 
-type ListLocalProjectsInput = z.infer<typeof listLocalProjectsInput>;
+type ListLocalProjectsInput = InferSchema<ReturnType<typeof getListLocalProjectsInput>>;
 
 interface LocalProjectInfo {
   name: string;

package/src/cli/mcp/tools/run-lint-tool.ts

@@ -7,17 +7,21 @@
 import * as dntShim from "../../../_dnt.shims.js";
 
 
-import { z } from "zod";
+import { defineSchema } from "../../../src/schemas/index.js";
+import type { InferSchema } from "../../../src/extensions/schema/index.js";
 import type { MCPTool } from "../tools.js";
 import { type LintResult, parseLintJsonOutput } from "../../commands/lint/command.js";
 
-const runLintInput = z.object({
-  timeout: z.number().optional().default(120000).describe(
-    "Maximum time to wait for lint completion in milliseconds. Defaults to 120000 (2 minutes).",
-  ),
-});
+const getRunLintInput = defineSchema((v) =>
+  v.object({
+    timeout: v.number().optional().default(120000).describe(
+      "Maximum time to wait for lint completion in milliseconds. Defaults to 120000 (2 minutes).",
+    ),
+  })
+);
+const runLintInput = getRunLintInput();
 
-type RunLintInput = z.infer<typeof runLintInput>;
+type RunLintInput = InferSchema<ReturnType<typeof getRunLintInput>>;
 
 const PROCESS_CLEANUP_TIMEOUT_MS = 1000;
 

package/src/cli/mcp/tools/run-tests-tool.ts

@@ -7,23 +7,27 @@
 import * as dntShim from "../../../_dnt.shims.js";
 
 
-import { z } from "zod";
+import { defineSchema } from "../../../src/schemas/index.js";
+import type { InferSchema } from "../../../src/extensions/schema/index.js";
 import type { MCPTool } from "../../../src/mcp/index.js";
 import { parseTestOutput, type TestResult } from "../../commands/test/command.js";
 
-const runTestsInput = z.object({
-  filter: z.string().optional().describe(
-    "Filter tests by name pattern. Example: 'router' to run only tests matching 'router'.",
-  ),
-  parallel: z.boolean().optional().default(false).describe(
-    "Run tests in parallel. Defaults to false.",
-  ),
-  timeout: z.number().optional().default(300000).describe(
-    "Maximum time to wait for test completion in milliseconds. Defaults to 300000 (5 minutes).",
-  ),
-});
+const getRunTestsInput = defineSchema((v) =>
+  v.object({
+    filter: v.string().optional().describe(
+      "Filter tests by name pattern. Example: 'router' to run only tests matching 'router'.",
+    ),
+    parallel: v.boolean().optional().default(false).describe(
+      "Run tests in parallel. Defaults to false.",
+    ),
+    timeout: v.number().optional().default(300000).describe(
+      "Maximum time to wait for test completion in milliseconds. Defaults to 300000 (5 minutes).",
+    ),
+  })
+);
+const runTestsInput = getRunTestsInput();
 
-type RunTestsInput = z.infer<typeof runTestsInput>;
+type RunTestsInput = InferSchema<ReturnType<typeof getRunTestsInput>>;
 
 /** Build the deno test command args from input options. */
 export function buildTestArgs(input: { filter?: string; parallel?: boolean }): string[] {

package/src/cli/mcp/tools/scaffold-tools.ts

@@ -2,7 +2,8 @@
  * MCP tools for scaffolding and conventions.
  */
 
-import { z } from "zod";
+import { defineSchema } from "../../../src/schemas/index.js";
+import type { InferSchema } from "../../../src/extensions/schema/index.js";
 import { join } from "../../../src/platform/compat/path/index.js";
 import { withSpan } from "../../../src/observability/tracing/otlp-setup.js";
 import type { MCPTool } from "../tools.js";
@@ -82,15 +83,15 @@ export function ${componentName}({ children }: ${componentName}Props) {
 
 function generateToolTemplate(name: string): string {
   return `import { tool } from "veryfront/tool";
-import { z } from "zod";
+import { defineSchema } from "veryfront/schemas";
 
 export default tool({
   id: "${name}",
   description: "Description of what this tool does",
-  parameters: z.object({
+  parameters: defineSchema((v) => v.object({
     // Add your parameters here
-    input: z.string().describe("Input parameter"),
-  }),
+    input: v.string().describe("Input parameter"),
+  }))(),
   execute: async ({ input }) => {
     // Implement your tool logic here
     return { result: input };
@@ -125,14 +126,14 @@ export default agent({
 
 function generatePromptTemplate(name: string): string {
   return `import { prompt } from "veryfront/prompt";
-import { z } from "zod";
+import { defineSchema } from "veryfront/schemas";
 
 export default prompt({
   id: "${name}",
   description: "Description of this prompt template",
-  argsSchema: z.object({
-    input: z.string().describe("User input"),
-  }),
+  argsSchema: defineSchema((v) => v.object({
+    input: v.string().describe("User input"),
+  }))(),
   getContent: ({ input }) => [
     { role: "system", content: "Role: describe what this assistant should do and its limits." },
     { role: "user", content: input },
@@ -145,22 +146,25 @@ export default prompt({
 // Scaffold Configuration
 // ============================================================================
 
-const scaffoldInput = z.object({
-  type: z.enum(["page", "api", "layout", "component", "tool", "agent", "prompt"]).describe(
-    "Type of entity to scaffold",
-  ),
-  name: z.string().describe(
-    "Name/path of the entity (e.g., 'users', 'api/users', 'dashboard/settings')",
-  ),
-  methods: z.array(z.enum(["GET", "POST", "PUT", "DELETE", "PATCH"])).optional().describe(
-    "HTTP methods for API routes (defaults to GET)",
-  ),
-  projectPath: z.string().optional().describe(
-    "Project directory (defaults to current working directory)",
-  ),
-});
+const getScaffoldInput = defineSchema((v) =>
+  v.object({
+    type: v.enum(["page", "api", "layout", "component", "tool", "agent", "prompt"]).describe(
+      "Type of entity to scaffold",
+    ),
+    name: v.string().describe(
+      "Name/path of the entity (e.g., 'users', 'api/users', 'dashboard/settings')",
+    ),
+    methods: v.array(v.enum(["GET", "POST", "PUT", "DELETE", "PATCH"])).optional().describe(
+      "HTTP methods for API routes (defaults to GET)",
+    ),
+    projectPath: v.string().optional().describe(
+      "Project directory (defaults to current working directory)",
+    ),
+  })
+);
+const scaffoldInput = getScaffoldInput();
 
-type ScaffoldInput = z.infer<typeof scaffoldInput>;
+type ScaffoldInput = InferSchema<ReturnType<typeof getScaffoldInput>>;
 type ScaffoldType = ScaffoldInput["type"];
 
 interface ScaffoldConfig {
@@ -223,7 +227,7 @@ export const vfScaffold: MCPTool<ScaffoldInput, ScaffoldResult> = {
         const slug = toSlug(input.name);
         const componentName = toComponentName(input.name);
 
-        const config = SCAFFOLD_CONFIGS[input.type];
+        const config = SCAFFOLD_CONFIGS[input.type]!;
         const directory = config.getDirectory(projectDir, slug);
         const filename = config.getFilename(slug, componentName);
         const filePath = join(directory, filename);
@@ -262,15 +266,18 @@ export const vfScaffold: MCPTool<ScaffoldInput, ScaffoldResult> = {
 // Tool: vf_get_conventions
 // ============================================================================
 
-const getConventionsInput = z.object({
-  topic: z
-    .enum(["all", "routing", "api", "components", "ai", "styling"])
-    .optional()
-    .default("all")
-    .describe("Specific topic to get conventions for"),
-});
+const getGetConventionsInput = defineSchema((v) =>
+  v.object({
+    topic: v
+      .enum(["all", "routing", "api", "components", "ai", "styling"])
+      .optional()
+      .default("all")
+      .describe("Specific topic to get conventions for"),
+  })
+);
+const getConventionsInput = getGetConventionsInput();
 
-type GetConventionsInput = z.infer<typeof getConventionsInput>;
+type GetConventionsInput = InferSchema<ReturnType<typeof getGetConventionsInput>>;
 
 interface Convention {
   topic: string;
@@ -362,7 +369,7 @@ const CONVENTIONS: Record<string, Convention> = {
       "AI tools go in ai/tools/ directory",
       "Agents go in ai/agents/ directory",
       "Prompts go in ai/prompts/ directory",
-      "Use Zod for tool parameter validation",
+      "Use defineSchema for tool parameter validation",
       "Tools should be focused on a single capability",
       "Agents combine tools with instructions for complex tasks",
     ],
@@ -374,10 +381,10 @@ const CONVENTIONS: Record<string, Convention> = {
       {
         good: `export const searchTool = {
   name: "search_docs",
-  parameters: z.object({ query: z.string() }),
+  parameters: defineSchema((v) => v.object({ query: v.string() }))(),
   execute: async ({ query }) => { /* ... */ }
 };`,
-        explanation: "Tool with Zod schema and typed execute function",
+        explanation: "Tool with defineSchema and typed execute function",
       },
     ],
   },

package/src/cli/mcp/tools/skill-tools.ts

@@ -2,7 +2,8 @@
  * MCP tools for skill discovery and reference loading.
  */
 
-import { z } from "zod";
+import { defineSchema } from "../../../src/schemas/index.js";
+import type { InferSchema } from "../../../src/extensions/schema/index.js";
 import { join } from "../../../src/platform/compat/path/index.js";
 import { cwd } from "../../../src/platform/index.js";
 import { withSpan } from "../../../src/observability/tracing/otlp-setup.js";
@@ -62,13 +63,15 @@ async function getSkillReferences(skillName: string): Promise<string[] | undefin
   return references.length ? references : undefined;
 }
 
-const getSkillsInput = z.object({
-  name: z.string().optional().describe(
-    "Specific skill name to get full content for (omit for list of all skills)",
-  ),
-});
+const getSkillsInput = defineSchema((v) =>
+  v.object({
+    name: v.string().optional().describe(
+      "Specific skill name to get full content for (omit for list of all skills)",
+    ),
+  })
+)();
 
-type GetSkillsInput = z.infer<typeof getSkillsInput>;
+type GetSkillsInput = InferSchema<typeof getSkillsInput>;
 
 interface SkillMetadata {
   name: string;
@@ -156,12 +159,14 @@ export const vfGetSkills: MCPTool<GetSkillsInput, GetSkillsResult> = {
     ),
 };
 
-const getSkillReferenceInput = z.object({
-  skill: z.string().describe("Skill name"),
-  reference: z.string().describe("Reference file path (e.g., 'references/ROUTES.md')"),
-});
+const getSkillReferenceInput = defineSchema((v) =>
+  v.object({
+    skill: v.string().describe("Skill name"),
+    reference: v.string().describe("Reference file path (e.g., 'references/ROUTES.md')"),
+  })
+)();
 
-type GetSkillReferenceInput = z.infer<typeof getSkillReferenceInput>;
+type GetSkillReferenceInput = InferSchema<typeof getSkillReferenceInput>;
 
 interface GetSkillReferenceResult {
   content?: string;

package/src/cli/mcp/tools.ts

@@ -2,7 +2,8 @@
  * MCP Tools for Veryfront Dev Server
  **************************/
 
-import { z } from "zod";
+import { defineSchema } from "../../src/schemas/index.js";
+import type { InferSchema } from "../../src/extensions/schema/index.js";
 import {
   type DevError,
   type ErrorType,
@@ -34,19 +35,22 @@ export function setServerStartTime(time: number): void {
   serverStartTime = time;
 }
 
-const getErrorsInput = z.object({
-  type: z.enum(["compile", "runtime", "bundle", "hmr", "module"]).optional().describe(
-    "Filter by error type. Example: 'compile'. Omit to return all types.",
-  ),
-  file: z.string().optional().describe(
-    "Filter by file path. Example: 'app/page.tsx'. Omit to return errors from all files.",
-  ),
-  limit: z.number().optional().default(50).describe(
-    "Maximum number of errors to return. Defaults to 50.",
-  ),
-});
-
-type GetErrorsInput = z.infer<typeof getErrorsInput>;
+const getGetErrorsInput = defineSchema((v) =>
+  v.object({
+    type: v.enum(["compile", "runtime", "bundle", "hmr", "module"]).optional().describe(
+      "Filter by error type. Example: 'compile'. Omit to return all types.",
+    ),
+    file: v.string().optional().describe(
+      "Filter by file path. Example: 'app/page.tsx'. Omit to return errors from all files.",
+    ),
+    limit: v.number().optional().default(50).describe(
+      "Maximum number of errors to return. Defaults to 50.",
+    ),
+  })
+);
+const getErrorsInput = getGetErrorsInput();
+
+type GetErrorsInput = InferSchema<ReturnType<typeof getGetErrorsInput>>;
 
 export const vfGetErrors: MCPTool<GetErrorsInput, DevError[]> = {
   name: "vf_get_errors",
@@ -66,25 +70,28 @@ export const vfGetErrors: MCPTool<GetErrorsInput, DevError[]> = {
   },
 };
 
-const getLogsInput = z.object({
-  level: z.enum(["debug", "info", "warn", "error"]).optional().describe(
-    "Filter by log level. Example: 'error'. Omit to return all levels.",
-  ),
-  source: z.string().optional().describe(
-    "Filter by log source. Example: 'server', 'hmr', 'transform'. Omit to return all sources.",
-  ),
-  pattern: z.string().optional().describe(
-    "Filter by pattern (case-insensitive substring match). Example: 'timeout'.",
-  ),
-  limit: z.number().optional().default(100).describe(
-    "Maximum number of log entries to return. Defaults to 100.",
-  ),
-  since: z.number().optional().describe(
-    "Only return logs after this Unix timestamp in milliseconds.",
-  ),
-});
-
-type GetLogsInput = z.infer<typeof getLogsInput>;
+const getGetLogsInput = defineSchema((v) =>
+  v.object({
+    level: v.enum(["debug", "info", "warn", "error"]).optional().describe(
+      "Filter by log level. Example: 'error'. Omit to return all levels.",
+    ),
+    source: v.string().optional().describe(
+      "Filter by log source. Example: 'server', 'hmr', 'transform'. Omit to return all sources.",
+    ),
+    pattern: v.string().optional().describe(
+      "Filter by pattern (case-insensitive substring match). Example: 'timeout'.",
+    ),
+    limit: v.number().optional().default(100).describe(
+      "Maximum number of log entries to return. Defaults to 100.",
+    ),
+    since: v.number().optional().describe(
+      "Only return logs after this Unix timestamp in milliseconds.",
+    ),
+  })
+);
+const getLogsInput = getGetLogsInput();
+
+type GetLogsInput = InferSchema<ReturnType<typeof getGetLogsInput>>;
 
 export const vfGetLogs: MCPTool<GetLogsInput, LogEntry[]> = {
   name: "vf_get_logs",
@@ -104,13 +111,16 @@ export const vfGetLogs: MCPTool<GetLogsInput, LogEntry[]> = {
   },
 };
 
-const clearCacheInput = z.object({
-  type: z.enum(["all", "modules", "mdx"]).optional().default("all").describe(
-    "Type of cache to clear. Example: 'modules'. Defaults to 'all'.",
-  ),
-});
+const getClearCacheInput = defineSchema((v) =>
+  v.object({
+    type: v.enum(["all", "modules", "mdx"]).optional().default("all").describe(
+      "Type of cache to clear. Example: 'modules'. Defaults to 'all'.",
+    ),
+  })
+);
+const clearCacheInput = getClearCacheInput();
 
-type ClearCacheInput = z.infer<typeof clearCacheInput>;
+type ClearCacheInput = InferSchema<ReturnType<typeof getClearCacheInput>>;
 
 interface ClearCacheOutput {
   success: boolean;
@@ -148,9 +158,10 @@ export const vfClearCache: MCPTool<ClearCacheInput, ClearCacheOutput> = {
   },
 };
 
-const getStatusInput = z.object({});
+const getGetStatusInput = defineSchema((v) => v.object({}));
+const getStatusInput = getGetStatusInput();
 
-type GetStatusInput = z.infer<typeof getStatusInput>;
+type GetStatusInput = InferSchema<ReturnType<typeof getGetStatusInput>>;
 
 interface ServerStatus {
   running: boolean;
@@ -193,16 +204,19 @@ export function createVfGetStatus(
 
 export const vfGetStatus = createVfGetStatus();
 
-const clearErrorsInput = z.object({
-  file: z.string().optional().describe(
-    "Clear errors for a specific file only. Example: 'app/page.tsx'. Omit to clear all files.",
-  ),
-  type: z.enum(["compile", "runtime", "bundle", "hmr", "module"]).optional().describe(
-    "Clear errors of a specific type only. Example: 'compile'. Omit to clear all types.",
-  ),
-});
-
-type ClearErrorsInput = z.infer<typeof clearErrorsInput>;
+const getClearErrorsInput = defineSchema((v) =>
+  v.object({
+    file: v.string().optional().describe(
+      "Clear errors for a specific file only. Example: 'app/page.tsx'. Omit to clear all files.",
+    ),
+    type: v.enum(["compile", "runtime", "bundle", "hmr", "module"]).optional().describe(
+      "Clear errors of a specific type only. Example: 'compile'. Omit to clear all types.",
+    ),
+  })
+);
+const clearErrorsInput = getClearErrorsInput();
+
+type ClearErrorsInput = InferSchema<ReturnType<typeof getClearErrorsInput>>;
 
 interface ClearErrorsOutput {
   cleared: number;

package/src/cli/shared/args.ts

@@ -6,13 +6,13 @@
  * @module cli/shared/args
  */
 
-import { z } from "zod";
+import type { Schema } from "../../src/extensions/schema/index.js";
 import type { ParsedArgs } from "./types.js";
 
 /** Compat type for safeParse result (SafeParseReturnType removed in zod v4). */
 export type SafeParseResult<T> =
   | { success: true; data: T; error?: never }
-  | { success: false; data?: never; error: z.ZodError };
+  | { success: false; data?: never; error: Error & { issues: unknown[] } };
 
 /**
  * Argument specification for a single option
@@ -96,11 +96,12 @@ export function extractArgs<T>(
  *
  * @example
  * ```ts
- * const PullArgsSchema = z.object({
- *   projectSlug: z.string().optional(),
- *   projectDir: z.string().optional(),
- *   force: z.boolean().default(false),
- * });
+ * const getPullArgsSchema = defineSchema((v) => v.object({
+ *   projectSlug: v.string().optional(),
+ *   projectDir: v.string().optional(),
+ *   force: v.boolean().default(false),
+ * }));
+ * const PullArgsSchema = getPullArgsSchema();
  *
  * const parsePullArgs = createArgParser(PullArgsSchema, {
  *   projectSlug: { keys: ["project-slug", "p"], type: "string", positional: 0 },
@@ -115,7 +116,7 @@ export function extractArgs<T>(
  * ```
  */
 export function createArgParser<T>(
-  schema: z.ZodType<T>,
+  schema: Schema<T>,
   argMap: ArgMap<T>,
 ): (args: ParsedArgs) => SafeParseResult<T> {
   return function parseArgs(args: ParsedArgs): SafeParseResult<T> {
@@ -123,7 +124,9 @@ export function createArgParser<T>(
     if (result.success) {
       return { success: true, data: result.data };
     }
-    return { success: false, error: result.error };
+    const message = result.issues?.map((i) => i.message).join("; ") ?? "Validation failed";
+    const error = Object.assign(new Error(message), { issues: result.issues ?? [] });
+    return { success: false, error };
   };
 }