@famgia/omnify-typescript 0.0.67 → 0.0.69

package/dist/index.cjs

@@ -1,7 +1,9 @@
 "use strict";
+var __create = Object.create;
 var __defProp = Object.defineProperty;
 var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
 var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
 var __hasOwnProp = Object.prototype.hasOwnProperty;
 var __export = (target, all) => {
   for (var name in all)
@@ -15,12 +17,22 @@ var __copyProps = (to, from, except, desc) => {
   }
   return to;
 };
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
 var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
 
 // src/index.ts
 var index_exports = {};
 __export(index_exports, {
   DEFAULT_VALIDATION_TEMPLATES: () => DEFAULT_VALIDATION_TEMPLATES,
+  STUB_FILES: () => STUB_FILES,
+  copyStubs: () => copyStubs,
   enumToUnionType: () => enumToUnionType,
   extractInlineEnums: () => extractInlineEnums,
   formatEnum: () => formatEnum,
@@ -28,18 +40,23 @@ __export(index_exports, {
   formatProperty: () => formatProperty,
   formatTypeAlias: () => formatTypeAlias,
   formatValidationMessage: () => formatValidationMessage,
+  generateAIGuides: () => generateAIGuides,
   generateEnums: () => generateEnums,
   generateInterfaces: () => generateInterfaces,
   generateModelRules: () => generateModelRules,
+  generatePluginEnums: () => generatePluginEnums,
   generateRulesFiles: () => generateRulesFiles,
   generateTypeScript: () => generateTypeScript,
   generateTypeScriptFiles: () => generateTypeScript,
   getPropertyType: () => getPropertyType,
+  getStubPaths: () => getStubPaths,
   getValidationMessages: () => getValidationMessages,
   mergeValidationTemplates: () => mergeValidationTemplates,
+  pluginEnumToTSEnum: () => pluginEnumToTSEnum,
   propertyToTSProperty: () => propertyToTSProperty,
   schemaToEnum: () => schemaToEnum,
   schemaToInterface: () => schemaToInterface,
+  shouldGenerateAIGuides: () => shouldGenerateAIGuides,
   toEnumMemberName: () => toEnumMemberName,
   toEnumName: () => toEnumName,
   toInterfaceName: () => toInterfaceName,
@@ -130,6 +147,10 @@ function getPropertyType(property, _allSchemas) {
         return "unknown";
     }
   }
+  if (property.type === "EnumRef") {
+    const enumRefProp = property;
+    return enumRefProp.enum;
+  }
   if (property.type === "Enum") {
     const enumProp = property;
     if (typeof enumProp.enum === "string") {
@@ -158,7 +179,7 @@ function propertyToTSProperties(propertyName, property, allSchemas, options = {}
       for (const field of customType.expand) {
         const fieldName = `${propertyName}_${toSnakeCase(field.suffix)}`;
         const fieldOverride = baseProp.fields?.[field.suffix];
-        const isNullable = fieldOverride?.nullable ?? baseProp.nullable ?? false;
+        const isNullable = fieldOverride?.nullable ?? field.sql?.nullable ?? baseProp.nullable ?? false;
         const tsType = field.typescript?.type ?? "string";
         expandedProps.push({
           name: fieldName,
@@ -303,12 +324,24 @@ function schemaToInterface(schema, allSchemas, options = {}) {
       }
     }
   }
+  const enumDependencySet = /* @__PURE__ */ new Set();
+  if (schema.properties) {
+    for (const property of Object.values(schema.properties)) {
+      if (property.type === "EnumRef") {
+        const enumRefProp = property;
+        if (enumRefProp.enum) {
+          enumDependencySet.add(enumRefProp.enum);
+        }
+      }
+    }
+  }
   const schemaDisplayName = resolveDisplayName(schema.displayName, options);
   return {
     name: toInterfaceName(schema.name),
     properties,
     comment: schemaDisplayName ?? schema.name,
-    dependencies: dependencySet.size > 0 ? Array.from(dependencySet).sort() : void 0
+    dependencies: dependencySet.size > 0 ? Array.from(dependencySet).sort() : void 0,
+    enumDependencies: enumDependencySet.size > 0 ? Array.from(enumDependencySet).sort() : void 0
   };
 }
 function formatProperty(property) {
@@ -355,7 +388,11 @@ function resolveDisplayName2(value, options = {}) {
   });
 }
 function toEnumMemberName(value) {
-  return value.split(/[-_\s]+/).map((word) => word.charAt(0).toUpperCase() + word.slice(1).toLowerCase()).join("").replace(/[^a-zA-Z0-9]/g, "");
+  let result = value.split(/[-_\s]+/).map((word) => word.charAt(0).toUpperCase() + word.slice(1).toLowerCase()).join("").replace(/[^a-zA-Z0-9]/g, "");
+  if (/^\d/.test(result)) {
+    result = "_" + result;
+  }
+  return result;
 }
 function toEnumName(schemaName) {
   return schemaName;
@@ -409,6 +446,46 @@ function generateEnums(schemas, options = {}) {
   }
   return enums;
 }
+function pluginEnumToTSEnum(enumDef, options = {}) {
+  const values = enumDef.values.map((v) => {
+    let label;
+    if (v.label !== void 0) {
+      if (typeof v.label === "string") {
+        label = v.label;
+      } else if (options.multiLocale) {
+        label = v.label;
+      } else {
+        label = resolveDisplayName2(v.label, options);
+      }
+    }
+    return {
+      name: toEnumMemberName(v.value),
+      value: v.value,
+      label,
+      extra: v.extra
+    };
+  });
+  let comment;
+  if (enumDef.displayName !== void 0) {
+    if (typeof enumDef.displayName === "string") {
+      comment = enumDef.displayName;
+    } else {
+      comment = resolveDisplayName2(enumDef.displayName, options);
+    }
+  }
+  return {
+    name: enumDef.name,
+    values,
+    comment: comment ?? enumDef.name
+  };
+}
+function generatePluginEnums(pluginEnums, options = {}) {
+  const enums = [];
+  for (const enumDef of pluginEnums.values()) {
+    enums.push(pluginEnumToTSEnum(enumDef, options));
+  }
+  return enums;
+}
 function isMultiLocaleLabel(label) {
   return label !== void 0 && typeof label === "object";
 }
@@ -429,7 +506,7 @@ ${enumValues}
 `);
   parts.push(`/** All ${name} values */
 `);
-  parts.push(`export const ${name}Values = Object.values(${name});
+  parts.push(`export const ${name}Values = Object.values(${name}) as ${name}[];
 
 `);
   parts.push(`/** Type guard for ${name} */
@@ -447,10 +524,10 @@ ${enumValues}
     if (hasMultiLocale) {
       const labelEntries = values.filter((v) => v.label !== void 0).map((v) => {
         if (isMultiLocaleLabel(v.label)) {
-          const locales = Object.entries(v.label).map(([locale, text]) => `${locale}: '${text}'`).join(", ");
+          const locales = Object.entries(v.label).map(([locale, text]) => `'${locale}': '${escapeString(text)}'`).join(", ");
           return `  [${name}.${v.name}]: { ${locales} },`;
         }
-        return `  [${name}.${v.name}]: { default: '${v.label}' },`;
+        return `  [${name}.${v.name}]: { default: '${escapeString(String(v.label))}' },`;
       }).join("\n");
       parts.push(`const ${lowerFirst(name)}Labels: Partial<Record<${name}, Record<string, string>>> = {
 ${labelEntries}
@@ -467,13 +544,15 @@ ${labelEntries}
 `);
       parts.push(`  if (locale && labels[locale]) return labels[locale];
 `);
-      parts.push(`  return Object.values(labels)[0] ?? value;
+      parts.push(`  // Fallback: ja \u2192 en \u2192 first available
+`);
+      parts.push(`  return labels['ja'] ?? labels['en'] ?? Object.values(labels)[0] ?? value;
 `);
       parts.push(`}
 
 `);
     } else {
-      const labelEntries = values.filter((v) => v.label !== void 0).map((v) => `  [${name}.${v.name}]: '${v.label}',`).join("\n");
+      const labelEntries = values.filter((v) => v.label !== void 0).map((v) => `  [${name}.${v.name}]: '${escapeString(String(v.label))}',`).join("\n");
       parts.push(`const ${lowerFirst(name)}Labels: Partial<Record<${name}, string>> = {
 ${labelEntries}
 };
@@ -529,6 +608,9 @@ ${extraEntries}
 function lowerFirst(str) {
   return str.charAt(0).toLowerCase() + str.slice(1);
 }
+function escapeString(str) {
+  return str.replace(/\\/g, "\\\\").replace(/'/g, "\\'");
+}
 function enumToUnionType(enumDef) {
   const type = enumDef.values.map((v) => `'${v.value}'`).join(" | ");
   return {
@@ -1050,6 +1132,13 @@ function getZodSchemaForType(propDef, fieldName, customTypes) {
     case "Json":
       schema = "z.unknown()";
       break;
+    case "EnumRef":
+      if (typeof def.enum === "string") {
+        schema = `z.nativeEnum(${def.enum})`;
+      } else {
+        schema = "z.string()";
+      }
+      break;
     case "Enum":
       if (typeof def.enum === "string") {
         schema = `${def.enum}Schema`;
@@ -1095,15 +1184,35 @@ function generateCompoundTypeSchemas(propName, propDef, customType, options) {
   for (const field of customType.expand) {
     const fieldName = `${toSnakeCase(propName)}_${toSnakeCase(field.suffix)}`;
     const fieldOverride = propFields?.[field.suffix];
-    const isNullable = fieldOverride?.nullable ?? propDef.nullable ?? false;
-    const length = fieldOverride?.length ?? field.sql?.length;
+    const isNullable = fieldOverride?.nullable ?? field.sql?.nullable ?? propDef.nullable ?? false;
+    const pluginRules = field.rules;
+    const overrideRules = fieldOverride?.rules;
+    const length = fieldOverride?.length ?? overrideRules?.maxLength ?? pluginRules?.maxLength ?? field.sql?.length;
+    const minLength = overrideRules?.minLength ?? pluginRules?.minLength;
+    const pattern = overrideRules?.pattern ?? pluginRules?.pattern;
+    const format = overrideRules?.format ?? pluginRules?.format;
     let schema = "z.string()";
+    if (format === "email") {
+      schema = "z.string().email()";
+    } else if (format === "url") {
+      schema = "z.string().url()";
+    } else if (format === "phone") {
+      schema = "z.string()";
+    } else if (format === "postal_code") {
+      schema = `z.string().regex(/^\\d{3}-?\\d{4}$/)`;
+    }
     if (!isNullable) {
-      schema += ".min(1)";
+      const min = minLength ?? 1;
+      schema += `.min(${min})`;
+    } else if (minLength) {
+      schema += `.min(${minLength})`;
     }
     if (length) {
       schema += `.max(${length})`;
     }
+    if (pattern && !format) {
+      schema += `.regex(/${pattern}/)`;
+    }
     if (isNullable) {
       schema += ".optional().nullable()";
     }
@@ -1159,6 +1268,7 @@ function generateDisplayNames(schema, options) {
     schema.name
   );
   const propertyDisplayNames = {};
+  const propertyPlaceholders = {};
   if (schema.properties) {
     for (const [propName, propDef] of Object.entries(schema.properties)) {
       const prop = propDef;
@@ -1166,19 +1276,47 @@ function generateDisplayNames(schema, options) {
       if (customTypes) {
         const customType = customTypes.get(propDef.type);
         if (customType?.compound && customType.expand) {
-          for (const field of customType.expand) {
-            const expandedFieldName = `${fieldName}_${toSnakeCase(field.suffix)}`;
-            propertyDisplayNames[expandedFieldName] = getMultiLocaleDisplayName2(
+          if (prop.displayName) {
+            propertyDisplayNames[fieldName] = getMultiLocaleDisplayName2(
               prop.displayName,
               locales,
               fallbackLocale,
               propName
             );
-            for (const locale of locales) {
-              propertyDisplayNames[expandedFieldName] = {
-                ...propertyDisplayNames[expandedFieldName],
-                [locale]: `${propertyDisplayNames[expandedFieldName][locale]} (${field.suffix})`
-              };
+          }
+          for (const field of customType.expand) {
+            const expandedFieldName = `${fieldName}_${toSnakeCase(field.suffix)}`;
+            const fieldOverride = prop.fields?.[field.suffix];
+            const labelSource = fieldOverride?.displayName ?? field.label;
+            if (labelSource) {
+              propertyDisplayNames[expandedFieldName] = getMultiLocaleDisplayName2(
+                labelSource,
+                locales,
+                fallbackLocale,
+                field.suffix
+              );
+            } else {
+              propertyDisplayNames[expandedFieldName] = getMultiLocaleDisplayName2(
+                prop.displayName,
+                locales,
+                fallbackLocale,
+                propName
+              );
+              for (const locale of locales) {
+                propertyDisplayNames[expandedFieldName] = {
+                  ...propertyDisplayNames[expandedFieldName],
+                  [locale]: `${propertyDisplayNames[expandedFieldName][locale]} (${field.suffix})`
+                };
+              }
+            }
+            const placeholderSource = fieldOverride?.placeholder ?? field.placeholder;
+            if (placeholderSource) {
+              propertyPlaceholders[expandedFieldName] = getMultiLocaleDisplayName2(
+                placeholderSource,
+                locales,
+                fallbackLocale,
+                ""
+              );
             }
           }
           continue;
@@ -1190,9 +1328,17 @@ function generateDisplayNames(schema, options) {
         fallbackLocale,
         propName
       );
+      if (prop.placeholder) {
+        propertyPlaceholders[fieldName] = getMultiLocaleDisplayName2(
+          prop.placeholder,
+          locales,
+          fallbackLocale,
+          ""
+        );
+      }
     }
   }
-  return { displayName, propertyDisplayNames };
+  return { displayName, propertyDisplayNames, propertyPlaceholders };
 }
 function getExcludedFields(schema, customTypes) {
   const createExclude = /* @__PURE__ */ new Set();
@@ -1236,24 +1382,44 @@ function formatZodSchemasSection(schemaName, zodSchemas, displayNames, excludedF
   const lowerName = schemaName.charAt(0).toLowerCase() + schemaName.slice(1);
   parts.push(`// ============================================================================
 `);
-  parts.push(`// Display Names
+  parts.push(`// I18n (Internationalization)
 `);
   parts.push(`// ============================================================================
 
 `);
-  parts.push(`/** Display name for ${schemaName} */
+  parts.push(`/**
 `);
-  parts.push(`export const ${schemaName}DisplayName = ${JSON.stringify(displayNames.displayName, null, 2)} as const;
-
+  parts.push(` * Unified i18n object for ${schemaName}
 `);
-  parts.push(`/** Property display names for ${schemaName} */
+  parts.push(` * Contains model label and all field labels/placeholders
+`);
+  parts.push(` */
+`);
+  parts.push(`export const ${lowerName}I18n = {
+`);
+  parts.push(`  /** Model display name */
+`);
+  parts.push(`  label: ${JSON.stringify(displayNames.displayName)},
+`);
+  parts.push(`  /** Field labels and placeholders */
 `);
-  parts.push(`export const ${schemaName}PropertyDisplayNames = {
+  parts.push(`  fields: {
 `);
-  for (const [propName, localeMap] of Object.entries(displayNames.propertyDisplayNames)) {
-    parts.push(`  ${propName}: ${JSON.stringify(localeMap)},
+  for (const [propName, labelMap] of Object.entries(displayNames.propertyDisplayNames)) {
+    const placeholderMap = displayNames.propertyPlaceholders[propName];
+    parts.push(`    ${propName}: {
+`);
+    parts.push(`      label: ${JSON.stringify(labelMap)},
+`);
+    if (placeholderMap) {
+      parts.push(`      placeholder: ${JSON.stringify(placeholderMap)},
+`);
+    }
+    parts.push(`    },
 `);
   }
+  parts.push(`  },
+`);
   parts.push(`} as const;
 
 `);
@@ -1310,35 +1476,50 @@ function formatZodSchemasSection(schemaName, zodSchemas, displayNames, excludedF
 `);
   parts.push(`// ============================================================================
 `);
-  parts.push(`// Helper Functions
+  parts.push(`// I18n Helper Functions
 `);
   parts.push(`// ============================================================================
 
 `);
-  parts.push(`/** Get display name for a specific locale */
+  parts.push(`/** Get model label for a specific locale */
 `);
-  parts.push(`export function get${schemaName}DisplayName(locale: string): string {
+  parts.push(`export function get${schemaName}Label(locale: string): string {
 `);
-  parts.push(`  return ${schemaName}DisplayName[locale as keyof typeof ${schemaName}DisplayName] ?? ${schemaName}DisplayName['en'] ?? '${schemaName}';
+  parts.push(`  return ${lowerName}I18n.label[locale as keyof typeof ${lowerName}I18n.label] ?? ${lowerName}I18n.label['en'] ?? '${schemaName}';
 `);
   parts.push(`}
 
 `);
-  parts.push(`/** Get property display name for a specific locale */
+  parts.push(`/** Get field label for a specific locale */
 `);
-  parts.push(`export function get${schemaName}PropertyDisplayName(property: string, locale: string): string {
+  parts.push(`export function get${schemaName}FieldLabel(field: string, locale: string): string {
 `);
-  parts.push(`  const names = ${schemaName}PropertyDisplayNames[property as keyof typeof ${schemaName}PropertyDisplayNames];
+  parts.push(`  const fieldI18n = ${lowerName}I18n.fields[field as keyof typeof ${lowerName}I18n.fields];
 `);
-  parts.push(`  if (!names) return property;
+  parts.push(`  if (!fieldI18n) return field;
 `);
-  parts.push(`  return names[locale as keyof typeof names] ?? names['en'] ?? property;
+  parts.push(`  return fieldI18n.label[locale as keyof typeof fieldI18n.label] ?? fieldI18n.label['en'] ?? field;
+`);
+  parts.push(`}
+
+`);
+  parts.push(`/** Get field placeholder for a specific locale */
+`);
+  parts.push(`export function get${schemaName}FieldPlaceholder(field: string, locale: string): string {
+`);
+  parts.push(`  const fieldI18n = ${lowerName}I18n.fields[field as keyof typeof ${lowerName}I18n.fields];
+`);
+  parts.push(`  if (!fieldI18n || !('placeholder' in fieldI18n)) return '';
+`);
+  parts.push(`  const placeholder = fieldI18n.placeholder as Record<string, string>;
+`);
+  parts.push(`  return placeholder[locale] ?? placeholder['en'] ?? '';
 `);
   parts.push(`}
 `);
   return parts.join("");
 }
-function formatZodModelFile(schemaName) {
+function formatZodModelFile(schemaName, _hasPlaceholders = false) {
   const lowerName = schemaName.charAt(0).toLowerCase() + schemaName.slice(1);
   return `/**
  * ${schemaName} Model
@@ -1354,10 +1535,10 @@ import {
   base${schemaName}Schemas,
   base${schemaName}CreateSchema,
   base${schemaName}UpdateSchema,
-  ${schemaName}DisplayName,
-  ${schemaName}PropertyDisplayNames,
-  get${schemaName}DisplayName,
-  get${schemaName}PropertyDisplayName,
+  ${lowerName}I18n,
+  get${schemaName}Label,
+  get${schemaName}FieldLabel,
+  get${schemaName}FieldPlaceholder,
 } from './base/${schemaName}.js';
 
 // ============================================================================
@@ -1383,12 +1564,12 @@ export const ${lowerName}UpdateSchema = base${schemaName}UpdateSchema;
 export type ${schemaName}Create = z.infer<typeof ${lowerName}CreateSchema>;
 export type ${schemaName}Update = z.infer<typeof ${lowerName}UpdateSchema>;
 
-// Re-export display names and helpers
+// Re-export i18n and helpers
 export {
-  ${schemaName}DisplayName,
-  ${schemaName}PropertyDisplayNames,
-  get${schemaName}DisplayName,
-  get${schemaName}PropertyDisplayName,
+  ${lowerName}I18n,
+  get${schemaName}Label,
+  get${schemaName}FieldLabel,
+  get${schemaName}FieldPlaceholder,
 };
 
 // Re-export base type for internal use
@@ -1504,13 +1685,24 @@ function generateBaseInterfaceFile(schemaName, schemas, options) {
     parts.push(`import type { ${commonImports.join(", ")} } from '../common.js';
 `);
   }
+  if (iface.enumDependencies && iface.enumDependencies.length > 0) {
+    const enumPrefix = options.enumImportPrefix ? `../${options.enumImportPrefix}` : "../enum";
+    const pluginEnumNames = new Set(
+      options.pluginEnums ? Array.from(options.pluginEnums.keys()) : []
+    );
+    for (const enumName of iface.enumDependencies) {
+      const enumPath = pluginEnumNames.has(enumName) ? `${enumPrefix}/plugin/${enumName}.js` : `${enumPrefix}/${enumName}.js`;
+      parts.push(`import { ${enumName} } from '${enumPath}';
+`);
+    }
+  }
   if (iface.dependencies && iface.dependencies.length > 0) {
     for (const dep of iface.dependencies) {
       parts.push(`import type { ${dep} } from './${dep}.js';
 `);
     }
     parts.push("\n");
-  } else if (commonImports.length > 0 || options.generateZodSchemas) {
+  } else if (commonImports.length > 0 || options.generateZodSchemas || iface.enumDependencies && iface.enumDependencies.length > 0) {
     parts.push("\n");
   }
   parts.push(formatInterface(iface));
@@ -1531,15 +1723,17 @@ function generateBaseInterfaceFile(schemaName, schemas, options) {
     overwrite: true
   };
 }
-function generateEnumFile(enumDef) {
+function generateEnumFile(enumDef, isPluginEnum = false) {
   const parts = [generateBaseHeader()];
   parts.push(formatEnum(enumDef));
   parts.push("\n");
+  const filePath = isPluginEnum ? `plugin/${enumDef.name}.ts` : `${enumDef.name}.ts`;
   return {
-    filePath: `enum/${enumDef.name}.ts`,
+    filePath,
     content: parts.join(""),
     types: [enumDef.name],
-    overwrite: true
+    overwrite: true,
+    category: "enum"
   };
 }
 function generateTypeAliasFile(alias) {
@@ -1547,10 +1741,11 @@ function generateTypeAliasFile(alias) {
   parts.push(formatTypeAlias(alias));
   parts.push("\n");
   return {
-    filePath: `enum/${alias.name}.ts`,
+    filePath: `${alias.name}.ts`,
     content: parts.join(""),
     types: [alias.name],
-    overwrite: true
+    overwrite: true,
+    category: "enum"
   };
 }
 function generateModelFile(schemaName, options) {
@@ -1591,6 +1786,88 @@ function generateModelFile(schemaName, options) {
     // Never overwrite user models
   };
 }
+var DEFAULT_VALIDATION_MESSAGES = {
+  required: {
+    en: "${displayName} is required",
+    ja: "${displayName}\u306F\u5FC5\u9808\u3067\u3059",
+    vi: "${displayName} l\xE0 b\u1EAFt bu\u1ED9c",
+    ko: "${displayName}\uC740(\uB294) \uD544\uC218\uC785\uB2C8\uB2E4",
+    "zh-CN": "${displayName}\u662F\u5FC5\u586B\u9879",
+    "zh-TW": "${displayName}\u70BA\u5FC5\u586B\u6B04\u4F4D",
+    th: "${displayName} \u0E08\u0E33\u0E40\u0E1B\u0E47\u0E19\u0E15\u0E49\u0E2D\u0E07\u0E01\u0E23\u0E2D\u0E01",
+    es: "${displayName} es obligatorio"
+  },
+  minLength: {
+    en: "${displayName} must be at least ${min} characters",
+    ja: "${displayName}\u306F${min}\u6587\u5B57\u4EE5\u4E0A\u3067\u5165\u529B\u3057\u3066\u304F\u3060\u3055\u3044",
+    vi: "${displayName} ph\u1EA3i c\xF3 \xEDt nh\u1EA5t ${min} k\xFD t\u1EF1",
+    ko: "${displayName}\uC740(\uB294) ${min}\uC790 \uC774\uC0C1\uC774\uC5B4\uC57C \uD569\uB2C8\uB2E4",
+    "zh-CN": "${displayName}\u81F3\u5C11\u9700\u8981${min}\u4E2A\u5B57\u7B26",
+    "zh-TW": "${displayName}\u81F3\u5C11\u9700\u8981${min}\u500B\u5B57\u5143",
+    th: "${displayName} \u0E15\u0E49\u0E2D\u0E07\u0E21\u0E35\u0E2D\u0E22\u0E48\u0E32\u0E07\u0E19\u0E49\u0E2D\u0E22 ${min} \u0E15\u0E31\u0E27\u0E2D\u0E31\u0E01\u0E29\u0E23",
+    es: "${displayName} debe tener al menos ${min} caracteres"
+  },
+  maxLength: {
+    en: "${displayName} must be at most ${max} characters",
+    ja: "${displayName}\u306F${max}\u6587\u5B57\u4EE5\u5185\u3067\u5165\u529B\u3057\u3066\u304F\u3060\u3055\u3044",
+    vi: "${displayName} kh\xF4ng \u0111\u01B0\u1EE3c qu\xE1 ${max} k\xFD t\u1EF1",
+    ko: "${displayName}\uC740(\uB294) ${max}\uC790 \uC774\uD558\uC5EC\uC57C \uD569\uB2C8\uB2E4",
+    "zh-CN": "${displayName}\u6700\u591A${max}\u4E2A\u5B57\u7B26",
+    "zh-TW": "${displayName}\u6700\u591A${max}\u500B\u5B57\u5143",
+    th: "${displayName} \u0E15\u0E49\u0E2D\u0E07\u0E44\u0E21\u0E48\u0E40\u0E01\u0E34\u0E19 ${max} \u0E15\u0E31\u0E27\u0E2D\u0E31\u0E01\u0E29\u0E23",
+    es: "${displayName} debe tener como m\xE1ximo ${max} caracteres"
+  },
+  min: {
+    en: "${displayName} must be at least ${min}",
+    ja: "${displayName}\u306F${min}\u4EE5\u4E0A\u3067\u5165\u529B\u3057\u3066\u304F\u3060\u3055\u3044",
+    vi: "${displayName} ph\u1EA3i l\u1EDBn h\u01A1n ho\u1EB7c b\u1EB1ng ${min}",
+    ko: "${displayName}\uC740(\uB294) ${min} \uC774\uC0C1\uC774\uC5B4\uC57C \uD569\uB2C8\uB2E4",
+    "zh-CN": "${displayName}\u5FC5\u987B\u5927\u4E8E\u7B49\u4E8E${min}",
+    "zh-TW": "${displayName}\u5FC5\u9808\u5927\u65BC\u7B49\u65BC${min}",
+    th: "${displayName} \u0E15\u0E49\u0E2D\u0E07\u0E21\u0E32\u0E01\u0E01\u0E27\u0E48\u0E32\u0E2B\u0E23\u0E37\u0E2D\u0E40\u0E17\u0E48\u0E32\u0E01\u0E31\u0E1A ${min}",
+    es: "${displayName} debe ser al menos ${min}"
+  },
+  max: {
+    en: "${displayName} must be at most ${max}",
+    ja: "${displayName}\u306F${max}\u4EE5\u4E0B\u3067\u5165\u529B\u3057\u3066\u304F\u3060\u3055\u3044",
+    vi: "${displayName} ph\u1EA3i nh\u1ECF h\u01A1n ho\u1EB7c b\u1EB1ng ${max}",
+    ko: "${displayName}\uC740(\uB294) ${max} \uC774\uD558\uC5EC\uC57C \uD569\uB2C8\uB2E4",
+    "zh-CN": "${displayName}\u5FC5\u987B\u5C0F\u4E8E\u7B49\u4E8E${max}",
+    "zh-TW": "${displayName}\u5FC5\u9808\u5C0F\u65BC\u7B49\u65BC${max}",
+    th: "${displayName} \u0E15\u0E49\u0E2D\u0E07\u0E19\u0E49\u0E2D\u0E22\u0E01\u0E27\u0E48\u0E32\u0E2B\u0E23\u0E37\u0E2D\u0E40\u0E17\u0E48\u0E32\u0E01\u0E31\u0E1A ${max}",
+    es: "${displayName} debe ser como m\xE1ximo ${max}"
+  },
+  email: {
+    en: "Please enter a valid email address",
+    ja: "\u6709\u52B9\u306A\u30E1\u30FC\u30EB\u30A2\u30C9\u30EC\u30B9\u3092\u5165\u529B\u3057\u3066\u304F\u3060\u3055\u3044",
+    vi: "Vui l\xF2ng nh\u1EADp \u0111\u1ECBa ch\u1EC9 email h\u1EE3p l\u1EC7",
+    ko: "\uC720\uD6A8\uD55C \uC774\uBA54\uC77C \uC8FC\uC18C\uB97C \uC785\uB825\uD558\uC138\uC694",
+    "zh-CN": "\u8BF7\u8F93\u5165\u6709\u6548\u7684\u7535\u5B50\u90AE\u4EF6\u5730\u5740",
+    "zh-TW": "\u8ACB\u8F38\u5165\u6709\u6548\u7684\u96FB\u5B50\u90F5\u4EF6\u5730\u5740",
+    th: "\u0E01\u0E23\u0E38\u0E13\u0E32\u0E01\u0E23\u0E2D\u0E01\u0E2D\u0E35\u0E40\u0E21\u0E25\u0E17\u0E35\u0E48\u0E16\u0E39\u0E01\u0E15\u0E49\u0E2D\u0E07",
+    es: "Por favor, introduce una direcci\xF3n de correo electr\xF3nico v\xE1lida"
+  },
+  url: {
+    en: "Please enter a valid URL",
+    ja: "\u6709\u52B9\u306AURL\u3092\u5165\u529B\u3057\u3066\u304F\u3060\u3055\u3044",
+    vi: "Vui l\xF2ng nh\u1EADp URL h\u1EE3p l\u1EC7",
+    ko: "\uC720\uD6A8\uD55C URL\uC744 \uC785\uB825\uD558\uC138\uC694",
+    "zh-CN": "\u8BF7\u8F93\u5165\u6709\u6548\u7684URL",
+    "zh-TW": "\u8ACB\u8F38\u5165\u6709\u6548\u7684\u7DB2\u5740",
+    th: "\u0E01\u0E23\u0E38\u0E13\u0E32\u0E01\u0E23\u0E2D\u0E01 URL \u0E17\u0E35\u0E48\u0E16\u0E39\u0E01\u0E15\u0E49\u0E2D\u0E07",
+    es: "Por favor, introduce una URL v\xE1lida"
+  },
+  pattern: {
+    en: "${displayName} format is invalid",
+    ja: "${displayName}\u306E\u5F62\u5F0F\u304C\u6B63\u3057\u304F\u3042\u308A\u307E\u305B\u3093",
+    vi: "${displayName} kh\xF4ng \u0111\xFAng \u0111\u1ECBnh d\u1EA1ng",
+    ko: "${displayName} \uD615\uC2DD\uC774 \uC62C\uBC14\uB974\uC9C0 \uC54A\uC2B5\uB2C8\uB2E4",
+    "zh-CN": "${displayName}\u683C\u5F0F\u4E0D\u6B63\u786E",
+    "zh-TW": "${displayName}\u683C\u5F0F\u4E0D\u6B63\u78BA",
+    th: "\u0E23\u0E39\u0E1B\u0E41\u0E1A\u0E1A${displayName}\u0E44\u0E21\u0E48\u0E16\u0E39\u0E01\u0E15\u0E49\u0E2D\u0E07",
+    es: "El formato de ${displayName} no es v\xE1lido"
+  }
+};
 function generateCommonFile(options) {
   const locales = options.localeConfig?.locales ?? ["ja", "en"];
   const localeUnion = locales.map((l) => `'${l}'`).join(" | ");
@@ -1638,15 +1915,142 @@ export type DateString = string;
     overwrite: true
   };
 }
-function generateIndexFile(schemas, enums, typeAliases, options) {
+function generateI18nFile(options) {
+  const locales = options.localeConfig?.locales ?? ["ja", "en"];
+  const defaultLocale = options.localeConfig?.defaultLocale ?? "ja";
+  const fallbackLocale = options.localeConfig?.fallbackLocale ?? "en";
+  const userMessages = options.localeConfig?.messages ?? {};
+  const mergedMessages = {};
+  for (const [key, defaultMsgs] of Object.entries(DEFAULT_VALIDATION_MESSAGES)) {
+    mergedMessages[key] = {};
+    for (const locale of locales) {
+      if (defaultMsgs[locale]) {
+        mergedMessages[key][locale] = defaultMsgs[locale];
+      }
+    }
+  }
+  for (const [key, userMsgs] of Object.entries(userMessages)) {
+    if (userMsgs) {
+      if (!mergedMessages[key]) {
+        mergedMessages[key] = {};
+      }
+      for (const [locale, msg] of Object.entries(userMsgs)) {
+        mergedMessages[key][locale] = msg;
+      }
+    }
+  }
+  const messagesJson = JSON.stringify(mergedMessages, null, 2);
+  const content = `${generateBaseHeader()}
+import type { LocaleMap } from './common.js';
+
+/**
+ * Default locale for this project.
+ */
+export const defaultLocale = '${defaultLocale}' as const;
+
+/**
+ * Fallback locale when requested locale is not found.
+ */
+export const fallbackLocale = '${fallbackLocale}' as const;
+
+/**
+ * Supported locales in this project.
+ */
+export const supportedLocales = ${JSON.stringify(locales)} as const;
+
+/**
+ * Validation messages for all supported locales.
+ * Use getMessage(key, locale, params) to get formatted message.
+ */
+export const validationMessages = ${messagesJson} as const;
+
+/**
+ * Get validation message for a specific key and locale.
+ * Supports template placeholders: \${displayName}, \${min}, \${max}, etc.
+ *
+ * @param key - Message key (e.g., 'required', 'minLength')
+ * @param locale - Locale code (e.g., 'ja', 'en')
+ * @param params - Template parameters to replace
+ * @returns Formatted message string
+ *
+ * @example
+ * getMessage('required', 'ja', { displayName: '\u6C0F\u540D' })
+ * // => '\u6C0F\u540D\u306F\u5FC5\u9808\u3067\u3059'
+ */
+export function getMessage(
+  key: string,
+  locale: string,
+  params: Record<string, string | number> = {}
+): string {
+  const messages = validationMessages[key as keyof typeof validationMessages];
+  if (!messages) return key;
+
+  let message = (messages as LocaleMap)[locale]
+    ?? (messages as LocaleMap)[fallbackLocale]
+    ?? (messages as LocaleMap)[defaultLocale]
+    ?? key;
+
+  // Replace template placeholders
+  for (const [param, value] of Object.entries(params)) {
+    message = message.replace(new RegExp(\`\\\\$\\{\${param}\\}\`, 'g'), String(value));
+  }
+
+  return message;
+}
+
+/**
+ * Get all validation messages for a specific locale.
+ *
+ * @param locale - Locale code
+ * @returns Object with all messages for the locale
+ */
+export function getMessages(locale: string): Record<string, string> {
+  const result: Record<string, string> = {};
+  for (const [key, messages] of Object.entries(validationMessages)) {
+    result[key] = (messages as LocaleMap)[locale]
+      ?? (messages as LocaleMap)[fallbackLocale]
+      ?? (messages as LocaleMap)[defaultLocale]
+      ?? key;
+  }
+  return result;
+}
+`;
+  return {
+    filePath: "i18n.ts",
+    content,
+    types: ["validationMessages", "getMessage", "getMessages"],
+    overwrite: true
+  };
+}
+function generateIndexFile(schemas, enums, pluginEnums, typeAliases, options) {
   const parts = [generateBaseHeader()];
   parts.push(`// Common Types
 `);
   parts.push(`export type { LocaleMap, Locale, ValidationRule, DateTimeString, DateString } from './common.js';
 
 `);
-  if (enums.length > 0 || typeAliases.length > 0) {
-    parts.push(`// Enums
+  parts.push(`// i18n (Internationalization)
+`);
+  parts.push(`export {
+`);
+  parts.push(`  defaultLocale,
+`);
+  parts.push(`  fallbackLocale,
+`);
+  parts.push(`  supportedLocales,
+`);
+  parts.push(`  validationMessages,
+`);
+  parts.push(`  getMessage,
+`);
+  parts.push(`  getMessages,
+`);
+  parts.push(`} from './i18n.js';
+
+`);
+  const enumPrefix = options.enumImportPrefix ?? "./enum";
+  if (enums.length > 0) {
+    parts.push(`// Schema Enums
 `);
     for (const enumDef of enums) {
       parts.push(`export {
@@ -1661,9 +2065,35 @@ function generateIndexFile(schemas, enums, typeAliases, options) {
 `);
       parts.push(`  get${enumDef.name}Extra,
 `);
-      parts.push(`} from './enum/${enumDef.name}.js';
+      parts.push(`} from '${enumPrefix}/${enumDef.name}.js';
 `);
     }
+    parts.push("\n");
+  }
+  if (pluginEnums.length > 0) {
+    parts.push(`// Plugin Enums
+`);
+    for (const enumDef of pluginEnums) {
+      parts.push(`export {
+`);
+      parts.push(`  ${enumDef.name},
+`);
+      parts.push(`  ${enumDef.name}Values,
+`);
+      parts.push(`  is${enumDef.name},
+`);
+      parts.push(`  get${enumDef.name}Label,
+`);
+      parts.push(`  get${enumDef.name}Extra,
+`);
+      parts.push(`} from '${enumPrefix}/plugin/${enumDef.name}.js';
+`);
+    }
+    parts.push("\n");
+  }
+  if (typeAliases.length > 0) {
+    parts.push(`// Inline Enums (Type Aliases)
+`);
     for (const alias of typeAliases) {
       parts.push(`export {
 `);
@@ -1677,13 +2107,13 @@ function generateIndexFile(schemas, enums, typeAliases, options) {
 `);
       parts.push(`  get${alias.name}Extra,
 `);
-      parts.push(`} from './enum/${alias.name}.js';
+      parts.push(`} from '${enumPrefix}/${alias.name}.js';
 `);
     }
     parts.push("\n");
   }
   if (options.generateZodSchemas) {
-    parts.push(`// Models (with Zod schemas and Create/Update types)
+    parts.push(`// Models (with Zod schemas, i18n, and Create/Update types)
 `);
     for (const schema of Object.values(schemas)) {
       if (schema.kind === "enum") continue;
@@ -1699,13 +2129,13 @@ function generateIndexFile(schemas, enums, typeAliases, options) {
 `);
       parts.push(`  ${lowerName}UpdateSchema,
 `);
-      parts.push(`  ${schema.name}DisplayName,
+      parts.push(`  ${lowerName}I18n,
 `);
-      parts.push(`  ${schema.name}PropertyDisplayNames,
+      parts.push(`  get${schema.name}Label,
 `);
-      parts.push(`  get${schema.name}DisplayName,
+      parts.push(`  get${schema.name}FieldLabel,
 `);
-      parts.push(`  get${schema.name}PropertyDisplayName,
+      parts.push(`  get${schema.name}FieldPlaceholder,
 `);
       parts.push(`} from './${schema.name}.js';
 `);
@@ -1751,9 +2181,47 @@ function generateIndexFile(schemas, enums, typeAliases, options) {
 function generateTypeScript(schemas, options = {}) {
   const opts = { ...DEFAULT_OPTIONS, ...options };
   const files = [];
+  const schemasByName = /* @__PURE__ */ new Map();
+  for (const schema of Object.values(schemas)) {
+    const paths = schemasByName.get(schema.name) ?? [];
+    paths.push(schema.relativePath ?? schema.filePath);
+    schemasByName.set(schema.name, paths);
+  }
+  const duplicateSchemas = Array.from(schemasByName.entries()).filter(([, paths]) => paths.length > 1);
+  if (duplicateSchemas.length > 0) {
+    const errors = duplicateSchemas.map(
+      ([name, paths]) => `  - "${name}" defined in: ${paths.join(", ")}`
+    ).join("\n");
+    throw new Error(
+      `Duplicate schema/enum names detected. Names must be globally unique:
+${errors}
+Hint: Rename to unique names like "Blog${duplicateSchemas[0][0]}" or "Shop${duplicateSchemas[0][0]}"`
+    );
+  }
+  if (opts.pluginEnums && opts.pluginEnums.size > 0) {
+    const conflicts = [];
+    for (const schema of Object.values(schemas)) {
+      if (schema.kind === "enum" && opts.pluginEnums.has(schema.name)) {
+        conflicts.push(`"${schema.name}" (schema: ${schema.relativePath ?? schema.filePath}, plugin enum)`);
+      }
+    }
+    if (conflicts.length > 0) {
+      throw new Error(
+        `Schema enum conflicts with plugin enum:
+  - ${conflicts.join("\n  - ")}
+Hint: Rename your schema enum to avoid conflict with plugin-provided enums`
+      );
+    }
+  }
   const enums = generateEnums(schemas, opts);
   for (const enumDef of enums) {
-    files.push(generateEnumFile(enumDef));
+    files.push(generateEnumFile(enumDef, false));
+  }
+  if (opts.pluginEnums && opts.pluginEnums.size > 0) {
+    const pluginEnums = generatePluginEnums(opts.pluginEnums, opts);
+    for (const enumDef of pluginEnums) {
+      files.push(generateEnumFile(enumDef, true));
+    }
   }
   const typeAliases = extractInlineEnums(schemas, opts);
   for (const alias of typeAliases) {
@@ -1774,12 +2242,235 @@ function generateTypeScript(schemas, options = {}) {
     files.push(...rulesFiles);
   }
   files.push(generateCommonFile(opts));
-  files.push(generateIndexFile(schemas, enums, typeAliases, opts));
+  files.push(generateI18nFile(opts));
+  const pluginEnumsList = opts.pluginEnums ? generatePluginEnums(opts.pluginEnums, opts) : [];
+  files.push(generateIndexFile(schemas, enums, pluginEnumsList, typeAliases, opts));
   return files;
 }
+
+// src/stubs.ts
+var import_fs = __toESM(require("fs"), 1);
+var import_path = __toESM(require("path"), 1);
+var import_url = require("url");
+var import_meta = {};
+var __filename = (0, import_url.fileURLToPath)(import_meta.url);
+var __dirname = import_path.default.dirname(__filename);
+var STUB_FILES = [
+  // Components
+  {
+    stub: "JapaneseNameField.tsx.stub",
+    output: "components/JapaneseNameField.tsx",
+    indexExport: ""
+    // Handled by components-index.ts.stub
+  },
+  {
+    stub: "JapaneseAddressField.tsx.stub",
+    output: "components/JapaneseAddressField.tsx",
+    indexExport: ""
+    // Handled by components-index.ts.stub
+  },
+  {
+    stub: "JapaneseBankField.tsx.stub",
+    output: "components/JapaneseBankField.tsx",
+    indexExport: ""
+    // Handled by components-index.ts.stub
+  },
+  {
+    stub: "components-index.ts.stub",
+    output: "components/index.ts",
+    indexExport: ""
+    // This IS the index
+  },
+  // Hooks
+  {
+    stub: "use-form-mutation.ts.stub",
+    output: "hooks/use-form-mutation.ts",
+    indexExport: `export { useFormMutation } from './use-form-mutation';
+`
+  },
+  // Lib
+  {
+    stub: "zod-i18n.ts.stub",
+    output: "lib/zod-i18n.ts",
+    indexExport: `export { setZodLocale, getZodLocale, getZodMessage } from './zod-i18n';
+`
+  },
+  {
+    stub: "form-validation.ts.stub",
+    output: "lib/form-validation.ts",
+    indexExport: `export { zodRule, requiredRule } from './form-validation';
+export * from './rules';
+`
+  },
+  // Rules
+  {
+    stub: "rules/kana.ts.stub",
+    output: "lib/rules/kana.ts",
+    indexExport: ""
+    // Will be handled by rules/index.ts
+  },
+  {
+    stub: "rules/index.ts.stub",
+    output: "lib/rules/index.ts",
+    indexExport: ""
+    // Already exported via form-validation
+  }
+];
+function copyStubs(options) {
+  const { targetDir, skipIfExists = true } = options;
+  const stubsDir = import_path.default.join(__dirname, "..", "stubs");
+  const result = { copied: [], skipped: [] };
+  const directories = /* @__PURE__ */ new Map();
+  for (const { stub, output, indexExport } of STUB_FILES) {
+    const stubPath = import_path.default.join(stubsDir, stub);
+    const outputPath = import_path.default.join(targetDir, output);
+    const outputDir = import_path.default.dirname(outputPath);
+    const dirName = import_path.default.dirname(output).split("/")[0];
+    if (!directories.has(dirName)) {
+      directories.set(dirName, "");
+    }
+    directories.set(dirName, directories.get(dirName) + indexExport);
+    if (!import_fs.default.existsSync(outputDir)) {
+      import_fs.default.mkdirSync(outputDir, { recursive: true });
+    }
+    if (skipIfExists && import_fs.default.existsSync(outputPath)) {
+      result.skipped.push(output);
+      continue;
+    }
+    if (import_fs.default.existsSync(stubPath)) {
+      const content = import_fs.default.readFileSync(stubPath, "utf-8");
+      import_fs.default.writeFileSync(outputPath, content);
+      result.copied.push(output);
+    }
+  }
+  for (const [dirName, exports2] of directories) {
+    const indexPath = import_path.default.join(targetDir, dirName, "index.ts");
+    if (skipIfExists && import_fs.default.existsSync(indexPath)) {
+      continue;
+    }
+    import_fs.default.writeFileSync(indexPath, exports2);
+    result.copied.push(`${dirName}/index.ts`);
+  }
+  return result;
+}
+function getStubPaths() {
+  return STUB_FILES.map((s) => s.output);
+}
+
+// src/ai-guides/generator.ts
+var import_node_fs = require("fs");
+var import_node_path = require("path");
+var import_node_url = require("url");
+var import_meta2 = {};
+var __filename2 = (0, import_node_url.fileURLToPath)(import_meta2.url);
+var __dirname2 = (0, import_node_path.dirname)(__filename2);
+function getStubsDir() {
+  const devPath = (0, import_node_path.resolve)(__dirname2, "../../stubs/ai-guides");
+  if ((0, import_node_fs.existsSync)(devPath)) {
+    return devPath;
+  }
+  const distPath = (0, import_node_path.resolve)(__dirname2, "../stubs/ai-guides");
+  if ((0, import_node_fs.existsSync)(distPath)) {
+    return distPath;
+  }
+  throw new Error("AI guides stubs not found");
+}
+function extractTypescriptBasePath(typescriptPath) {
+  if (!typescriptPath) return "src";
+  const normalized = typescriptPath.replace(/\\/g, "/");
+  const parts = normalized.split("/").filter(Boolean);
+  if (parts.length > 1) {
+    return parts.slice(0, -1).join("/");
+  }
+  return "src";
+}
+function replacePlaceholders(content, basePath) {
+  return content.replace(/\{\{TYPESCRIPT_BASE\}\}/g, basePath);
+}
+function copyStubs2(srcDir, destDir, transform) {
+  const writtenFiles = [];
+  if (!(0, import_node_fs.existsSync)(srcDir)) {
+    return writtenFiles;
+  }
+  if (!(0, import_node_fs.existsSync)(destDir)) {
+    (0, import_node_fs.mkdirSync)(destDir, { recursive: true });
+  }
+  const entries = (0, import_node_fs.readdirSync)(srcDir, { withFileTypes: true });
+  for (const entry of entries) {
+    const srcPath = (0, import_node_path.join)(srcDir, entry.name);
+    if (entry.isDirectory()) {
+      const subDestDir = (0, import_node_path.join)(destDir, entry.name);
+      const subFiles = copyStubs2(srcPath, subDestDir, transform);
+      writtenFiles.push(...subFiles);
+    } else if (entry.isFile() && entry.name.endsWith(".stub")) {
+      const destName = entry.name.slice(0, -5);
+      const destPath = (0, import_node_path.join)(destDir, destName);
+      let content = (0, import_node_fs.readFileSync)(srcPath, "utf-8");
+      if (transform) {
+        content = transform(content);
+      }
+      (0, import_node_fs.writeFileSync)(destPath, content);
+      writtenFiles.push(destPath);
+    }
+  }
+  return writtenFiles;
+}
+function generateAIGuides(rootDir, options = {}) {
+  const stubsDir = getStubsDir();
+  const basePath = options.typescriptBasePath || extractTypescriptBasePath(options.typescriptPath);
+  const result = {
+    claudeGuides: 0,
+    claudeChecklists: 0,
+    cursorRules: 0,
+    files: []
+  };
+  const claudeSrcDir = (0, import_node_path.join)(stubsDir, "react");
+  const claudeDestDir = (0, import_node_path.resolve)(rootDir, ".claude/omnify/guides/react");
+  if ((0, import_node_fs.existsSync)(claudeSrcDir)) {
+    const files = copyStubs2(claudeSrcDir, claudeDestDir);
+    result.claudeGuides = files.length;
+    result.files.push(...files);
+  }
+  const claudeChecklistsSrcDir = (0, import_node_path.join)(stubsDir, "checklists");
+  const claudeChecklistsDestDir = (0, import_node_path.resolve)(rootDir, ".claude/omnify/checklists");
+  if ((0, import_node_fs.existsSync)(claudeChecklistsSrcDir)) {
+    const files = copyStubs2(claudeChecklistsSrcDir, claudeChecklistsDestDir);
+    result.claudeChecklists = files.length;
+    result.files.push(...files);
+  }
+  const cursorSrcDir = (0, import_node_path.join)(stubsDir, "cursor");
+  const cursorDestDir = (0, import_node_path.resolve)(rootDir, ".cursor/rules/omnify");
+  if ((0, import_node_fs.existsSync)(cursorSrcDir)) {
+    const files = copyStubs2(
+      cursorSrcDir,
+      cursorDestDir,
+      (content) => replacePlaceholders(content, basePath)
+    );
+    result.cursorRules = files.length;
+    result.files.push(...files);
+  }
+  return result;
+}
+function shouldGenerateAIGuides(rootDir) {
+  const claudeDir = (0, import_node_path.resolve)(rootDir, ".claude/omnify/guides/react");
+  const cursorDir = (0, import_node_path.resolve)(rootDir, ".cursor/rules/omnify");
+  if (!(0, import_node_fs.existsSync)(claudeDir) || !(0, import_node_fs.existsSync)(cursorDir)) {
+    return true;
+  }
+  try {
+    const claudeFiles = (0, import_node_fs.readdirSync)(claudeDir);
+    const cursorFiles = (0, import_node_fs.readdirSync)(cursorDir);
+    const hasReactRules = cursorFiles.some((f) => f.startsWith("react"));
+    return claudeFiles.length === 0 || !hasReactRules;
+  } catch {
+    return true;
+  }
+}
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {
   DEFAULT_VALIDATION_TEMPLATES,
+  STUB_FILES,
+  copyStubs,
   enumToUnionType,
   extractInlineEnums,
   formatEnum,
@@ -1787,18 +2478,23 @@ function generateTypeScript(schemas, options = {}) {
   formatProperty,
   formatTypeAlias,
   formatValidationMessage,
+  generateAIGuides,
   generateEnums,
   generateInterfaces,
   generateModelRules,
+  generatePluginEnums,
   generateRulesFiles,
   generateTypeScript,
   generateTypeScriptFiles,
   getPropertyType,
+  getStubPaths,
   getValidationMessages,
   mergeValidationTemplates,
+  pluginEnumToTSEnum,
   propertyToTSProperty,
   schemaToEnum,
   schemaToInterface,
+  shouldGenerateAIGuides,
   toEnumMemberName,
   toEnumName,
   toInterfaceName,