@vibe-agent-toolkit/utils 0.1.7 → 0.1.9

package/README.md

@@ -29,6 +29,50 @@ import {
 
 ## Available Utilities
 
+### Zod Type Introspection (Version-Agnostic)
+
+**Purpose**: Runtime Zod type detection that works across Zod v3 and v4.
+
+Uses duck typing via `_def.typeName` instead of `instanceof` checks, which fail when library and user Zod versions differ. Essential for libraries that accept user-provided Zod schemas.
+
+**Quick Example**:
+```typescript
+import { getZodTypeName, isZodType, ZodTypeNames } from '@vibe-agent-toolkit/utils';
+import { z } from 'zod';
+
+const schema = z.string().optional();
+
+// Get type name (works with Zod v3 or v4)
+const typeName = getZodTypeName(schema);
+console.log(typeName); // 'ZodOptional'
+
+// Check if matches expected type
+if (isZodType(schema, ZodTypeNames.STRING)) {
+  console.log('String type!');
+}
+```
+
+**Available Functions**:
+- `getZodTypeName(zodType)` - Extract `_def.typeName` safely
+- `isZodType(zodType, typeName)` - Check if type matches expected name
+- `unwrapZodType(zodType)` - Unwrap optional/nullable to get inner type
+- `isZodOptional(zodType)` - Check if type is optional
+- `isZodNullable(zodType)` - Check if type is nullable
+
+**Available Constants** (`ZodTypeNames`):
+```typescript
+STRING, NUMBER, BOOLEAN, ARRAY, OBJECT, ENUM,
+OPTIONAL, NULLABLE, DATE, BIGINT, NATIVENUM,
+UNION, INTERSECTION, TUPLE, RECORD, MAP, SET,
+FUNCTION, LAZY, PROMISE, and more...
+```
+
+**See**: [docs/zod-compatibility.md](../../docs/zod-compatibility.md) for complete guide
+
+**Peer Dependency**: Requires `zod ^3.25.0 || ^4.0.0`
+
+---
+
 ### Process Spawning
 - `safeExecSync()` - Cross-platform secure command execution without shell
 

package/dist/index.d.ts

@@ -12,4 +12,5 @@ export * from './gitignore-checker.js';
 export * from './git-utils.js';
 export * from './git-tracker.js';
 export * from './test-helpers.js';
+export * from './zod-introspection.js';
 //# sourceMappingURL=index.d.ts.map

package/dist/index.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAAA;;;;;GAKG;AAGH,cAAc,gBAAgB,CAAC;AAG/B,cAAc,iBAAiB,CAAC;AAGhC,cAAc,eAAe,CAAC;AAG9B,cAAc,mBAAmB,CAAC;AAGlC,cAAc,wBAAwB,CAAC;AAGvC,cAAc,gBAAgB,CAAC;AAG/B,cAAc,kBAAkB,CAAC;AAGjC,cAAc,mBAAmB,CAAC"}
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAAA;;;;;GAKG;AAGH,cAAc,gBAAgB,CAAC;AAG/B,cAAc,iBAAiB,CAAC;AAGhC,cAAc,eAAe,CAAC;AAG9B,cAAc,mBAAmB,CAAC;AAGlC,cAAc,wBAAwB,CAAC;AAGvC,cAAc,gBAAgB,CAAC;AAG/B,cAAc,kBAAkB,CAAC;AAGjC,cAAc,mBAAmB,CAAC;AAGlC,cAAc,wBAAwB,CAAC"}

package/dist/index.js

@@ -20,4 +20,6 @@ export * from './git-utils.js';
 export * from './git-tracker.js';
 // Test helpers for isolated test output directories
 export * from './test-helpers.js';
+// Zod type introspection (version-agnostic)
+export * from './zod-introspection.js';
 //# sourceMappingURL=index.js.map

package/dist/index.js.map

@@ -1 +1 @@
-{"version":3,"file":"index.js","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAAA;;;;;GAKG;AAEH,8DAA8D;AAC9D,cAAc,gBAAgB,CAAC;AAE/B,gCAAgC;AAChC,cAAc,iBAAiB,CAAC;AAEhC,uBAAuB;AACvB,cAAc,eAAe,CAAC;AAE9B,wCAAwC;AACxC,cAAc,mBAAmB,CAAC;AAElC,sBAAsB;AACtB,cAAc,wBAAwB,CAAC;AAEvC,8CAA8C;AAC9C,cAAc,gBAAgB,CAAC;AAE/B,yDAAyD;AACzD,cAAc,kBAAkB,CAAC;AAEjC,oDAAoD;AACpD,cAAc,mBAAmB,CAAC"}
+{"version":3,"file":"index.js","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAAA;;;;;GAKG;AAEH,8DAA8D;AAC9D,cAAc,gBAAgB,CAAC;AAE/B,gCAAgC;AAChC,cAAc,iBAAiB,CAAC;AAEhC,uBAAuB;AACvB,cAAc,eAAe,CAAC;AAE9B,wCAAwC;AACxC,cAAc,mBAAmB,CAAC;AAElC,sBAAsB;AACtB,cAAc,wBAAwB,CAAC;AAEvC,8CAA8C;AAC9C,cAAc,gBAAgB,CAAC;AAE/B,yDAAyD;AACzD,cAAc,kBAAkB,CAAC;AAEjC,oDAAoD;AACpD,cAAc,mBAAmB,CAAC;AAElC,4CAA4C;AAC5C,cAAc,wBAAwB,CAAC"}

package/dist/zod-introspection.d.ts

@@ -0,0 +1,146 @@
+/**
+ * Zod type introspection utilities
+ *
+ * Provides version-agnostic type detection using duck typing instead of
+ * instanceof checks, which fail across Zod v3/v4 boundaries.
+ *
+ * @module zod-introspection
+ */
+/**
+ * Zod type names from _def.typeName
+ *
+ * These internal type names are stable across Zod v3 and v4.
+ * Using these constants instead of instanceof checks ensures
+ * compatibility when user's Zod version differs from library's.
+ *
+ * @see https://github.com/colinhacks/zod/issues/2543
+ */
+export declare const ZodTypeNames: {
+    readonly STRING: "ZodString";
+    readonly NUMBER: "ZodNumber";
+    readonly BOOLEAN: "ZodBoolean";
+    readonly ARRAY: "ZodArray";
+    readonly OBJECT: "ZodObject";
+    readonly ENUM: "ZodEnum";
+    readonly OPTIONAL: "ZodOptional";
+    readonly NULLABLE: "ZodNullable";
+    readonly DATE: "ZodDate";
+    readonly LITERAL: "ZodLiteral";
+    readonly UNION: "ZodUnion";
+    readonly INTERSECTION: "ZodIntersection";
+    readonly TUPLE: "ZodTuple";
+    readonly RECORD: "ZodRecord";
+    readonly MAP: "ZodMap";
+    readonly SET: "ZodSet";
+    readonly FUNCTION: "ZodFunction";
+    readonly LAZY: "ZodLazy";
+    readonly PROMISE: "ZodPromise";
+    readonly BRANDED: "ZodBranded";
+    readonly PIPELINE: "ZodPipeline";
+    readonly READONLY: "ZodReadonly";
+    readonly SYMBOL: "ZodSymbol";
+    readonly UNDEFINED: "ZodUndefined";
+    readonly NULL: "ZodNull";
+    readonly ANY: "ZodAny";
+    readonly UNKNOWN: "ZodUnknown";
+    readonly NEVER: "ZodNever";
+    readonly VOID: "ZodVoid";
+    readonly BIGINT: "ZodBigInt";
+    readonly EFFECTS: "ZodEffects";
+    readonly NATIVENUM: "ZodNativeEnum";
+    readonly DISCRIMINATED_UNION: "ZodDiscriminatedUnion";
+    readonly DEFAULT: "ZodDefault";
+    readonly CATCH: "ZodCatch";
+    readonly NAN: "ZodNaN";
+};
+/**
+ * Type representing valid Zod type names
+ */
+export type ZodTypeName = (typeof ZodTypeNames)[keyof typeof ZodTypeNames];
+/**
+ * Get Zod type name in version-agnostic way
+ *
+ * Supports both Zod v3 and v4:
+ * - Zod v3: Uses _def.typeName (e.g., 'ZodString')
+ * - Zod v4: Uses _def.type (e.g., 'string'), converts to v3 format
+ *
+ * Uses duck typing instead of instanceof checks, which fail when
+ * user's Zod version differs from library's Zod version.
+ *
+ * @param zodType - Zod type to introspect
+ * @returns Type name string (e.g., 'ZodString') or undefined if not a Zod type
+ *
+ * @example
+ * ```typescript
+ * import { z } from 'zod';
+ * import { getZodTypeName, ZodTypeNames } from '@vibe-agent-toolkit/utils';
+ *
+ * const schema = z.string();
+ * const typeName = getZodTypeName(schema);
+ * console.log(typeName); // 'ZodString' (both v3 and v4)
+ *
+ * if (typeName === ZodTypeNames.STRING) {
+ *   console.log('It\'s a string schema!');
+ * }
+ * ```
+ */
+export declare function getZodTypeName(zodType: unknown): string | undefined;
+/**
+ * Check if Zod type matches expected type name
+ *
+ * Version-agnostic type checking using duck typing.
+ * Safer than instanceof when Zod versions may differ.
+ *
+ * @param zodType - Zod type to check
+ * @param typeName - Expected type name constant from ZodTypeNames
+ * @returns True if type matches, false otherwise
+ *
+ * @example
+ * ```typescript
+ * import { z } from 'zod';
+ * import { isZodType, ZodTypeNames } from '@vibe-agent-toolkit/utils';
+ *
+ * const schema = z.array(z.string());
+ *
+ * if (isZodType(schema, ZodTypeNames.ARRAY)) {
+ *   console.log('It\'s an array schema!');
+ * }
+ * ```
+ */
+export declare function isZodType(zodType: unknown, typeName: ZodTypeName): boolean;
+/**
+ * Unwrap optional/nullable Zod types to get inner type
+ *
+ * Recursively unwraps ZodOptional and ZodNullable to reach
+ * the underlying type. Returns original type if not wrapped.
+ *
+ * @param zodType - Zod type to unwrap
+ * @returns Unwrapped Zod type
+ *
+ * @example
+ * ```typescript
+ * import { z } from 'zod';
+ * import { unwrapZodType, getZodTypeName, ZodTypeNames } from '@vibe-agent-toolkit/utils';
+ *
+ * const schema = z.string().optional();
+ * const unwrapped = unwrapZodType(schema);
+ *
+ * console.log(getZodTypeName(unwrapped)); // 'ZodString'
+ * ```
+ */
+export declare function unwrapZodType(zodType: unknown): unknown;
+/**
+ * Check if Zod type is optional (ZodOptional)
+ *
+ * @param zodType - Zod type to check
+ * @returns True if type is optional
+ */
+export declare function isZodOptional(zodType: unknown): boolean;
+/**
+ * Check if Zod type is nullable (ZodNullable)
+ *
+ * @param zodType - Zod type to check
+ * @returns True if type is nullable
+ */
+export declare function isZodNullable(zodType: unknown): boolean;
+//# sourceMappingURL=zod-introspection.d.ts.map

package/dist/zod-introspection.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"zod-introspection.d.ts","sourceRoot":"","sources":["../src/zod-introspection.ts"],"names":[],"mappings":"AAAA;;;;;;;GAOG;AAEH;;;;;;;;GAQG;AACH,eAAO,MAAM,YAAY;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAqCf,CAAC;AAEX;;GAEG;AACH,MAAM,MAAM,WAAW,GAAG,CAAC,OAAO,YAAY,CAAC,CAAC,MAAM,OAAO,YAAY,CAAC,CAAC;AAkC3E;;;;;;;;;;;;;;;;;;;;;;;;;;GA0BG;AACH,wBAAgB,cAAc,CAAC,OAAO,EAAE,OAAO,GAAG,MAAM,GAAG,SAAS,CAiBnE;AAED;;;;;;;;;;;;;;;;;;;;;GAqBG;AACH,wBAAgB,SAAS,CAAC,OAAO,EAAE,OAAO,EAAE,QAAQ,EAAE,WAAW,GAAG,OAAO,CAE1E;AAED;;;;;;;;;;;;;;;;;;;GAmBG;AACH,wBAAgB,aAAa,CAAC,OAAO,EAAE,OAAO,GAAG,OAAO,CAUvD;AAED;;;;;GAKG;AACH,wBAAgB,aAAa,CAAC,OAAO,EAAE,OAAO,GAAG,OAAO,CAEvD;AAED;;;;;GAKG;AACH,wBAAgB,aAAa,CAAC,OAAO,EAAE,OAAO,GAAG,OAAO,CAEvD"}

