veryfront 0.1.501 → 0.1.503

package/src/cli/commands/files/command.ts

@@ -1,5 +1,9 @@
-import { z } from "zod";
-type SafeParseResult<T> = { success: true; data: T } | { success: false; error: z.ZodError };
+import { defineSchema } from "../../../src/schemas/index.js";
+import type { InferSchema } from "../../../src/extensions/schema/index.js";
+type SafeParseResult<T> = { success: true; data: T } | {
+  success: false;
+  error: Error & { issues: unknown[] };
+};
 import { createFileSystem } from "../../../src/platform/index.js";
 import { dirname, normalize } from "../../../src/platform/compat/path/index.js";
 import { withSpan } from "../../../src/observability/tracing/otlp-setup.js";
@@ -13,44 +17,60 @@ const MAIN_SOURCE = { type: "main" } as const;
 
 type RemoteFileEntry = Awaited<ReturnType<typeof listAllFiles>>[number];
 
-const FilesListArgsSchema = z.object({
-  projectSlug: z.string().optional(),
-  projectDir: z.string().optional(),
-  path: z.string().optional(),
-  json: z.boolean().default(false),
-  quiet: z.boolean().default(false),
-});
-
-const FilesGetArgsSchema = z.object({
-  projectSlug: z.string().optional(),
-  projectDir: z.string().optional(),
-  remotePath: z.string().min(1),
-  output: z.string().optional(),
-  json: z.boolean().default(false),
-  quiet: z.boolean().default(false),
-});
-
-const FilesPutArgsSchema = z.object({
-  projectSlug: z.string().optional(),
-  projectDir: z.string().optional(),
-  remotePath: z.string().min(1),
-  from: z.string().min(1),
-  json: z.boolean().default(false),
-  quiet: z.boolean().default(false),
-});
-
-const FilesDeleteArgsSchema = z.object({
-  projectSlug: z.string().optional(),
-  projectDir: z.string().optional(),
-  remotePath: z.string().min(1),
-  json: z.boolean().default(false),
-  quiet: z.boolean().default(false),
-});
-
-export type FilesListOptions = z.infer<typeof FilesListArgsSchema>;
-export type FilesGetOptions = z.infer<typeof FilesGetArgsSchema>;
-export type FilesPutOptions = z.infer<typeof FilesPutArgsSchema>;
-export type FilesDeleteOptions = z.infer<typeof FilesDeleteArgsSchema>;
+const getFilesListArgsSchema = defineSchema((v) =>
+  v.object({
+    projectSlug: v.string().optional(),
+    projectDir: v.string().optional(),
+    path: v.string().optional(),
+    json: v.boolean().default(false),
+    quiet: v.boolean().default(false),
+  })
+);
+
+const FilesListArgsSchema = getFilesListArgsSchema();
+
+const getFilesGetArgsSchema = defineSchema((v) =>
+  v.object({
+    projectSlug: v.string().optional(),
+    projectDir: v.string().optional(),
+    remotePath: v.string().min(1),
+    output: v.string().optional(),
+    json: v.boolean().default(false),
+    quiet: v.boolean().default(false),
+  })
+);
+
+const FilesGetArgsSchema = getFilesGetArgsSchema();
+
+const getFilesPutArgsSchema = defineSchema((v) =>
+  v.object({
+    projectSlug: v.string().optional(),
+    projectDir: v.string().optional(),
+    remotePath: v.string().min(1),
+    from: v.string().min(1),
+    json: v.boolean().default(false),
+    quiet: v.boolean().default(false),
+  })
+);
+
+const FilesPutArgsSchema = getFilesPutArgsSchema();
+
+const getFilesDeleteArgsSchema = defineSchema((v) =>
+  v.object({
+    projectSlug: v.string().optional(),
+    projectDir: v.string().optional(),
+    remotePath: v.string().min(1),
+    json: v.boolean().default(false),
+    quiet: v.boolean().default(false),
+  })
+);
+
+const FilesDeleteArgsSchema = getFilesDeleteArgsSchema();
+
+export type FilesListOptions = InferSchema<ReturnType<typeof getFilesListArgsSchema>>;
+export type FilesGetOptions = InferSchema<ReturnType<typeof getFilesGetArgsSchema>>;
+export type FilesPutOptions = InferSchema<ReturnType<typeof getFilesPutArgsSchema>>;
+export type FilesDeleteOptions = InferSchema<ReturnType<typeof getFilesDeleteArgsSchema>>;
 
 function getBooleanArg(args: ParsedArgs, ...keys: string[]): boolean {
   return keys.some((key) => Boolean(args[key]));
@@ -95,7 +115,7 @@ export function parseFilesListArgs(
     path: getStringArg(args, "path"),
     json: getBooleanArg(args, "json", "j"),
     quiet: getBooleanArg(args, "quiet", "q"),
-  });
+  }) as SafeParseResult<FilesListOptions>;
 }
 
 export function parseFilesGetArgs(
@@ -108,7 +128,7 @@ export function parseFilesGetArgs(
     output: getStringArg(args, "output", "o"),
     json: getBooleanArg(args, "json", "j"),
     quiet: getBooleanArg(args, "quiet", "q"),
-  });
+  }) as SafeParseResult<FilesGetOptions>;
 }
 
 export function parseFilesPutArgs(
@@ -121,7 +141,7 @@ export function parseFilesPutArgs(
     from: getStringArg(args, "from") ?? "",
     json: getBooleanArg(args, "json", "j"),
     quiet: getBooleanArg(args, "quiet", "q"),
-  });
+  }) as SafeParseResult<FilesPutOptions>;
 }
 
 export function parseFilesDeleteArgs(
@@ -133,7 +153,7 @@ export function parseFilesDeleteArgs(
     remotePath: typeof args._[2] === "string" ? args._[2] : "",
     json: getBooleanArg(args, "json", "j"),
     quiet: getBooleanArg(args, "quiet", "q"),
-  });
+  }) as SafeParseResult<FilesDeleteOptions>;
 }
 
 export function buildRemoteFileUrl(projectSlug: string, remotePath: string): string {

package/src/cli/commands/generate/handler.ts

@@ -2,7 +2,7 @@
  * Generate command handler
  */
 
-import { z } from "zod";
+import { defineSchema } from "../../../src/schemas/index.js";
 import { generateCommand } from "./index.js";
 import { showLogo } from "../../utils/index.js";
 import { createArgParser } from "../../shared/args.js";
@@ -11,10 +11,14 @@ import { cwd } from "../../../src/platform/index.js";
 
 const VALID_TYPES = ["page", "layout", "provider", "api", "integration"] as const;
 
-const GenerateArgsSchema = z.object({
-  type: z.enum(VALID_TYPES).optional(),
-  name: z.string().optional(),
-});
+const getGenerateArgsSchema = defineSchema((v) =>
+  v.object({
+    type: v.enum(VALID_TYPES).optional(),
+    name: v.string().optional(),
+  })
+);
+
+const GenerateArgsSchema = getGenerateArgsSchema();
 
 export const parseGenerateArgs = createArgParser(GenerateArgsSchema, {
   type: { keys: ["type"], type: "string", positional: 0 },

package/src/cli/commands/generate/integration-generator-helpers.ts

@@ -145,8 +145,8 @@ export function getNonInteractiveConfig(
 
 const TOOL_FILE_CONTENTS: Record<string, { inputSchema: string; executeBody: string }> = {
   "list-items.ts": {
-    inputSchema: `limit: z.number().optional().describe("Maximum number of items to return"),
-    offset: z.number().optional().describe("Number of items to skip"),`,
+    inputSchema: `limit: v.number().optional().describe("Maximum number of items to return"),
+    offset: v.number().optional().describe("Number of items to skip"),`,
     executeBody: `const items = await listItems({
         limit: input.limit,
         offset: input.offset,
@@ -158,7 +158,7 @@ const TOOL_FILE_CONTENTS: Record<string, { inputSchema: string; executeBody: str
       };`,
   },
   "get-item.ts": {
-    inputSchema: `id: z.string().describe("The ID of the item to retrieve"),`,
+    inputSchema: `id: v.string().describe("The ID of the item to retrieve"),`,
     executeBody: `const item = await getItem(input.id);
       return {
         success: true,
@@ -166,7 +166,7 @@ const TOOL_FILE_CONTENTS: Record<string, { inputSchema: string; executeBody: str
       };`,
   },
   "search.ts": {
-    inputSchema: `query: z.string().describe("Search query"),`,
+    inputSchema: `query: v.string().describe("Search query"),`,
     executeBody: `const results = await searchItems(input.query);
       return {
         success: true,

package/src/cli/commands/generate/integration-generator.ts

@@ -725,15 +725,19 @@ async function createToolSkeletons(baseDir: string, config: IntegrationConfig):
  */
 
 import { tool } from "veryfront/tool";
-import { z } from "zod";
+import { defineSchema } from "veryfront/schemas";
 import { listItems, getItem, searchItems } from "../lib/${config.name}-client.ts";
 
+const getInputSchema = defineSchema((v) =>
+  v.object({
+    ${inputSchema}
+  })
+);
+
 export default tool({
   id: "${tool.id}",
   description: "${tool.description}",
-  inputSchema: z.object({
-    ${inputSchema}
-  }),
+  inputSchema: getInputSchema(),
   execute: async (input) => {
     try {
       ${executeBody}

package/src/cli/commands/install/detect.ts

@@ -30,7 +30,7 @@ export async function detectAITools(
 
   const detected: AIToolId[] = [];
   for (const toolId of Object.keys(rules) as AIToolId[]) {
-    if (await rules[toolId](cwd)) detected.push(toolId);
+    if (await rules[toolId]!(cwd)) detected.push(toolId);
   }
 
   return detected;

package/src/cli/commands/install/handler.ts

@@ -2,17 +2,21 @@
  * Install/Uninstall command handler
  */
 
-import { z } from "zod";
+import { defineSchema } from "../../../src/schemas/index.js";
 import { installCommand } from "./install.js";
 import { uninstallCommand } from "./uninstall.js";
 import { CommonArgs, createArgParser, parseArgsOrThrow } from "../../shared/args.js";
 import type { ParsedArgs } from "../../shared/types.js";
 
-const InstallArgsSchema = z.object({
-  target: z.string().optional(),
-  global: z.boolean().default(false),
-  force: z.boolean().default(false),
-});
+const getInstallArgsSchema = defineSchema((v) =>
+  v.object({
+    target: v.string().optional(),
+    global: v.boolean().default(false),
+    force: v.boolean().default(false),
+  })
+);
+
+const InstallArgsSchema = getInstallArgsSchema();
 
 export const parseInstallArgs = createArgParser(InstallArgsSchema, {
   target: { keys: ["target", "t"], type: "string" },

package/src/cli/commands/install/install.ts

@@ -5,7 +5,7 @@
 import { dirname, join } from "../../../src/platform/compat/path/index.js";
 import { cwd as getCwd } from "../../../src/platform/index.js";
 import { exists, mkdir, writeTextFile } from "../../../src/platform/index.js";
-import { z } from "zod";
+import { defineSchema } from "../../../src/schemas/index.js";
 import { type EnvironmentConfig, getEnvironmentConfig } from "../../../src/config/index.js";
 import { bold, dim, multiSelect, type MultiSelectOption, muted, success, warning } from "../../ui/index.js";
 import { detectAITools, formatDetectionHint } from "./detect.js";
@@ -17,28 +17,36 @@ import {
   InstallOptionsSchema,
 } from "./types.js";
 
-const TargetFlagSchema = z
-  .string()
-  .transform((val) => {
-    if (val === "all") return AI_TOOLS.map((t) => t.id);
+const getTargetFlagSchema = defineSchema((v) =>
+  v
+    .string()
+    .transform((val) => {
+      if (val === "all") return AI_TOOLS.map((t) => t.id);
 
-    return val
-      .split(",")
-      .map((t) => t.trim())
-      .filter(isValidToolId);
-  })
-  .refine((arr) => arr.length > 0, { message: "No valid targets specified" });
+      return val
+        .split(",")
+        .map((t) => t.trim())
+        .filter(isValidToolId);
+    })
+    .refine((arr) => arr.length > 0, { message: "No valid targets specified" })
+);
+
+const TargetFlagSchema = getTargetFlagSchema();
 
 export function parseTargetFlag(target: string): AIToolId[] {
   return TargetFlagSchema.parse(target);
 }
 
+const getAIToolIdArraySchema = defineSchema((v) => v.array(AIToolIdSchema).min(1));
+
+const AIToolIdArraySchema = getAIToolIdArraySchema();
+
 export async function installTargets(
   targets: AIToolId[],
   options: Pick<InstallOptions, "cwd" | "force" | "global">,
   env: EnvironmentConfig = getEnvironmentConfig(),
 ): Promise<void> {
-  z.array(AIToolIdSchema).min(1).parse(targets);
+  AIToolIdArraySchema.parse(targets);
 
   const cwd = options.cwd ?? getCwd();
   const homeDir = env.homeDir!;

package/src/cli/commands/install/types.ts

@@ -1,41 +1,58 @@
-import { z } from "zod";
-
-export const AIToolIdSchema = z.enum([
-  "cursor",
-  "claude-code",
-  "skill",
-  "copilot",
-  "windsurf",
-  "agents",
-]);
-
-export type AIToolId = z.infer<typeof AIToolIdSchema>;
-
-export const AIToolSchema = z.object({
-  id: AIToolIdSchema,
-  label: z.string().min(1),
-  file: z.string().min(1),
-  description: z.string().min(1),
-  template: z.string().min(1),
-});
-
-export type AITool = z.infer<typeof AIToolSchema>;
-
-const BaseCommandOptionsSchema = z.object({
-  target: z.string().optional(),
-  global: z.boolean().optional(),
-  force: z.boolean().optional(),
-  cwd: z.string().optional(),
-});
-
-export const InstallOptionsSchema = BaseCommandOptionsSchema;
-export type InstallOptions = z.infer<typeof InstallOptionsSchema>;
-
-export const UninstallOptionsSchema = BaseCommandOptionsSchema;
-export type UninstallOptions = z.infer<typeof UninstallOptionsSchema>;
-
-export const DetectOptionsSchema = z.object({
-  cwd: z.string().optional(),
-});
-
-export type DetectOptions = z.infer<typeof DetectOptionsSchema>;
+import { defineSchema } from "../../../src/schemas/index.js";
+import type { InferSchema } from "../../../src/extensions/schema/index.js";
+
+export const getAIToolIdSchema = defineSchema((v) =>
+  v.enum([
+    "cursor",
+    "claude-code",
+    "skill",
+    "copilot",
+    "windsurf",
+    "agents",
+  ])
+);
+
+export const AIToolIdSchema = getAIToolIdSchema();
+
+export type AIToolId = InferSchema<ReturnType<typeof getAIToolIdSchema>>;
+
+export const getAIToolSchema = defineSchema((v) =>
+  v.object({
+    id: getAIToolIdSchema(),
+    label: v.string().min(1),
+    file: v.string().min(1),
+    description: v.string().min(1),
+    template: v.string().min(1),
+  })
+);
+
+export const AIToolSchema = getAIToolSchema();
+
+export type AITool = InferSchema<ReturnType<typeof getAIToolSchema>>;
+
+const getBaseCommandOptionsSchema = defineSchema((v) =>
+  v.object({
+    target: v.string().optional(),
+    global: v.boolean().optional(),
+    force: v.boolean().optional(),
+    cwd: v.string().optional(),
+  })
+);
+
+export const getInstallOptionsSchema = getBaseCommandOptionsSchema;
+export const InstallOptionsSchema = getInstallOptionsSchema();
+export type InstallOptions = InferSchema<ReturnType<typeof getInstallOptionsSchema>>;
+
+export const getUninstallOptionsSchema = getBaseCommandOptionsSchema;
+export const UninstallOptionsSchema = getUninstallOptionsSchema();
+export type UninstallOptions = InferSchema<ReturnType<typeof getUninstallOptionsSchema>>;
+
+export const getDetectOptionsSchema = defineSchema((v) =>
+  v.object({
+    cwd: v.string().optional(),
+  })
+);
+
+export const DetectOptionsSchema = getDetectOptionsSchema();
+
+export type DetectOptions = InferSchema<ReturnType<typeof getDetectOptionsSchema>>;

package/src/cli/commands/install/uninstall.ts

@@ -5,7 +5,7 @@
 import { dirname, join } from "../../../src/platform/compat/path/index.js";
 import { cwd as getCwd } from "../../../src/platform/index.js";
 import { exists, readDir, remove } from "../../../src/platform/index.js";
-import { z } from "zod";
+import { defineSchema } from "../../../src/schemas/index.js";
 import { type EnvironmentConfig, getEnvironmentConfig } from "../../../src/config/index.js";
 import { bold, brand, multiSelect, type MultiSelectOption, muted, success, warning } from "../../ui/index.js";
 import { AI_TOOLS, getToolById } from "./registry.js";
@@ -40,12 +40,16 @@ async function isDirEmpty(path: string): Promise<boolean> {
   return true;
 }
 
+const getAIToolIdArraySchema = defineSchema((v) => v.array(AIToolIdSchema).min(1));
+
+const AIToolIdArraySchema = getAIToolIdArraySchema();
+
 export async function uninstallTargets(
   targets: AIToolId[],
   options: Pick<UninstallOptions, "cwd" | "global">,
   env: EnvironmentConfig = getEnvironmentConfig(),
 ): Promise<void> {
-  z.array(AIToolIdSchema).min(1).parse(targets);
+  AIToolIdArraySchema.parse(targets);
 
   const cwd = options.cwd ?? getCwd();
   const homeDir = env.homeDir!;

package/src/cli/commands/knowledge/command.ts

@@ -1,6 +1,10 @@
 import * as dntShim from "../../../_dnt.shims.js";
-import { z } from "zod";
-type SafeParseResult<T> = { success: true; data: T } | { success: false; error: z.ZodError };
+import { defineSchema } from "../../../src/schemas/index.js";
+import type { InferSchema } from "../../../src/extensions/schema/index.js";
+type SafeParseResult<T> = { success: true; data: T } | {
+  success: false;
+  error: Error & { issues: unknown[] };
+};
 import { type CommandResult, createFileSystem, getEnv, runCommand } from "../../../src/platform/index.js";
 import { basename } from "../../../src/platform/compat/path/index.js";
 import { withSpan } from "../../../src/observability/tracing/otlp-setup.js";
@@ -57,60 +61,64 @@ type DownloadResult = { uploadPath: string; localPath: string; bytes?: number };
 
 const knowledgeJobLogger = serverLogger.component("knowledge-ingest");
 
-const KnowledgeIngestArgsSchema = z.object({
-  projectSlug: z.string().optional(),
-  projectDir: z.string().optional(),
-  sources: z.array(z.string()).default([]),
-  path: z.string().optional(),
-  all: z.boolean().default(false),
-  recursive: z.boolean().default(false),
-  outputDir: z.string().optional(),
-  knowledgePath: z.string().default("knowledge"),
-  description: z.string().optional(),
-  slug: z.string().optional(),
-  json: z.boolean().default(false),
-  quiet: z.boolean().default(false),
-}).superRefine((value, ctx) => {
-  const hasExplicitSources = value.sources.length > 0;
-  const hasPath = typeof value.path === "string" && value.path.length > 0;
-
-  if (hasExplicitSources && (hasPath || value.all)) {
-    ctx.addIssue({
-      code: z.ZodIssueCode.custom,
-      message: "Use either explicit source paths or --path with --all, not both.",
-    });
-  }
+const getKnowledgeIngestArgsSchema = defineSchema((v) =>
+  v.object({
+    projectSlug: v.string().optional(),
+    projectDir: v.string().optional(),
+    sources: v.array(v.string()).default([]),
+    path: v.string().optional(),
+    all: v.boolean().default(false),
+    recursive: v.boolean().default(false),
+    outputDir: v.string().optional(),
+    knowledgePath: v.string().default("knowledge"),
+    description: v.string().optional(),
+    slug: v.string().optional(),
+    json: v.boolean().default(false),
+    quiet: v.boolean().default(false),
+  }).superRefine((value, ctx) => {
+    const hasExplicitSources = value.sources.length > 0;
+    const hasPath = typeof value.path === "string" && value.path.length > 0;
+
+    if (hasExplicitSources && (hasPath || value.all)) {
+      ctx.addIssue({
+        code: "custom",
+        message: "Use either explicit source paths or --path with --all, not both.",
+      });
+    }
 
-  if (!hasExplicitSources && !hasPath && !value.all) {
-    ctx.addIssue({
-      code: z.ZodIssueCode.custom,
-      message: "Provide one or more source paths or use --path with --all.",
-    });
-  }
+    if (!hasExplicitSources && !hasPath && !value.all) {
+      ctx.addIssue({
+        code: "custom",
+        message: "Provide one or more source paths or use --path with --all.",
+      });
+    }
 
-  if (hasPath && !value.all) {
-    ctx.addIssue({
-      code: z.ZodIssueCode.custom,
-      message: "--path requires --all.",
-    });
-  }
+    if (hasPath && !value.all) {
+      ctx.addIssue({
+        code: "custom",
+        message: "--path requires --all.",
+      });
+    }
 
-  if (!hasPath && value.all) {
-    ctx.addIssue({
-      code: z.ZodIssueCode.custom,
-      message: "--all requires --path.",
-    });
-  }
+    if (!hasPath && value.all) {
+      ctx.addIssue({
+        code: "custom",
+        message: "--all requires --path.",
+      });
+    }
 
-  if (value.slug && value.sources.length !== 1) {
-    ctx.addIssue({
-      code: z.ZodIssueCode.custom,
-      message: "--slug can only be used with a single explicit source.",
-    });
-  }
-});
+    if (value.slug && value.sources.length !== 1) {
+      ctx.addIssue({
+        code: "custom",
+        message: "--slug can only be used with a single explicit source.",
+      });
+    }
+  })
+);
 
-export type KnowledgeIngestOptions = z.infer<typeof KnowledgeIngestArgsSchema>;
+const KnowledgeIngestArgsSchema = getKnowledgeIngestArgsSchema();
+
+export type KnowledgeIngestOptions = InferSchema<ReturnType<typeof getKnowledgeIngestArgsSchema>>;
 
 function getBooleanArg(args: ParsedArgs, ...keys: string[]): boolean {
   return keys.some((key) => Boolean(args[key]));
@@ -170,7 +178,7 @@ export function parseKnowledgeIngestArgs(
     slug: getStringArg(args, "slug"),
     json: getBooleanArg(args, "json", "j"),
     quiet: getBooleanArg(args, "quiet", "q"),
-  });
+  }) as SafeParseResult<KnowledgeIngestOptions>;
 }
 
 function defaultOutputRoot(): Promise<string> {

package/src/cli/commands/lock/handler.ts

@@ -2,20 +2,24 @@
  * Lock command handler
  */
 
-import { z } from "zod";
+import { defineSchema } from "../../../src/schemas/index.js";
 import { lockCommand } from "./command.js";
 import { createArgParser } from "../../shared/args.js";
 import type { ParsedArgs } from "../../shared/types.js";
 import { handleProjectDirCommand } from "../../shared/handler-utils.js";
 
-const LockArgsSchema = z.object({
-  projectDir: z.string().default(""),
-  update: z.boolean().default(false),
-  verify: z.boolean().default(false),
-  clear: z.boolean().default(false),
-  list: z.boolean().default(false),
-  force: z.boolean().default(false),
-});
+const getLockArgsSchema = defineSchema((v) =>
+  v.object({
+    projectDir: v.string().default(""),
+    update: v.boolean().default(false),
+    verify: v.boolean().default(false),
+    clear: v.boolean().default(false),
+    list: v.boolean().default(false),
+    force: v.boolean().default(false),
+  })
+);
+
+const LockArgsSchema = getLockArgsSchema();
 
 const parseLockArgs = createArgParser(LockArgsSchema, {
   projectDir: { keys: ["project"], type: "string" },

package/src/cli/commands/mcp/handler.ts

@@ -4,13 +4,17 @@
 import * as dntShim from "../../../_dnt.shims.js";
 
 
-import { z } from "zod";
+import { defineSchema } from "../../../src/schemas/index.js";
 import { createArgParser, parseArgsOrThrow } from "../../shared/args.js";
 import type { ParsedArgs } from "../../shared/types.js";
 
-const MCPArgsSchema = z.object({
-  port: z.number().optional(),
-});
+const getMCPArgsSchema = defineSchema((v) =>
+  v.object({
+    port: v.number().optional(),
+  })
+);
+
+const MCPArgsSchema = getMCPArgsSchema();
 
 export const parseMCPArgs = createArgParser(MCPArgsSchema, {
   port: { keys: ["port"], type: "number" },