@famgia/omnify-cli 0.0.162 → 0.0.164

package/dist/cli.js

@@ -7,8 +7,8 @@ var __require = /* @__PURE__ */ ((x) => typeof require !== "undefined" ? require
 });
 
 // src/cli.ts
-import { existsSync as existsSync12 } from "fs";
-import { resolve as resolve12 } from "path";
+import { existsSync as existsSync13 } from "fs";
+import { resolve as resolve13 } from "path";
 import { Command } from "commander";
 import { OmnifyError as OmnifyError7 } from "@famgia/omnify-core";
 
@@ -552,15 +552,109 @@ function registerInitCommand(program2) {
 }
 
 // src/commands/validate.ts
-import { existsSync as existsSync4 } from "fs";
-import { resolve as resolve4, dirname as dirname2 } from "path";
+import { existsSync as existsSync5 } from "fs";
+import { resolve as resolve5, dirname as dirname3 } from "path";
 import { loadSchemas, mergePartialSchemas, validateSchemas, OmnifyError as OmnifyError2 } from "@famgia/omnify-core";
 
 // src/config/loader.ts
-import { existsSync as existsSync3 } from "fs";
-import { resolve as resolve3, dirname } from "path";
+import { existsSync as existsSync4 } from "fs";
+import { resolve as resolve4, dirname as dirname2 } from "path";
 import { createJiti } from "jiti";
 import { configError, configNotFoundError } from "@famgia/omnify-core";
