@famgia/omnify-cli 0.0.4 → 0.0.6

package/dist/index.js

@@ -1,12 +1,160 @@
-#!/usr/bin/env node
-
-// src/index.ts
-import { Command } from "commander";
-import { OmnifyError as OmnifyError5 } from "@famgia/omnify-core";
+// src/config/loader.ts
+import { existsSync } from "fs";
+import { resolve, dirname } from "path";
+import { createJiti } from "jiti";
+import { configError, configNotFoundError } from "@famgia/omnify-core";
+var CONFIG_FILES = [
+  "omnify.config.ts",
+  "omnify.config.js",
+  "omnify.config.mjs",
+  "omnify.config.cjs"
+];
+function findConfigFile(startDir) {
+  const cwd = resolve(startDir);
+  for (const filename of CONFIG_FILES) {
+    const configPath = resolve(cwd, filename);
+    if (existsSync(configPath)) {
+      return configPath;
+    }
+  }
+  return null;
+}
+async function loadConfigFile(configPath) {
+  const jiti = createJiti(configPath, {
+    interopDefault: true,
+    moduleCache: false
+  });
+  try {
+    const module = await jiti.import(configPath);
+    const config = module;
+    if ("default" in config) {
+      return config.default;
+    }
+    return config;
+  } catch (error) {
+    const message = error instanceof Error ? error.message : String(error);
+    throw 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 ? dirname(configPath) : process.cwd();
+  for (const plugin of plugins) {
+    if (typeof plugin === "string") {
+      const jiti = createJiti(configDir, {
+        interopDefault: true,
+        moduleCache: false
+      });
+      try {
+        const module = await jiti.import(plugin);
+        const loadedPlugin = module.default ?? module;
+        resolved.push(loadedPlugin);
+      } catch (error) {
+        const message = error instanceof Error ? error.message : String(error);
+        throw 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 = resolve(rootDir, config.schemasDir);
+  if (!existsSync(schemaPath)) {
+    throw 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 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 = resolve(startDir);
+  const configPath = findConfigFile(cwd);
+  if (configPath) {
+    const userConfig = await loadConfigFile(configPath);
+    const config = await resolveConfig(userConfig, configPath);
+    return {
+      config,
+      configPath
+    };
+  }
+  throw configNotFoundError(resolve(cwd, "omnify.config.ts"));
+}
+function defineConfig(config) {
+  return config;
+}
 
 // src/commands/init.ts
-import { existsSync, mkdirSync, writeFileSync } from "fs";
-import { resolve } from "path";
+import { existsSync as existsSync2, mkdirSync, writeFileSync } from "fs";
+import { resolve as resolve2 } from "path";
+import { select, confirm, input } from "@inquirer/prompts";
 
 // src/output/logger.ts
 import pc from "picocolors";
@@ -133,7 +281,7 @@ var logger = new Logger();
 
 // src/commands/init.ts
 var EXAMPLE_SCHEMA = `# Example User schema
-# See https://omnify.dev/docs/schemas for documentation
+# See https://github.com/famgia/omnify for documentation
 
 name: User
 displayName: User Account
@@ -158,78 +306,193 @@ options:
   timestamps: true
   softDelete: true
 `;
-var EXAMPLE_CONFIG = `import { defineConfig } from '@famgia/omnify-cli';
+function generateConfig(config) {
+  const imports = [`import { defineConfig } from '@famgia/omnify';`];
+  const plugins = [];
+  if (config.migrationTool === "laravel") {
+    imports.push(`import laravel from '@famgia/omnify-laravel/plugin';`);
+    plugins.push(`    laravel({
+      migrationsPath: '${config.migrationsPath}',
+      typesPath: '${config.typesPath}',
+      singleFile: true,
+      generateMigrations: true,
+      generateTypes: ${config.generateTypes},
+    }),`);
+  }
+  if (config.migrationTool === "prisma") {
+    plugins.push(`    // Prisma plugin coming soon!
+    // prisma({ schemaPath: 'prisma/schema.prisma' }),`);
+  }
+  if (config.migrationTool === "drizzle") {
+    plugins.push(`    // Drizzle plugin coming soon!
+    // drizzle({ schemaPath: 'src/db/schema.ts' }),`);
+  }
+  if (config.migrationTool === "none" && config.generateTypes) {
+    imports.push(`import laravel from '@famgia/omnify-laravel/plugin';`);
+    plugins.push(`    laravel({
+      typesPath: '${config.typesPath}',
+      generateMigrations: false,
+      generateTypes: true,
+    }),`);
+  }
+  const dbUrlExamples = {
+    mysql: "mysql://root:password@localhost:3306/omnify_dev",
+    postgres: "postgres://postgres:password@localhost:5432/omnify_dev",
+    sqlite: "sqlite://./omnify_dev.db"
+  };
+  return `${imports.join("\n")}
 
 export default defineConfig({
   // Schema files location
-  schemasDir: './schemas',
+  schemasDir: '${config.schemasDir}',
+
+  // Lock file for tracking schema changes
+  lockFilePath: './omnify.lock',
 
   // Database configuration
   database: {
-    driver: 'mysql',
-    // Development database URL for Atlas diff operations
-    // devUrl: 'mysql://root@localhost:3306/omnify_dev',
+    driver: '${config.database}',
+    // REQUIRED: Set your development database URL
+    // devUrl: '${dbUrlExamples[config.database]}',
   },
 
-  // Output configuration
-  output: {
-    laravel: {
-      migrationsPath: 'database/migrations',
-    },
-    typescript: {
-      path: 'types',
-      singleFile: true,
-    },
-  },
-
-  // Plugins for custom types
+  // Generator plugins
   plugins: [
-    // '@famgia/omnify-japan',
+${plugins.join("\n\n")}
   ],
 });
 `;
+}
 async function runInit(options) {
   const cwd = process.cwd();
-  logger.header("Initializing Omnify Project");
-  const configPath = resolve(cwd, "omnify.config.ts");
-  if (existsSync(configPath) && !options.force) {
+  logger.header("Omnify Project Setup");
+  logger.newline();
+  const configPath = resolve2(cwd, "omnify.config.ts");
+  if (existsSync2(configPath) && !options.force) {
     logger.warn("omnify.config.ts already exists. Use --force to overwrite.");
     return;
   }
-  const schemasDir = resolve(cwd, "schemas");
-  if (!existsSync(schemasDir)) {
-    mkdirSync(schemasDir, { recursive: true });
-    logger.step("Created schemas/ directory");
+  let config;
+  if (options.yes) {
+    config = {
+      database: "mysql",
+      migrationTool: "laravel",
+      generateTypes: true,
+      migrationsPath: "database/migrations",
+      typesPath: "resources/js/types",
+      schemasDir: "./schemas"
+    };
+    logger.info("Using default configuration...");
   } else {
-    logger.debug("schemas/ directory already exists");
+    logger.info("Answer a few questions to configure your project:\n");
+    const database = await select({
+      message: "Which database?",
+      choices: [
+        { name: "MySQL / MariaDB", value: "mysql" },
+        { name: "PostgreSQL", value: "postgres" },
+        { name: "SQLite", value: "sqlite" }
+      ],
+      default: "mysql"
+    });
+    const migrationTool = await select({
+      message: "Which migration tool?",
+      choices: [
+        { name: "Laravel (PHP)", value: "laravel" },
+        { name: "Prisma (coming soon)", value: "prisma", disabled: true },
+        { name: "Drizzle (coming soon)", value: "drizzle", disabled: true },
+        { name: "None (types only)", value: "none" }
+      ],
+      default: "laravel"
+    });
+    const generateTypes = await confirm({
+      message: "Generate TypeScript types?",
+      default: true
+    });
+    const defaultPaths = {
+      laravel: { migrations: "database/migrations", types: "resources/js/types" },
+      prisma: { migrations: "prisma/migrations", types: "src/types" },
+      drizzle: { migrations: "drizzle", types: "src/types" },
+      none: { migrations: "", types: "types" }
+    };
+    const defaults = defaultPaths[migrationTool];
+    let migrationsPath = defaults.migrations;
+    let typesPath = defaults.types;
+    if (migrationTool !== "none") {
+      migrationsPath = await input({
+        message: "Migrations output path:",
+        default: defaults.migrations
+      });
+    }
+    if (generateTypes) {
+      typesPath = await input({
+        message: "TypeScript types path:",
+        default: defaults.types
+      });
+    }
+    const schemasDir2 = await input({
+      message: "Schemas directory:",
+      default: "./schemas"
+    });
+    config = {
+      database,
+      migrationTool,
+      generateTypes,
+      migrationsPath,
+      typesPath,
+      schemasDir: schemasDir2
+    };
+  }
+  logger.newline();
+  logger.step("Creating project files...");
+  const schemasDir = resolve2(cwd, config.schemasDir);
+  if (!existsSync2(schemasDir)) {
+    mkdirSync(schemasDir, { recursive: true });
+    logger.debug(`Created ${config.schemasDir}/ directory`);
   }
-  const examplePath = resolve(schemasDir, "User.yaml");
-  if (!existsSync(examplePath) || options.force) {
+  const examplePath = resolve2(schemasDir, "User.yaml");
+  if (!existsSync2(examplePath) || options.force) {
     writeFileSync(examplePath, EXAMPLE_SCHEMA);
-    logger.step("Created example schema: schemas/User.yaml");
-  } else {
-    logger.debug("Example schema already exists");
+    logger.debug("Created example schema: User.yaml");
   }
-  writeFileSync(configPath, EXAMPLE_CONFIG);
-  logger.step("Created omnify.config.ts");
+  const configContent = generateConfig(config);
+  writeFileSync(configPath, configContent);
+  logger.debug("Created omnify.config.ts");
   logger.newline();
-  logger.success("Project initialized successfully!");
+  logger.success("Project initialized!");
   logger.newline();
-  logger.info("Next steps:");
+  const toolName = config.migrationTool === "laravel" ? "Laravel" : config.migrationTool === "prisma" ? "Prisma" : config.migrationTool === "drizzle" ? "Drizzle" : "None";
+  logger.info("Configuration:");
   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'
+    `Database: ${config.database}`,
+    `Migration tool: ${toolName}`,
+    `TypeScript types: ${config.generateTypes ? "Yes" : "No"}`
   ]);
+  logger.newline();
+  logger.info("Files created:");
+  logger.list(["omnify.config.ts", `${config.schemasDir}/User.yaml`]);
+  logger.newline();
+  logger.info("Next steps:");
+  logger.newline();
+  logger.step("1. Set database URL in omnify.config.ts");
+  logger.newline();
+  logger.step("2. Define schemas in " + config.schemasDir + "/");
+  logger.newline();
+  logger.step("3. Generate:");
+  logger.info("   npx omnify validate");
+  logger.info("   npx omnify generate");
+  logger.newline();
 }
-function registerInitCommand(program2) {
-  program2.command("init").description("Initialize a new omnify project").option("-f, --force", "Overwrite existing files").action(async (options) => {
+function registerInitCommand(program) {
+  program.command("init").description("Initialize a new omnify project").option("-f, --force", "Overwrite existing files").option("-y, --yes", "Use default configuration (skip prompts)").action(async (options) => {
     try {
       await runInit(options);
     } catch (error) {
       if (error instanceof Error) {
+        if (error.message.includes("User force closed")) {
+          logger.newline();
+          logger.info("Setup cancelled.");
+          process.exit(0);
+        }
         logger.error(error.message);
       }
       process.exit(1);
@@ -240,161 +503,6 @@ function registerInitCommand(program2) {
 // src/commands/validate.ts
 import { resolve as resolve3, dirname as dirname2 } from "path";
 import { loadSchemas, validateSchemas, OmnifyError as OmnifyError2 } from "@famgia/omnify-core";
-
-// src/config/loader.ts
-import { existsSync as existsSync2 } from "fs";
-import { resolve as resolve2, dirname } from "path";
-import { createJiti } from "jiti";
-import { configError, configNotFoundError } from "@famgia/omnify-core";
-var CONFIG_FILES = [
-  "omnify.config.ts",
-  "omnify.config.js",
-  "omnify.config.mjs",
-  "omnify.config.cjs"
-];
-function findConfigFile(startDir) {
-  const cwd = resolve2(startDir);
-  for (const filename of CONFIG_FILES) {
-    const configPath = resolve2(cwd, filename);
-    if (existsSync2(configPath)) {
-      return configPath;
-    }
-  }
-  return null;
-}
-async function loadConfigFile(configPath) {
-  const jiti = createJiti(configPath, {
-    interopDefault: true,
-    moduleCache: false
-  });
-  try {
-    const module = await jiti.import(configPath);
-    const config = module;
-    if ("default" in config) {
-      return config.default;
-    }
-    return config;
-  } catch (error) {
-    const message = error instanceof Error ? error.message : String(error);
-    throw 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 ? dirname(configPath) : process.cwd();
-  for (const plugin of plugins) {
-    if (typeof plugin === "string") {
-      const jiti = createJiti(configDir, {
-        interopDefault: true,
-        moduleCache: false
-      });
-      try {
-        const module = await jiti.import(plugin);
-        const loadedPlugin = module.default ?? module;
-        resolved.push(loadedPlugin);
-      } catch (error) {
-        const message = error instanceof Error ? error.message : String(error);
-        throw 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 = resolve2(rootDir, config.schemasDir);
-  if (!existsSync2(schemaPath)) {
-    throw 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 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 = resolve2(startDir);
-  const configPath = findConfigFile(cwd);
-  if (configPath) {
-    const userConfig = await loadConfigFile(configPath);
-    const config = await resolveConfig(userConfig, configPath);
-    return {
-      config,
-      configPath
-    };
-  }
-  throw configNotFoundError(resolve2(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");
@@ -432,8 +540,8 @@ async function runValidate(options) {
     process.exit(2);
   }
 }
-function registerValidateCommand(program2) {
-  program2.command("validate").description("Validate schema files").option("-v, --verbose", "Show detailed output").action(async (options) => {
+function registerValidateCommand(program) {
+  program.command("validate").description("Validate schema files").option("-v, --verbose", "Show detailed output").action(async (options) => {
     try {
       await runValidate(options);
     } catch (error) {
@@ -536,8 +644,8 @@ async function runDiff(options) {
   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) => {
+function registerDiffCommand(program) {
+  program.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) {
@@ -556,9 +664,101 @@ function registerDiffCommand(program2) {
 // src/commands/generate.ts
 import { existsSync as existsSync3, mkdirSync as mkdirSync2, writeFileSync as writeFileSync2 } from "fs";
 import { resolve as resolve5, dirname as dirname4 } from "path";
-import { loadSchemas as loadSchemas3, validateSchemas as validateSchemas3, OmnifyError as OmnifyError4 } from "@famgia/omnify-core";
-import { updateLockFile } from "@famgia/omnify-atlas";
+import {
+  loadSchemas as loadSchemas3,
+  validateSchemas as validateSchemas3,
+  OmnifyError as OmnifyError4,
+  PluginManager
+} from "@famgia/omnify-core";
+import {
+  writeLockFile,
+  readLockFile,
+  updateLockFile,
+  buildSchemaHashes
+} from "@famgia/omnify-atlas";
 import { generateMigrations, generateTypeScript } from "@famgia/omnify-laravel";
+function hasPluginGenerators(plugins) {
+  return plugins.some((p) => p.generators && p.generators.length > 0);
+}
+function writeGeneratorOutputs(outputs, rootDir) {
+  const counts = { migrations: 0, types: 0, other: 0 };
+  for (const output of outputs) {
+    const filePath = resolve5(rootDir, output.path);
+    const dir = dirname4(filePath);
+    if (!existsSync3(dir)) {
+      mkdirSync2(dir, { recursive: true });
+      logger.debug(`Created directory: ${dir}`);
+    }
+    writeFileSync2(filePath, output.content);
+    logger.debug(`Created: ${output.path}`);
+    if (output.type === "migration") counts.migrations++;
+    else if (output.type === "type") counts.types++;
+    else counts.other++;
+  }
+  return counts;
+}
+async function runPluginGeneration(plugins, schemas, rootDir, verbose) {
+  const pluginManager = new PluginManager({
+    cwd: rootDir,
+    verbose,
+    logger: {
+      debug: (msg) => logger.debug(msg),
+      info: (msg) => logger.info(msg),
+      warn: (msg) => logger.warn(msg),
+      error: (msg) => logger.error(msg)
+    }
+  });
+  for (const plugin of plugins) {
+    await pluginManager.register(plugin);
+  }
+  const result = await pluginManager.runGenerators(schemas);
+  if (!result.success) {
+    for (const error of result.errors) {
+      logger.error(`Generator ${error.generatorName} failed: ${error.message}`);
+    }
+    throw new Error("Generator execution failed");
+  }
+  return writeGeneratorOutputs(result.outputs, rootDir);
+}
+function runDirectGeneration(schemas, config, rootDir, options) {
+  let migrationsGenerated = 0;
+  let typesGenerated = 0;
+  if (!options.typesOnly && config.output.laravel) {
+    logger.step("Generating Laravel migrations...");
+    const migrationsDir = resolve5(rootDir, config.output.laravel.migrationsPath);
+    if (!existsSync3(migrationsDir)) {
+      mkdirSync2(migrationsDir, { recursive: true });
+      logger.debug(`Created directory: ${migrationsDir}`);
+    }
+    const migrations = generateMigrations(schemas);
+    for (const migration of migrations) {
+      const filePath = resolve5(migrationsDir, migration.fileName);
+      writeFileSync2(filePath, migration.content);
+      logger.debug(`Created: ${migration.fileName}`);
+      migrationsGenerated++;
+    }
+    logger.success(`Generated ${migrationsGenerated} migration(s)`);
+  }
+  if (!options.migrationsOnly && config.output.typescript) {
+    logger.step("Generating TypeScript types...");
+    const typesDir = resolve5(rootDir, config.output.typescript.path);
+    if (!existsSync3(typesDir)) {
+      mkdirSync2(typesDir, { recursive: true });
+      logger.debug(`Created directory: ${typesDir}`);
+    }
+    const typeFiles = generateTypeScript(schemas, {
+      singleFile: config.output.typescript.singleFile
+    });
+    for (const file of typeFiles) {
+      const filePath = resolve5(typesDir, file.fileName);
+      writeFileSync2(filePath, file.content);
+      logger.debug(`Created: ${file.fileName}`);
+      typesGenerated++;
+    }
+    logger.success(`Generated ${typesGenerated} TypeScript file(s)`);
+  }
+  return { migrations: migrationsGenerated, types: typesGenerated };
+}
 async function runGenerate(options) {
   logger.setVerbose(options.verbose ?? false);
   logger.header("Generating Outputs");
@@ -601,54 +801,48 @@ async function runGenerate(options) {
   }
   let migrationsGenerated = 0;
   let typesGenerated = 0;
-  if (!options.typesOnly) {
-    logger.step("Generating Laravel migrations...");
-    const migrationsDir = resolve5(rootDir, config.output.laravel.migrationsPath);
-    if (!existsSync3(migrationsDir)) {
-      mkdirSync2(migrationsDir, { recursive: true });
-      logger.debug(`Created directory: ${migrationsDir}`);
+  const usePlugins = hasPluginGenerators(config.plugins);
+  if (usePlugins) {
+    logger.step("Running plugin generators...");
+    const counts = await runPluginGeneration(
+      config.plugins,
+      schemas,
+      rootDir,
+      options.verbose ?? false
+    );
+    migrationsGenerated = counts.migrations;
+    typesGenerated = counts.types;
+    if (counts.migrations > 0) {
+      logger.success(`Generated ${counts.migrations} migration(s)`);
     }
-    const migrations = generateMigrations(schemas);
-    for (const migration of migrations) {
-      const filePath = resolve5(migrationsDir, migration.fileName);
-      writeFileSync2(filePath, migration.content);
-      logger.debug(`Created: ${migration.fileName}`);
-      migrationsGenerated++;
+    if (counts.types > 0) {
+      logger.success(`Generated ${counts.types} TypeScript file(s)`);
     }
-    logger.success(`Generated ${migrationsGenerated} migration(s)`);
-  }
-  if (!options.migrationsOnly) {
-    logger.step("Generating TypeScript types...");
-    const typesDir = resolve5(rootDir, config.output.typescript.path);
-    if (!existsSync3(typesDir)) {
-      mkdirSync2(typesDir, { recursive: true });
-      logger.debug(`Created directory: ${typesDir}`);
+    if (counts.other > 0) {
+      logger.success(`Generated ${counts.other} other file(s)`);
     }
-    const typeFiles = generateTypeScript(schemas, {
-      singleFile: config.output.typescript.singleFile
-    });
-    for (const file of typeFiles) {
-      const filePath = resolve5(typesDir, file.fileName);
-      writeFileSync2(filePath, file.content);
-      logger.debug(`Created: ${file.fileName}`);
-      typesGenerated++;
-    }
-    logger.success(`Generated ${typesGenerated} TypeScript file(s)`);
+  } else {
+    const counts = runDirectGeneration(schemas, config, rootDir, options);
+    migrationsGenerated = counts.migrations;
+    typesGenerated = counts.types;
   }
   logger.step("Updating lock file...");
-  await updateLockFile(lockPath, schemas);
+  const existingLock = await readLockFile(lockPath);
+  const schemaHashes = await buildSchemaHashes(schemas);
+  const newLockFile = updateLockFile(existingLock, schemaHashes, config.database.driver);
+  await writeLockFile(lockPath, newLockFile);
   logger.debug(`Updated: ${config.lockFilePath}`);
   logger.newline();
   logger.success("Generation complete!");
-  if (migrationsGenerated > 0) {
+  if (migrationsGenerated > 0 && config.output.laravel) {
     logger.info(`  Migrations: ${config.output.laravel.migrationsPath}/`);
   }
-  if (typesGenerated > 0) {
+  if (typesGenerated > 0 && config.output.typescript) {
     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) => {
+function registerGenerateCommand(program) {
+  program.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) {
@@ -663,38 +857,14 @@ function registerGenerateCommand(program2) {
     }
   });
 }
-
-// src/index.ts
-var VERSION = "0.0.1";
-var program = new 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 OmnifyError5) {
-    logger.formatError(error);
-    process.exit(logger.getExitCode(error));
-  } else {
-    logger.error(error.message);
-    process.exit(1);
-  }
-});
-process.on("unhandledRejection", (reason) => {
-  if (reason instanceof OmnifyError5) {
-    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();
 export {
   defineConfig,
-  loadConfig
+  loadConfig,
+  logger,
+  registerDiffCommand,
+  registerGenerateCommand,
+  registerInitCommand,
+  registerValidateCommand,
+  runInit
 };
 //# sourceMappingURL=index.js.map