@famgia/omnify-cli 2.0.10 → 2.0.11

package/dist/index.cjs

@@ -30,14 +30,20 @@ var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: tru
 // src/index.ts
 var index_exports = {};
 __export(index_exports, {
+  VERSION_LOCK_FILE: () => VERSION_LOCK_FILE,
+  checkPluginVersions: () => checkPluginVersions,
   defineConfig: () => defineConfig,
+  getCliVersion: () => getCliVersion,
   loadConfig: () => loadConfig,
   logger: () => logger,
+  readVersionLock: () => readVersionLock,
   registerDiffCommand: () => registerDiffCommand,
   registerGenerateCommand: () => registerGenerateCommand,
   registerInitCommand: () => registerInitCommand,
   registerValidateCommand: () => registerValidateCommand,
-  runInit: () => runInit
+  runInit: () => runInit,
+  updateVersionLock: () => updateVersionLock,
+  writeVersionLock: () => writeVersionLock
 });
 module.exports = __toCommonJS(index_exports);
 
@@ -1135,8 +1141,8 @@ function registerDiffCommand(program) {
 }
 
 // src/commands/generate.ts
-var import_node_fs8 = require("fs");
-var import_node_path8 = require("path");
+var import_node_fs9 = require("fs");
+var import_node_path9 = require("path");
 var import_omnify_core5 = require("@famgia/omnify-core");
 var import_omnify_atlas2 = require("@famgia/omnify-atlas");
 var import_omnify_laravel = require("@famgia/omnify-laravel");
@@ -1145,17 +1151,19 @@ var import_omnify_typescript = require("@famgia/omnify-typescript");
 // src/guides/index.ts
 var import_node_fs7 = require("fs");
 var import_node_path7 = require("path");
