@famgia/omnify-cli 0.0.1

package/dist/index.cjs

@@ -0,0 +1,733 @@
+#!/usr/bin/env node
+#!/usr/bin/env node
+"use strict";
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/index.ts
+var index_exports = {};
+__export(index_exports, {
+  defineConfig: () => defineConfig,
+  loadConfig: () => loadConfig
+});
+module.exports = __toCommonJS(index_exports);
+var import_commander = require("commander");
+var import_omnify_core6 = require("@famgia/omnify-core");
+
+// src/commands/init.ts
+var import_node_fs = require("fs");
+var import_node_path = require("path");
+
+// src/output/logger.ts
+var import_picocolors = __toESM(require("picocolors"), 1);
+var import_omnify_core = require("@famgia/omnify-core");
+var Logger = class {
+  _verbose;
+  _quiet;
+  _startTime;
+  constructor(options = {}) {
+    this._verbose = options.verbose ?? false;
+    this._quiet = options.quiet ?? false;
+    this._startTime = Date.now();
+  }
+  /**
+   * Enable or disable verbose mode.
+   */
+  setVerbose(verbose) {
+    this._verbose = verbose;
+  }
+  /**
+   * Enable or disable quiet mode.
+   */
+  setQuiet(quiet) {
+    this._quiet = quiet;
+  }
+  /**
+   * Log an info message.
+   */
+  info(message) {
+    if (!this._quiet) {
+      console.log(message);
+    }
+  }
+  /**
+   * Log a success message.
+   */
+  success(message) {
+    if (!this._quiet) {
+      console.log(import_picocolors.default.green("\u2713") + " " + message);
+    }
+  }
+  /**
+   * Log a warning message.
+   */
+  warn(message) {
+    if (!this._quiet) {
+      console.log(import_picocolors.default.yellow("\u26A0") + " " + import_picocolors.default.yellow(message));
+    }
+  }
+  /**
+   * Log an error message.
+   */
+  error(message) {
+    console.error(import_picocolors.default.red("\u2717") + " " + import_picocolors.default.red(message));
+  }
+  /**
+   * Log a debug message (only in verbose mode).
+   */
+  debug(message) {
+    if (this._verbose && !this._quiet) {
+      console.log(import_picocolors.default.dim("  " + message));
+    }
+  }
+  /**
+   * Log a step message.
+   */
+  step(message) {
+    if (!this._quiet) {
+      console.log(import_picocolors.default.cyan("\u2192") + " " + message);
+    }
+  }
+  /**
+   * Log a header.
+   */
+  header(message) {
+    if (!this._quiet) {
+      console.log();
+      console.log(import_picocolors.default.bold(message));
+      console.log();
+    }
+  }
+  /**
+   * Log a list item.
+   */
+  list(items) {
+    if (!this._quiet) {
+      for (const item of items) {
+        console.log("  \u2022 " + item);
+      }
+    }
+  }
+  /**
+   * Log a timing message.
+   */
+  timing(message) {
+    if (this._verbose && !this._quiet) {
+      const elapsed = Date.now() - this._startTime;
+      console.log(import_picocolors.default.dim(`  [${elapsed}ms] ${message}`));
+    }
+  }
+  /**
+   * Log an empty line.
+   */
+  newline() {
+    if (!this._quiet) {
+      console.log();
+    }
+  }
+  /**
+   * Format and log an OmnifyError.
+   */
+  formatError(error) {
+    const formatted = (0, import_omnify_core.formatError)(error, { color: true });
+    console.error(formatted);
+  }
+  /**
+   * Get exit code for an error.
+   */
+  getExitCode(error) {
+    return (0, import_omnify_core.getExitCode)(error);
+  }
+};
+var logger = new Logger();
+
+// src/commands/init.ts
+var EXAMPLE_SCHEMA = `# Example User schema
+# See https://omnify.dev/docs/schemas for documentation
+
+name: User
+displayName: User Account
+kind: object
+
+properties:
+  email:
+    type: Email
+    unique: true
+    displayName: Email Address
+
+  name:
+    type: String
+    displayName: Full Name
+
+  bio:
+    type: Text
+    nullable: true
+    displayName: Biography
+
+options:
+  timestamps: true
+  softDelete: true
+`;
+var EXAMPLE_CONFIG = `import { defineConfig } from '@famgia/omnify-cli';
+
+export default defineConfig({
+  // Schema files location
+  schemasDir: './schemas',
+
+  // Database configuration
+  database: {
+    driver: 'mysql',
+    // Development database URL for Atlas diff operations
+    // devUrl: 'mysql://root@localhost:3306/omnify_dev',
+  },
+
+  // Output configuration
+  output: {
+    laravel: {
+      migrationsPath: 'database/migrations',
+    },
+    typescript: {
+      path: 'types',
+      singleFile: true,
+    },
+  },
+
+  // Plugins for custom types
+  plugins: [
+    // '@famgia/omnify-japan',
+  ],
+});
+`;
+async function runInit(options) {
+  const cwd = process.cwd();
+  logger.header("Initializing Omnify Project");
+  const configPath = (0, import_node_path.resolve)(cwd, "omnify.config.ts");
+  if ((0, import_node_fs.existsSync)(configPath) && !options.force) {
+    logger.warn("omnify.config.ts already exists. Use --force to overwrite.");
+    return;
+  }
+  const schemasDir = (0, import_node_path.resolve)(cwd, "schemas");
+  if (!(0, import_node_fs.existsSync)(schemasDir)) {
+    (0, import_node_fs.mkdirSync)(schemasDir, { recursive: true });
+    logger.step("Created schemas/ directory");
+  } else {
+    logger.debug("schemas/ directory already exists");
+  }
+  const examplePath = (0, import_node_path.resolve)(schemasDir, "User.yaml");
+  if (!(0, import_node_fs.existsSync)(examplePath) || options.force) {
+    (0, import_node_fs.writeFileSync)(examplePath, EXAMPLE_SCHEMA);
+    logger.step("Created example schema: schemas/User.yaml");
+  } else {
+    logger.debug("Example schema already exists");
+  }
+  (0, import_node_fs.writeFileSync)(configPath, EXAMPLE_CONFIG);
+  logger.step("Created omnify.config.ts");
+  logger.newline();
+  logger.success("Project initialized successfully!");
+  logger.newline();
+  logger.info("Next steps:");
+  logger.list([
+    "Edit omnify.config.ts to configure your database",
+    "Add your schema files to the schemas/ directory",
+    'Run "omnify validate" to check your schemas',
+    'Run "omnify diff" to preview changes',
+    'Run "omnify generate" to create migrations and types'
+  ]);
+}
+function registerInitCommand(program2) {
+  program2.command("init").description("Initialize a new omnify project").option("-f, --force", "Overwrite existing files").action(async (options) => {
+    try {
+      await runInit(options);
+    } catch (error) {
+      if (error instanceof Error) {
+        logger.error(error.message);
+      }
+      process.exit(1);
+    }
+  });
+}
+
+// src/commands/validate.ts
+var import_node_path3 = require("path");
+var import_omnify_core3 = require("@famgia/omnify-core");
+
+// src/config/loader.ts
+var import_node_fs2 = require("fs");
+var import_node_path2 = require("path");
+var import_jiti = require("jiti");
+var import_omnify_core2 = require("@famgia/omnify-core");
+var CONFIG_FILES = [
+  "omnify.config.ts",
+  "omnify.config.js",
+  "omnify.config.mjs",
+  "omnify.config.cjs"
+];
+function findConfigFile(startDir) {
+  const cwd = (0, import_node_path2.resolve)(startDir);
+  for (const filename of CONFIG_FILES) {
+    const configPath = (0, import_node_path2.resolve)(cwd, filename);
+    if ((0, import_node_fs2.existsSync)(configPath)) {
+      return configPath;
+    }
+  }
+  return null;
+}
+async function loadConfigFile(configPath) {
+  const jiti = (0, import_jiti.createJiti)(configPath, {
+    interopDefault: true,
+    moduleCache: false
+  });
+  try {
+    const module2 = await jiti.import(configPath);
+    const config = module2;
+    if ("default" in config) {
+      return config.default;
+    }
+    return config;
+  } catch (error) {
+    const message = error instanceof Error ? error.message : String(error);
+    throw (0, import_omnify_core2.configError)(
+      `Failed to load config file: ${message}. Check your omnify.config.ts for syntax errors.`,
+      "E002"
+    );
+  }
+}
+async function resolvePlugins(plugins, configPath) {
+  if (!plugins || plugins.length === 0) {
+    return [];
+  }
+  const resolved = [];
+  const configDir = configPath ? (0, import_node_path2.dirname)(configPath) : process.cwd();
+  for (const plugin of plugins) {
+    if (typeof plugin === "string") {
+      const jiti = (0, import_jiti.createJiti)(configDir, {
+        interopDefault: true,
+        moduleCache: false
+      });
+      try {
+        const module2 = await jiti.import(plugin);
+        const loadedPlugin = module2.default ?? module2;
+        resolved.push(loadedPlugin);
+      } catch (error) {
+        const message = error instanceof Error ? error.message : String(error);
+        throw (0, import_omnify_core2.configError)(
+          `Failed to load plugin '${plugin}': ${message}. Ensure the plugin is installed: npm install ${plugin}`,
+          "E301"
+        );
+      }
+    } else {
+      resolved.push(plugin);
+    }
+  }
+  return resolved;
+}
+async function resolveConfig(userConfig, configPath) {
+  const plugins = await resolvePlugins(userConfig.plugins, configPath);
+  const databaseConfig = {
+    driver: userConfig.database.driver,
+    enableFieldComments: userConfig.database.enableFieldComments ?? false
+  };
+  const database = userConfig.database.devUrl !== void 0 ? { ...databaseConfig, devUrl: userConfig.database.devUrl } : databaseConfig;
+  const laravelConfig = {
+    migrationsPath: userConfig.output?.laravel?.migrationsPath ?? "database/migrations"
+  };
+  const laravel = buildLaravelConfig(laravelConfig, userConfig.output?.laravel);
+  const typescript = {
+    path: userConfig.output?.typescript?.path ?? "types",
+    singleFile: userConfig.output?.typescript?.singleFile ?? true,
+    generateEnums: userConfig.output?.typescript?.generateEnums ?? true,
+    generateRelationships: userConfig.output?.typescript?.generateRelationships ?? true
+  };
+  const result = {
+    schemasDir: userConfig.schemasDir ?? "./schemas",
+    database,
+    output: {
+      laravel,
+      typescript
+    },
+    plugins,
+    verbose: userConfig.verbose ?? false,
+    lockFilePath: userConfig.lockFilePath ?? ".omnify.lock"
+  };
+  return result;
+}
+function buildLaravelConfig(base, userLaravel) {
+  const config = { ...base };
+  if (userLaravel?.modelsPath !== void 0) {
+    config.modelsPath = userLaravel.modelsPath;
+  }
+  if (userLaravel?.modelsNamespace !== void 0) {
+    config.modelsNamespace = userLaravel.modelsNamespace;
+  }
+  if (userLaravel?.factoriesPath !== void 0) {
+    config.factoriesPath = userLaravel.factoriesPath;
+  }
+  if (userLaravel?.enumsPath !== void 0) {
+    config.enumsPath = userLaravel.enumsPath;
+  }
+  if (userLaravel?.enumsNamespace !== void 0) {
+    config.enumsNamespace = userLaravel.enumsNamespace;
+  }
+  return config;
+}
+function validateConfig(config, rootDir) {
+  const schemaPath = (0, import_node_path2.resolve)(rootDir, config.schemasDir);
+  if (!(0, import_node_fs2.existsSync)(schemaPath)) {
+    throw (0, import_omnify_core2.configError)(
+      `Schema directory not found: ${schemaPath}. Create the '${config.schemasDir}' directory or update schemasDir in config.`,
+      "E002"
+    );
+  }
+}
+function requireDevUrl(config) {
+  if (!config.database.devUrl) {
+    throw (0, import_omnify_core2.configError)(
+      `database.devUrl is required for diff and generate operations. Add devUrl to your database config, e.g., "mysql://root@localhost:3306/omnify_dev"`,
+      "E003"
+    );
+  }
+}
+async function loadConfig(startDir = process.cwd()) {
+  const cwd = (0, import_node_path2.resolve)(startDir);
+  const configPath = findConfigFile(cwd);
+  if (configPath) {
+    const userConfig = await loadConfigFile(configPath);
+    const config = await resolveConfig(userConfig, configPath);
+    return {
+      config,
+      configPath
+    };
+  }
+  throw (0, import_omnify_core2.configNotFoundError)((0, import_node_path2.resolve)(cwd, "omnify.config.ts"));
+}
+function defineConfig(config) {
+  return config;
+}
+
+// src/commands/validate.ts
+async function runValidate(options) {
+  logger.setVerbose(options.verbose ?? false);
+  logger.header("Validating Schemas");
+  logger.debug("Loading configuration...");
+  logger.timing("Config load start");
+  const { config, configPath } = await loadConfig();
+  logger.timing("Config loaded");
+  const rootDir = configPath ? (0, import_node_path3.dirname)(configPath) : process.cwd();
+  validateConfig(config, rootDir);
+  const schemaPath = (0, import_node_path3.resolve)(rootDir, config.schemasDir);
+  logger.step(`Loading schemas from ${schemaPath}`);
+  logger.timing("Schema load start");
+  const schemas = await (0, import_omnify_core3.loadSchemas)(schemaPath);
+  const schemaCount = Object.keys(schemas).length;
+  logger.timing("Schemas loaded");
+  if (schemaCount === 0) {
+    logger.warn("No schema files found");
+    return;
+  }
+  logger.debug(`Found ${schemaCount} schema(s)`);
+  logger.step("Validating schemas...");
+  logger.timing("Validation start");
+  const result = (0, import_omnify_core3.validateSchemas)(schemas);
+  logger.timing("Validation complete");
+  if (result.valid) {
+    logger.success(`All ${schemaCount} schema(s) are valid`);
+  } else {
+    logger.error(`Found ${result.errors.length} validation error(s)`);
+    logger.newline();
+    for (const error of result.errors) {
+      const omnifyError = import_omnify_core3.OmnifyError.fromInfo(error);
+      logger.formatError(omnifyError);
+      logger.newline();
+    }
+    process.exit(2);
+  }
+}
+function registerValidateCommand(program2) {
+  program2.command("validate").description("Validate schema files").option("-v, --verbose", "Show detailed output").action(async (options) => {
+    try {
+      await runValidate(options);
+    } catch (error) {
+      if (error instanceof import_omnify_core3.OmnifyError) {
+        logger.formatError(error);
+        process.exit(logger.getExitCode(error));
+      } else if (error instanceof Error) {
+        logger.error(error.message);
+        process.exit(1);
+      }
+      process.exit(1);
+    }
+  });
+}
+
+// src/commands/diff.ts
+var import_node_path4 = require("path");
+var import_omnify_core4 = require("@famgia/omnify-core");
+
+// src/operations/diff.ts
+var import_omnify_atlas = require("@famgia/omnify-atlas");
+async function runDiffOperation(options) {
+  const { schemas, devUrl, driver, workDir } = options;
+  const preview = await (0, import_omnify_atlas.generatePreview)(schemas, {
+    driver,
+    devUrl,
+    workDir
+  }, {
+    warnDestructive: true,
+    showSql: true
+  });
+  const formattedPreview = (0, import_omnify_atlas.formatPreview)(preview, "text");
+  return {
+    hasChanges: preview.hasChanges,
+    hasDestructiveChanges: preview.hasDestructiveChanges,
+    preview,
+    formattedPreview,
+    sql: preview.sql
+  };
+}
+
+// src/commands/diff.ts
+var import_picocolors2 = __toESM(require("picocolors"), 1);
+async function runDiff(options) {
+  logger.setVerbose(options.verbose ?? false);
+  logger.header("Checking for Schema Changes");
+  logger.debug("Loading configuration...");
+  const { config, configPath } = await loadConfig();
+  const rootDir = configPath ? (0, import_node_path4.dirname)(configPath) : process.cwd();
+  validateConfig(config, rootDir);
+  requireDevUrl(config);
+  const schemaPath = (0, import_node_path4.resolve)(rootDir, config.schemasDir);
+  logger.step(`Loading schemas from ${schemaPath}`);
+  const schemas = await (0, import_omnify_core4.loadSchemas)(schemaPath);
+  const schemaCount = Object.keys(schemas).length;
+  if (schemaCount === 0) {
+    logger.warn("No schema files found");
+    return;
+  }
+  logger.debug(`Found ${schemaCount} schema(s)`);
+  logger.step("Validating schemas...");
+  const validationResult = (0, import_omnify_core4.validateSchemas)(schemas);
+  if (!validationResult.valid) {
+    logger.error("Schema validation failed. Fix errors before running diff.");
+    for (const error of validationResult.errors) {
+      const omnifyError = import_omnify_core4.OmnifyError.fromInfo(error);
+      logger.formatError(omnifyError);
+    }
+    process.exit(2);
+  }
+  logger.step("Running Atlas diff...");
+  const lockPath = (0, import_node_path4.resolve)(rootDir, config.lockFilePath);
+  const diffResult = await runDiffOperation({
+    schemas,
+    devUrl: config.database.devUrl,
+    lockFilePath: lockPath,
+    driver: config.database.driver,
+    workDir: rootDir
+  });
+  if (!diffResult.hasChanges) {
+    logger.success("No changes detected");
+    return;
+  }
+  logger.newline();
+  console.log(import_picocolors2.default.bold("Changes detected:"));
+  console.log();
+  console.log(diffResult.formattedPreview);
+  if (diffResult.hasDestructiveChanges) {
+    logger.newline();
+    logger.warn("This preview contains destructive changes. Review carefully.");
+  }
+  if (options.check) {
+    logger.newline();
+    logger.info("Changes detected (--check mode)");
+    process.exit(1);
+  }
+  logger.newline();
+  logger.info('Run "omnify generate" to create migrations');
+}
+function registerDiffCommand(program2) {
+  program2.command("diff").description("Show pending schema changes").option("-v, --verbose", "Show detailed output").option("--check", "Exit with code 1 if changes exist (for CI)").action(async (options) => {
+    try {
+      await runDiff(options);
+    } catch (error) {
+      if (error instanceof import_omnify_core4.OmnifyError) {
+        logger.formatError(error);
+        process.exit(logger.getExitCode(error));
+      } else if (error instanceof Error) {
+        logger.error(error.message);
+        process.exit(1);
+      }
+      process.exit(1);
+    }
+  });
+}
+
+// src/commands/generate.ts
+var import_node_fs3 = require("fs");
+var import_node_path5 = 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");
+async function runGenerate(options) {
+  logger.setVerbose(options.verbose ?? false);
+  logger.header("Generating Outputs");
+  logger.debug("Loading configuration...");
+  const { config, configPath } = await loadConfig();
+  const rootDir = configPath ? (0, import_node_path5.dirname)(configPath) : process.cwd();
+  validateConfig(config, rootDir);
+  requireDevUrl(config);
+  const schemaPath = (0, import_node_path5.resolve)(rootDir, config.schemasDir);
+  logger.step(`Loading schemas from ${schemaPath}`);
+  const schemas = await (0, import_omnify_core5.loadSchemas)(schemaPath);
+  const schemaCount = Object.keys(schemas).length;
+  if (schemaCount === 0) {
+    logger.warn("No schema files found");
+    return;
+  }
+  logger.debug(`Found ${schemaCount} schema(s)`);
+  logger.step("Validating schemas...");
+  const validationResult = (0, import_omnify_core5.validateSchemas)(schemas);
+  if (!validationResult.valid) {
+    logger.error("Schema validation failed. Fix errors before generating.");
+    for (const error of validationResult.errors) {
+      const omnifyError = import_omnify_core5.OmnifyError.fromInfo(error);
+      logger.formatError(omnifyError);
+    }
+    process.exit(2);
+  }
+  logger.step("Checking for changes...");
+  const lockPath = (0, import_node_path5.resolve)(rootDir, config.lockFilePath);
+  const diffResult = await runDiffOperation({
+    schemas,
+    devUrl: config.database.devUrl,
+    lockFilePath: lockPath,
+    driver: config.database.driver,
+    workDir: rootDir
+  });
+  if (!diffResult.hasChanges && !options.force) {
+    logger.success("No changes to generate");
+    return;
+  }
+  let migrationsGenerated = 0;
+  let typesGenerated = 0;
+  if (!options.typesOnly) {
+    logger.step("Generating Laravel migrations...");
+    const migrationsDir = (0, import_node_path5.resolve)(rootDir, config.output.laravel.migrationsPath);
+    if (!(0, import_node_fs3.existsSync)(migrationsDir)) {
+      (0, import_node_fs3.mkdirSync)(migrationsDir, { recursive: true });
+      logger.debug(`Created directory: ${migrationsDir}`);
+    }
+    const migrations = (0, import_omnify_laravel.generateMigrations)(schemas);
+    for (const migration of migrations) {
+      const filePath = (0, import_node_path5.resolve)(migrationsDir, migration.fileName);
+      (0, import_node_fs3.writeFileSync)(filePath, migration.content);
+      logger.debug(`Created: ${migration.fileName}`);
+      migrationsGenerated++;
+    }
+    logger.success(`Generated ${migrationsGenerated} migration(s)`);
+  }
+  if (!options.migrationsOnly) {
+    logger.step("Generating TypeScript types...");
+    const typesDir = (0, import_node_path5.resolve)(rootDir, config.output.typescript.path);
+    if (!(0, import_node_fs3.existsSync)(typesDir)) {
+      (0, import_node_fs3.mkdirSync)(typesDir, { recursive: true });
+      logger.debug(`Created directory: ${typesDir}`);
+    }
+    const typeFiles = (0, import_omnify_laravel.generateTypeScript)(schemas, {
+      singleFile: config.output.typescript.singleFile
+    });
+    for (const file of typeFiles) {
+      const filePath = (0, import_node_path5.resolve)(typesDir, file.fileName);
+      (0, import_node_fs3.writeFileSync)(filePath, file.content);
+      logger.debug(`Created: ${file.fileName}`);
+      typesGenerated++;
+    }
+    logger.success(`Generated ${typesGenerated} TypeScript file(s)`);
+  }
+  logger.step("Updating lock file...");
+  await (0, import_omnify_atlas2.updateLockFile)(lockPath, schemas);
+  logger.debug(`Updated: ${config.lockFilePath}`);
+  logger.newline();
+  logger.success("Generation complete!");
+  if (migrationsGenerated > 0) {
+    logger.info(`  Migrations: ${config.output.laravel.migrationsPath}/`);
+  }
+  if (typesGenerated > 0) {
+    logger.info(`  Types: ${config.output.typescript.path}/`);
+  }
+}
+function registerGenerateCommand(program2) {
+  program2.command("generate").description("Generate Laravel migrations and TypeScript types").option("-v, --verbose", "Show detailed output").option("--migrations-only", "Only generate migrations").option("--types-only", "Only generate TypeScript types").option("-f, --force", "Generate even if no changes detected").action(async (options) => {
+    try {
+      await runGenerate(options);
+    } catch (error) {
+      if (error instanceof import_omnify_core5.OmnifyError) {
+        logger.formatError(error);
+        process.exit(logger.getExitCode(error));
+      } else if (error instanceof Error) {
+        logger.error(error.message);
+        process.exit(1);
+      }
+      process.exit(1);
+    }
+  });
+}
+
+// src/index.ts
+var VERSION = "0.0.1";
+var program = new import_commander.Command();
+program.name("omnify").description("Schema-first database migrations for Laravel and TypeScript").version(VERSION);
+registerInitCommand(program);
+registerValidateCommand(program);
+registerDiffCommand(program);
+registerGenerateCommand(program);
+process.on("uncaughtException", (error) => {
+  if (error instanceof import_omnify_core6.OmnifyError) {
+    logger.formatError(error);
+    process.exit(logger.getExitCode(error));
+  } else {
+    logger.error(error.message);
+    process.exit(1);
+  }
+});
+process.on("unhandledRejection", (reason) => {
+  if (reason instanceof import_omnify_core6.OmnifyError) {
+    logger.formatError(reason);
+    process.exit(logger.getExitCode(reason));
+  } else if (reason instanceof Error) {
+    logger.error(reason.message);
+  } else {
+    logger.error(String(reason));
+  }
+  process.exit(1);
+});
+program.parse();
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  defineConfig,
+  loadConfig
+});
+//# sourceMappingURL=index.cjs.map