@famgia/omnify-cli 2.0.9 → 2.0.11

package/dist/cli.js

@@ -7,8 +7,8 @@ var __require = /* @__PURE__ */ ((x) => typeof require !== "undefined" ? require
 });
 
 // src/cli.ts
-import { existsSync as existsSync13 } from "fs";
-import { resolve as resolve13 } from "path";
+import { existsSync as existsSync14 } from "fs";
+import { resolve as resolve14 } from "path";
 import { Command } from "commander";
 import { OmnifyError as OmnifyError7 } from "@famgia/omnify-core";
 
@@ -1108,8 +1108,8 @@ function registerDiffCommand(program2) {
 }
 
 // src/commands/generate.ts
-import { existsSync as existsSync8, mkdirSync as mkdirSync3, writeFileSync as writeFileSync4, readdirSync as readdirSync2 } from "fs";
-import { resolve as resolve8, dirname as dirname6, relative } from "path";
+import { existsSync as existsSync9, mkdirSync as mkdirSync3, writeFileSync as writeFileSync5, readdirSync as readdirSync2 } from "fs";
+import { resolve as resolve9, dirname as dirname6, relative } from "path";
 import {
   loadSchemas as loadSchemas3,
   mergePartialSchemas as mergePartialSchemas3,
@@ -1144,17 +1144,19 @@ import { generateTypeScript, generateAIGuides as generateTypescriptAIGuides, sho
 // src/guides/index.ts
 import { existsSync as existsSync7, writeFileSync as writeFileSync3, mkdirSync as mkdirSync2, readdirSync, readFileSync as readFileSync3 } from "fs";
 import { resolve as resolve7, dirname as dirname5, join } from "path";
-import "url";
-var CLAUDE_MD = `# Omnify Project
+var OMNIFY_SECTION_START = "<!-- OMNIFY_SECTION_START -->";
+var OMNIFY_SECTION_END = "<!-- OMNIFY_SECTION_END -->";
+var OMNIFY_SECTION = `${OMNIFY_SECTION_START}
+## Omnify Schema System
 
 This project uses **Omnify** for schema-driven code generation.
 
-## Quick Reference
+### Quick Reference
 
 - **Schema Guide**: @.claude/omnify/guides/omnify/schema-guide.md
 - **Config Guide**: @.claude/omnify/guides/omnify/config-guide.md
 
-## Commands
+### Commands
 
 \`\`\`bash
 npx omnify generate    # Generate code from schemas
@@ -1162,41 +1164,52 @@ npx omnify validate    # Validate schemas
 php artisan migrate    # Run database migrations
 \`\`\`
 
-## Critical Rules
+### Critical Rules
 
-### \u26D4 DO NOT EDIT Auto-Generated Files
+#### \u26D4 DO NOT EDIT Auto-Generated Files
 - \`database/migrations/omnify/**\` - Regenerated on \`npx omnify generate\`
 - \`app/Models/OmnifyBase/**\` - Base models (extend, don't edit)
 - \`app/Http/Requests/OmnifyBase/**\` - Base requests
 - \`app/Http/Resources/OmnifyBase/**\` - Base resources
 
-### \u2705 Schema-First Workflow
+#### \u2705 Schema-First Workflow
 1. Edit YAML schema in \`schemas/\`
 2. Run \`npx omnify generate\`
 3. Run \`php artisan migrate\`
 
 **NEVER use \`php artisan make:migration\`** - Always use schemas!
+${OMNIFY_SECTION_END}`;
+function updateClaudeMd(rootDir) {
+  const claudeMdPath = resolve7(rootDir, "CLAUDE.md");
+  if (!existsSync7(claudeMdPath)) {
+    writeFileSync3(claudeMdPath, `# Project Documentation
 
-## Documentation Structure
-
-\`\`\`
-.claude/
-\u251C\u2500\u2500 CLAUDE.md              # This file (root pointer)
-\u251C\u2500\u2500 rules/                 # Claude Code rules (path-specific)
-\u2502   \u2514\u2500\u2500 omnify/*.md
-\u2514\u2500\u2500 omnify/                # Detailed guides
-    \u251C\u2500\u2500 guides/
-    \u2502   \u251C\u2500\u2500 omnify/        # Schema & config docs
-    \u2502   \u251C\u2500\u2500 laravel/       # Laravel patterns
-    \u2502   \u2514\u2500\u2500 react/         # React patterns
-    \u251C\u2500\u2500 workflows/         # Step-by-step workflows
-    \u2514\u2500\u2500 agents/            # AI agent prompts
-\`\`\`
-
-## Individual Preferences
-
-Add your personal preferences in \`CLAUDE.local.md\` (gitignored).
-`;
+${OMNIFY_SECTION}
+`);
+    return true;
+  }
+  const currentContent = readFileSync3(claudeMdPath, "utf8");
+  const hasOmnifySection = currentContent.includes(OMNIFY_SECTION_START);
+  if (hasOmnifySection) {
+    const regex = new RegExp(
+      `${escapeRegExp(OMNIFY_SECTION_START)}[\\s\\S]*?${escapeRegExp(OMNIFY_SECTION_END)}`,
+      "g"
+    );
+    const newContent = currentContent.replace(regex, OMNIFY_SECTION);
+    if (newContent !== currentContent) {
+      writeFileSync3(claudeMdPath, newContent);
+      return true;
+    }
+    return false;
+  } else {
+    const newContent = currentContent.trimEnd() + "\n\n" + OMNIFY_SECTION + "\n";
+    writeFileSync3(claudeMdPath, newContent);
+    return true;
+  }
+}
+function escapeRegExp(string) {
+  return string.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+}
 function copyOmnifyGuides(rootDir) {
   let filesWritten = 0;
   const omnifyPkgPaths = [
@@ -1251,20 +1264,141 @@ function copyOmnifyGuides(rootDir) {
 }
 function generateAIGuides(rootDir, _plugins) {
   let filesWritten = 0;
-  const claudeMdPath = resolve7(rootDir, "CLAUDE.md");
-  writeFileSync3(claudeMdPath, CLAUDE_MD);
-  filesWritten++;
+  if (updateClaudeMd(rootDir)) {
+    filesWritten++;
+  }
   filesWritten += copyOmnifyGuides(rootDir);
   return filesWritten;
 }
 
+// src/version-lock/index.ts
+import { readFileSync as readFileSync4, writeFileSync as writeFileSync4, existsSync as existsSync8 } from "fs";
+import { resolve as resolve8 } from "path";
+var VERSION_LOCK_FILE = ".omnify-versions.lock";
+function readVersionLock(rootDir) {
+  const lockPath = resolve8(rootDir, VERSION_LOCK_FILE);
+  if (!existsSync8(lockPath)) {
+    return null;
+  }
+  try {
+    const content = readFileSync4(lockPath, "utf-8");
+    return JSON.parse(content);
+  } catch {
+    return null;
+  }
+}
+function writeVersionLock(rootDir, lock) {
+  const lockPath = resolve8(rootDir, VERSION_LOCK_FILE);
+  const content = JSON.stringify(lock, null, 2);
+  writeFileSync4(lockPath, content + "\n");
+}
+function parseVersion(version) {
+  const cleanVersion = version.replace(/^v/, "");
+  const match = cleanVersion.match(/^(\d+)\.(\d+)\.(\d+)/);
+  if (!match) {
+    return null;
+  }
+  return {
+    major: parseInt(match[1], 10),
+    minor: parseInt(match[2], 10),
+    patch: parseInt(match[3], 10)
+  };
+}
+function compareVersions(a, b) {
+  const parsedA = parseVersion(a);
+  const parsedB = parseVersion(b);
+  if (!parsedA || !parsedB) {
+    return 0;
+  }
+  if (parsedA.major !== parsedB.major) {
+    return parsedA.major > parsedB.major ? 1 : -1;
+  }
+  if (parsedA.minor !== parsedB.minor) {
+    return parsedA.minor > parsedB.minor ? 1 : -1;
+  }
+  if (parsedA.patch !== parsedB.patch) {
+    return parsedA.patch > parsedB.patch ? 1 : -1;
+  }
+  return 0;
+}
+function checkPluginVersions(plugins, lockFile) {
+  const mismatches = [];
+  const newPlugins = [];
+  const lockedVersions = /* @__PURE__ */ new Map();
+  for (const entry of lockFile.plugins) {
+    lockedVersions.set(entry.name, entry.version);
+  }
+  for (const plugin of plugins) {
+    const lockedVersion = lockedVersions.get(plugin.name);
+    if (!lockedVersion) {
+      newPlugins.push(plugin.name);
+      continue;
+    }
+    const comparison = compareVersions(plugin.version, lockedVersion);
+    if (comparison < 0) {
+      mismatches.push({
+        name: plugin.name,
+        required: lockedVersion,
+        installed: plugin.version
+      });
+    }
+  }
+  return {
+    valid: mismatches.length === 0,
+    mismatches,
+    newPlugins
+  };
+}
+function updateVersionLock(rootDir, plugins, cliVersion) {
+  const now = (/* @__PURE__ */ new Date()).toISOString();
+  const existingLock = readVersionLock(rootDir);
+  const existingEntries = /* @__PURE__ */ new Map();
+  if (existingLock) {
+    for (const entry of existingLock.plugins) {
+      existingEntries.set(entry.name, entry);
+    }
+  }
+  const pluginEntries = [];
+  for (const plugin of plugins) {
+    const existing = existingEntries.get(plugin.name);
+    if (!existing || compareVersions(plugin.version, existing.version) > 0) {
+      pluginEntries.push({
+        name: plugin.name,
+        version: plugin.version,
+        updatedAt: now
+      });
+    } else {
+      pluginEntries.push(existing);
+    }
+  }
+  pluginEntries.sort((a, b) => a.name.localeCompare(b.name));
+  const lock = {
+    version: 1,
+    cliVersion,
+    plugins: pluginEntries,
+    updatedAt: now
+  };
+  writeVersionLock(rootDir, lock);
+  return lock;
+}
+function getCliVersion() {
+  try {
+    const pkgPath = new URL("../../package.json", import.meta.url);
+    const pkgContent = readFileSync4(pkgPath, "utf-8");
+    const pkg = JSON.parse(pkgContent);
+    return pkg.version;
+  } catch {
+    return "unknown";
+  }
+}
+
 // src/commands/generate.ts
 function hasPluginGenerators(plugins) {
   return plugins.some((p) => p.generators && p.generators.length > 0);
 }
 function getExistingMigrationTables(migrationsDir) {
   const existingTables = /* @__PURE__ */ new Set();
-  if (!existsSync8(migrationsDir)) {
+  if (!existsSync9(migrationsDir)) {
     return existingTables;
   }
   try {
@@ -1457,17 +1591,17 @@ function schemaChangeToVersionChange(change) {
 function writeGeneratorOutputs(outputs, rootDir) {
   const counts = { migrations: 0, types: 0, models: 0, factories: 0, other: 0 };
   for (const output of outputs) {
-    const filePath = resolve8(rootDir, output.path);
+    const filePath = resolve9(rootDir, output.path);
     const dir = dirname6(filePath);
-    if (!existsSync8(dir)) {
+    if (!existsSync9(dir)) {
       mkdirSync3(dir, { recursive: true });
       logger.debug(`Created directory: ${dir}`);
     }
-    if (output.skipIfExists && existsSync8(filePath)) {
+    if (output.skipIfExists && existsSync9(filePath)) {
       logger.debug(`Skipped (exists): ${output.path}`);
       continue;
     }
-    writeFileSync4(filePath, output.content);
+    writeFileSync5(filePath, output.content);
     logger.debug(`Created: ${output.path}`);
     if (output.type === "migration") counts.migrations++;
     else if (output.type === "type") counts.types++;
@@ -1477,7 +1611,7 @@ function writeGeneratorOutputs(outputs, rootDir) {
   }
   return counts;
 }
-async function runPluginGeneration(plugins, schemas, rootDir, verbose, changes) {
+async function runPluginGeneration(plugins, schemas, rootDir, verbose, changes, localeConfig) {
   const pluginManager = new PluginManager({
     cwd: rootDir,
     verbose,
@@ -1486,7 +1620,8 @@ async function runPluginGeneration(plugins, schemas, rootDir, verbose, changes)
       info: (msg) => logger.info(msg),
       warn: (msg) => logger.warn(msg),
       error: (msg) => logger.error(msg)
-    }
+    },
+    localeConfig
   });
   for (const plugin of plugins) {
     await pluginManager.register(plugin);
@@ -1523,8 +1658,8 @@ function runDirectGeneration(schemas, config, rootDir, options, changes) {
   }
   if (!options.typesOnly && config.output.laravel) {
     logger.step("Generating Laravel migrations...");
-    const migrationsDir = resolve8(rootDir, config.output.laravel.migrationsPath);
-    if (!existsSync8(migrationsDir)) {
+    const migrationsDir = resolve9(rootDir, config.output.laravel.migrationsPath);
+    if (!existsSync9(migrationsDir)) {
       mkdirSync3(migrationsDir, { recursive: true });
       logger.debug(`Created directory: ${migrationsDir}`);
     }
@@ -1546,8 +1681,8 @@ function runDirectGeneration(schemas, config, rootDir, options, changes) {
           logger.debug(`Skipped CREATE for ${tableName} (already exists)`);
           continue;
         }
-        const filePath = resolve8(migrationsDir, migration.fileName);
-        writeFileSync4(filePath, migration.content);
+        const filePath = resolve9(migrationsDir, migration.fileName);
+        writeFileSync5(filePath, migration.content);
         logger.debug(`Created: ${migration.fileName}`);
         migrationsGenerated++;
       }
@@ -1555,8 +1690,8 @@ function runDirectGeneration(schemas, config, rootDir, options, changes) {
     if (alterChanges.length > 0) {
       const alterMigrations = generateMigrationsFromChanges(alterChanges);
       for (const migration of alterMigrations) {
-        const filePath = resolve8(migrationsDir, migration.fileName);
-        writeFileSync4(filePath, migration.content);
+        const filePath = resolve9(migrationsDir, migration.fileName);
+        writeFileSync5(filePath, migration.content);
         logger.debug(`Created: ${migration.fileName}`);
         migrationsGenerated++;
       }
@@ -1567,12 +1702,12 @@ function runDirectGeneration(schemas, config, rootDir, options, changes) {
     logger.step("Generating Laravel models...");
     const modelsPath = config.output.laravel.modelsPath;
     const baseModelsPath = config.output.laravel.baseModelsPath ?? `${modelsPath}/OmnifyBase`;
-    const modelsDir = resolve8(rootDir, modelsPath);
-    const baseModelsDir = resolve8(rootDir, baseModelsPath);
-    if (!existsSync8(modelsDir)) {
+    const modelsDir = resolve9(rootDir, modelsPath);
+    const baseModelsDir = resolve9(rootDir, baseModelsPath);
+    if (!existsSync9(modelsDir)) {
       mkdirSync3(modelsDir, { recursive: true });
     }
-    if (!existsSync8(baseModelsDir)) {
+    if (!existsSync9(baseModelsDir)) {
       mkdirSync3(baseModelsDir, { recursive: true });
     }
     const providersPath = config.output.laravel.providersPath ?? "app/Providers";
@@ -1583,16 +1718,16 @@ function runDirectGeneration(schemas, config, rootDir, options, changes) {
       customTypes: customTypesMap
     });
     for (const model of models) {
-      const filePath = resolve8(rootDir, getModelPath(model));
+      const filePath = resolve9(rootDir, getModelPath(model));
       const fileDir = dirname6(filePath);
-      if (!existsSync8(fileDir)) {
+      if (!existsSync9(fileDir)) {
         mkdirSync3(fileDir, { recursive: true });
       }
-      if (!model.overwrite && existsSync8(filePath)) {
+      if (!model.overwrite && existsSync9(filePath)) {
         logger.debug(`Skipped (exists): ${getModelPath(model)}`);
         continue;
       }
-      writeFileSync4(filePath, model.content);
+      writeFileSync5(filePath, model.content);
       logger.debug(`Created: ${getModelPath(model)}`);
       modelsGenerated++;
     }
@@ -1601,24 +1736,24 @@ function runDirectGeneration(schemas, config, rootDir, options, changes) {
   if (!options.typesOnly && config.output.laravel?.factoriesPath) {
     logger.step("Generating Laravel factories...");
     const factoriesPath = config.output.laravel.factoriesPath;
-    const factoriesDir = resolve8(rootDir, factoriesPath);
-    if (!existsSync8(factoriesDir)) {
+    const factoriesDir = resolve9(rootDir, factoriesPath);
+    if (!existsSync9(factoriesDir)) {
       mkdirSync3(factoriesDir, { recursive: true });
     }
     const factories = generateFactories(schemas, {
       factoryPath: factoriesPath
     });
     for (const factory of factories) {
-      const filePath = resolve8(rootDir, getFactoryPath(factory));
+      const filePath = resolve9(rootDir, getFactoryPath(factory));
       const fileDir = dirname6(filePath);
-      if (!existsSync8(fileDir)) {
+      if (!existsSync9(fileDir)) {
         mkdirSync3(fileDir, { recursive: true });
       }
-      if (!factory.overwrite && existsSync8(filePath)) {
+      if (!factory.overwrite && existsSync9(filePath)) {
         logger.debug(`Skipped (exists): ${getFactoryPath(factory)}`);
         continue;
       }
-      writeFileSync4(filePath, factory.content);
+      writeFileSync5(filePath, factory.content);
       logger.debug(`Created: ${getFactoryPath(factory)}`);
       factoriesGenerated++;
     }
@@ -1627,32 +1762,32 @@ function runDirectGeneration(schemas, config, rootDir, options, changes) {
   if (!options.migrationsOnly && config.output.typescript) {
     logger.step("Generating TypeScript types...");
     const tsConfig = config.output.typescript;
-    const basePath = resolve8(rootDir, tsConfig.path);
-    const schemasDir = resolve8(basePath, tsConfig.schemasDir ?? "schemas");
-    const enumDir = resolve8(basePath, tsConfig.enumDir ?? "enum");
-    const omnifyBaseDir = resolve8(rootDir, "node_modules/@omnify-base");
-    const pluginEnumDir = resolve8(omnifyBaseDir, "enum");
-    const baseSchemasDir = resolve8(omnifyBaseDir, "schemas");
+    const basePath = resolve9(rootDir, tsConfig.path);
+    const schemasDir = resolve9(basePath, tsConfig.schemasDir ?? "schemas");
+    const enumDir = resolve9(basePath, tsConfig.enumDir ?? "enum");
+    const omnifyBaseDir = resolve9(rootDir, "node_modules/@omnify-base");
+    const pluginEnumDir = resolve9(omnifyBaseDir, "enum");
+    const baseSchemasDir = resolve9(omnifyBaseDir, "schemas");
     const enumImportPrefix = relative(schemasDir, enumDir).replace(/\\/g, "/");
-    if (!existsSync8(schemasDir)) {
+    if (!existsSync9(schemasDir)) {
       mkdirSync3(schemasDir, { recursive: true });
       logger.debug(`Created directory: ${schemasDir}`);
     }
-    if (!existsSync8(enumDir)) {
+    if (!existsSync9(enumDir)) {
       mkdirSync3(enumDir, { recursive: true });
       logger.debug(`Created directory: ${enumDir}`);
     }
-    if (!existsSync8(pluginEnumDir)) {
+    if (!existsSync9(pluginEnumDir)) {
       mkdirSync3(pluginEnumDir, { recursive: true });
       logger.debug(`Created directory: ${pluginEnumDir}`);
     }
-    if (!existsSync8(baseSchemasDir)) {
+    if (!existsSync9(baseSchemasDir)) {
       mkdirSync3(baseSchemasDir, { recursive: true });
       logger.debug(`Created directory: ${baseSchemasDir}`);
     }
-    const omnifyPkgJson = resolve8(omnifyBaseDir, "package.json");
-    if (!existsSync8(omnifyPkgJson)) {
-      writeFileSync4(omnifyPkgJson, JSON.stringify({
+    const omnifyPkgJson = resolve9(omnifyBaseDir, "package.json");
+    if (!existsSync9(omnifyPkgJson)) {
+      writeFileSync5(omnifyPkgJson, JSON.stringify({
         name: "@omnify-base",
         version: "0.0.0",
         private: true,
@@ -1689,16 +1824,16 @@ function runDirectGeneration(schemas, config, rootDir, options, changes) {
       } else {
         outputDir = schemasDir;
       }
-      const filePath = resolve8(outputDir, outputFilePath);
+      const filePath = resolve9(outputDir, outputFilePath);
       const fileDir = dirname6(filePath);
-      if (!existsSync8(fileDir)) {
+      if (!existsSync9(fileDir)) {
         mkdirSync3(fileDir, { recursive: true });
       }
-      if (!file.overwrite && existsSync8(filePath)) {
+      if (!file.overwrite && existsSync9(filePath)) {
         logger.debug(`Skipped (exists): ${file.filePath}`);
         continue;
       }
-      writeFileSync4(filePath, file.content);
+      writeFileSync5(filePath, file.content);
       logger.debug(`Created: ${file.filePath}`);
       typesGenerated++;
     }
@@ -1728,7 +1863,49 @@ async function runGenerate(options) {
   const { config, configPath: configPath2 } = await loadConfig();
   const rootDir = configPath2 ? dirname6(configPath2) : process.cwd();
   validateConfig(config, rootDir);
-  const schemaPath = resolve8(rootDir, config.schemasDir);
+  if (config.plugins.length > 0) {
+    const versionLock = readVersionLock(rootDir);
+    if (versionLock) {
+      logger.debug("Checking plugin versions against lock file...");
+      const versionCheck = checkPluginVersions(config.plugins, versionLock);
+      if (!versionCheck.valid) {
+        logger.newline();
+        logger.error("\u{1F512} PLUGIN VERSION MISMATCH");
+        logger.error("");
+        logger.error("The following plugins are older than required by the version lock:");
+        logger.newline();
+        for (const mismatch of versionCheck.mismatches) {
+          logger.error(`  \u2022 ${mismatch.name}`);
+          logger.error(`    Required: ${mismatch.required}`);
+          logger.error(`    Installed: ${mismatch.installed}`);
+        }
+        logger.newline();
+        logger.error(`Version lock file: ${VERSION_LOCK_FILE}`);
+        logger.newline();
+        logger.info("To fix this, upgrade the outdated plugins:");
+        logger.info("");
+        for (const mismatch of versionCheck.mismatches) {
+          logger.info(`  npm install ${mismatch.name}@latest`);
+        }
+        logger.newline();
+        logger.info("Or if you intentionally want to use older versions, delete the lock file:");
+        logger.info(`  rm ${VERSION_LOCK_FILE}`);
+        logger.newline();
+        throw new OmnifyError4(
+          "Plugin version mismatch: installed versions are older than lock file requirements",
+          "E501",
+          void 0,
+          "Upgrade plugins or delete the version lock file to regenerate it."
+        );
+      }
+      if (versionCheck.newPlugins.length > 0) {
+        logger.debug(`New plugins detected: ${versionCheck.newPlugins.join(", ")}`);
+      }
+    } else {
+      logger.debug(`No version lock file found (${VERSION_LOCK_FILE})`);
+    }
+  }
+  const schemaPath = resolve9(rootDir, config.schemasDir);
   logger.step(`Loading schemas from ${schemaPath}`);
   let schemas = await loadSchemas3(schemaPath);
   logger.debug(`Found ${Object.keys(schemas).length} schema(s) in main directory`);
@@ -1737,9 +1914,9 @@ async function runGenerate(options) {
   if (additionalPaths.length > 0) {
     logger.step(`Loading schemas from ${additionalPaths.length} additional path(s)`);
     for (const entry of additionalPaths) {
-      const absolutePath = resolve8(rootDir, entry.path);
+      const absolutePath = resolve9(rootDir, entry.path);
       logger.debug(`  Checking: ${entry.path} \u2192 ${absolutePath}`);
-      if (existsSync8(absolutePath)) {
+      if (existsSync9(absolutePath)) {
         let packageSchemas = await loadSchemas3(absolutePath, { skipPartialResolution: true });
         if (entry.output) {
           const schemasWithOutput = {};
@@ -1794,12 +1971,12 @@ async function runGenerate(options) {
     process.exit(2);
   }
   logger.step("Checking for changes...");
-  const lockPath = resolve8(rootDir, config.lockFilePath);
+  const lockPath = resolve9(rootDir, config.lockFilePath);
   const existingLock = await readLockFile(lockPath);
   const currentSnapshots = await buildSchemaSnapshots(schemas);
   const v2Lock = existingLock && isLockFileV2(existingLock) ? existingLock : null;
   const comparison = compareSchemasDeep(currentSnapshots, v2Lock);
-  const chainFilePath = resolve8(rootDir, VERSION_CHAIN_FILE);
+  const chainFilePath = resolve9(rootDir, VERSION_CHAIN_FILE);
   const versionChain = await readVersionChain(chainFilePath);
   if (versionChain && comparison.hasChanges) {
     const schemaActions = [];
@@ -1836,7 +2013,7 @@ async function runGenerate(options) {
     }
   }
   if (existingLock && config.output.laravel?.migrationsPath) {
-    const migrationsDir = resolve8(rootDir, config.output.laravel.migrationsPath);
+    const migrationsDir = resolve9(rootDir, config.output.laravel.migrationsPath);
     const migrationValidation = await validateMigrations(existingLock, migrationsDir);
     if (!migrationValidation.valid) {
       logger.newline();
@@ -1896,7 +2073,7 @@ async function runGenerate(options) {
         const alterMigrations = toRegenerate.filter((m) => m.type === "alter" || m.type === "drop");
         if (createMigrations.length > 0) {
           logger.info(`Regenerating ${createMigrations.length} missing CREATE migration(s) with original timestamps...`);
-          const migrationsDir2 = resolve8(rootDir, config.output.laravel.migrationsPath);
+          const migrationsDir2 = resolve9(rootDir, config.output.laravel.migrationsPath);
           const customTypesMap2 = /* @__PURE__ */ new Map();
           for (const plugin of config.plugins) {
             if (plugin.types) {
@@ -1918,8 +2095,8 @@ async function runGenerate(options) {
               customTypes: customTypesMap2
             });
             for (const mig of regenerated) {
-              const filePath = resolve8(migrationsDir2, migData.fileName);
-              writeFileSync4(filePath, mig.content);
+              const filePath = resolve9(migrationsDir2, migData.fileName);
+              writeFileSync5(filePath, mig.content);
               logger.success(`  Regenerated: ${migData.fileName}`);
             }
           }
@@ -1975,7 +2152,8 @@ async function runGenerate(options) {
       schemas,
       rootDir,
       options.verbose ?? false,
-      comparison.changes
+      comparison.changes,
+      config.locale
     );
     migrationsGenerated = counts.migrations;
     typesGenerated = counts.types;
@@ -1997,32 +2175,32 @@ async function runGenerate(options) {
     if (!options.migrationsOnly && config.output.typescript && typesGenerated === 0) {
       logger.step("Generating TypeScript types...");
       const tsConfig2 = config.output.typescript;
-      const basePath2 = resolve8(rootDir, tsConfig2.path);
-      const schemasDir2 = resolve8(basePath2, tsConfig2.schemasDir ?? "schemas");
-      const enumDir2 = resolve8(basePath2, tsConfig2.enumDir ?? "enum");
-      const omnifyBaseDir2 = resolve8(rootDir, "node_modules/@omnify-base");
-      const pluginEnumDir2 = resolve8(omnifyBaseDir2, "enum");
-      const baseSchemasDir2 = resolve8(omnifyBaseDir2, "schemas");
+      const basePath2 = resolve9(rootDir, tsConfig2.path);
+      const schemasDir2 = resolve9(basePath2, tsConfig2.schemasDir ?? "schemas");
+      const enumDir2 = resolve9(basePath2, tsConfig2.enumDir ?? "enum");
+      const omnifyBaseDir2 = resolve9(rootDir, "node_modules/@omnify-base");
+      const pluginEnumDir2 = resolve9(omnifyBaseDir2, "enum");
+      const baseSchemasDir2 = resolve9(omnifyBaseDir2, "schemas");
       const enumImportPrefix2 = relative(schemasDir2, enumDir2).replace(/\\/g, "/");
-      if (!existsSync8(schemasDir2)) {
+      if (!existsSync9(schemasDir2)) {
         mkdirSync3(schemasDir2, { recursive: true });
         logger.debug(`Created directory: ${schemasDir2}`);
       }
-      if (!existsSync8(enumDir2)) {
+      if (!existsSync9(enumDir2)) {
         mkdirSync3(enumDir2, { recursive: true });
         logger.debug(`Created directory: ${enumDir2}`);
       }
-      if (!existsSync8(pluginEnumDir2)) {
+      if (!existsSync9(pluginEnumDir2)) {
         mkdirSync3(pluginEnumDir2, { recursive: true });
         logger.debug(`Created directory: ${pluginEnumDir2}`);
       }
-      if (!existsSync8(baseSchemasDir2)) {
+      if (!existsSync9(baseSchemasDir2)) {
         mkdirSync3(baseSchemasDir2, { recursive: true });
         logger.debug(`Created directory: ${baseSchemasDir2}`);
       }
-      const omnifyPkgJson2 = resolve8(omnifyBaseDir2, "package.json");
-      if (!existsSync8(omnifyPkgJson2)) {
-        writeFileSync4(omnifyPkgJson2, JSON.stringify({
+      const omnifyPkgJson2 = resolve9(omnifyBaseDir2, "package.json");
+      if (!existsSync9(omnifyPkgJson2)) {
+        writeFileSync5(omnifyPkgJson2, JSON.stringify({
           name: "@omnify-base",
           version: "0.0.0",
           private: true,
@@ -2059,16 +2237,16 @@ async function runGenerate(options) {
         } else {
           outputDir2 = schemasDir2;
         }
-        const filePath = resolve8(outputDir2, outputFilePath2);
+        const filePath = resolve9(outputDir2, outputFilePath2);
         const fileDir = dirname6(filePath);
-        if (!existsSync8(fileDir)) {
+        if (!existsSync9(fileDir)) {
           mkdirSync3(fileDir, { recursive: true });
         }
-        if (!file.overwrite && existsSync8(filePath)) {
+        if (!file.overwrite && existsSync9(filePath)) {
           logger.debug(`Skipped (exists): ${file.filePath}`);
           continue;
         }
-        writeFileSync4(filePath, file.content);
+        writeFileSync5(filePath, file.content);
         logger.debug(`Created: ${file.filePath}`);
         typesGenerated++;
       }
@@ -2138,6 +2316,15 @@ async function runGenerate(options) {
   } catch (guideError) {
     logger.debug(`Could not generate AI guides: ${guideError.message}`);
   }
+  if (config.plugins.length > 0) {
+    try {
+      const cliVersion = getCliVersion();
+      const updatedLock = updateVersionLock(rootDir, config.plugins, cliVersion);
+      logger.debug(`Updated version lock: ${updatedLock.plugins.length} plugin(s)`);
+    } catch (lockError) {
+      logger.debug(`Could not update version lock: ${lockError.message}`);
+    }
+  }
   logger.newline();
   logger.success("Generation complete!");
   if (migrationsGenerated > 0 && config.output.laravel) {
@@ -2168,23 +2355,23 @@ function registerGenerateCommand(program2) {
 }
 
 // src/commands/reset.ts
-import { existsSync as existsSync9, readdirSync as readdirSync3, rmSync, statSync } from "fs";
-import { resolve as resolve9, dirname as dirname7, join as join2 } from "path";
+import { existsSync as existsSync10, readdirSync as readdirSync3, rmSync, statSync } from "fs";
+import { resolve as resolve10, dirname as dirname7, join as join2 } from "path";
 import { createInterface } from "readline";
 async function confirm2(message) {
   const rl = createInterface({
     input: process.stdin,
     output: process.stdout
   });
-  return new Promise((resolve14) => {
+  return new Promise((resolve15) => {
     rl.question(`${message} (y/N) `, (answer) => {
       rl.close();
-      resolve14(answer.toLowerCase() === "y" || answer.toLowerCase() === "yes");
+      resolve15(answer.toLowerCase() === "y" || answer.toLowerCase() === "yes");
     });
   });
 }
 function countFiles(dir) {
-  if (!existsSync9(dir)) return 0;
+  if (!existsSync10(dir)) return 0;
   let count = 0;
   const entries = readdirSync3(dir);
   for (const entry of entries) {
@@ -2199,7 +2386,7 @@ function countFiles(dir) {
   return count;
 }
 function deleteDir(dir, verbose) {
-  if (!existsSync9(dir)) return 0;
+  if (!existsSync10(dir)) return 0;
   const count = countFiles(dir);
   rmSync(dir, { recursive: true, force: true });
   if (verbose) {
@@ -2208,7 +2395,7 @@ function deleteDir(dir, verbose) {
   return count;
 }
 function deleteFilesInDir(dir, pattern, verbose) {
-  if (!existsSync9(dir)) return 0;
+  if (!existsSync10(dir)) return 0;
   let count = 0;
   const entries = readdirSync3(dir);
   for (const entry of entries) {
@@ -2243,8 +2430,8 @@ async function runReset(options) {
   ];
   for (const { name, paths: relPaths } of omnifyBasePaths) {
     for (const relPath of relPaths) {
-      const omnifyBasePath = resolve9(rootDir, relPath);
-      if (existsSync9(omnifyBasePath)) {
+      const omnifyBasePath = resolve10(rootDir, relPath);
+      if (existsSync10(omnifyBasePath)) {
         paths.push({ name, path: omnifyBasePath, type: "dir" });
         break;
       }
@@ -2252,8 +2439,8 @@ async function runReset(options) {
   }
   for (const { name, paths: relPaths } of legacyGeneratedPaths) {
     for (const relPath of relPaths) {
-      const legacyPath = resolve9(rootDir, relPath);
-      if (existsSync9(legacyPath)) {
+      const legacyPath = resolve10(rootDir, relPath);
+      if (existsSync10(legacyPath)) {
         paths.push({ name, path: legacyPath, type: "dir" });
         break;
       }
@@ -2264,8 +2451,8 @@ async function runReset(options) {
     "backend/database/migrations/omnify"
   ];
   for (const relPath of migrationPaths) {
-    const migrationsPath = resolve9(rootDir, relPath);
-    if (existsSync9(migrationsPath)) {
+    const migrationsPath = resolve10(rootDir, relPath);
+    if (existsSync10(migrationsPath)) {
       paths.push({
         name: "Omnify migrations",
         path: migrationsPath,
@@ -2277,15 +2464,15 @@ async function runReset(options) {
   }
   const laravelConfig = config.output.laravel;
   if (laravelConfig?.modelsPath) {
-    const modelsPath = resolve9(rootDir, laravelConfig.modelsPath);
+    const modelsPath = resolve10(rootDir, laravelConfig.modelsPath);
     const omnifyBasePath = join2(modelsPath, "OmnifyBase");
-    if (existsSync9(omnifyBasePath) && !paths.some((p) => p.path === omnifyBasePath)) {
+    if (existsSync10(omnifyBasePath) && !paths.some((p) => p.path === omnifyBasePath)) {
       paths.push({ name: "OmnifyBase models", path: omnifyBasePath, type: "dir" });
     }
   }
   if (laravelConfig?.migrationsPath) {
-    const migrationsPath = resolve9(rootDir, laravelConfig.migrationsPath);
-    if (existsSync9(migrationsPath) && !paths.some((p) => p.path === migrationsPath)) {
+    const migrationsPath = resolve10(rootDir, laravelConfig.migrationsPath);
+    if (existsSync10(migrationsPath) && !paths.some((p) => p.path === migrationsPath)) {
       paths.push({
         name: "Omnify migrations",
         path: migrationsPath,
@@ -2298,18 +2485,18 @@ async function runReset(options) {
     for (const additionalPath of config.additionalSchemaPaths) {
       const pkgOutput = additionalPath.output?.laravel;
       if (pkgOutput?.base) {
-        const pkgBase = resolve9(rootDir, pkgOutput.base);
+        const pkgBase = resolve10(rootDir, pkgOutput.base);
         const pkgName = additionalPath.namespace ?? "Package";
         const pkgOmnifyBase = join2(pkgBase, pkgOutput.baseModelsPath ?? "src/Models/OmnifyBase");
-        if (existsSync9(pkgOmnifyBase) && !paths.some((p) => p.path === pkgOmnifyBase)) {
+        if (existsSync10(pkgOmnifyBase) && !paths.some((p) => p.path === pkgOmnifyBase)) {
           paths.push({ name: `${pkgName} OmnifyBase`, path: pkgOmnifyBase, type: "dir" });
         }
         const pkgGenerated = join2(pkgBase, "src/Models/Generated");
-        if (existsSync9(pkgGenerated) && !paths.some((p) => p.path === pkgGenerated)) {
+        if (existsSync10(pkgGenerated) && !paths.some((p) => p.path === pkgGenerated)) {
           paths.push({ name: `${pkgName} Legacy Generated`, path: pkgGenerated, type: "dir" });
         }
         const pkgMigrations = join2(pkgBase, pkgOutput.migrationsPath ?? "database/migrations/omnify");
-        if (existsSync9(pkgMigrations) && !paths.some((p) => p.path === pkgMigrations)) {
+        if (existsSync10(pkgMigrations) && !paths.some((p) => p.path === pkgMigrations)) {
           paths.push({
             name: `${pkgName} migrations`,
             path: pkgMigrations,
@@ -2317,18 +2504,18 @@ async function runReset(options) {
           });
         }
         const pkgProviders = join2(pkgBase, pkgOutput.providersPath ?? "src/Providers");
-        if (existsSync9(pkgProviders) && !paths.some((p) => p.path === pkgProviders)) {
+        if (existsSync10(pkgProviders) && !paths.some((p) => p.path === pkgProviders)) {
           paths.push({ name: `${pkgName} Providers`, path: pkgProviders, type: "dir" });
         }
         const pkgFactories = join2(pkgBase, pkgOutput.factoriesPath ?? "database/factories");
-        if (existsSync9(pkgFactories) && !paths.some((p) => p.path === pkgFactories)) {
+        if (existsSync10(pkgFactories) && !paths.some((p) => p.path === pkgFactories)) {
           paths.push({ name: `${pkgName} Factories`, path: pkgFactories, type: "dir" });
         }
       }
     }
   }
   const typescriptPath = config.output.typescript?.path;
-  const tsBasePath = typescriptPath ? resolve9(rootDir, typescriptPath) : null;
+  const tsBasePath = typescriptPath ? resolve10(rootDir, typescriptPath) : null;
   const commonTsPaths = [
     "resources/ts/omnify",
     "resources/ts/omnify/schemas",
@@ -2338,45 +2525,45 @@ async function runReset(options) {
     "src/types/models"
   ];
   let foundTsPath = tsBasePath;
-  if (!foundTsPath || !existsSync9(foundTsPath)) {
+  if (!foundTsPath || !existsSync10(foundTsPath)) {
     for (const relPath of commonTsPaths) {
-      const tsPath = resolve9(rootDir, relPath);
-      if (existsSync9(tsPath)) {
+      const tsPath = resolve10(rootDir, relPath);
+      if (existsSync10(tsPath)) {
         foundTsPath = tsPath;
         break;
       }
     }
   }
-  if (foundTsPath && existsSync9(foundTsPath)) {
+  if (foundTsPath && existsSync10(foundTsPath)) {
     const autoGeneratedDirs = ["base", "enum", "rules", "hooks", "lib"];
     for (const subDir of autoGeneratedDirs) {
       const subPath = join2(foundTsPath, subDir);
-      if (existsSync9(subPath)) {
+      if (existsSync10(subPath)) {
         paths.push({ name: `TypeScript ${subDir}`, path: subPath, type: "dir" });
       }
     }
     const autoGeneratedFiles = ["common.ts", "index.ts", "i18n.ts"];
     for (const fileName of autoGeneratedFiles) {
       const filePath = join2(foundTsPath, fileName);
-      if (existsSync9(filePath)) {
+      if (existsSync10(filePath)) {
         paths.push({ name: `TypeScript ${fileName}`, path: filePath, type: "file" });
       }
     }
   }
-  const lockFilePath = resolve9(rootDir, config.lockFilePath);
-  if (existsSync9(lockFilePath)) {
+  const lockFilePath = resolve10(rootDir, config.lockFilePath);
+  if (existsSync10(lockFilePath)) {
     paths.push({ name: "Lock file", path: lockFilePath, type: "file" });
   }
-  const versionsDir = resolve9(rootDir, ".omnify-versions");
-  if (existsSync9(versionsDir)) {
+  const versionsDir = resolve10(rootDir, ".omnify-versions");
+  if (existsSync10(versionsDir)) {
     paths.push({ name: "Version history", path: versionsDir, type: "dir" });
   }
-  const omnifyVersionsDir = resolve9(rootDir, ".omnify/versions");
-  if (existsSync9(omnifyVersionsDir)) {
+  const omnifyVersionsDir = resolve10(rootDir, ".omnify/versions");
+  if (existsSync10(omnifyVersionsDir)) {
     paths.push({ name: "Version history (.omnify/versions)", path: omnifyVersionsDir, type: "dir" });
   }
-  const logsDir = resolve9(rootDir, ".omnify/logs");
-  if (existsSync9(logsDir)) {
+  const logsDir = resolve10(rootDir, ".omnify/logs");
+  if (existsSync10(logsDir)) {
     paths.push({ name: "Logs", path: logsDir, type: "dir" });
   }
   if (paths.length === 0) {
@@ -2447,8 +2634,8 @@ function registerResetCommand(program2) {
 
 // src/commands/create-project.ts
 import { execSync, spawn } from "child_process";
-import { existsSync as existsSync10, rmSync as rmSync2, readFileSync as readFileSync4, writeFileSync as writeFileSync5 } from "fs";
-import { resolve as resolve10 } from "path";
+import { existsSync as existsSync11, rmSync as rmSync2, readFileSync as readFileSync5, writeFileSync as writeFileSync6 } from "fs";
+import { resolve as resolve11 } from "path";
 var BOILERPLATE_REPO = "https://github.com/omnifyjp/omnify-laravel-boilerplate.git";
 var IS_WINDOWS = process.platform === "win32";
 function checkGit() {
@@ -2549,9 +2736,9 @@ var GITIGNORE_ENTRIES_TO_REMOVE = [
   ".claude/omnify/"
 ];
 function cleanupGitignore(targetDir) {
-  const gitignorePath = resolve10(targetDir, ".gitignore");
-  if (!existsSync10(gitignorePath)) return;
-  const content = readFileSync4(gitignorePath, "utf-8");
+  const gitignorePath = resolve11(targetDir, ".gitignore");
+  if (!existsSync11(gitignorePath)) return;
+  const content = readFileSync5(gitignorePath, "utf-8");
   const lines = content.split("\n");
   const cleanedLines = lines.filter((line) => {
     const trimmed = line.trim();
@@ -2560,13 +2747,13 @@ function cleanupGitignore(targetDir) {
   while (cleanedLines.length > 0 && cleanedLines[0].trim() === "") {
     cleanedLines.shift();
   }
-  writeFileSync5(gitignorePath, cleanedLines.join("\n"));
+  writeFileSync6(gitignorePath, cleanedLines.join("\n"));
 }
 function cloneRepo(repo, targetDir) {
   logger.step(`Cloning boilerplate from ${repo}...`);
   execSync(`git clone --depth 1 ${repo} "${targetDir}"`, { stdio: "inherit" });
-  const gitDir = resolve10(targetDir, ".git");
-  if (existsSync10(gitDir)) {
+  const gitDir = resolve11(targetDir, ".git");
+  if (existsSync11(gitDir)) {
     rmSync2(gitDir, { recursive: true, force: true });
   }
   cleanupGitignore(targetDir);
@@ -2574,7 +2761,7 @@ function cloneRepo(repo, targetDir) {
   logger.success("Repository cloned successfully");
 }
 function runCommand(command, targetDir) {
-  return new Promise((resolve14, reject) => {
+  return new Promise((resolve15, reject) => {
     const child = spawn(command, [], {
       cwd: targetDir,
       shell: true,
@@ -2582,7 +2769,7 @@ function runCommand(command, targetDir) {
     });
     child.on("close", (code) => {
       if (code === 0) {
-        resolve14();
+        resolve15();
       } else {
         reject(new Error(`Command failed with exit code ${code}`));
       }
@@ -2630,13 +2817,13 @@ async function runSetup(targetDir) {
   }
 }
 async function runCreateProject(projectName, options) {
-  const targetDir = resolve10(process.cwd(), projectName);
+  const targetDir = resolve11(process.cwd(), projectName);
   const repo = options.repo ?? BOILERPLATE_REPO;
   if (!checkGit()) {
     logger.error("Git is not installed. Please install git first.");
     process.exit(1);
   }
-  if (existsSync10(targetDir)) {
+  if (existsSync11(targetDir)) {
     logger.error(`Directory "${projectName}" already exists.`);
     process.exit(1);
   }
@@ -2662,7 +2849,7 @@ async function runCreateProject(projectName, options) {
     logger.info("  pnpm run dev");
     logger.newline();
   } catch (error) {
-    if (!cloneSucceeded && existsSync10(targetDir)) {
+    if (!cloneSucceeded && existsSync11(targetDir)) {
       rmSync2(targetDir, { recursive: true, force: true });
     } else if (cloneSucceeded) {
       logger.newline();
@@ -2688,8 +2875,8 @@ function registerCreateProjectCommand(program2) {
 }
 
 // src/commands/deploy.ts
-import { existsSync as existsSync11 } from "fs";
-import { resolve as resolve11, dirname as dirname8 } from "path";
+import { existsSync as existsSync12 } from "fs";
+import { resolve as resolve12, dirname as dirname8 } from "path";
 import { loadSchemas as loadSchemas4, OmnifyError as OmnifyError5 } from "@famgia/omnify-core";
 import {
   VERSION_CHAIN_FILE as VERSION_CHAIN_FILE2,
@@ -2704,7 +2891,7 @@ async function confirmDeploy(schemaCount, environment, version) {
     input: process.stdin,
     output: process.stdout
   });
-  return new Promise((resolve14) => {
+  return new Promise((resolve15) => {
     logger.newline();
     logger.warn("\u26A0\uFE0F  WARNING: This action is IRREVERSIBLE!");
     logger.warn("");
@@ -2720,7 +2907,7 @@ async function confirmDeploy(schemaCount, environment, version) {
     logger.newline();
     rl.question('   Type "LOCK" to confirm: ', (answer) => {
       rl.close();
-      resolve14(answer.trim().toUpperCase() === "LOCK");
+      resolve15(answer.trim().toUpperCase() === "LOCK");
     });
   });
 }
@@ -2743,9 +2930,9 @@ async function runDeploy(options) {
   const { config, configPath: configPath2 } = await loadConfig();
   const rootDir = configPath2 ? dirname8(configPath2) : process.cwd();
   validateConfig(config, rootDir);
-  const schemasDir = resolve11(rootDir, config.schemasDir);
-  const chainFilePath = resolve11(rootDir, VERSION_CHAIN_FILE2);
-  if (!existsSync11(schemasDir)) {
+  const schemasDir = resolve12(rootDir, config.schemasDir);
+  const chainFilePath = resolve12(rootDir, VERSION_CHAIN_FILE2);
+  if (!existsSync12(schemasDir)) {
     throw new OmnifyError5(
       `Schemas directory not found: ${schemasDir}`,
       "E003",
@@ -2899,8 +3086,8 @@ function registerDeployCommand(program2) {
 }
 
 // src/commands/verify.ts
-import { existsSync as existsSync12 } from "fs";
-import { resolve as resolve12, dirname as dirname9 } from "path";
+import { existsSync as existsSync13 } from "fs";
+import { resolve as resolve13, dirname as dirname9 } from "path";
 import { OmnifyError as OmnifyError6 } from "@famgia/omnify-core";
 import {
   VERSION_CHAIN_FILE as VERSION_CHAIN_FILE3,
@@ -2918,9 +3105,9 @@ async function runVerify(options) {
   const { config, configPath: configPath2 } = await loadConfig();
   const rootDir = configPath2 ? dirname9(configPath2) : process.cwd();
   validateConfig(config, rootDir);
-  const schemasDir = resolve12(rootDir, config.schemasDir);
-  const chainFilePath = resolve12(rootDir, VERSION_CHAIN_FILE3);
-  if (!existsSync12(chainFilePath)) {
+  const schemasDir = resolve13(rootDir, config.schemasDir);
+  const chainFilePath = resolve13(rootDir, VERSION_CHAIN_FILE3);
+  if (!existsSync13(chainFilePath)) {
     if (options.json) {
       console.log(JSON.stringify({
         valid: true,
@@ -3100,8 +3287,8 @@ process.on("unhandledRejection", (reason) => {
 var args = process.argv.slice(2);
 var firstArg = args[0];
 var hasCommand = firstArg !== void 0 && !firstArg.startsWith("-");
-var configPath = resolve13(process.cwd(), "omnify.config.ts");
-var hasConfig = existsSync13(configPath);
+var configPath = resolve14(process.cwd(), "omnify.config.ts");
+var hasConfig = existsSync14(configPath);
 if (!hasCommand && !hasConfig) {
   runInit({}).catch((error) => {
     if (error instanceof Error) {