-var import_node_url = require("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
@@ -1163,41 +1171,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 = (0, import_node_path7.resolve)(rootDir, "CLAUDE.md");
+  if (!(0, import_node_fs7.existsSync)(claudeMdPath)) {
+    (0, import_node_fs7.writeFileSync)(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 = (0, import_node_fs7.readFileSync)(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) {
+      (0, import_node_fs7.writeFileSync)(claudeMdPath, newContent);
+      return true;
+    }
+    return false;
+  } else {
+    const newContent = currentContent.trimEnd() + "\n\n" + OMNIFY_SECTION + "\n";
+    (0, import_node_fs7.writeFileSync)(claudeMdPath, newContent);
+    return true;
+  }
+}
+function escapeRegExp(string) {
+  return string.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+}
 function copyOmnifyGuides(rootDir) {
   let filesWritten = 0;
   const omnifyPkgPaths = [
@@ -1252,24 +1271,146 @@ function copyOmnifyGuides(rootDir) {
 }
 function generateAIGuides(rootDir, _plugins) {
   let filesWritten = 0;
-  const claudeMdPath = (0, import_node_path7.resolve)(rootDir, "CLAUDE.md");
-  (0, import_node_fs7.writeFileSync)(claudeMdPath, CLAUDE_MD);
-  filesWritten++;
+  if (updateClaudeMd(rootDir)) {
+    filesWritten++;
+  }
   filesWritten += copyOmnifyGuides(rootDir);
   return filesWritten;
 }
 
+// src/version-lock/index.ts
+var import_node_fs8 = require("fs");
+var import_node_path8 = require("path");
+var import_meta = {};
+var VERSION_LOCK_FILE = ".omnify-versions.lock";
+function readVersionLock(rootDir) {
+  const lockPath = (0, import_node_path8.resolve)(rootDir, VERSION_LOCK_FILE);
+  if (!(0, import_node_fs8.existsSync)(lockPath)) {
+    return null;
+  }
+  try {
+    const content = (0, import_node_fs8.readFileSync)(lockPath, "utf-8");
+    return JSON.parse(content);
+  } catch {
+    return null;
+  }
+}
+function writeVersionLock(rootDir, lock) {
+  const lockPath = (0, import_node_path8.resolve)(rootDir, VERSION_LOCK_FILE);
+  const content = JSON.stringify(lock, null, 2);
+  (0, import_node_fs8.writeFileSync)(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 = (0, import_node_fs8.readFileSync)(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 (!(0, import_node_fs8.existsSync)(migrationsDir)) {
+  if (!(0, import_node_fs9.existsSync)(migrationsDir)) {
     return existingTables;
   }
   try {
-    const files = (0, import_node_fs8.readdirSync)(migrationsDir);
+    const files = (0, import_node_fs9.readdirSync)(migrationsDir);
     const createMigrationPattern = /^\d{4}_\d{2}_\d{2}_\d{6}_create_(.+)_table\.php$/;
     for (const file of files) {
       const match = file.match(createMigrationPattern);
@@ -1458,17 +1599,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 = (0, import_node_path8.resolve)(rootDir, output.path);
-    const dir = (0, import_node_path8.dirname)(filePath);
-    if (!(0, import_node_fs8.existsSync)(dir)) {
-      (0, import_node_fs8.mkdirSync)(dir, { recursive: true });
+    const filePath = (0, import_node_path9.resolve)(rootDir, output.path);
+    const dir = (0, import_node_path9.dirname)(filePath);
+    if (!(0, import_node_fs9.existsSync)(dir)) {
+      (0, import_node_fs9.mkdirSync)(dir, { recursive: true });
       logger.debug(`Created directory: ${dir}`);
     }
-    if (output.skipIfExists && (0, import_node_fs8.existsSync)(filePath)) {
+    if (output.skipIfExists && (0, import_node_fs9.existsSync)(filePath)) {
       logger.debug(`Skipped (exists): ${output.path}`);
       continue;
     }
-    (0, import_node_fs8.writeFileSync)(filePath, output.content);
+    (0, import_node_fs9.writeFileSync)(filePath, output.content);
     logger.debug(`Created: ${output.path}`);
     if (output.type === "migration") counts.migrations++;
     else if (output.type === "type") counts.types++;
@@ -1478,7 +1619,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 import_omnify_core5.PluginManager({
     cwd: rootDir,
     verbose,
@@ -1487,7 +1628,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);
@@ -1524,9 +1666,9 @@ function runDirectGeneration(schemas, config, rootDir, options, changes) {
   }
   if (!options.typesOnly && config.output.laravel) {
     logger.step("Generating Laravel migrations...");
-    const migrationsDir = (0, import_node_path8.resolve)(rootDir, config.output.laravel.migrationsPath);
-    if (!(0, import_node_fs8.existsSync)(migrationsDir)) {
-      (0, import_node_fs8.mkdirSync)(migrationsDir, { recursive: true });
+    const migrationsDir = (0, import_node_path9.resolve)(rootDir, config.output.laravel.migrationsPath);
+    if (!(0, import_node_fs9.existsSync)(migrationsDir)) {
+      (0, import_node_fs9.mkdirSync)(migrationsDir, { recursive: true });
       logger.debug(`Created directory: ${migrationsDir}`);
     }
     const addedSchemaNames = new Set(
@@ -1547,8 +1689,8 @@ function runDirectGeneration(schemas, config, rootDir, options, changes) {
           logger.debug(`Skipped CREATE for ${tableName} (already exists)`);
           continue;
         }
-        const filePath = (0, import_node_path8.resolve)(migrationsDir, migration.fileName);
-        (0, import_node_fs8.writeFileSync)(filePath, migration.content);
+        const filePath = (0, import_node_path9.resolve)(migrationsDir, migration.fileName);
+        (0, import_node_fs9.writeFileSync)(filePath, migration.content);
         logger.debug(`Created: ${migration.fileName}`);
         migrationsGenerated++;
       }
@@ -1556,8 +1698,8 @@ function runDirectGeneration(schemas, config, rootDir, options, changes) {
     if (alterChanges.length > 0) {
       const alterMigrations = (0, import_omnify_laravel.generateMigrationsFromChanges)(alterChanges);
       for (const migration of alterMigrations) {
-        const filePath = (0, import_node_path8.resolve)(migrationsDir, migration.fileName);
-        (0, import_node_fs8.writeFileSync)(filePath, migration.content);
+        const filePath = (0, import_node_path9.resolve)(migrationsDir, migration.fileName);
+        (0, import_node_fs9.writeFileSync)(filePath, migration.content);
         logger.debug(`Created: ${migration.fileName}`);
         migrationsGenerated++;
       }
@@ -1568,13 +1710,13 @@ 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 = (0, import_node_path8.resolve)(rootDir, modelsPath);
-    const baseModelsDir = (0, import_node_path8.resolve)(rootDir, baseModelsPath);
-    if (!(0, import_node_fs8.existsSync)(modelsDir)) {
-      (0, import_node_fs8.mkdirSync)(modelsDir, { recursive: true });
+    const modelsDir = (0, import_node_path9.resolve)(rootDir, modelsPath);
+    const baseModelsDir = (0, import_node_path9.resolve)(rootDir, baseModelsPath);
+    if (!(0, import_node_fs9.existsSync)(modelsDir)) {
+      (0, import_node_fs9.mkdirSync)(modelsDir, { recursive: true });
     }
-    if (!(0, import_node_fs8.existsSync)(baseModelsDir)) {
-      (0, import_node_fs8.mkdirSync)(baseModelsDir, { recursive: true });
+    if (!(0, import_node_fs9.existsSync)(baseModelsDir)) {
+      (0, import_node_fs9.mkdirSync)(baseModelsDir, { recursive: true });
     }
     const providersPath = config.output.laravel.providersPath ?? "app/Providers";
     const models = (0, import_omnify_laravel.generateModels)(schemas, {
@@ -1584,16 +1726,16 @@ function runDirectGeneration(schemas, config, rootDir, options, changes) {
       customTypes: customTypesMap
     });
     for (const model of models) {
-      const filePath = (0, import_node_path8.resolve)(rootDir, (0, import_omnify_laravel.getModelPath)(model));
-      const fileDir = (0, import_node_path8.dirname)(filePath);
-      if (!(0, import_node_fs8.existsSync)(fileDir)) {
-        (0, import_node_fs8.mkdirSync)(fileDir, { recursive: true });
+      const filePath = (0, import_node_path9.resolve)(rootDir, (0, import_omnify_laravel.getModelPath)(model));
+      const fileDir = (0, import_node_path9.dirname)(filePath);
+      if (!(0, import_node_fs9.existsSync)(fileDir)) {
+        (0, import_node_fs9.mkdirSync)(fileDir, { recursive: true });
       }
-      if (!model.overwrite && (0, import_node_fs8.existsSync)(filePath)) {
+      if (!model.overwrite && (0, import_node_fs9.existsSync)(filePath)) {
         logger.debug(`Skipped (exists): ${(0, import_omnify_laravel.getModelPath)(model)}`);
         continue;
       }
-      (0, import_node_fs8.writeFileSync)(filePath, model.content);
+      (0, import_node_fs9.writeFileSync)(filePath, model.content);
       logger.debug(`Created: ${(0, import_omnify_laravel.getModelPath)(model)}`);
       modelsGenerated++;
     }
@@ -1602,24 +1744,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 = (0, import_node_path8.resolve)(rootDir, factoriesPath);
-    if (!(0, import_node_fs8.existsSync)(factoriesDir)) {
-      (0, import_node_fs8.mkdirSync)(factoriesDir, { recursive: true });
+    const factoriesDir = (0, import_node_path9.resolve)(rootDir, factoriesPath);
+    if (!(0, import_node_fs9.existsSync)(factoriesDir)) {
+      (0, import_node_fs9.mkdirSync)(factoriesDir, { recursive: true });
     }
     const factories = (0, import_omnify_laravel.generateFactories)(schemas, {
       factoryPath: factoriesPath
     });
     for (const factory of factories) {
-      const filePath = (0, import_node_path8.resolve)(rootDir, (0, import_omnify_laravel.getFactoryPath)(factory));
-      const fileDir = (0, import_node_path8.dirname)(filePath);
-      if (!(0, import_node_fs8.existsSync)(fileDir)) {
-        (0, import_node_fs8.mkdirSync)(fileDir, { recursive: true });
+      const filePath = (0, import_node_path9.resolve)(rootDir, (0, import_omnify_laravel.getFactoryPath)(factory));
+      const fileDir = (0, import_node_path9.dirname)(filePath);
+      if (!(0, import_node_fs9.existsSync)(fileDir)) {
+        (0, import_node_fs9.mkdirSync)(fileDir, { recursive: true });
       }
-      if (!factory.overwrite && (0, import_node_fs8.existsSync)(filePath)) {
+      if (!factory.overwrite && (0, import_node_fs9.existsSync)(filePath)) {
         logger.debug(`Skipped (exists): ${(0, import_omnify_laravel.getFactoryPath)(factory)}`);
         continue;
       }
-      (0, import_node_fs8.writeFileSync)(filePath, factory.content);
+      (0, import_node_fs9.writeFileSync)(filePath, factory.content);
       logger.debug(`Created: ${(0, import_omnify_laravel.getFactoryPath)(factory)}`);
       factoriesGenerated++;
     }
@@ -1628,32 +1770,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 = (0, import_node_path8.resolve)(rootDir, tsConfig.path);
-    const schemasDir = (0, import_node_path8.resolve)(basePath, tsConfig.schemasDir ?? "schemas");
-    const enumDir = (0, import_node_path8.resolve)(basePath, tsConfig.enumDir ?? "enum");
-    const omnifyBaseDir = (0, import_node_path8.resolve)(rootDir, "node_modules/@omnify-base");
-    const pluginEnumDir = (0, import_node_path8.resolve)(omnifyBaseDir, "enum");
-    const baseSchemasDir = (0, import_node_path8.resolve)(omnifyBaseDir, "schemas");
-    const enumImportPrefix = (0, import_node_path8.relative)(schemasDir, enumDir).replace(/\\/g, "/");
-    if (!(0, import_node_fs8.existsSync)(schemasDir)) {
-      (0, import_node_fs8.mkdirSync)(schemasDir, { recursive: true });
+    const basePath = (0, import_node_path9.resolve)(rootDir, tsConfig.path);
+    const schemasDir = (0, import_node_path9.resolve)(basePath, tsConfig.schemasDir ?? "schemas");
+    const enumDir = (0, import_node_path9.resolve)(basePath, tsConfig.enumDir ?? "enum");
+    const omnifyBaseDir = (0, import_node_path9.resolve)(rootDir, "node_modules/@omnify-base");
+    const pluginEnumDir = (0, import_node_path9.resolve)(omnifyBaseDir, "enum");
+    const baseSchemasDir = (0, import_node_path9.resolve)(omnifyBaseDir, "schemas");
+    const enumImportPrefix = (0, import_node_path9.relative)(schemasDir, enumDir).replace(/\\/g, "/");
+    if (!(0, import_node_fs9.existsSync)(schemasDir)) {
+      (0, import_node_fs9.mkdirSync)(schemasDir, { recursive: true });
       logger.debug(`Created directory: ${schemasDir}`);
     }
-    if (!(0, import_node_fs8.existsSync)(enumDir)) {
-      (0, import_node_fs8.mkdirSync)(enumDir, { recursive: true });
+    if (!(0, import_node_fs9.existsSync)(enumDir)) {
+      (0, import_node_fs9.mkdirSync)(enumDir, { recursive: true });
       logger.debug(`Created directory: ${enumDir}`);
     }
-    if (!(0, import_node_fs8.existsSync)(pluginEnumDir)) {
-      (0, import_node_fs8.mkdirSync)(pluginEnumDir, { recursive: true });
+    if (!(0, import_node_fs9.existsSync)(pluginEnumDir)) {
+      (0, import_node_fs9.mkdirSync)(pluginEnumDir, { recursive: true });
       logger.debug(`Created directory: ${pluginEnumDir}`);
     }
-    if (!(0, import_node_fs8.existsSync)(baseSchemasDir)) {
-      (0, import_node_fs8.mkdirSync)(baseSchemasDir, { recursive: true });
+    if (!(0, import_node_fs9.existsSync)(baseSchemasDir)) {
+      (0, import_node_fs9.mkdirSync)(baseSchemasDir, { recursive: true });
       logger.debug(`Created directory: ${baseSchemasDir}`);
     }
-    const omnifyPkgJson = (0, import_node_path8.resolve)(omnifyBaseDir, "package.json");
-    if (!(0, import_node_fs8.existsSync)(omnifyPkgJson)) {
-      (0, import_node_fs8.writeFileSync)(omnifyPkgJson, JSON.stringify({
+    const omnifyPkgJson = (0, import_node_path9.resolve)(omnifyBaseDir, "package.json");
+    if (!(0, import_node_fs9.existsSync)(omnifyPkgJson)) {
+      (0, import_node_fs9.writeFileSync)(omnifyPkgJson, JSON.stringify({
         name: "@omnify-base",
         version: "0.0.0",
         private: true,
@@ -1690,16 +1832,16 @@ function runDirectGeneration(schemas, config, rootDir, options, changes) {
       } else {
         outputDir = schemasDir;
       }
-      const filePath = (0, import_node_path8.resolve)(outputDir, outputFilePath);
-      const fileDir = (0, import_node_path8.dirname)(filePath);
-      if (!(0, import_node_fs8.existsSync)(fileDir)) {
-        (0, import_node_fs8.mkdirSync)(fileDir, { recursive: true });
+      const filePath = (0, import_node_path9.resolve)(outputDir, outputFilePath);
+      const fileDir = (0, import_node_path9.dirname)(filePath);
+      if (!(0, import_node_fs9.existsSync)(fileDir)) {
+        (0, import_node_fs9.mkdirSync)(fileDir, { recursive: true });
       }
-      if (!file.overwrite && (0, import_node_fs8.existsSync)(filePath)) {
+      if (!file.overwrite && (0, import_node_fs9.existsSync)(filePath)) {
         logger.debug(`Skipped (exists): ${file.filePath}`);
         continue;
       }
-      (0, import_node_fs8.writeFileSync)(filePath, file.content);
+      (0, import_node_fs9.writeFileSync)(filePath, file.content);
       logger.debug(`Created: ${file.filePath}`);
       typesGenerated++;
     }
@@ -1727,9 +1869,51 @@ async function runGenerate(options) {
   logger.header("Generating Outputs");
   logger.debug("Loading configuration...");
   const { config, configPath } = await loadConfig();
-  const rootDir = configPath ? (0, import_node_path8.dirname)(configPath) : process.cwd();
+  const rootDir = configPath ? (0, import_node_path9.dirname)(configPath) : process.cwd();
   validateConfig(config, rootDir);
-  const schemaPath = (0, import_node_path8.resolve)(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 import_omnify_core5.OmnifyError(
+          "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 = (0, import_node_path9.resolve)(rootDir, config.schemasDir);
   logger.step(`Loading schemas from ${schemaPath}`);
   let schemas = await (0, import_omnify_core5.loadSchemas)(schemaPath);
   logger.debug(`Found ${Object.keys(schemas).length} schema(s) in main directory`);
@@ -1738,9 +1922,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 = (0, import_node_path8.resolve)(rootDir, entry.path);
+      const absolutePath = (0, import_node_path9.resolve)(rootDir, entry.path);
       logger.debug(`  Checking: ${entry.path} \u2192 ${absolutePath}`);
-      if ((0, import_node_fs8.existsSync)(absolutePath)) {
+      if ((0, import_node_fs9.existsSync)(absolutePath)) {
         let packageSchemas = await (0, import_omnify_core5.loadSchemas)(absolutePath, { skipPartialResolution: true });
         if (entry.output) {
           const schemasWithOutput = {};
@@ -1795,12 +1979,12 @@ async function runGenerate(options) {
     process.exit(2);
   }
   logger.step("Checking for changes...");
-  const lockPath = (0, import_node_path8.resolve)(rootDir, config.lockFilePath);
+  const lockPath = (0, import_node_path9.resolve)(rootDir, config.lockFilePath);
   const existingLock = await (0, import_omnify_atlas2.readLockFile)(lockPath);
   const currentSnapshots = await (0, import_omnify_atlas2.buildSchemaSnapshots)(schemas);
   const v2Lock = existingLock && (0, import_omnify_atlas2.isLockFileV2)(existingLock) ? existingLock : null;
   const comparison = (0, import_omnify_atlas2.compareSchemasDeep)(currentSnapshots, v2Lock);
-  const chainFilePath = (0, import_node_path8.resolve)(rootDir, import_omnify_atlas2.VERSION_CHAIN_FILE);
+  const chainFilePath = (0, import_node_path9.resolve)(rootDir, import_omnify_atlas2.VERSION_CHAIN_FILE);
   const versionChain = await (0, import_omnify_atlas2.readVersionChain)(chainFilePath);
   if (versionChain && comparison.hasChanges) {
     const schemaActions = [];
@@ -1837,7 +2021,7 @@ async function runGenerate(options) {
     }
   }
   if (existingLock && config.output.laravel?.migrationsPath) {
-    const migrationsDir = (0, import_node_path8.resolve)(rootDir, config.output.laravel.migrationsPath);
+    const migrationsDir = (0, import_node_path9.resolve)(rootDir, config.output.laravel.migrationsPath);
     const migrationValidation = await (0, import_omnify_atlas2.validateMigrations)(existingLock, migrationsDir);
     if (!migrationValidation.valid) {
       logger.newline();
@@ -1897,7 +2081,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 = (0, import_node_path8.resolve)(rootDir, config.output.laravel.migrationsPath);
+          const migrationsDir2 = (0, import_node_path9.resolve)(rootDir, config.output.laravel.migrationsPath);
           const customTypesMap2 = /* @__PURE__ */ new Map();
           for (const plugin of config.plugins) {
             if (plugin.types) {
@@ -1919,8 +2103,8 @@ async function runGenerate(options) {
               customTypes: customTypesMap2
             });
             for (const mig of regenerated) {
-              const filePath = (0, import_node_path8.resolve)(migrationsDir2, migData.fileName);
-              (0, import_node_fs8.writeFileSync)(filePath, mig.content);
+              const filePath = (0, import_node_path9.resolve)(migrationsDir2, migData.fileName);
+              (0, import_node_fs9.writeFileSync)(filePath, mig.content);
               logger.success(`  Regenerated: ${migData.fileName}`);
             }
           }
@@ -1976,7 +2160,8 @@ async function runGenerate(options) {
       schemas,
       rootDir,
       options.verbose ?? false,
-      comparison.changes
+      comparison.changes,
+      config.locale
     );
     migrationsGenerated = counts.migrations;
     typesGenerated = counts.types;
@@ -1998,32 +2183,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 = (0, import_node_path8.resolve)(rootDir, tsConfig2.path);
-      const schemasDir2 = (0, import_node_path8.resolve)(basePath2, tsConfig2.schemasDir ?? "schemas");
-      const enumDir2 = (0, import_node_path8.resolve)(basePath2, tsConfig2.enumDir ?? "enum");
-      const omnifyBaseDir2 = (0, import_node_path8.resolve)(rootDir, "node_modules/@omnify-base");
-      const pluginEnumDir2 = (0, import_node_path8.resolve)(omnifyBaseDir2, "enum");
-      const baseSchemasDir2 = (0, import_node_path8.resolve)(omnifyBaseDir2, "schemas");
-      const enumImportPrefix2 = (0, import_node_path8.relative)(schemasDir2, enumDir2).replace(/\\/g, "/");
-      if (!(0, import_node_fs8.existsSync)(schemasDir2)) {
-        (0, import_node_fs8.mkdirSync)(schemasDir2, { recursive: true });
+      const basePath2 = (0, import_node_path9.resolve)(rootDir, tsConfig2.path);
+      const schemasDir2 = (0, import_node_path9.resolve)(basePath2, tsConfig2.schemasDir ?? "schemas");
+      const enumDir2 = (0, import_node_path9.resolve)(basePath2, tsConfig2.enumDir ?? "enum");
+      const omnifyBaseDir2 = (0, import_node_path9.resolve)(rootDir, "node_modules/@omnify-base");
+      const pluginEnumDir2 = (0, import_node_path9.resolve)(omnifyBaseDir2, "enum");
+      const baseSchemasDir2 = (0, import_node_path9.resolve)(omnifyBaseDir2, "schemas");
+      const enumImportPrefix2 = (0, import_node_path9.relative)(schemasDir2, enumDir2).replace(/\\/g, "/");
+      if (!(0, import_node_fs9.existsSync)(schemasDir2)) {
+        (0, import_node_fs9.mkdirSync)(schemasDir2, { recursive: true });
         logger.debug(`Created directory: ${schemasDir2}`);
       }
-      if (!(0, import_node_fs8.existsSync)(enumDir2)) {
-        (0, import_node_fs8.mkdirSync)(enumDir2, { recursive: true });
+      if (!(0, import_node_fs9.existsSync)(enumDir2)) {
+        (0, import_node_fs9.mkdirSync)(enumDir2, { recursive: true });
         logger.debug(`Created directory: ${enumDir2}`);
       }
-      if (!(0, import_node_fs8.existsSync)(pluginEnumDir2)) {
-        (0, import_node_fs8.mkdirSync)(pluginEnumDir2, { recursive: true });
+      if (!(0, import_node_fs9.existsSync)(pluginEnumDir2)) {
+        (0, import_node_fs9.mkdirSync)(pluginEnumDir2, { recursive: true });
         logger.debug(`Created directory: ${pluginEnumDir2}`);
       }
-      if (!(0, import_node_fs8.existsSync)(baseSchemasDir2)) {
-        (0, import_node_fs8.mkdirSync)(baseSchemasDir2, { recursive: true });
+      if (!(0, import_node_fs9.existsSync)(baseSchemasDir2)) {
+        (0, import_node_fs9.mkdirSync)(baseSchemasDir2, { recursive: true });
         logger.debug(`Created directory: ${baseSchemasDir2}`);
       }
-      const omnifyPkgJson2 = (0, import_node_path8.resolve)(omnifyBaseDir2, "package.json");
-      if (!(0, import_node_fs8.existsSync)(omnifyPkgJson2)) {
-        (0, import_node_fs8.writeFileSync)(omnifyPkgJson2, JSON.stringify({
+      const omnifyPkgJson2 = (0, import_node_path9.resolve)(omnifyBaseDir2, "package.json");
+      if (!(0, import_node_fs9.existsSync)(omnifyPkgJson2)) {
+        (0, import_node_fs9.writeFileSync)(omnifyPkgJson2, JSON.stringify({
           name: "@omnify-base",
           version: "0.0.0",
           private: true,
@@ -2060,16 +2245,16 @@ async function runGenerate(options) {
         } else {
           outputDir2 = schemasDir2;
         }
-        const filePath = (0, import_node_path8.resolve)(outputDir2, outputFilePath2);
-        const fileDir = (0, import_node_path8.dirname)(filePath);
-        if (!(0, import_node_fs8.existsSync)(fileDir)) {
-          (0, import_node_fs8.mkdirSync)(fileDir, { recursive: true });
+        const filePath = (0, import_node_path9.resolve)(outputDir2, outputFilePath2);
+        const fileDir = (0, import_node_path9.dirname)(filePath);
+        if (!(0, import_node_fs9.existsSync)(fileDir)) {
+          (0, import_node_fs9.mkdirSync)(fileDir, { recursive: true });
         }
-        if (!file.overwrite && (0, import_node_fs8.existsSync)(filePath)) {
+        if (!file.overwrite && (0, import_node_fs9.existsSync)(filePath)) {
           logger.debug(`Skipped (exists): ${file.filePath}`);
           continue;
         }
-        (0, import_node_fs8.writeFileSync)(filePath, file.content);
+        (0, import_node_fs9.writeFileSync)(filePath, file.content);
         logger.debug(`Created: ${file.filePath}`);
         typesGenerated++;
       }
@@ -2139,6 +2324,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) {
@@ -2169,13 +2363,19 @@ function registerGenerateCommand(program) {
 }
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {
+  VERSION_LOCK_FILE,
+  checkPluginVersions,
   defineConfig,
+  getCliVersion,
   loadConfig,
   logger,
+  readVersionLock,
   registerDiffCommand,
   registerGenerateCommand,
   registerInitCommand,
   registerValidateCommand,
-  runInit
+  runInit,
+  updateVersionLock,
+  writeVersionLock
 });
 //# sourceMappingURL=index.cjs.map