veryfront 0.1.501 → 0.1.503

package/src/cli/shared/config.ts

@@ -5,7 +5,8 @@
  * @module cli/shared/config
  */
 
-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 { createFileSystem, cwd, getEnv } from "../../src/platform/index.js";
 import { type EnvironmentConfig, getEnvironmentConfig } from "../../src/config/index.js";
@@ -14,21 +15,27 @@ import { readToken } from "../auth/token-store.js";
 import { ensureAuthenticated } from "../auth/login.js";
 import { DEFAULT_API_URL } from "./constants.js";
 
-export const VeryfrontConfigSchema = z.object({
-  projectSlug: z.string().optional(),
-  /** List of project slugs for multi-project pull */
-  projects: z.array(z.string()).optional(),
-  apiToken: z.string().optional(),
-  apiUrl: z.string().optional(),
-});
-export type VeryfrontConfig = z.infer<typeof VeryfrontConfigSchema>;
-
-export const ResolvedConfigSchema = z.object({
-  apiUrl: z.string(),
-  apiToken: z.string(),
-  projectSlug: z.string(),
-});
-export type ResolvedConfig = z.infer<typeof ResolvedConfigSchema>;
+export const getVeryfrontConfigSchema = defineSchema((v) =>
+  v.object({
+    projectSlug: v.string().optional(),
+    /** List of project slugs for multi-project pull */
+    projects: v.array(v.string()).optional(),
+    apiToken: v.string().optional(),
+    apiUrl: v.string().optional(),
+  })
+);
+export const VeryfrontConfigSchema = getVeryfrontConfigSchema();
+export type VeryfrontConfig = InferSchema<ReturnType<typeof getVeryfrontConfigSchema>>;
+
+export const getResolvedConfigSchema = defineSchema((v) =>
+  v.object({
+    apiUrl: v.string(),
+    apiToken: v.string(),
+    projectSlug: v.string(),
+  })
+);
+export const ResolvedConfigSchema = getResolvedConfigSchema();
+export type ResolvedConfig = InferSchema<ReturnType<typeof getResolvedConfigSchema>>;
 
 export async function readConfigFile(projectDir: string): Promise<VeryfrontConfig | null> {
   const fs = createFileSystem();
@@ -176,12 +183,15 @@ export interface ApiClient {
   delete<T>(path: string): Promise<T>;
 }
 
-export const ApiErrorSchema = z.object({
-  error: z.string(),
-  message: z.string().optional(),
-  code: z.string().optional(),
-});
-export type ApiError = z.infer<typeof ApiErrorSchema>;
+export const getApiErrorSchema = defineSchema((v) =>
+  v.object({
+    error: v.string(),
+    message: v.string().optional(),
+    code: v.string().optional(),
+  })
+);
+export const ApiErrorSchema = getApiErrorSchema();
+export type ApiError = InferSchema<ReturnType<typeof getApiErrorSchema>>;
 
 export function createApiClient(config: ResolvedConfig): ApiClient {
   const { apiUrl, apiToken } = config;

package/src/cli/shared/project-source-context.ts

@@ -56,7 +56,7 @@ export async function withProjectSourceContext<T>(
 ): Promise<T> {
   const baseAdapter = await runtime.get();
   const initialConfig = await getConfig(projectDir, baseAdapter);
-  const adapter = await enhanceAdapterWithFS(baseAdapter, initialConfig, projectDir);
+  const adapter = await enhanceAdapterWithFS(baseAdapter, initialConfig as any, projectDir);
   const proxyContext = getProxyProjectSourceContext();
 
   if (

package/src/cli/shared/types.ts

@@ -1,7 +1,9 @@
-import { z } from "zod";
+import { defineSchema } from "../../src/schemas/index.js";
+import type { InferSchema } from "../../src/extensions/schema/index.js";
 
-export const ServerModeSchema = z.enum(["combined", "proxy", "production"]);
-export type ServerMode = z.infer<typeof ServerModeSchema>;
+export const getServerModeSchema = defineSchema((v) => v.enum(["combined", "proxy", "production"]));
+export const ServerModeSchema = getServerModeSchema();
+export type ServerMode = InferSchema<ReturnType<typeof getServerModeSchema>>;
 
 export interface ParsedArgs {
   _: (string | number)[];

package/src/cli/skills/types.ts

@@ -1,35 +1,40 @@
-import { z } from "zod";
+import { defineSchema } from "../../src/schemas/index.js";
+import type { InferSchema } from "../../src/extensions/schema/index.js";
 
-export const SkillManifestSchema = z.object({
-  name: z.string(),
-  version: z.string(),
-  description: z.string(),
-  requires: z
-    .object({
-      cli: z.array(z.string()).optional(),
-      mcp: z.array(z.string()).optional(),
-    })
-    .optional(),
-  inputs: z
-    .record(
-      z.string(),
-      z.object({
-        type: z.string(),
-        default: z.unknown().optional(),
-        description: z.string().optional(),
-      }),
-    )
-    .optional(),
-});
+export const getSkillManifestSchema = defineSchema((v) =>
+  v.object({
+    name: v.string(),
+    version: v.string(),
+    description: v.string(),
+    requires: v
+      .object({
+        cli: v.array(v.string()).optional(),
+        mcp: v.array(v.string()).optional(),
+      })
+      .optional(),
+    inputs: v
+      .record(
+        v.string(),
+        v.object({
+          type: v.string(),
+          default: v.unknown().optional(),
+          description: v.string().optional(),
+        }),
+      )
+      .optional(),
+  })
+);
+export const SkillManifestSchema = getSkillManifestSchema();
 
-export type SkillManifest = z.infer<typeof SkillManifestSchema>;
+export type SkillManifest = InferSchema<ReturnType<typeof getSkillManifestSchema>>;
 
 export function parseSkillJson(
   raw: unknown,
 ): { success: true; data: SkillManifest } | { success: false; error: string } {
   const result = SkillManifestSchema.safeParse(raw);
   if (result.success) return { success: true, data: result.data };
-  return { success: false, error: result.error.message };
+  const message = result.issues?.map((i) => i.message).join("; ") ?? "Validation failed";
+  return { success: false, error: message };
 }
 
 export interface LoadedSkill {