package/dist/zod-introspection.js

@@ -0,0 +1,200 @@
+/**
+ * Zod type introspection utilities
+ *
+ * Provides version-agnostic type detection using duck typing instead of
+ * instanceof checks, which fail across Zod v3/v4 boundaries.
+ *
+ * @module zod-introspection
+ */
+/**
+ * Zod type names from _def.typeName
+ *
+ * These internal type names are stable across Zod v3 and v4.
+ * Using these constants instead of instanceof checks ensures
+ * compatibility when user's Zod version differs from library's.
+ *
+ * @see https://github.com/colinhacks/zod/issues/2543
+ */
+export const ZodTypeNames = {
+    STRING: 'ZodString',
+    NUMBER: 'ZodNumber',
+    BOOLEAN: 'ZodBoolean',
+    ARRAY: 'ZodArray',
+    OBJECT: 'ZodObject',
+    ENUM: 'ZodEnum',
+    OPTIONAL: 'ZodOptional',
+    NULLABLE: 'ZodNullable',
+    DATE: 'ZodDate',
+    LITERAL: 'ZodLiteral',
+    UNION: 'ZodUnion',
+    INTERSECTION: 'ZodIntersection',
+    TUPLE: 'ZodTuple',
+    RECORD: 'ZodRecord',
+    MAP: 'ZodMap',
+    SET: 'ZodSet',
+    FUNCTION: 'ZodFunction',
+    LAZY: 'ZodLazy',
+    PROMISE: 'ZodPromise',
+    BRANDED: 'ZodBranded',
+    PIPELINE: 'ZodPipeline',
+    READONLY: 'ZodReadonly',
+    SYMBOL: 'ZodSymbol',
+    UNDEFINED: 'ZodUndefined',
+    NULL: 'ZodNull',
+    ANY: 'ZodAny',
+    UNKNOWN: 'ZodUnknown',
+    NEVER: 'ZodNever',
+    VOID: 'ZodVoid',
+    BIGINT: 'ZodBigInt',
+    EFFECTS: 'ZodEffects',
+    NATIVENUM: 'ZodNativeEnum',
+    DISCRIMINATED_UNION: 'ZodDiscriminatedUnion',
+    DEFAULT: 'ZodDefault',
+    CATCH: 'ZodCatch',
+    NAN: 'ZodNaN',
+};
+/**
+ * Convert Zod v4 lowercase type to v3 PascalCase format
+ *
+ * Zod v4 changed from _def.typeName ('ZodString') to _def.type ('string').
+ * This function normalizes v4 types to match v3 format for consistency.
+ *
+ * @param v4Type - Lowercase type from Zod v4 _def.type
+ * @returns PascalCase type name with 'Zod' prefix
+ * @internal
+ *
+ * @example
+ * ```typescript
+ * zodV4TypeToV3Name('string')  // 'ZodString'
+ * zodV4TypeToV3Name('array')   // 'ZodArray'
+ * zodV4TypeToV3Name('optional') // 'ZodOptional'
+ * ```
+ */
+function zodV4TypeToV3Name(v4Type) {
+    // Handle special cases with different naming
+    const specialCases = {
+        nativeenum: 'ZodNativeEnum',
+        bigint: 'ZodBigInt',
+    };
+    if (specialCases[v4Type]) {
+        return specialCases[v4Type];
+    }
+    // Convert: 'string' → 'ZodString', 'array' → 'ZodArray'
+    return 'Zod' + v4Type.charAt(0).toUpperCase() + v4Type.slice(1);
+}
+/**
+ * Get Zod type name in version-agnostic way
+ *
+ * Supports both Zod v3 and v4:
+ * - Zod v3: Uses _def.typeName (e.g., 'ZodString')
+ * - Zod v4: Uses _def.type (e.g., 'string'), converts to v3 format
+ *
+ * Uses duck typing instead of instanceof checks, which fail when
+ * user's Zod version differs from library's Zod version.
+ *
+ * @param zodType - Zod type to introspect
+ * @returns Type name string (e.g., 'ZodString') or undefined if not a Zod type
+ *
+ * @example
+ * ```typescript
+ * import { z } from 'zod';
+ * import { getZodTypeName, ZodTypeNames } from '@vibe-agent-toolkit/utils';
+ *
+ * const schema = z.string();
+ * const typeName = getZodTypeName(schema);
+ * console.log(typeName); // 'ZodString' (both v3 and v4)
+ *
+ * if (typeName === ZodTypeNames.STRING) {
+ *   console.log('It\'s a string schema!');
+ * }
+ * ```
+ */
+export function getZodTypeName(zodType) {
+    // eslint-disable-next-line @typescript-eslint/no-explicit-any
+    const def = zodType?._def;
+    if (!def)
+        return undefined;
+    // Zod v3: uses _def.typeName (e.g., 'ZodString')
+    if (def.typeName) {
+        return def.typeName;
+    }
+    // Zod v4: uses _def.type (e.g., 'string')
+    // Convert to Zod v3 format for consistency
+    if (def.type) {
+        return zodV4TypeToV3Name(def.type);
+    }
+    return undefined;
+}
+/**
+ * Check if Zod type matches expected type name
+ *
+ * Version-agnostic type checking using duck typing.
+ * Safer than instanceof when Zod versions may differ.
+ *
+ * @param zodType - Zod type to check
+ * @param typeName - Expected type name constant from ZodTypeNames
+ * @returns True if type matches, false otherwise
+ *
+ * @example
+ * ```typescript
+ * import { z } from 'zod';
+ * import { isZodType, ZodTypeNames } from '@vibe-agent-toolkit/utils';
+ *
+ * const schema = z.array(z.string());
+ *
+ * if (isZodType(schema, ZodTypeNames.ARRAY)) {
+ *   console.log('It\'s an array schema!');
+ * }
+ * ```
+ */
+export function isZodType(zodType, typeName) {
+    return getZodTypeName(zodType) === typeName;
+}
+/**
+ * Unwrap optional/nullable Zod types to get inner type
+ *
+ * Recursively unwraps ZodOptional and ZodNullable to reach
+ * the underlying type. Returns original type if not wrapped.
+ *
+ * @param zodType - Zod type to unwrap
+ * @returns Unwrapped Zod type
+ *
+ * @example
+ * ```typescript
+ * import { z } from 'zod';
+ * import { unwrapZodType, getZodTypeName, ZodTypeNames } from '@vibe-agent-toolkit/utils';
+ *
+ * const schema = z.string().optional();
+ * const unwrapped = unwrapZodType(schema);
+ *
+ * console.log(getZodTypeName(unwrapped)); // 'ZodString'
+ * ```
+ */
+export function unwrapZodType(zodType) {
+    const typeName = getZodTypeName(zodType);
+    if (typeName === ZodTypeNames.OPTIONAL || typeName === ZodTypeNames.NULLABLE) {
+        // eslint-disable-next-line @typescript-eslint/no-explicit-any
+        const inner = zodType.unwrap?.() ?? zodType._def?.innerType;
+        return inner ? unwrapZodType(inner) : zodType;
+    }
+    return zodType;
+}
+/**
+ * Check if Zod type is optional (ZodOptional)
+ *
+ * @param zodType - Zod type to check
+ * @returns True if type is optional
+ */
+export function isZodOptional(zodType) {
+    return isZodType(zodType, ZodTypeNames.OPTIONAL);
+}
+/**
+ * Check if Zod type is nullable (ZodNullable)
+ *
+ * @param zodType - Zod type to check
+ * @returns True if type is nullable
+ */
+export function isZodNullable(zodType) {
+    return isZodType(zodType, ZodTypeNames.NULLABLE);
+}
+//# sourceMappingURL=zod-introspection.js.map

package/dist/zod-introspection.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"zod-introspection.js","sourceRoot":"","sources":["../src/zod-introspection.ts"],"names":[],"mappings":"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"}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@vibe-agent-toolkit/utils",
-  "version": "0.1.7",
+  "version": "0.1.9",
   "type": "module",
   "description": "Core utility functions with no external dependencies",
   "keywords": [
@@ -34,12 +34,16 @@
     "picomatch": "^4.0.3",
     "which": "^5.0.0"
   },
+  "peerDependencies": {
+    "zod": "^3.25.0 || ^4.0.0"
+  },
   "devDependencies": {
     "@types/picomatch": "^4.0.2",
     "@types/which": "^3.0.4",
     "rimraf": "^6.0.1",
     "typescript": "^5.9.3",
-    "vitest": "^3.2.4"
+    "vitest": "^3.2.4",
+    "zod": "^3.25.0"
   },
   "publishConfig": {
     "access": "public"