@famgia/omnify-cli 2.0.10 → 2.0.11

package/dist/index.js

@@ -1102,8 +1102,8 @@ function registerDiffCommand(program) {
 }
 
 // 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,
@@ -1138,17 +1138,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
@@ -1156,41 +1158,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 = [
@@ -1245,20 +1258,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 {
@@ -1451,17 +1585,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++;
@@ -1471,7 +1605,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,
@@ -1480,7 +1614,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);
@@ -1517,8 +1652,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}`);
     }
@@ -1540,8 +1675,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++;
       }
@@ -1549,8 +1684,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++;
       }
@@ -1561,12 +1696,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";
@@ -1577,16 +1712,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++;
     }
@@ -1595,24 +1730,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++;
     }
@@ -1621,32 +1756,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,
@@ -1683,16 +1818,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++;
     }
@@ -1722,7 +1857,49 @@ async function runGenerate(options) {
   const { config, configPath } = await loadConfig();
   const rootDir = configPath ? dirname6(configPath) : 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`);
@@ -1731,9 +1908,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 = {};
@@ -1788,12 +1965,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 = [];
@@ -1830,7 +2007,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();
@@ -1890,7 +2067,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) {
@@ -1912,8 +2089,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}`);
             }
           }
@@ -1969,7 +2146,8 @@ async function runGenerate(options) {
       schemas,
       rootDir,
       options.verbose ?? false,
-      comparison.changes
+      comparison.changes,
+      config.locale
     );
     migrationsGenerated = counts.migrations;
     typesGenerated = counts.types;
@@ -1991,32 +2169,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,
@@ -2053,16 +2231,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++;
       }
@@ -2132,6 +2310,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) {
@@ -2161,13 +2348,19 @@ function registerGenerateCommand(program) {
   });
 }
 export {
+  VERSION_LOCK_FILE,
+  checkPluginVersions,
   defineConfig,
+  getCliVersion,
   loadConfig,
   logger,
+  readVersionLock,
   registerDiffCommand,
   registerGenerateCommand,
   registerInitCommand,
   registerValidateCommand,
-  runInit
+  runInit,
+  updateVersionLock,
+  writeVersionLock
 };
 //# sourceMappingURL=index.js.map