+
+// src/config/discovery.ts
+import { existsSync as existsSync3, readFileSync as readFileSync2 } from "fs";
+import { resolve as resolve3 } from "path";
+var MANIFEST_FILENAME = ".omnify-packages.json";
+var MANIFEST_VERSION = 1;
+function loadPackageManifest(projectRoot) {
+  const manifestPath = resolve3(projectRoot, MANIFEST_FILENAME);
+  if (!existsSync3(manifestPath)) {
+    logger.debug(`Package manifest not found: ${manifestPath}`);
+    return null;
+  }
+  try {
+    const content = readFileSync2(manifestPath, "utf-8");
+    const manifest = JSON.parse(content);
+    if (manifest.version !== MANIFEST_VERSION) {
+      logger.warn(
+        `Package manifest version mismatch: expected ${MANIFEST_VERSION}, got ${manifest.version}. Run \`composer dump-autoload\` to regenerate.`
+      );
+    }
+    return manifest;
+  } catch (error) {
+    const message = error instanceof Error ? error.message : String(error);
+    logger.warn(`Failed to read package manifest: ${message}`);
+    return null;
+  }
+}
+function packageConfigToSchemaPath(packageName, config) {
+  const result = {
+    path: config.schemas,
+    namespace: config.namespace
+  };
+  if (config.options) {
+    const opts = config.options;
+    const basePath = config.schemas.replace(/\/database\/schemas\/?$/, "");
+    const laravelOutput = {
+      base: basePath
+    };
+    if (opts.modelNamespace) {
+      laravelOutput.modelsNamespace = opts.modelNamespace;
+    }
+    if (opts.migrationsPath) {
+      laravelOutput.migrationsPath = opts.migrationsPath.replace(basePath + "/", "");
+    }
+    if (opts.factoriesPath) {
+      laravelOutput.factoriesPath = opts.factoriesPath.replace(basePath + "/", "");
+    }
+    if (opts.generateServiceProvider !== void 0) {
+      laravelOutput.generateServiceProvider = opts.generateServiceProvider;
+    }
+    if (opts.generateMigrations !== void 0) {
+      laravelOutput.generateMigrations = opts.generateMigrations;
+    }
+    if (opts.generateModels !== void 0) {
+      laravelOutput.generateModels = opts.generateModels;
+    }
+    result.output = { laravel: laravelOutput };
+  }
+  return result;
+}
+function discoverPackages(projectRoot, discoveryConfig, explicitPaths) {
+  const result = [];
+  const excludeSet = new Set(discoveryConfig.exclude ?? []);
+  if (discoveryConfig.enabled !== false) {
+    const manifest = loadPackageManifest(projectRoot);
+    if (manifest) {
+      const sortedPackages = Object.entries(manifest.packages).sort(
+        ([, a], [, b]) => (a.priority ?? 100) - (b.priority ?? 100)
+      );
+      for (const [packageName, config] of sortedPackages) {
+        if (excludeSet.has(packageName)) {
+          logger.debug(`Skipping excluded package: ${packageName}`);
+          continue;
+        }
+        const schemasPath = resolve3(projectRoot, config.schemas);
+        if (!existsSync3(schemasPath)) {
+          logger.debug(`Package schemas not found, skipping: ${schemasPath}`);
+          continue;
+        }
+        result.push(packageConfigToSchemaPath(packageName, config));
+        logger.debug(`Discovered package: ${packageName} (${config.namespace ?? "no namespace"})`);
+      }
+      if (result.length > 0) {
+        logger.info(`Auto-discovered ${result.length} package(s) from ${MANIFEST_FILENAME}`);
+      }
+    }
+  }
+  if (explicitPaths?.length) {
+    result.push(...explicitPaths);
+  }
+  return result;
+}
+
+// src/config/loader.ts
 var CONFIG_FILES = [
   "omnify.config.ts",
   "omnify.config.js",
@@ -568,10 +662,10 @@ var CONFIG_FILES = [
   "omnify.config.cjs"
 ];
 function findConfigFile(startDir) {
-  const cwd = resolve3(startDir);
+  const cwd = resolve4(startDir);
   for (const filename of CONFIG_FILES) {
-    const configPath2 = resolve3(cwd, filename);
-    if (existsSync3(configPath2)) {
+    const configPath2 = resolve4(cwd, filename);
+    if (existsSync4(configPath2)) {
       return configPath2;
     }
   }
@@ -602,7 +696,7 @@ async function resolvePlugins(plugins, configPath2) {
     return [];
   }
   const resolved = [];
-  const configDir = configPath2 ? dirname(configPath2) : process.cwd();
+  const configDir = configPath2 ? dirname2(configPath2) : process.cwd();
   for (const plugin of plugins) {
     if (typeof plugin === "string") {
       const jiti = createJiti(configDir, {
@@ -628,6 +722,16 @@ async function resolvePlugins(plugins, configPath2) {
 }
 async function resolveConfig(userConfig, configPath2) {
   const plugins = await resolvePlugins(userConfig.plugins, configPath2);
+  const projectRoot = configPath2 ? dirname2(configPath2) : process.cwd();
+  const discovery = {
+    enabled: userConfig.discovery?.enabled ?? true,
+    exclude: userConfig.discovery?.exclude
+  };
+  const allSchemaPaths = discoverPackages(
+    projectRoot,
+    discovery,
+    userConfig.additionalSchemaPaths
+  );
   const databaseConfig = {
     driver: userConfig.database.driver,
     enableFieldComments: userConfig.database.enableFieldComments ?? false
@@ -656,8 +760,9 @@ async function resolveConfig(userConfig, configPath2) {
     plugins,
     verbose: userConfig.verbose ?? false,
     lockFilePath: userConfig.lockFilePath ?? ".omnify.lock",
+    discovery,
     ...userConfig.locale && { locale: userConfig.locale },
-    ...userConfig.additionalSchemaPaths && { additionalSchemaPaths: userConfig.additionalSchemaPaths }
+    ...allSchemaPaths.length > 0 && { additionalSchemaPaths: allSchemaPaths }
   };
   return result;
 }
@@ -687,8 +792,8 @@ function buildLaravelConfig(base, userLaravel) {
   return config;
 }
 function validateConfig(config, rootDir) {
-  const schemaPath = resolve3(rootDir, config.schemasDir);
-  if (!existsSync3(schemaPath)) {
+  const schemaPath = resolve4(rootDir, config.schemasDir);
+  if (!existsSync4(schemaPath)) {
     throw configError(
       `Schema directory not found: ${schemaPath}. Create the '${config.schemasDir}' directory or update schemasDir in config.`,
       "E002"
@@ -704,7 +809,7 @@ function requireDevUrl(config) {
   }
 }
 async function loadConfig(startDir = process.cwd()) {
-  const cwd = resolve3(startDir);
+  const cwd = resolve4(startDir);
   const configPath2 = findConfigFile(cwd);
   if (configPath2) {
     const userConfig = await loadConfigFile(configPath2);
@@ -714,7 +819,7 @@ async function loadConfig(startDir = process.cwd()) {
       configPath: configPath2
     };
   }
-  throw configNotFoundError(resolve3(cwd, "omnify.config.ts"));
+  throw configNotFoundError(resolve4(cwd, "omnify.config.ts"));
 }
 
 // src/commands/validate.ts
@@ -725,9 +830,9 @@ async function runValidate(options) {
   logger.timing("Config load start");
   const { config, configPath: configPath2 } = await loadConfig();
   logger.timing("Config loaded");
-  const rootDir = configPath2 ? dirname2(configPath2) : process.cwd();
+  const rootDir = configPath2 ? dirname3(configPath2) : process.cwd();
   validateConfig(config, rootDir);
-  const schemaPath = resolve4(rootDir, config.schemasDir);
+  const schemaPath = resolve5(rootDir, config.schemasDir);
   logger.step(`Loading schemas from ${schemaPath}`);
   logger.timing("Schema load start");
   let schemas = await loadSchemas(schemaPath);
@@ -737,9 +842,9 @@ async function runValidate(options) {
   if (additionalPaths.length > 0) {
     logger.step(`Loading schemas from ${additionalPaths.length} additional path(s)`);
     for (const entry of additionalPaths) {
-      const absolutePath = resolve4(rootDir, entry.path);
+      const absolutePath = resolve5(rootDir, entry.path);
       logger.debug(`  Checking: ${entry.path} \u2192 ${absolutePath}`);
-      if (existsSync4(absolutePath)) {
+      if (existsSync5(absolutePath)) {
         const packageSchemas = await loadSchemas(absolutePath, { skipPartialResolution: true });
         const count = Object.keys(packageSchemas).filter((k) => !k.startsWith("__partial__")).length;
         const partialCount = Object.keys(packageSchemas).filter((k) => k.startsWith("__partial__")).length;
@@ -797,8 +902,8 @@ function registerValidateCommand(program2) {
 }
 
 // src/commands/diff.ts
-import { existsSync as existsSync5 } from "fs";
-import { resolve as resolve5, dirname as dirname3 } from "path";
+import { existsSync as existsSync6 } from "fs";
+import { resolve as resolve6, dirname as dirname4 } from "path";
 import { loadSchemas as loadSchemas2, mergePartialSchemas as mergePartialSchemas2, validateSchemas as validateSchemas2, OmnifyError as OmnifyError3 } from "@famgia/omnify-core";
 
 // src/operations/diff.ts
@@ -833,10 +938,10 @@ async function runDiff(options) {
   logger.header("Checking for Schema Changes");
   logger.debug("Loading configuration...");
   const { config, configPath: configPath2 } = await loadConfig();
-  const rootDir = configPath2 ? dirname3(configPath2) : process.cwd();
+  const rootDir = configPath2 ? dirname4(configPath2) : process.cwd();
   validateConfig(config, rootDir);
   requireDevUrl(config);
-  const schemaPath = resolve5(rootDir, config.schemasDir);
+  const schemaPath = resolve6(rootDir, config.schemasDir);
   logger.step(`Loading schemas from ${schemaPath}`);
   let schemas = await loadSchemas2(schemaPath);
   logger.debug(`Found ${Object.keys(schemas).length} schema(s) in main directory`);
@@ -845,9 +950,9 @@ async function runDiff(options) {
   if (additionalPaths.length > 0) {
     logger.step(`Loading schemas from ${additionalPaths.length} additional path(s)`);
     for (const entry of additionalPaths) {
-      const absolutePath = resolve5(rootDir, entry.path);
+      const absolutePath = resolve6(rootDir, entry.path);
       logger.debug(`  Checking: ${entry.path} \u2192 ${absolutePath}`);
-      if (existsSync5(absolutePath)) {
+      if (existsSync6(absolutePath)) {
         const packageSchemas = await loadSchemas2(absolutePath, { skipPartialResolution: true });
         const count = Object.keys(packageSchemas).filter((k) => !k.startsWith("__partial__")).length;
         const partialCount = Object.keys(packageSchemas).filter((k) => k.startsWith("__partial__")).length;
@@ -880,7 +985,7 @@ async function runDiff(options) {
     process.exit(2);
   }
   logger.step("Running Atlas diff...");
-  const lockPath = resolve5(rootDir, config.lockFilePath);
+  const lockPath = resolve6(rootDir, config.lockFilePath);
   const diffResult = await runDiffOperation({
     schemas,
     devUrl: config.database.devUrl,
@@ -926,8 +1031,8 @@ function registerDiffCommand(program2) {
 }
 
 // src/commands/generate.ts
-import { existsSync as existsSync7, mkdirSync as mkdirSync3, writeFileSync as writeFileSync4, readdirSync as readdirSync2 } from "fs";
-import { resolve as resolve7, dirname as dirname5, relative } from "path";
+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 {
   loadSchemas as loadSchemas3,
   mergePartialSchemas as mergePartialSchemas3,
@@ -960,8 +1065,8 @@ import {
 import { generateTypeScript, copyStubs, generateAIGuides as generateTypescriptAIGuides, shouldGenerateAIGuides as shouldGenerateTypescriptAIGuides } from "@famgia/omnify-typescript";
 
 // src/guides/index.ts
-import { existsSync as existsSync6, writeFileSync as writeFileSync3, mkdirSync as mkdirSync2, readdirSync, readFileSync as readFileSync2 } from "fs";
-import { resolve as resolve6, dirname as dirname4, join } from "path";
+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
 
@@ -1018,35 +1123,35 @@ Add your personal preferences in \`CLAUDE.local.md\` (gitignored).
 function copyOmnifyGuides(rootDir) {
   let filesWritten = 0;
   const omnifyPkgPaths = [
-    resolve6(rootDir, "node_modules", "@famgia", "omnify", "stubs", "ai-guides", "omnify"),
-    resolve6(rootDir, "node_modules", ".pnpm", "@famgia+omnify@*", "node_modules", "@famgia", "omnify", "stubs", "ai-guides", "omnify")
+    resolve7(rootDir, "node_modules", "@famgia", "omnify", "stubs", "ai-guides", "omnify"),
+    resolve7(rootDir, "node_modules", ".pnpm", "@famgia+omnify@*", "node_modules", "@famgia", "omnify", "stubs", "ai-guides", "omnify")
   ];
   let stubsDir = null;
   for (const pkgPath of omnifyPkgPaths) {
     if (pkgPath.includes("*")) {
-      const parentDir = dirname4(dirname4(pkgPath));
-      if (existsSync6(parentDir)) {
+      const parentDir = dirname5(dirname5(pkgPath));
+      if (existsSync7(parentDir)) {
         const entries = readdirSync(parentDir);
         for (const entry of entries) {
           if (entry.startsWith("@famgia+omnify@")) {
             const testPath = join(parentDir, entry, "node_modules", "@famgia", "omnify", "stubs", "ai-guides", "omnify");
-            if (existsSync6(testPath)) {
+            if (existsSync7(testPath)) {
               stubsDir = testPath;
               break;
             }
           }
         }
       }
-    } else if (existsSync6(pkgPath)) {
+    } else if (existsSync7(pkgPath)) {
       stubsDir = pkgPath;
       break;
     }
   }
   if (!stubsDir) {
     try {
-      const omnifyPath = dirname4(__require.resolve("@famgia/omnify/package.json", { paths: [rootDir] }));
+      const omnifyPath = dirname5(__require.resolve("@famgia/omnify/package.json", { paths: [rootDir] }));
       const testPath = join(omnifyPath, "stubs", "ai-guides", "omnify");
-      if (existsSync6(testPath)) {
+      if (existsSync7(testPath)) {
         stubsDir = testPath;
       }
     } catch {
@@ -1055,13 +1160,13 @@ function copyOmnifyGuides(rootDir) {
   if (!stubsDir) {
     return 0;
   }
-  const destDir = resolve6(rootDir, ".claude", "omnify", "guides", "omnify");
+  const destDir = resolve7(rootDir, ".claude", "omnify", "guides", "omnify");
   mkdirSync2(destDir, { recursive: true });
   const files = readdirSync(stubsDir).filter((f) => f.endsWith(".stub"));
   for (const file of files) {
     const srcPath = join(stubsDir, file);
     const destPath = join(destDir, file.replace(".stub", ""));
-    const content = readFileSync2(srcPath, "utf8");
+    const content = readFileSync3(srcPath, "utf8");
     writeFileSync3(destPath, content);
     filesWritten++;
   }
@@ -1069,8 +1174,8 @@ function copyOmnifyGuides(rootDir) {
 }
 function generateAIGuides(rootDir, _plugins) {
   let filesWritten = 0;
-  const claudeMdPath = resolve6(rootDir, "CLAUDE.md");
-  if (!existsSync6(claudeMdPath)) {
+  const claudeMdPath = resolve7(rootDir, "CLAUDE.md");
+  if (!existsSync7(claudeMdPath)) {
     writeFileSync3(claudeMdPath, CLAUDE_MD);
     filesWritten++;
   }
@@ -1084,7 +1189,7 @@ function hasPluginGenerators(plugins) {
 }
 function getExistingMigrationTables(migrationsDir) {
   const existingTables = /* @__PURE__ */ new Set();
-  if (!existsSync7(migrationsDir)) {
+  if (!existsSync8(migrationsDir)) {
     return existingTables;
   }
   try {
@@ -1277,13 +1382,13 @@ 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 = resolve7(rootDir, output.path);
-    const dir = dirname5(filePath);
-    if (!existsSync7(dir)) {
+    const filePath = resolve8(rootDir, output.path);
+    const dir = dirname6(filePath);
+    if (!existsSync8(dir)) {
       mkdirSync3(dir, { recursive: true });
       logger.debug(`Created directory: ${dir}`);
     }
-    if (output.skipIfExists && existsSync7(filePath)) {
+    if (output.skipIfExists && existsSync8(filePath)) {
       logger.debug(`Skipped (exists): ${output.path}`);
       continue;
     }
@@ -1343,8 +1448,8 @@ function runDirectGeneration(schemas, config, rootDir, options, changes) {
   }
   if (!options.typesOnly && config.output.laravel) {
     logger.step("Generating Laravel migrations...");
-    const migrationsDir = resolve7(rootDir, config.output.laravel.migrationsPath);
-    if (!existsSync7(migrationsDir)) {
+    const migrationsDir = resolve8(rootDir, config.output.laravel.migrationsPath);
+    if (!existsSync8(migrationsDir)) {
       mkdirSync3(migrationsDir, { recursive: true });
       logger.debug(`Created directory: ${migrationsDir}`);
     }
@@ -1366,7 +1471,7 @@ function runDirectGeneration(schemas, config, rootDir, options, changes) {
           logger.debug(`Skipped CREATE for ${tableName} (already exists)`);
           continue;
         }
-        const filePath = resolve7(migrationsDir, migration.fileName);
+        const filePath = resolve8(migrationsDir, migration.fileName);
         writeFileSync4(filePath, migration.content);
         logger.debug(`Created: ${migration.fileName}`);
         migrationsGenerated++;
@@ -1375,7 +1480,7 @@ function runDirectGeneration(schemas, config, rootDir, options, changes) {
     if (alterChanges.length > 0) {
       const alterMigrations = generateMigrationsFromChanges(alterChanges);
       for (const migration of alterMigrations) {
-        const filePath = resolve7(migrationsDir, migration.fileName);
+        const filePath = resolve8(migrationsDir, migration.fileName);
         writeFileSync4(filePath, migration.content);
         logger.debug(`Created: ${migration.fileName}`);
         migrationsGenerated++;
@@ -1387,12 +1492,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 = resolve7(rootDir, modelsPath);
-    const baseModelsDir = resolve7(rootDir, baseModelsPath);
-    if (!existsSync7(modelsDir)) {
+    const modelsDir = resolve8(rootDir, modelsPath);
+    const baseModelsDir = resolve8(rootDir, baseModelsPath);
+    if (!existsSync8(modelsDir)) {
       mkdirSync3(modelsDir, { recursive: true });
     }
-    if (!existsSync7(baseModelsDir)) {
+    if (!existsSync8(baseModelsDir)) {
       mkdirSync3(baseModelsDir, { recursive: true });
     }
     const providersPath = config.output.laravel.providersPath ?? "app/Providers";
@@ -1403,12 +1508,12 @@ function runDirectGeneration(schemas, config, rootDir, options, changes) {
       customTypes: customTypesMap
     });
     for (const model of models) {
-      const filePath = resolve7(rootDir, getModelPath(model));
-      const fileDir = dirname5(filePath);
-      if (!existsSync7(fileDir)) {
+      const filePath = resolve8(rootDir, getModelPath(model));
+      const fileDir = dirname6(filePath);
+      if (!existsSync8(fileDir)) {
         mkdirSync3(fileDir, { recursive: true });
       }
-      if (!model.overwrite && existsSync7(filePath)) {
+      if (!model.overwrite && existsSync8(filePath)) {
         logger.debug(`Skipped (exists): ${getModelPath(model)}`);
         continue;
       }
@@ -1421,20 +1526,20 @@ 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 = resolve7(rootDir, factoriesPath);
-    if (!existsSync7(factoriesDir)) {
+    const factoriesDir = resolve8(rootDir, factoriesPath);
+    if (!existsSync8(factoriesDir)) {
       mkdirSync3(factoriesDir, { recursive: true });
     }
     const factories = generateFactories(schemas, {
       factoryPath: factoriesPath
     });
     for (const factory of factories) {
-      const filePath = resolve7(rootDir, getFactoryPath(factory));
-      const fileDir = dirname5(filePath);
-      if (!existsSync7(fileDir)) {
+      const filePath = resolve8(rootDir, getFactoryPath(factory));
+      const fileDir = dirname6(filePath);
+      if (!existsSync8(fileDir)) {
         mkdirSync3(fileDir, { recursive: true });
       }
-      if (!factory.overwrite && existsSync7(filePath)) {
+      if (!factory.overwrite && existsSync8(filePath)) {
         logger.debug(`Skipped (exists): ${getFactoryPath(factory)}`);
         continue;
       }
@@ -1447,15 +1552,15 @@ 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 = resolve7(rootDir, tsConfig.path);
-    const schemasDir = resolve7(basePath, tsConfig.schemasDir ?? "schemas");
-    const enumDir = resolve7(basePath, tsConfig.enumDir ?? "enum");
+    const basePath = resolve8(rootDir, tsConfig.path);
+    const schemasDir = resolve8(basePath, tsConfig.schemasDir ?? "schemas");
+    const enumDir = resolve8(basePath, tsConfig.enumDir ?? "enum");
     const enumImportPrefix = relative(schemasDir, enumDir).replace(/\\/g, "/");
-    if (!existsSync7(schemasDir)) {
+    if (!existsSync8(schemasDir)) {
       mkdirSync3(schemasDir, { recursive: true });
       logger.debug(`Created directory: ${schemasDir}`);
     }
-    if (!existsSync7(enumDir)) {
+    if (!existsSync8(enumDir)) {
       mkdirSync3(enumDir, { recursive: true });
       logger.debug(`Created directory: ${enumDir}`);
     }
@@ -1471,12 +1576,12 @@ function runDirectGeneration(schemas, config, rootDir, options, changes) {
     });
     for (const file of typeFiles) {
       const outputDir = file.category === "enum" ? enumDir : schemasDir;
-      const filePath = resolve7(outputDir, file.filePath);
-      const fileDir = dirname5(filePath);
-      if (!existsSync7(fileDir)) {
+      const filePath = resolve8(outputDir, file.filePath);
+      const fileDir = dirname6(filePath);
+      if (!existsSync8(fileDir)) {
         mkdirSync3(fileDir, { recursive: true });
       }
-      if (!file.overwrite && existsSync7(filePath)) {
+      if (!file.overwrite && existsSync8(filePath)) {
         logger.debug(`Skipped (exists): ${file.filePath}`);
         continue;
       }
@@ -1507,9 +1612,9 @@ async function runGenerate(options) {
   logger.header("Generating Outputs");
   logger.debug("Loading configuration...");
   const { config, configPath: configPath2 } = await loadConfig();
-  const rootDir = configPath2 ? dirname5(configPath2) : process.cwd();
+  const rootDir = configPath2 ? dirname6(configPath2) : process.cwd();
   validateConfig(config, rootDir);
-  const schemaPath = resolve7(rootDir, config.schemasDir);
+  const schemaPath = resolve8(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`);
@@ -1518,9 +1623,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 = resolve7(rootDir, entry.path);
+      const absolutePath = resolve8(rootDir, entry.path);
       logger.debug(`  Checking: ${entry.path} \u2192 ${absolutePath}`);
-      if (existsSync7(absolutePath)) {
+      if (existsSync8(absolutePath)) {
         let packageSchemas = await loadSchemas3(absolutePath, { skipPartialResolution: true });
         if (entry.output) {
           const schemasWithOutput = {};
@@ -1575,12 +1680,12 @@ async function runGenerate(options) {
     process.exit(2);
   }
   logger.step("Checking for changes...");
-  const lockPath = resolve7(rootDir, config.lockFilePath);
+  const lockPath = resolve8(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 = resolve7(rootDir, VERSION_CHAIN_FILE);
+  const chainFilePath = resolve8(rootDir, VERSION_CHAIN_FILE);
   const versionChain = await readVersionChain(chainFilePath);
   if (versionChain && comparison.hasChanges) {
     const schemaActions = [];
@@ -1617,7 +1722,7 @@ async function runGenerate(options) {
     }
   }
   if (existingLock && config.output.laravel?.migrationsPath) {
-    const migrationsDir = resolve7(rootDir, config.output.laravel.migrationsPath);
+    const migrationsDir = resolve8(rootDir, config.output.laravel.migrationsPath);
     const migrationValidation = await validateMigrations(existingLock, migrationsDir);
     if (!migrationValidation.valid) {
       logger.newline();
@@ -1741,15 +1846,15 @@ async function runGenerate(options) {
     if (!options.migrationsOnly && config.output.typescript && typesGenerated === 0) {
       logger.step("Generating TypeScript types...");
       const tsConfig2 = config.output.typescript;
-      const basePath2 = resolve7(rootDir, tsConfig2.path);
-      const schemasDir2 = resolve7(basePath2, tsConfig2.schemasDir ?? "schemas");
-      const enumDir2 = resolve7(basePath2, tsConfig2.enumDir ?? "enum");
+      const basePath2 = resolve8(rootDir, tsConfig2.path);
+      const schemasDir2 = resolve8(basePath2, tsConfig2.schemasDir ?? "schemas");
+      const enumDir2 = resolve8(basePath2, tsConfig2.enumDir ?? "enum");
       const enumImportPrefix2 = relative(schemasDir2, enumDir2).replace(/\\/g, "/");
-      if (!existsSync7(schemasDir2)) {
+      if (!existsSync8(schemasDir2)) {
         mkdirSync3(schemasDir2, { recursive: true });
         logger.debug(`Created directory: ${schemasDir2}`);
       }
-      if (!existsSync7(enumDir2)) {
+      if (!existsSync8(enumDir2)) {
         mkdirSync3(enumDir2, { recursive: true });
         logger.debug(`Created directory: ${enumDir2}`);
       }
@@ -1765,12 +1870,12 @@ async function runGenerate(options) {
       });
       for (const file of typeFiles) {
         const outputDir2 = file.category === "enum" ? enumDir2 : schemasDir2;
-        const filePath = resolve7(outputDir2, file.filePath);
-        const fileDir = dirname5(filePath);
-        if (!existsSync7(fileDir)) {
+        const filePath = resolve8(outputDir2, file.filePath);
+        const fileDir = dirname6(filePath);
+        if (!existsSync8(fileDir)) {
           mkdirSync3(fileDir, { recursive: true });
         }
-        if (!file.overwrite && existsSync7(filePath)) {
+        if (!file.overwrite && existsSync8(filePath)) {
           logger.debug(`Skipped (exists): ${file.filePath}`);
           continue;
         }
@@ -1873,23 +1978,23 @@ function registerGenerateCommand(program2) {
 }
 
 // src/commands/reset.ts
-import { existsSync as existsSync8, readdirSync as readdirSync3, rmSync, statSync } from "fs";
-import { resolve as resolve8, dirname as dirname6, join as join2 } from "path";
+import { existsSync as existsSync9, readdirSync as readdirSync3, rmSync, statSync } from "fs";
+import { resolve as resolve9, 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((resolve13) => {
+  return new Promise((resolve14) => {
     rl.question(`${message} (y/N) `, (answer) => {
       rl.close();
-      resolve13(answer.toLowerCase() === "y" || answer.toLowerCase() === "yes");
+      resolve14(answer.toLowerCase() === "y" || answer.toLowerCase() === "yes");
     });
   });
 }
 function countFiles(dir) {
-  if (!existsSync8(dir)) return 0;
+  if (!existsSync9(dir)) return 0;
   let count = 0;
   const entries = readdirSync3(dir);
   for (const entry of entries) {
@@ -1904,7 +2009,7 @@ function countFiles(dir) {
   return count;
 }
 function deleteDir(dir, verbose) {
-  if (!existsSync8(dir)) return 0;
+  if (!existsSync9(dir)) return 0;
   const count = countFiles(dir);
   rmSync(dir, { recursive: true, force: true });
   if (verbose) {
@@ -1913,7 +2018,7 @@ function deleteDir(dir, verbose) {
   return count;
 }
 function deleteFilesInDir(dir, pattern, verbose) {
-  if (!existsSync8(dir)) return 0;
+  if (!existsSync9(dir)) return 0;
   let count = 0;
   const entries = readdirSync3(dir);
   for (const entry of entries) {
@@ -1934,7 +2039,7 @@ async function runReset(options) {
   logger.header("Reset Omnify Generated Files");
   logger.debug("Loading configuration...");
   const { config, configPath: configPath2 } = await loadConfig();
-  const rootDir = configPath2 ? dirname6(configPath2) : process.cwd();
+  const rootDir = configPath2 ? dirname7(configPath2) : process.cwd();
   const paths = [];
   const omnifyBasePaths = [
     { name: "OmnifyBase models", paths: ["app/Models/OmnifyBase", "backend/app/Models/OmnifyBase"] },
@@ -1948,8 +2053,8 @@ async function runReset(options) {
   ];
   for (const { name, paths: relPaths } of omnifyBasePaths) {
     for (const relPath of relPaths) {
-      const omnifyBasePath = resolve8(rootDir, relPath);
-      if (existsSync8(omnifyBasePath)) {
+      const omnifyBasePath = resolve9(rootDir, relPath);
+      if (existsSync9(omnifyBasePath)) {
         paths.push({ name, path: omnifyBasePath, type: "dir" });
         break;
       }
@@ -1957,8 +2062,8 @@ async function runReset(options) {
   }
   for (const { name, paths: relPaths } of legacyGeneratedPaths) {
     for (const relPath of relPaths) {
-      const legacyPath = resolve8(rootDir, relPath);
-      if (existsSync8(legacyPath)) {
+      const legacyPath = resolve9(rootDir, relPath);
+      if (existsSync9(legacyPath)) {
         paths.push({ name, path: legacyPath, type: "dir" });
         break;
       }
@@ -1969,8 +2074,8 @@ async function runReset(options) {
     "backend/database/migrations/omnify"
   ];
   for (const relPath of migrationPaths) {
-    const migrationsPath = resolve8(rootDir, relPath);
-    if (existsSync8(migrationsPath)) {
+    const migrationsPath = resolve9(rootDir, relPath);
+    if (existsSync9(migrationsPath)) {
       paths.push({
         name: "Omnify migrations",
         path: migrationsPath,
@@ -1982,15 +2087,15 @@ async function runReset(options) {
   }
   const laravelConfig = config.output.laravel;
   if (laravelConfig?.modelsPath) {
-    const modelsPath = resolve8(rootDir, laravelConfig.modelsPath);
+    const modelsPath = resolve9(rootDir, laravelConfig.modelsPath);
     const omnifyBasePath = join2(modelsPath, "OmnifyBase");
-    if (existsSync8(omnifyBasePath) && !paths.some((p) => p.path === omnifyBasePath)) {
+    if (existsSync9(omnifyBasePath) && !paths.some((p) => p.path === omnifyBasePath)) {
       paths.push({ name: "OmnifyBase models", path: omnifyBasePath, type: "dir" });
     }
   }
   if (laravelConfig?.migrationsPath) {
-    const migrationsPath = resolve8(rootDir, laravelConfig.migrationsPath);
-    if (existsSync8(migrationsPath) && !paths.some((p) => p.path === migrationsPath)) {
+    const migrationsPath = resolve9(rootDir, laravelConfig.migrationsPath);
+    if (existsSync9(migrationsPath) && !paths.some((p) => p.path === migrationsPath)) {
       paths.push({
         name: "Omnify migrations",
         path: migrationsPath,
@@ -2003,18 +2108,18 @@ async function runReset(options) {
     for (const additionalPath of config.additionalSchemaPaths) {
       const pkgOutput = additionalPath.output?.laravel;
       if (pkgOutput?.base) {
-        const pkgBase = resolve8(rootDir, pkgOutput.base);
+        const pkgBase = resolve9(rootDir, pkgOutput.base);
         const pkgName = additionalPath.namespace ?? "Package";
         const pkgOmnifyBase = join2(pkgBase, pkgOutput.baseModelsPath ?? "src/Models/OmnifyBase");
-        if (existsSync8(pkgOmnifyBase) && !paths.some((p) => p.path === pkgOmnifyBase)) {
+        if (existsSync9(pkgOmnifyBase) && !paths.some((p) => p.path === pkgOmnifyBase)) {
           paths.push({ name: `${pkgName} OmnifyBase`, path: pkgOmnifyBase, type: "dir" });
         }
         const pkgGenerated = join2(pkgBase, "src/Models/Generated");
-        if (existsSync8(pkgGenerated) && !paths.some((p) => p.path === pkgGenerated)) {
+        if (existsSync9(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");
-        if (existsSync8(pkgMigrations) && !paths.some((p) => p.path === pkgMigrations)) {
+        if (existsSync9(pkgMigrations) && !paths.some((p) => p.path === pkgMigrations)) {
           paths.push({
             name: `${pkgName} migrations`,
             path: pkgMigrations,
@@ -2022,18 +2127,18 @@ async function runReset(options) {
           });
         }
         const pkgProviders = join2(pkgBase, pkgOutput.providersPath ?? "src/Providers");
-        if (existsSync8(pkgProviders) && !paths.some((p) => p.path === pkgProviders)) {
+        if (existsSync9(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 (existsSync8(pkgFactories) && !paths.some((p) => p.path === pkgFactories)) {
+        if (existsSync9(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 ? resolve8(rootDir, typescriptPath) : null;
+  const tsBasePath = typescriptPath ? resolve9(rootDir, typescriptPath) : null;
   const commonTsPaths = [
     "resources/ts/omnify",
     "resources/ts/omnify/schemas",
@@ -2043,45 +2148,45 @@ async function runReset(options) {
     "src/types/models"
   ];
   let foundTsPath = tsBasePath;
-  if (!foundTsPath || !existsSync8(foundTsPath)) {
+  if (!foundTsPath || !existsSync9(foundTsPath)) {
     for (const relPath of commonTsPaths) {
-      const tsPath = resolve8(rootDir, relPath);
-      if (existsSync8(tsPath)) {
+      const tsPath = resolve9(rootDir, relPath);
+      if (existsSync9(tsPath)) {
         foundTsPath = tsPath;
         break;
       }
     }
   }
-  if (foundTsPath && existsSync8(foundTsPath)) {
+  if (foundTsPath && existsSync9(foundTsPath)) {
     const autoGeneratedDirs = ["base", "enum", "rules", "hooks", "lib"];
     for (const subDir of autoGeneratedDirs) {
       const subPath = join2(foundTsPath, subDir);
-      if (existsSync8(subPath)) {
+      if (existsSync9(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 (existsSync8(filePath)) {
+      if (existsSync9(filePath)) {
         paths.push({ name: `TypeScript ${fileName}`, path: filePath, type: "file" });
       }
     }
   }
-  const lockFilePath = resolve8(rootDir, config.lockFilePath);
-  if (existsSync8(lockFilePath)) {
+  const lockFilePath = resolve9(rootDir, config.lockFilePath);
+  if (existsSync9(lockFilePath)) {
     paths.push({ name: "Lock file", path: lockFilePath, type: "file" });
   }
-  const versionsDir = resolve8(rootDir, ".omnify-versions");
-  if (existsSync8(versionsDir)) {
+  const versionsDir = resolve9(rootDir, ".omnify-versions");
+  if (existsSync9(versionsDir)) {
     paths.push({ name: "Version history", path: versionsDir, type: "dir" });
   }
-  const omnifyVersionsDir = resolve8(rootDir, ".omnify/versions");
-  if (existsSync8(omnifyVersionsDir)) {
+  const omnifyVersionsDir = resolve9(rootDir, ".omnify/versions");
+  if (existsSync9(omnifyVersionsDir)) {
     paths.push({ name: "Version history (.omnify/versions)", path: omnifyVersionsDir, type: "dir" });
   }
-  const logsDir = resolve8(rootDir, ".omnify/logs");
-  if (existsSync8(logsDir)) {
+  const logsDir = resolve9(rootDir, ".omnify/logs");
+  if (existsSync9(logsDir)) {
     paths.push({ name: "Logs", path: logsDir, type: "dir" });
   }
   if (paths.length === 0) {
@@ -2152,8 +2257,8 @@ function registerResetCommand(program2) {
 
 // src/commands/create-project.ts
 import { execSync, spawn } from "child_process";
-import { existsSync as existsSync9, rmSync as rmSync2, readFileSync as readFileSync3, writeFileSync as writeFileSync5 } from "fs";
-import { resolve as resolve9 } from "path";
+import { existsSync as existsSync10, rmSync as rmSync2, readFileSync as readFileSync4, writeFileSync as writeFileSync5 } from "fs";
+import { resolve as resolve10 } from "path";
 var BOILERPLATE_REPO = "https://github.com/omnifyjp/omnify-laravel-boilerplate.git";
 var IS_WINDOWS = process.platform === "win32";
 function checkGit() {
@@ -2254,9 +2359,9 @@ var GITIGNORE_ENTRIES_TO_REMOVE = [
   ".claude/omnify/"
 ];
 function cleanupGitignore(targetDir) {
-  const gitignorePath = resolve9(targetDir, ".gitignore");
-  if (!existsSync9(gitignorePath)) return;
-  const content = readFileSync3(gitignorePath, "utf-8");
+  const gitignorePath = resolve10(targetDir, ".gitignore");
+  if (!existsSync10(gitignorePath)) return;
+  const content = readFileSync4(gitignorePath, "utf-8");
   const lines = content.split("\n");
   const cleanedLines = lines.filter((line) => {
     const trimmed = line.trim();
@@ -2270,8 +2375,8 @@ function cleanupGitignore(targetDir) {
 function cloneRepo(repo, targetDir) {
   logger.step(`Cloning boilerplate from ${repo}...`);
   execSync(`git clone --depth 1 ${repo} "${targetDir}"`, { stdio: "inherit" });
-  const gitDir = resolve9(targetDir, ".git");
-  if (existsSync9(gitDir)) {
+  const gitDir = resolve10(targetDir, ".git");
+  if (existsSync10(gitDir)) {
     rmSync2(gitDir, { recursive: true, force: true });
   }
   cleanupGitignore(targetDir);
@@ -2279,7 +2384,7 @@ function cloneRepo(repo, targetDir) {
   logger.success("Repository cloned successfully");
 }
 function runCommand(command, targetDir) {
-  return new Promise((resolve13, reject) => {
+  return new Promise((resolve14, reject) => {
     const child = spawn(command, [], {
       cwd: targetDir,
       shell: true,
@@ -2287,7 +2392,7 @@ function runCommand(command, targetDir) {
     });
     child.on("close", (code) => {
       if (code === 0) {
-        resolve13();
+        resolve14();
       } else {
         reject(new Error(`Command failed with exit code ${code}`));
       }
@@ -2335,13 +2440,13 @@ async function runSetup(targetDir) {
   }
 }
 async function runCreateProject(projectName, options) {
-  const targetDir = resolve9(process.cwd(), projectName);
+  const targetDir = resolve10(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 (existsSync9(targetDir)) {
+  if (existsSync10(targetDir)) {
     logger.error(`Directory "${projectName}" already exists.`);
     process.exit(1);
   }
@@ -2367,7 +2472,7 @@ async function runCreateProject(projectName, options) {
     logger.info("  pnpm run dev");
     logger.newline();
   } catch (error) {
-    if (!cloneSucceeded && existsSync9(targetDir)) {
+    if (!cloneSucceeded && existsSync10(targetDir)) {
       rmSync2(targetDir, { recursive: true, force: true });
     } else if (cloneSucceeded) {
       logger.newline();
@@ -2393,8 +2498,8 @@ function registerCreateProjectCommand(program2) {
 }
 
 // src/commands/deploy.ts
-import { existsSync as existsSync10 } from "fs";
-import { resolve as resolve10, dirname as dirname7 } from "path";
+import { existsSync as existsSync11 } from "fs";
+import { resolve as resolve11, dirname as dirname8 } from "path";
 import { loadSchemas as loadSchemas4, OmnifyError as OmnifyError5 } from "@famgia/omnify-core";
 import {
   VERSION_CHAIN_FILE as VERSION_CHAIN_FILE2,
@@ -2409,7 +2514,7 @@ async function confirmDeploy(schemaCount, environment, version) {
     input: process.stdin,
     output: process.stdout
   });
-  return new Promise((resolve13) => {
+  return new Promise((resolve14) => {
     logger.newline();
     logger.warn("\u26A0\uFE0F  WARNING: This action is IRREVERSIBLE!");
     logger.warn("");
@@ -2425,7 +2530,7 @@ async function confirmDeploy(schemaCount, environment, version) {
     logger.newline();
     rl.question('   Type "LOCK" to confirm: ', (answer) => {
       rl.close();
-      resolve13(answer.trim().toUpperCase() === "LOCK");
+      resolve14(answer.trim().toUpperCase() === "LOCK");
     });
   });
 }
@@ -2446,11 +2551,11 @@ async function runDeploy(options) {
   logger.header("Deploy Version Lock");
   logger.debug("Loading configuration...");
   const { config, configPath: configPath2 } = await loadConfig();
-  const rootDir = configPath2 ? dirname7(configPath2) : process.cwd();
+  const rootDir = configPath2 ? dirname8(configPath2) : process.cwd();
   validateConfig(config, rootDir);
-  const schemasDir = resolve10(rootDir, config.schemasDir);
-  const chainFilePath = resolve10(rootDir, VERSION_CHAIN_FILE2);
-  if (!existsSync10(schemasDir)) {
+  const schemasDir = resolve11(rootDir, config.schemasDir);
+  const chainFilePath = resolve11(rootDir, VERSION_CHAIN_FILE2);
+  if (!existsSync11(schemasDir)) {
     throw new OmnifyError5(
       `Schemas directory not found: ${schemasDir}`,
       "E003",
@@ -2604,8 +2709,8 @@ function registerDeployCommand(program2) {
 }
 
 // src/commands/verify.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 dirname9 } from "path";
 import { OmnifyError as OmnifyError6 } from "@famgia/omnify-core";
 import {
   VERSION_CHAIN_FILE as VERSION_CHAIN_FILE3,
@@ -2621,11 +2726,11 @@ async function runVerify(options) {
   }
   logger.debug("Loading configuration...");
   const { config, configPath: configPath2 } = await loadConfig();
-  const rootDir = configPath2 ? dirname8(configPath2) : process.cwd();
+  const rootDir = configPath2 ? dirname9(configPath2) : process.cwd();
   validateConfig(config, rootDir);
-  const schemasDir = resolve11(rootDir, config.schemasDir);
-  const chainFilePath = resolve11(rootDir, VERSION_CHAIN_FILE3);
-  if (!existsSync11(chainFilePath)) {
+  const schemasDir = resolve12(rootDir, config.schemasDir);
+  const chainFilePath = resolve12(rootDir, VERSION_CHAIN_FILE3);
+  if (!existsSync12(chainFilePath)) {
     if (options.json) {
       console.log(JSON.stringify({
         valid: true,
@@ -2805,8 +2910,8 @@ process.on("unhandledRejection", (reason) => {
 var args = process.argv.slice(2);
 var firstArg = args[0];
 var hasCommand = firstArg !== void 0 && !firstArg.startsWith("-");
-var configPath = resolve12(process.cwd(), "omnify.config.ts");
-var hasConfig = existsSync12(configPath);
+var configPath = resolve13(process.cwd(), "omnify.config.ts");
+var hasConfig = existsSync13(configPath);
 if (!hasCommand && !hasConfig) {
   runInit({}).catch((error) => {
     if (error instanceof Error) {