@xubylele/schema-forge 1.4.0 → 1.5.0

package/dist/cli.js

@@ -29,7 +29,7 @@ var import_commander6 = require("commander");
 // package.json
 var package_default = {
   name: "@xubylele/schema-forge",
-  version: "1.4.0",
+  version: "1.5.0",
   description: "Universal migration generator from schema DSL",
   main: "dist/cli.js",
   type: "commonjs",
@@ -69,6 +69,7 @@ var package_default = {
     node: ">=18.0.0"
   },
   dependencies: {
+    "@xubylele/schema-forge-core": "^1.0.4",
     boxen: "^8.0.1",
     chalk: "^5.6.2",
     commander: "^14.0.3"
@@ -85,375 +86,7 @@ var package_default = {
 
 // src/commands/diff.ts
 var import_commander = require("commander");
-var import_path4 = __toESM(require("path"));
-
-// src/core/normalize.ts
-function normalizeIdent(input) {
-  return input.trim().toLowerCase().replace(/[^a-z0-9]+/g, "_").replace(/_+/g, "_").replace(/^_+|_+$/g, "");
-}
-function pkName(table) {
-  return `pk_${normalizeIdent(table)}`;
-}
-function uqName(table, column) {
-  return `uq_${normalizeIdent(table)}_${normalizeIdent(column)}`;
-}
-function legacyPkName(table) {
-  return `${normalizeIdent(table)}_pkey`;
-}
-function legacyUqName(table, column) {
-  return `${normalizeIdent(table)}_${normalizeIdent(column)}_key`;
-}
-function normalizeSpacesOutsideQuotes(value) {
-  let result = "";
-  let inSingleQuote = false;
-  let inDoubleQuote = false;
-  let pendingSpace = false;
-  for (const char of value) {
-    if (char === "'" && !inDoubleQuote) {
-      if (pendingSpace && result.length > 0 && result[result.length - 1] !== " ") {
-        result += " ";
-      }
-      pendingSpace = false;
-      inSingleQuote = !inSingleQuote;
-      result += char;
-      continue;
-    }
-    if (char === '"' && !inSingleQuote) {
-      if (pendingSpace && result.length > 0 && result[result.length - 1] !== " ") {
-        result += " ";
-      }
-      pendingSpace = false;
-      inDoubleQuote = !inDoubleQuote;
-      result += char;
-      continue;
-    }
-    if (!inSingleQuote && !inDoubleQuote && /\s/.test(char)) {
-      pendingSpace = true;
-      continue;
-    }
-    if (pendingSpace && result.length > 0 && result[result.length - 1] !== " ") {
-      result += " ";
-    }
-    pendingSpace = false;
-    result += char;
-  }
-  return result.trim();
-}
-function normalizeKnownFunctionsOutsideQuotes(value) {
-  let result = "";
-  let inSingleQuote = false;
-  let inDoubleQuote = false;
-  let buffer = "";
-  function flushBuffer() {
-    if (!buffer) {
-      return;
-    }
-    result += buffer.replace(/\bnow\s*\(\s*\)/gi, "now()").replace(/\bgen_random_uuid\s*\(\s*\)/gi, "gen_random_uuid()");
-    buffer = "";
-  }
-  for (const char of value) {
-    if (char === "'" && !inDoubleQuote) {
-      flushBuffer();
-      inSingleQuote = !inSingleQuote;
-      result += char;
-      continue;
-    }
-    if (char === '"' && !inSingleQuote) {
-      flushBuffer();
-      inDoubleQuote = !inDoubleQuote;
-      result += char;
-      continue;
-    }
-    if (inSingleQuote || inDoubleQuote) {
-      result += char;
-      continue;
-    }
-    buffer += char;
-  }
-  flushBuffer();
-  return result;
-}
-function normalizePunctuationOutsideQuotes(value) {
-  let result = "";
-  let inSingleQuote = false;
-  let inDoubleQuote = false;
-  for (let index = 0; index < value.length; index++) {
-    const char = value[index];
-    if (char === "'" && !inDoubleQuote) {
-      inSingleQuote = !inSingleQuote;
-      result += char;
-      continue;
-    }
-    if (char === '"' && !inSingleQuote) {
-      inDoubleQuote = !inDoubleQuote;
-      result += char;
-      continue;
-    }
-    if (!inSingleQuote && !inDoubleQuote && (char === "(" || char === ")")) {
-      while (result.endsWith(" ")) {
-        result = result.slice(0, -1);
-      }
-      result += char;
-      let lookahead = index + 1;
-      while (lookahead < value.length && value[lookahead] === " ") {
-        lookahead++;
-      }
-      index = lookahead - 1;
-      continue;
-    }
-    if (!inSingleQuote && !inDoubleQuote && char === ",") {
-      while (result.endsWith(" ")) {
-        result = result.slice(0, -1);
-      }
-      result += ", ";
-      let lookahead = index + 1;
-      while (lookahead < value.length && value[lookahead] === " ") {
-        lookahead++;
-      }
-      index = lookahead - 1;
-      continue;
-    }
-    result += char;
-  }
-  return result;
-}
-function normalizeDefault(expr) {
-  if (expr === void 0 || expr === null) {
-    return null;
-  }
-  const trimmed = expr.trim();
-  if (trimmed.length === 0) {
-    return null;
-  }
-  const normalizedSpacing = normalizeSpacesOutsideQuotes(trimmed);
-  const normalizedPunctuation = normalizePunctuationOutsideQuotes(normalizedSpacing);
-  return normalizeKnownFunctionsOutsideQuotes(normalizedPunctuation);
-}
-
-// src/core/diff.ts
-function getTableNamesFromState(state) {
-  return new Set(Object.keys(state.tables));
-}
-function getTableNamesFromSchema(schema) {
-  return new Set(Object.keys(schema.tables));
-}
-function getColumnNamesFromState(stateColumns) {
-  return new Set(Object.keys(stateColumns));
-}
-function getColumnNamesFromSchema(dbColumns) {
-  return new Set(dbColumns.map((column) => column.name));
-}
-function getSortedNames(names) {
-  return Array.from(names).sort((a, b) => a.localeCompare(b));
-}
-function normalizeColumnType(type) {
-  return type.toLowerCase().trim().replace(/\s+/g, " ").replace(/\s*\(\s*/g, "(").replace(/\s*,\s*/g, ",").replace(/\s*\)\s*/g, ")");
-}
-function resolveStatePrimaryKey(table) {
-  return table.primaryKey ?? Object.entries(table.columns).find(([, column]) => column.primaryKey)?.[0] ?? null;
-}
-function resolveSchemaPrimaryKey(table) {
-  return table.primaryKey ?? table.columns.find((column) => column.primaryKey)?.name ?? null;
-}
-function normalizeNullable(nullable) {
-  return nullable ?? true;
-}
-function diffSchemas(oldState, newSchema) {
-  const operations = [];
-  const oldTableNames = getTableNamesFromState(oldState);
-  const newTableNames = getTableNamesFromSchema(newSchema);
-  const sortedNewTableNames = getSortedNames(newTableNames);
-  const sortedOldTableNames = getSortedNames(oldTableNames);
-  for (const tableName of sortedNewTableNames) {
-    if (!oldTableNames.has(tableName)) {
-      operations.push({
-        kind: "create_table",
-        table: newSchema.tables[tableName]
-      });
-    }
-  }
-  const commonTableNames = sortedNewTableNames.filter(
-    (tableName) => oldTableNames.has(tableName)
-  );
-  for (const tableName of commonTableNames) {
-    const newTable = newSchema.tables[tableName];
-    const oldTable = oldState.tables[tableName];
-    if (!newTable || !oldTable) {
-      continue;
-    }
-    for (const column of newTable.columns) {
-      const previousColumn = oldTable.columns[column.name];
-      if (!previousColumn) {
-        continue;
-      }
-      const previousType = normalizeColumnType(previousColumn.type);
-      const currentType = normalizeColumnType(column.type);
-      if (previousType !== currentType) {
-        operations.push({
-          kind: "column_type_changed",
-          tableName,
-          columnName: column.name,
-          fromType: previousColumn.type,
-          toType: column.type
-        });
-      }
-    }
-  }
-  for (const tableName of commonTableNames) {
-    const newTable = newSchema.tables[tableName];
-    const oldTable = oldState.tables[tableName];
-    if (!newTable || !oldTable) {
-      continue;
-    }
-    const previousPrimaryKey = resolveStatePrimaryKey(oldTable);
-    const currentPrimaryKey = resolveSchemaPrimaryKey(newTable);
-    if (previousPrimaryKey !== null && previousPrimaryKey !== currentPrimaryKey) {
-      operations.push({
-        kind: "drop_primary_key_constraint",
-        tableName
-      });
-    }
-  }
-  for (const tableName of commonTableNames) {
-    const newTable = newSchema.tables[tableName];
-    const oldTable = oldState.tables[tableName];
-    if (!newTable || !oldTable) {
-      continue;
-    }
-    for (const column of newTable.columns) {
-      const previousColumn = oldTable.columns[column.name];
-      if (!previousColumn) {
-        continue;
-      }
-      const previousUnique = previousColumn.unique ?? false;
-      const currentUnique = column.unique ?? false;
-      if (previousUnique !== currentUnique) {
-        operations.push({
-          kind: "column_unique_changed",
-          tableName,
-          columnName: column.name,
-          from: previousUnique,
-          to: currentUnique
-        });
-      }
-    }
-  }
-  for (const tableName of commonTableNames) {
-    const newTable = newSchema.tables[tableName];
-    const oldTable = oldState.tables[tableName];
-    if (!newTable || !oldTable) {
-      continue;
-    }
-    for (const column of newTable.columns) {
-      const previousColumn = oldTable.columns[column.name];
-      if (!previousColumn) {
-        continue;
-      }
-      const previousNullable = normalizeNullable(previousColumn.nullable);
-      const currentNullable = normalizeNullable(column.nullable);
-      if (previousNullable !== currentNullable) {
-        operations.push({
-          kind: "column_nullability_changed",
-          tableName,
-          columnName: column.name,
-          from: previousNullable,
-          to: currentNullable
-        });
-      }
-    }
-  }
-  for (const tableName of commonTableNames) {
-    const newTable = newSchema.tables[tableName];
-    const oldTable = oldState.tables[tableName];
-    if (!newTable || !oldTable) {
-      continue;
-    }
-    for (const column of newTable.columns) {
-      const previousColumn = oldTable.columns[column.name];
-      if (!previousColumn) {
-        continue;
-      }
-      const previousDefault = normalizeDefault(previousColumn.default);
-      const currentDefault = normalizeDefault(column.default);
-      if (previousDefault !== currentDefault) {
-        operations.push({
-          kind: "column_default_changed",
-          tableName,
-          columnName: column.name,
-          fromDefault: previousDefault,
-          toDefault: currentDefault
-        });
-      }
-    }
-  }
-  for (const tableName of commonTableNames) {
-    const newTable = newSchema.tables[tableName];
-    const oldTable = oldState.tables[tableName];
-    if (!newTable || !oldTable) {
-      continue;
-    }
-    const oldColumnNames = getColumnNamesFromState(oldTable.columns);
-    for (const column of newTable.columns) {
-      if (!oldColumnNames.has(column.name)) {
-        operations.push({
-          kind: "add_column",
-          tableName,
-          column
-        });
-      }
-    }
-  }
-  for (const tableName of commonTableNames) {
-    const newTable = newSchema.tables[tableName];
-    const oldTable = oldState.tables[tableName];
-    if (!newTable || !oldTable) {
-      continue;
-    }
-    const previousPrimaryKey = resolveStatePrimaryKey(oldTable);
-    const currentPrimaryKey = resolveSchemaPrimaryKey(newTable);
-    if (currentPrimaryKey !== null && previousPrimaryKey !== currentPrimaryKey) {
-      operations.push({
-        kind: "add_primary_key_constraint",
-        tableName,
-        columnName: currentPrimaryKey
-      });
-    }
-  }
-  for (const tableName of commonTableNames) {
-    const newTable = newSchema.tables[tableName];
-    const oldTable = oldState.tables[tableName];
-    if (!newTable || !oldTable) {
-      continue;
-    }
-    const newColumnNames = getColumnNamesFromSchema(newTable.columns);
-    for (const columnName of Object.keys(oldTable.columns)) {
-      if (!newColumnNames.has(columnName)) {
-        operations.push({
-          kind: "drop_column",
-          tableName,
-          columnName
-        });
-      }
-    }
-  }
-  for (const tableName of sortedOldTableNames) {
-    if (!newTableNames.has(tableName)) {
-      operations.push({
-        kind: "drop_table",
-        tableName
-      });
-    }
-  }
-  return { operations };
-}
-
-// src/core/errors.ts
-var SchemaValidationError = class extends Error {
-  constructor(message) {
-    super(message);
-    this.name = "SchemaValidationError";
-  }
-};
+var import_path3 = __toESM(require("path"));
 
 // src/core/fs.ts
 var import_fs = require("fs");
@@ -509,329 +142,6 @@ async function writeJsonFile(filePath, data) {
     throw new Error(`Failed to write JSON file ${filePath}: ${error2}`);
   }
 }
-async function findFiles(dirPath, pattern) {
-  const results = [];
-  try {
-    const items = await import_fs.promises.readdir(dirPath, { withFileTypes: true });
-    for (const item of items) {
-      const fullPath = import_path.default.join(dirPath, item.name);
-      if (item.isDirectory()) {
-        const subResults = await findFiles(fullPath, pattern);
-        results.push(...subResults);
-      } else if (item.isFile() && pattern.test(item.name)) {
-        results.push(fullPath);
-      }
-    }
-  } catch (error2) {
-    throw new Error(`Failed to find files in ${dirPath}: ${error2}`);
-  }
-  return results;
-}
-
-// src/utils/output.ts
-var import_boxen = __toESM(require("boxen"));
-var import_chalk = require("chalk");
-var isInteractive = Boolean(process.stdout?.isTTY);
-var colorsEnabled = isInteractive && process.env.FORCE_COLOR !== "0" && !("NO_COLOR" in process.env);
-var color = new import_chalk.Chalk({ level: colorsEnabled ? 3 : 0 });
-var theme = {
-  primary: color.cyanBright,
-  success: color.hex("#00FF88"),
-  warning: color.hex("#FFD166"),
-  error: color.hex("#EF476F"),
-  accent: color.magentaBright
-};
-function success(message) {
-  const text = theme.success(`[OK] ${message}`);
-  if (!isInteractive) {
-    console.log(text);
-    return;
-  }
-  try {
-    console.log(
-      (0, import_boxen.default)(text, {
-        padding: 1,
-        borderColor: "cyan",
-        borderStyle: "round"
-      })
-    );
-  } catch {
-    console.log(text);
-  }
-}
-function info(message) {
-  console.log(theme.primary(message));
-}
-function warning(message) {
-  console.warn(theme.warning(`[WARN] ${message}`));
-}
-function error(message) {
-  console.error(theme.error(`[ERROR] ${message}`));
-}
-
-// src/core/parser.ts
-var SchemaParser = class {
-  /**
-   * Parse a schema from a JSON file
-   */
-  async parseSchemaFile(filePath) {
-    try {
-      const schema = await readJsonFile(filePath, {});
-      return this.normalizeSchema(schema);
-    } catch (error2) {
-      throw new Error(`Failed to parse schema file ${filePath}: ${error2}`);
-    }
-  }
-  /**
-   * Parse multiple schema files from a directory
-   */
-  async parseSchemaDirectory(dirPath) {
-    const schemaFiles = await findFiles(dirPath, /\.schema\.json$/);
-    const schemas = [];
-    for (const file of schemaFiles) {
-      try {
-        const schema = await this.parseSchemaFile(file);
-        schemas.push(schema);
-      } catch (error2) {
-        const reason = error2 instanceof Error ? error2.message : String(error2);
-        warning(`Could not parse ${file}: ${reason}`);
-      }
-    }
-    return schemas;
-  }
-  /**
-   * Merge multiple schemas into one
-   */
-  mergeSchemas(schemas) {
-    if (schemas.length === 0) {
-      throw new Error("Cannot merge empty schema array");
-    }
-    const baseSchema = schemas[0];
-    const mergedTables = [];
-    for (const schema of schemas) {
-      for (const table of schema.tables) {
-        const existingIndex = mergedTables.findIndex((t) => t.name === table.name);
-        if (existingIndex >= 0) {
-          warning(`Duplicate table '${table.name}' found, using first occurrence`);
-        } else {
-          mergedTables.push(table);
-        }
-      }
-    }
-    return {
-      version: baseSchema.version,
-      database: baseSchema.database,
-      tables: mergedTables
-    };
-  }
-  /**
-   * Normalize schema to ensure consistent structure
-   */
-  normalizeSchema(schema) {
-    return {
-      version: schema.version || "1.0.0",
-      database: schema.database || "postgres",
-      tables: schema.tables.map((table) => ({
-        ...table,
-        fields: table.fields.map((field) => ({
-          ...field,
-          required: field.required ?? false,
-          unique: field.unique ?? false
-        })),
-        indexes: table.indexes || [],
-        constraints: table.constraints || []
-      }))
-    };
-  }
-  /**
-   * Convert schema to JSON string
-   */
-  schemaToJson(schema, pretty = true) {
-    return pretty ? JSON.stringify(schema, null, 2) : JSON.stringify(schema);
-  }
-  /**
-   * Parse schema from JSON string
-   */
-  parseSchemaString(jsonString) {
-    try {
-      const schema = JSON.parse(jsonString);
-      return this.normalizeSchema(schema);
-    } catch (error2) {
-      throw new Error(`Failed to parse schema JSON: ${error2}`);
-    }
-  }
-};
-var defaultParser = new SchemaParser();
-function parseSchema(source) {
-  const lines = source.split("\n");
-  const tables = {};
-  let currentLine = 0;
-  const validBaseColumnTypes = /* @__PURE__ */ new Set([
-    "uuid",
-    "varchar",
-    "text",
-    "int",
-    "bigint",
-    "boolean",
-    "timestamptz",
-    "date"
-  ]);
-  function normalizeColumnType3(type) {
-    return type.toLowerCase().trim().replace(/\s+/g, " ").replace(/\s*\(\s*/g, "(").replace(/\s*,\s*/g, ",").replace(/\s*\)\s*/g, ")");
-  }
-  function isValidColumnType2(type) {
-    const normalizedType = normalizeColumnType3(type);
-    if (validBaseColumnTypes.has(normalizedType)) {
-      return true;
-    }
-    return /^varchar\(\d+\)$/.test(normalizedType) || /^numeric\(\d+,\d+\)$/.test(normalizedType);
-  }
-  function cleanLine(line) {
-    const commentIndex = line.search(/(?:\/\/|#)/);
-    if (commentIndex !== -1) {
-      line = line.substring(0, commentIndex);
-    }
-    return line.trim();
-  }
-  function parseForeignKey(fkRef, lineNum) {
-    const parts = fkRef.split(".");
-    if (parts.length !== 2 || !parts[0] || !parts[1]) {
-      throw new Error(`Line ${lineNum}: Invalid foreign key format '${fkRef}'. Expected format: table.column`);
-    }
-    return {
-      table: parts[0],
-      column: parts[1]
-    };
-  }
-  function parseColumn(line, lineNum) {
-    const tokens = line.split(/\s+/).filter((t) => t.length > 0);
-    const modifiers = /* @__PURE__ */ new Set(["pk", "unique", "nullable", "default", "fk"]);
-    if (tokens.length < 2) {
-      throw new Error(`Line ${lineNum}: Invalid column definition. Expected: <name> <type> [modifiers...]`);
-    }
-    const colName = tokens[0];
-    const colType = normalizeColumnType3(tokens[1]);
-    if (!isValidColumnType2(colType)) {
-      throw new Error(
-        `Line ${lineNum}: Invalid column type '${tokens[1]}'. Valid types: ${Array.from(validBaseColumnTypes).join(", ")}, varchar(n), numeric(p,s)`
-      );
-    }
-    const column = {
-      name: colName,
-      type: colType,
-      nullable: true
-    };
-    let i = 2;
-    while (i < tokens.length) {
-      const modifier = tokens[i];
-      switch (modifier) {
-        case "pk":
-          column.primaryKey = true;
-          i++;
-          break;
-        case "unique":
-          column.unique = true;
-          i++;
-          break;
-        case "nullable":
-          column.nullable = true;
-          i++;
-          break;
-        case "not":
-          if (tokens[i + 1] !== "null") {
-            throw new Error(`Line ${lineNum}: Unknown modifier 'not'`);
-          }
-          column.nullable = false;
-          i += 2;
-          break;
-        case "default":
-          i++;
-          if (i >= tokens.length) {
-            throw new Error(`Line ${lineNum}: 'default' modifier requires a value`);
-          }
-          {
-            const defaultTokens = [];
-            while (i < tokens.length && !modifiers.has(tokens[i])) {
-              defaultTokens.push(tokens[i]);
-              i++;
-            }
-            if (defaultTokens.length === 0) {
-              throw new Error(`Line ${lineNum}: 'default' modifier requires a value`);
-            }
-            column.default = defaultTokens.join(" ");
-          }
-          break;
-        case "fk":
-          i++;
-          if (i >= tokens.length) {
-            throw new Error(`Line ${lineNum}: 'fk' modifier requires a table.column reference`);
-          }
-          column.foreignKey = parseForeignKey(tokens[i], lineNum);
-          i++;
-          break;
-        default:
-          throw new Error(`Line ${lineNum}: Unknown modifier '${modifier}'`);
-      }
-    }
-    return column;
-  }
-  function parseTableBlock(startLine) {
-    const firstLine = cleanLine(lines[startLine]);
-    const match = firstLine.match(/^table\s+(\w+)\s*\{?\s*$/);
-    if (!match) {
-      throw new Error(`Line ${startLine + 1}: Invalid table definition. Expected: table <name> {`);
-    }
-    const tableName = match[1];
-    if (tables[tableName]) {
-      throw new Error(`Line ${startLine + 1}: Duplicate table definition '${tableName}'`);
-    }
-    const columns = [];
-    let lineIdx = startLine + 1;
-    let foundClosingBrace = false;
-    while (lineIdx < lines.length) {
-      const cleaned = cleanLine(lines[lineIdx]);
-      if (!cleaned) {
-        lineIdx++;
-        continue;
-      }
-      if (cleaned === "}") {
-        foundClosingBrace = true;
-        break;
-      }
-      try {
-        const column = parseColumn(cleaned, lineIdx + 1);
-        columns.push(column);
-      } catch (error2) {
-        throw error2;
-      }
-      lineIdx++;
-    }
-    if (!foundClosingBrace) {
-      throw new Error(`Line ${startLine + 1}: Table '${tableName}' block not closed (missing '}')`);
-    }
-    const primaryKeyColumn = columns.find((column) => column.primaryKey)?.name ?? null;
-    tables[tableName] = {
-      name: tableName,
-      columns,
-      ...primaryKeyColumn !== null && { primaryKey: primaryKeyColumn }
-    };
-    return lineIdx;
-  }
-  while (currentLine < lines.length) {
-    const cleaned = cleanLine(lines[currentLine]);
-    if (!cleaned) {
-      currentLine++;
-      continue;
-    }
-    if (cleaned.startsWith("table ")) {
-      currentLine = parseTableBlock(currentLine);
-    } else {
-      throw new Error(`Line ${currentLine + 1}: Unexpected content '${cleaned}'. Expected table definition.`);
-    }
-    currentLine++;
-  }
-  return { tables };
-}
 
 // src/core/paths.ts
 var import_path2 = __toESM(require("path"));
@@ -856,568 +166,129 @@ function getStatePath(root, config) {
   return import_path2.default.join(schemaForgeDir, fileName);
 }
 
-// src/core/state-manager.ts
-var import_path3 = __toESM(require("path"));
-var StateManager = class {
-  constructor(root = process.cwd()) {
-    this.config = null;
-    this.root = root;
-  }
-  /**
-   * Initialize a new SchemaForge project
-   */
-  async initializeProject(directory = ".", force = false) {
-    const configPath = import_path3.default.join(directory, "schemaforge.config.json");
-    if (await fileExists(configPath) && !force) {
-      throw new Error("SchemaForge project already initialized. Use --force to overwrite.");
-    }
-    const defaultConfig = {
-      version: "1.0.0",
-      database: "postgres",
-      schemaDir: "schemas",
-      outputDir: "output",
-      migrationDir: "migrations"
-    };
-    await writeJsonFile(configPath, defaultConfig);
-    await ensureDir(import_path3.default.join(directory, defaultConfig.schemaDir));
-    await ensureDir(import_path3.default.join(directory, defaultConfig.outputDir));
-    await ensureDir(import_path3.default.join(directory, defaultConfig.migrationDir));
-    const exampleSchema = {
-      version: "1.0.0",
-      database: "postgres",
-      tables: [
-        {
-          name: "users",
-          fields: [
-            { name: "id", type: "uuid", required: true, unique: true },
-            { name: "email", type: "string", required: true, unique: true, length: 255 },
-            { name: "name", type: "string", required: true, length: 255 },
-            { name: "created_at", type: "datetime", required: true }
-          ],
-          indexes: [
-            { name: "idx_users_email", fields: ["email"], unique: true }
-          ]
-        }
-      ]
-    };
-    const exampleSchemaPath = import_path3.default.join(
-      directory,
-      defaultConfig.schemaDir,
-      "example.schema.json"
-    );
-    await writeJsonFile(exampleSchemaPath, exampleSchema);
-    this.config = defaultConfig;
-  }
-  /**
-   * Load configuration from file
-   */
-  async loadConfig(directory = ".") {
-    const configPath = import_path3.default.join(directory, "schemaforge.config.json");
-    if (!await fileExists(configPath)) {
-      throw new Error('SchemaForge project not initialized. Run "schemaforge init" first.');
-    }
-    this.config = await readJsonFile(configPath, {});
-    return this.config;
-  }
-  /**
-   * Save configuration to file
-   */
-  async saveConfig(config, directory = ".") {
-    const configPath = import_path3.default.join(directory, "schemaforge.config.json");
-    await writeJsonFile(configPath, config);
-    this.config = config;
-  }
-  /**
-   * Get current configuration
-   */
-  getConfig() {
-    return this.config;
-  }
-  /**
-   * Update configuration
-   */
-  updateConfig(updates) {
-    if (!this.config) {
-      throw new Error("No configuration loaded");
-    }
-    this.config = { ...this.config, ...updates };
+// src/core/provider.ts
+var DEFAULT_PROVIDER = "postgres";
+function resolveProvider(provider) {
+  if (!provider) {
+    return { provider: DEFAULT_PROVIDER, usedDefault: true };
   }
-  /**
-   * Check if project is initialized
-   */
-  async isInitialized(directory = ".") {
-    const configPath = import_path3.default.join(directory, "schemaforge.config.json");
-    return await fileExists(configPath);
-  }
-  /**
-   * Get schema directory path
-   */
-  getSchemaDir() {
-    if (!this.config) {
-      throw new Error("No configuration loaded");
-    }
-    return import_path3.default.join(this.root, this.config.schemaDir);
-  }
-  /**
-   * Get output directory path
-   */
-  getOutputDir() {
-    if (!this.config) {
-      throw new Error("No configuration loaded");
-    }
-    return import_path3.default.join(this.root, this.config.outputDir);
-  }
-  /**
-   * Get migration directory path
-   */
-  getMigrationDir() {
-    if (!this.config) {
-      throw new Error("No configuration loaded");
-    }
-    return import_path3.default.join(this.root, this.config.migrationDir);
-  }
-};
-async function schemaToState(schema) {
-  const tables = {};
-  for (const [tableName, table] of Object.entries(schema.tables)) {
-    const columns = {};
-    const primaryKeyColumn = table.primaryKey ?? table.columns.find((column) => column.primaryKey)?.name ?? null;
-    for (const column of table.columns) {
-      columns[column.name] = {
-        type: column.type,
-        ...column.primaryKey !== void 0 && { primaryKey: column.primaryKey },
-        ...column.unique !== void 0 && { unique: column.unique },
-        nullable: column.nullable ?? true,
-        ...column.default !== void 0 && { default: column.default },
-        ...column.foreignKey !== void 0 && { foreignKey: column.foreignKey }
-      };
-    }
-    tables[tableName] = {
-      columns,
-      ...primaryKeyColumn !== null && { primaryKey: primaryKeyColumn }
-    };
-  }
-  return {
-    version: 1,
-    tables
-  };
-}
-async function loadState(statePath) {
-  return await readJsonFile(statePath, { version: 1, tables: {} });
-}
-async function saveState(statePath, state) {
-  const dirPath = import_path3.default.dirname(statePath);
-  await ensureDir(dirPath);
-  await writeJsonFile(statePath, state);
+  return { provider, usedDefault: false };
 }
-var defaultStateManager = new StateManager();
 
-// src/core/validator.ts
-var SchemaValidator = class {
-  /**
-   * Validate a complete schema
-   */
-  validateSchema(schema) {
-    const errors = [];
-    if (!schema.version) {
-      errors.push({
-        path: "schema.version",
-        message: "Schema version is required",
-        severity: "error"
-      });
-    }
-    if (!schema.database) {
-      errors.push({
-        path: "schema.database",
-        message: "Database type is required",
-        severity: "error"
-      });
-    }
-    if (!schema.tables || schema.tables.length === 0) {
-      errors.push({
-        path: "schema.tables",
-        message: "Schema must contain at least one table",
-        severity: "error"
-      });
-    }
-    if (schema.tables) {
-      const tableNames = /* @__PURE__ */ new Set();
-      for (let i = 0; i < schema.tables.length; i++) {
-        const table = schema.tables[i];
-        const tableErrors = this.validateTable(table, i);
-        errors.push(...tableErrors);
-        if (tableNames.has(table.name)) {
-          errors.push({
-            path: `schema.tables[${i}].name`,
-            message: `Duplicate table name: ${table.name}`,
-            severity: "error"
-          });
-        }
-        tableNames.add(table.name);
-      }
-      errors.push(...this.validateReferences(schema));
-    }
-    return {
-      valid: errors.filter((e) => e.severity === "error").length === 0,
-      errors
-    };
-  }
-  /**
-   * Validate a table
-   */
-  validateTable(table, tableIndex) {
-    const errors = [];
-    const basePath = `schema.tables[${tableIndex}]`;
-    if (!table.name || table.name.trim() === "") {
-      errors.push({
-        path: `${basePath}.name`,
-        message: "Table name is required",
-        severity: "error"
-      });
-    }
-    if (table.name && !/^[a-zA-Z_][a-zA-Z0-9_]*$/.test(table.name)) {
-      errors.push({
-        path: `${basePath}.name`,
-        message: `Invalid table name '${table.name}': must start with letter or underscore and contain only alphanumeric characters and underscores`,
-        severity: "error"
-      });
-    }
-    if (!table.fields || table.fields.length === 0) {
-      errors.push({
-        path: `${basePath}.fields`,
-        message: `Table '${table.name}' must have at least one field`,
-        severity: "error"
-      });
-    }
-    if (table.fields) {
-      const fieldNames = /* @__PURE__ */ new Set();
-      for (let i = 0; i < table.fields.length; i++) {
-        const field = table.fields[i];
-        const fieldErrors = this.validateField(field, basePath, i);
-        errors.push(...fieldErrors);
-        if (fieldNames.has(field.name)) {
-          errors.push({
-            path: `${basePath}.fields[${i}].name`,
-            message: `Duplicate field name: ${field.name}`,
-            severity: "error"
-          });
-        }
-        fieldNames.add(field.name);
-      }
-    }
-    return errors;
-  }
-  /**
-   * Validate a field
-   */
-  validateField(field, tablePath, fieldIndex) {
-    const errors = [];
-    const basePath = `${tablePath}.fields[${fieldIndex}]`;
-    if (!field.name || field.name.trim() === "") {
-      errors.push({
-        path: `${basePath}.name`,
-        message: "Field name is required",
-        severity: "error"
-      });
-    }
-    if (field.name && !/^[a-zA-Z_][a-zA-Z0-9_]*$/.test(field.name)) {
-      errors.push({
-        path: `${basePath}.name`,
-        message: `Invalid field name '${field.name}': must start with letter or underscore and contain only alphanumeric characters and underscores`,
-        severity: "error"
-      });
-    }
-    if (!field.type) {
-      errors.push({
-        path: `${basePath}.type`,
-        message: "Field type is required",
-        severity: "error"
-      });
-    }
-    if (field.type === "enum") {
-      if (!field.enumValues || field.enumValues.length === 0) {
-        errors.push({
-          path: `${basePath}.enumValues`,
-          message: "Enum type requires enumValues array",
-          severity: "error"
-        });
-      }
-    }
-    if (field.type === "string" && field.length && field.length <= 0) {
-      errors.push({
-        path: `${basePath}.length`,
-        message: "String length must be greater than 0",
-        severity: "error"
-      });
-    }
-    return errors;
-  }
-  /**
-   * Validate foreign key references
-   */
-  validateReferences(schema) {
-    const errors = [];
-    const tableNames = new Set(schema.tables.map((t) => t.name));
-    for (let i = 0; i < schema.tables.length; i++) {
-      const table = schema.tables[i];
-      for (let j = 0; j < table.fields.length; j++) {
-        const field = table.fields[j];
-        if (field.references) {
-          const refTable = field.references.table;
-          const refField = field.references.field;
-          if (!tableNames.has(refTable)) {
-            errors.push({
-              path: `schema.tables[${i}].fields[${j}].references.table`,
-              message: `Referenced table '${refTable}' does not exist`,
-              severity: "error"
-            });
-          } else {
-            const referencedTable = schema.tables.find((t) => t.name === refTable);
-            if (referencedTable) {
-              const referencedField = referencedTable.fields.find((f) => f.name === refField);
-              if (!referencedField) {
-                errors.push({
-                  path: `schema.tables[${i}].fields[${j}].references.field`,
-                  message: `Referenced field '${refField}' does not exist in table '${refTable}'`,
-                  severity: "error"
-                });
-              }
-            }
-          }
-        }
-      }
-    }
-    return errors;
-  }
-};
-var defaultValidator = new SchemaValidator();
-var VALID_BASE_COLUMN_TYPES = [
-  "uuid",
-  "varchar",
-  "text",
-  "int",
-  "bigint",
-  "boolean",
-  "timestamptz",
-  "date"
-];
-function isValidColumnType(type) {
-  const normalizedType = type.toLowerCase().trim().replace(/\s+/g, " ").replace(/\s*\(\s*/g, "(").replace(/\s*,\s*/g, ",").replace(/\s*\)\s*/g, ")");
-  if (VALID_BASE_COLUMN_TYPES.includes(normalizedType)) {
-    return true;
-  }
-  return /^varchar\(\d+\)$/.test(normalizedType) || /^numeric\(\d+,\d+\)$/.test(normalizedType);
-}
-function validateSchema(schema) {
-  validateDuplicateTables(schema);
-  for (const tableName in schema.tables) {
-    const table = schema.tables[tableName];
-    validateTableColumns(tableName, table, schema.tables);
+// src/domain.ts
+var corePromise;
+async function loadCore() {
+  if (!corePromise) {
+    corePromise = import("@xubylele/schema-forge-core");
   }
+  return corePromise;
 }
-function validateDuplicateTables(schema) {
-  const tableNames = Object.keys(schema.tables);
-  const seen = /* @__PURE__ */ new Set();
-  for (const tableName of tableNames) {
-    if (seen.has(tableName)) {
-      throw new Error(`Duplicate table: '${tableName}'`);
-    }
-    seen.add(tableName);
-  }
+async function parseSchema(source) {
+  const core = await loadCore();
+  return core.parseSchema(source);
 }
-function validateTableColumns(tableName, table, allTables) {
-  const columnNames = /* @__PURE__ */ new Set();
-  const primaryKeyColumns = [];
-  for (const column of table.columns) {
-    if (columnNames.has(column.name)) {
-      throw new Error(`Table '${tableName}': duplicate column '${column.name}'`);
-    }
-    columnNames.add(column.name);
-    if (column.primaryKey) {
-      primaryKeyColumns.push(column.name);
-    }
-    if (!isValidColumnType(column.type)) {
-      throw new Error(
-        `Table '${tableName}', column '${column.name}': type '${column.type}' is not valid. Supported types: ${VALID_BASE_COLUMN_TYPES.join(", ")}, varchar(n), numeric(p,s)`
-      );
-    }
-    if (column.foreignKey) {
-      const fkTable = column.foreignKey.table;
-      const fkColumn = column.foreignKey.column;
-      if (!allTables[fkTable]) {
-        throw new Error(
-          `Table '${tableName}', column '${column.name}': referenced table '${fkTable}' does not exist`
-        );
-      }
-      const referencedTable = allTables[fkTable];
-      const columnExists = referencedTable.columns.some((col) => col.name === fkColumn);
-      if (!columnExists) {
-        throw new Error(
-          `Table '${tableName}', column '${column.name}': table '${fkTable}' does not have column '${fkColumn}'`
-        );
-      }
-    }
-  }
-  if (primaryKeyColumns.length > 1) {
-    throw new Error(`Table '${tableName}': can only have one primary key (found ${primaryKeyColumns.length})`);
-  }
-  const normalizedPrimaryKey = table.primaryKey ?? primaryKeyColumns[0] ?? null;
-  if (table.primaryKey && !columnNames.has(table.primaryKey)) {
-    throw new Error(
-      `Table '${tableName}': primary key column '${table.primaryKey}' does not exist`
-    );
-  }
-  if (table.primaryKey && primaryKeyColumns.length === 1 && primaryKeyColumns[0] !== table.primaryKey) {
-    throw new Error(
-      `Table '${tableName}': column-level primary key '${primaryKeyColumns[0]}' does not match table primary key '${table.primaryKey}'`
-    );
-  }
-  if (normalizedPrimaryKey) {
-    const pkMatches = table.columns.filter((column) => column.name === normalizedPrimaryKey);
-    if (pkMatches.length !== 1) {
-      throw new Error(
-        `Table '${tableName}': primary key column '${normalizedPrimaryKey}' is invalid`
-      );
-    }
-  }
+async function validateSchema(schema) {
+  const core = await loadCore();
+  core.validateSchema(schema);
 }
-
-// src/generator/sql-generator.ts
-function generateSql(diff, provider, sqlConfig) {
-  const statements = [];
-  for (const operation of diff.operations) {
-    const sql = generateOperation(operation, provider, sqlConfig);
-    if (sql) {
-      statements.push(sql);
-    }
-  }
-  return statements.join("\n\n");
+async function diffSchemas(previousState, currentSchema) {
+  const core = await loadCore();
+  return core.diffSchemas(previousState, currentSchema);
 }
-function generateOperation(operation, provider, sqlConfig) {
-  switch (operation.kind) {
-    case "create_table":
-      return generateCreateTable(operation.table, provider, sqlConfig);
-    case "drop_table":
-      return generateDropTable(operation.tableName);
-    case "column_type_changed":
-      return generateAlterColumnType(
-        operation.tableName,
-        operation.columnName,
-        operation.toType
-      );
-    case "column_nullability_changed":
-      return generateAlterColumnNullability(
-        operation.tableName,
-        operation.columnName,
-        operation.to
-      );
-    case "add_column":
-      return generateAddColumn(operation.tableName, operation.column, provider, sqlConfig);
-    case "column_default_changed":
-      return generateAlterColumnDefault(
-        operation.tableName,
-        operation.columnName,
-        operation.toDefault
-      );
-    case "drop_column":
-      return generateDropColumn(operation.tableName, operation.columnName);
-    case "column_unique_changed":
-      return operation.to ? generateAddUniqueConstraint(operation.tableName, operation.columnName) : generateDropUniqueConstraint(operation.tableName, operation.columnName);
-    case "drop_primary_key_constraint":
-      return generateDropPrimaryKeyConstraint(operation.tableName);
-    case "add_primary_key_constraint":
-      return generateAddPrimaryKeyConstraint(operation.tableName, operation.columnName);
-  }
+async function generateSql(diff, provider, config) {
+  const core = await loadCore();
+  return core.generateSql(diff, provider, config);
 }
-function generateCreateTable(table, provider, sqlConfig) {
-  const columnDefs = table.columns.map(
-    (col) => generateColumnDefinition(col, provider, sqlConfig)
-  );
-  const lines = ["CREATE TABLE " + table.name + " ("];
-  columnDefs.forEach((colDef, index) => {
-    const isLast = index === columnDefs.length - 1;
-    lines.push("  " + colDef + (isLast ? "" : ","));
-  });
-  lines.push(");");
-  return lines.join("\n");
+async function schemaToState(schema) {
+  const core = await loadCore();
+  return core.schemaToState(schema);
 }
-function generateColumnDefinition(column, provider, sqlConfig) {
-  const parts = [column.name, column.type];
-  if (column.foreignKey) {
-    parts.push(
-      `references ${column.foreignKey.table}(${column.foreignKey.column})`
-    );
-  }
-  if (column.primaryKey) {
-    parts.push("primary key");
-  }
-  if (column.unique) {
-    parts.push("unique");
-  }
-  if (column.nullable === false) {
-    parts.push("not null");
-  }
-  if (column.default !== void 0) {
-    parts.push("default " + column.default);
-  } else if (column.type === "uuid" && column.primaryKey && provider === "supabase") {
-    parts.push("default gen_random_uuid()");
-  }
-  return parts.join(" ");
+async function loadState(statePath) {
+  const core = await loadCore();
+  return core.loadState(statePath);
 }
-function generateDropTable(tableName) {
-  return `DROP TABLE ${tableName};`;
+async function saveState(statePath, state) {
+  const core = await loadCore();
+  return core.saveState(statePath, state);
 }
-function generateAddColumn(tableName, column, provider, sqlConfig) {
-  const colDef = generateColumnDefinition(column, provider, sqlConfig);
-  return `ALTER TABLE ${tableName} ADD COLUMN ${colDef};`;
+async function validateSchemaChanges(previousState, currentSchema) {
+  const core = await loadCore();
+  return core.validateSchemaChanges(previousState, currentSchema);
 }
-function generateDropColumn(tableName, columnName) {
-  return `ALTER TABLE ${tableName} DROP COLUMN ${columnName};`;
+async function toValidationReport(findings) {
+  const core = await loadCore();
+  return core.toValidationReport(findings);
 }
-function generateAlterColumnType(tableName, columnName, newType) {
-  return `ALTER TABLE ${tableName} ALTER COLUMN ${columnName} TYPE ${newType} USING ${columnName}::${newType};`;
+async function parseMigrationSql(sql) {
+  const core = await loadCore();
+  return core.parseMigrationSql(sql);
 }
-function generateAddUniqueConstraint(tableName, columnName) {
-  const deterministicConstraintName = uqName(tableName, columnName);
-  return `ALTER TABLE ${tableName} ADD CONSTRAINT ${deterministicConstraintName} UNIQUE (${columnName});`;
+async function applySqlOps(ops) {
+  const core = await loadCore();
+  return core.applySqlOps(ops);
 }
-function generateDropUniqueConstraint(tableName, columnName) {
-  const deterministicConstraintName = uqName(tableName, columnName);
-  const fallbackConstraintName = legacyUqName(tableName, columnName);
-  return generateDropConstraintStatements(tableName, [deterministicConstraintName, fallbackConstraintName]);
+async function schemaToDsl(schema) {
+  const core = await loadCore();
+  return core.schemaToDsl(schema);
 }
-function generateDropPrimaryKeyConstraint(tableName) {
-  const deterministicConstraintName = pkName(tableName);
-  const fallbackConstraintName = legacyPkName(tableName);
-  return generateDropConstraintStatements(tableName, [deterministicConstraintName, fallbackConstraintName]);
+async function loadMigrationSqlInput(inputPath) {
+  const core = await loadCore();
+  return core.loadMigrationSqlInput(inputPath);
 }
-function generateAddPrimaryKeyConstraint(tableName, columnName) {
-  const deterministicConstraintName = pkName(tableName);
-  return `ALTER TABLE ${tableName} ADD CONSTRAINT ${deterministicConstraintName} PRIMARY KEY (${columnName});`;
+async function createSchemaValidationError(message) {
+  const core = await loadCore();
+  return new core.SchemaValidationError(message);
 }
-function generateDropConstraintStatements(tableName, constraintNames) {
-  const uniqueConstraintNames = Array.from(new Set(constraintNames));
-  return uniqueConstraintNames.map(
-    (constraintName) => `ALTER TABLE ${tableName} DROP CONSTRAINT IF EXISTS ${constraintName};`
-  ).join("\n");
+async function isSchemaValidationError(error2) {
+  const core = await loadCore();
+  return error2 instanceof core.SchemaValidationError;
 }
-function generateAlterColumnDefault(tableName, columnName, newDefault) {
-  if (newDefault === null) {
-    return `ALTER TABLE ${tableName} ALTER COLUMN ${columnName} DROP DEFAULT;`;
+
+// src/utils/output.ts
+var import_boxen = __toESM(require("boxen"));
+var import_chalk = require("chalk");
+var isInteractive = Boolean(process.stdout?.isTTY);
+var colorsEnabled = isInteractive && process.env.FORCE_COLOR !== "0" && !("NO_COLOR" in process.env);
+var color = new import_chalk.Chalk({ level: colorsEnabled ? 3 : 0 });
+var theme = {
+  primary: color.cyanBright,
+  success: color.hex("#00FF88"),
+  warning: color.hex("#FFD166"),
+  error: color.hex("#EF476F"),
+  accent: color.magentaBright
+};
+function success(message) {
+  const text = theme.success(`[OK] ${message}`);
+  if (!isInteractive) {
+    console.log(text);
+    return;
   }
-  return `ALTER TABLE ${tableName} ALTER COLUMN ${columnName} SET DEFAULT ${newDefault};`;
-}
-function generateAlterColumnNullability(tableName, columnName, toNullable) {
-  if (toNullable) {
-    return `ALTER TABLE ${tableName} ALTER COLUMN ${columnName} DROP NOT NULL;`;
+  try {
+    console.log(
+      (0, import_boxen.default)(text, {
+        padding: 1,
+        borderColor: "cyan",
+        borderStyle: "round"
+      })
+    );
+  } catch {
+    console.log(text);
   }
-  return `ALTER TABLE ${tableName} ALTER COLUMN ${columnName} SET NOT NULL;`;
+}
+function info(message) {
+  console.log(theme.primary(message));
+}
+function warning(message) {
+  console.warn(theme.warning(`[WARN] ${message}`));
+}
+function error(message) {
+  console.error(theme.error(`[ERROR] ${message}`));
 }
 
 // src/commands/diff.ts
 var REQUIRED_CONFIG_FIELDS = ["schemaFile", "stateFile"];
 function resolveConfigPath(root, targetPath) {
-  return import_path4.default.isAbsolute(targetPath) ? targetPath : import_path4.default.join(root, targetPath);
+  return import_path3.default.isAbsolute(targetPath) ? targetPath : import_path3.default.join(root, targetPath);
 }
 async function runDiff() {
   const root = getProjectRoot();
@@ -1434,33 +305,30 @@ async function runDiff() {
   }
   const schemaPath = resolveConfigPath(root, config.schemaFile);
   const statePath = resolveConfigPath(root, config.stateFile);
-  if (config.provider && config.provider !== "postgres" && config.provider !== "supabase") {
-    throw new Error(`Unsupported provider '${config.provider}'.`);
-  }
-  const provider = config.provider ?? "postgres";
+  const { provider } = resolveProvider(config.provider);
   const schemaSource = await readTextFile(schemaPath);
-  const schema = parseSchema(schemaSource);
+  const schema = await parseSchema(schemaSource);
   try {
-    validateSchema(schema);
+    await validateSchema(schema);
   } catch (error2) {
     if (error2 instanceof Error) {
-      throw new SchemaValidationError(error2.message);
+      throw await createSchemaValidationError(error2.message);
     }
     throw error2;
   }
   const previousState = await loadState(statePath);
-  const diff = diffSchemas(previousState, schema);
+  const diff = await diffSchemas(previousState, schema);
   if (diff.operations.length === 0) {
     success("No changes detected");
     return;
   }
-  const sql = generateSql(diff, provider, config.sql);
+  const sql = await generateSql(diff, provider, config.sql);
   console.log(sql);
 }
 
 // src/commands/generate.ts
 var import_commander2 = require("commander");
-var import_path5 = __toESM(require("path"));
+var import_path4 = __toESM(require("path"));
 
 // src/core/utils.ts
 function nowTimestamp() {
@@ -1479,7 +347,7 @@ var REQUIRED_CONFIG_FIELDS2 = [
   "outputDir"
 ];
 function resolveConfigPath2(root, targetPath) {
-  return import_path5.default.isAbsolute(targetPath) ? targetPath : import_path5.default.join(root, targetPath);
+  return import_path4.default.isAbsolute(targetPath) ? targetPath : import_path4.default.join(root, targetPath);
 }
 async function runGenerate(options) {
   const root = getProjectRoot();
@@ -1497,36 +365,33 @@ async function runGenerate(options) {
   const schemaPath = resolveConfigPath2(root, config.schemaFile);
   const statePath = resolveConfigPath2(root, config.stateFile);
   const outputDir = resolveConfigPath2(root, config.outputDir);
-  if (config.provider && config.provider !== "postgres" && config.provider !== "supabase") {
-    throw new Error(`Unsupported provider '${config.provider}'.`);
-  }
-  const provider = config.provider ?? "postgres";
-  if (!config.provider) {
+  const { provider, usedDefault } = resolveProvider(config.provider);
+  if (usedDefault) {
     info("Provider not set; defaulting to postgres.");
   }
   info("Generating SQL...");
   const schemaSource = await readTextFile(schemaPath);
-  const schema = parseSchema(schemaSource);
+  const schema = await parseSchema(schemaSource);
   try {
-    validateSchema(schema);
+    await validateSchema(schema);
   } catch (error2) {
     if (error2 instanceof Error) {
-      throw new SchemaValidationError(error2.message);
+      throw await createSchemaValidationError(error2.message);
     }
     throw error2;
   }
   const previousState = await loadState(statePath);
-  const diff = diffSchemas(previousState, schema);
+  const diff = await diffSchemas(previousState, schema);
   if (diff.operations.length === 0) {
     info("No changes detected");
     return;
   }
-  const sql = generateSql(diff, provider, config.sql);
+  const sql = await generateSql(diff, provider, config.sql);
   const timestamp = nowTimestamp();
   const slug = slugifyName(options.name ?? "migration");
   const fileName = `${timestamp}-${slug}.sql`;
   await ensureDir(outputDir);
-  const migrationPath = import_path5.default.join(outputDir, fileName);
+  const migrationPath = import_path4.default.join(outputDir, fileName);
   await writeTextFile(migrationPath, sql + "\n");
   const nextState = await schemaToState(schema);
   await saveState(statePath, nextState);
@@ -1535,840 +400,9 @@ async function runGenerate(options) {
 
 // src/commands/import.ts
 var import_commander3 = require("commander");
-var import_path7 = __toESM(require("path"));
-
-// src/core/sql/apply-ops.ts
-function toSchemaColumn(column) {
-  return {
-    name: column.name,
-    type: column.type,
-    nullable: column.nullable,
-    ...column.default !== void 0 ? { default: column.default } : {},
-    ...column.unique !== void 0 ? { unique: column.unique } : {},
-    ...column.primaryKey !== void 0 ? { primaryKey: column.primaryKey } : {}
-  };
-}
-function applySingleColumnConstraint(table, constraint) {
-  if (constraint.columns.length !== 1) {
-    return false;
-  }
-  const targetColumn = table.columns.find((column) => column.name === constraint.columns[0]);
-  if (!targetColumn) {
-    return false;
-  }
-  if (constraint.type === "PRIMARY_KEY") {
-    table.primaryKey = targetColumn.name;
-    targetColumn.primaryKey = true;
-    targetColumn.nullable = false;
-    return true;
-  }
-  targetColumn.unique = true;
-  return true;
-}
-function clearConstraintByName(table, name) {
-  if (name.endsWith("_pkey") || name.startsWith("pk_")) {
-    if (table.primaryKey) {
-      const pkColumn = table.columns.find((column) => column.name === table.primaryKey);
-      if (pkColumn) {
-        pkColumn.primaryKey = false;
-      }
-      table.primaryKey = null;
-    }
-    return;
-  }
-  if (name.endsWith("_key") || name.startsWith("uq_")) {
-    for (const column of table.columns) {
-      if (column.unique) {
-        column.unique = false;
-      }
-    }
-  }
-}
-function getOrCreateTable(tables, name) {
-  if (!tables[name]) {
-    tables[name] = { name, columns: [] };
-  }
-  return tables[name];
-}
-function applySqlOps(ops) {
-  const tables = {};
-  const warnings = [];
-  for (const op of ops) {
-    switch (op.kind) {
-      case "CREATE_TABLE": {
-        const table = {
-          name: op.table,
-          columns: op.columns.map(toSchemaColumn)
-        };
-        for (const column of table.columns) {
-          if (column.primaryKey) {
-            table.primaryKey = column.name;
-          }
-        }
-        for (const constraint of op.constraints) {
-          const applied = applySingleColumnConstraint(table, constraint);
-          if (!applied) {
-            warnings.push({
-              statement: `CREATE TABLE ${op.table}`,
-              reason: `Constraint ${constraint.type}${constraint.name ? ` (${constraint.name})` : ""} is unsupported for schema reconstruction`
-            });
-          }
-        }
-        tables[op.table] = table;
-        break;
-      }
-      case "ADD_COLUMN": {
-        const table = getOrCreateTable(tables, op.table);
-        table.columns = table.columns.filter((column) => column.name !== op.column.name);
-        table.columns.push(toSchemaColumn(op.column));
-        if (op.column.primaryKey) {
-          table.primaryKey = op.column.name;
-        }
-        break;
-      }
-      case "ALTER_COLUMN_TYPE": {
-        const table = tables[op.table];
-        if (!table) {
-          break;
-        }
-        const column = table.columns.find((item) => item.name === op.column);
-        if (column) {
-          column.type = op.toType;
-        }
-        break;
-      }
-      case "SET_NOT_NULL": {
-        const table = tables[op.table];
-        const column = table?.columns.find((item) => item.name === op.column);
-        if (column) {
-          column.nullable = false;
-        }
-        break;
-      }
-      case "DROP_NOT_NULL": {
-        const table = tables[op.table];
-        const column = table?.columns.find((item) => item.name === op.column);
-        if (column) {
-          column.nullable = true;
-        }
-        break;
-      }
-      case "SET_DEFAULT": {
-        const table = tables[op.table];
-        const column = table?.columns.find((item) => item.name === op.column);
-        if (column) {
-          column.default = op.expr;
-        }
-        break;
-      }
-      case "DROP_DEFAULT": {
-        const table = tables[op.table];
-        const column = table?.columns.find((item) => item.name === op.column);
-        if (column) {
-          column.default = null;
-        }
-        break;
-      }
-      case "ADD_CONSTRAINT": {
-        const table = tables[op.table];
-        if (!table) {
-          break;
-        }
-        const applied = applySingleColumnConstraint(table, op.constraint);
-        if (!applied) {
-          warnings.push({
-            statement: `ALTER TABLE ${op.table} ADD CONSTRAINT ${op.constraint.name ?? "<unnamed>"}`,
-            reason: `Constraint ${op.constraint.type} is unsupported for schema reconstruction`
-          });
-        }
-        break;
-      }
-      case "DROP_CONSTRAINT": {
-        const table = tables[op.table];
-        if (!table) {
-          break;
-        }
-        clearConstraintByName(table, op.name);
-        break;
-      }
-      case "DROP_COLUMN": {
-        const table = tables[op.table];
-        if (!table) {
-          break;
-        }
-        table.columns = table.columns.filter((column) => column.name !== op.column);
-        if (table.primaryKey === op.column) {
-          table.primaryKey = null;
-        }
-        break;
-      }
-      case "DROP_TABLE": {
-        delete tables[op.table];
-        break;
-      }
-    }
-  }
-  const schema = { tables };
-  return { schema, warnings };
-}
-
-// src/core/sql/load-migrations.ts
-var import_fs6 = require("fs");
-var import_path6 = __toESM(require("path"));
-async function loadMigrationSqlInput(inputPath) {
-  const stats = await import_fs6.promises.stat(inputPath);
-  if (stats.isFile()) {
-    if (!inputPath.toLowerCase().endsWith(".sql")) {
-      throw new Error(`Input file must be a .sql file: ${inputPath}`);
-    }
-    return [{ filePath: inputPath, sql: await readTextFile(inputPath) }];
-  }
-  if (!stats.isDirectory()) {
-    throw new Error(`Input path must be a .sql file or directory: ${inputPath}`);
-  }
-  const sqlFiles = await findFiles(inputPath, /\.sql$/i);
-  sqlFiles.sort((left, right) => import_path6.default.basename(left).localeCompare(import_path6.default.basename(right)));
-  const result = [];
-  for (const filePath of sqlFiles) {
-    result.push({
-      filePath,
-      sql: await readTextFile(filePath)
-    });
-  }
-  return result;
-}
-
-// src/core/sql/split-statements.ts
-function splitSqlStatements(sql) {
-  const statements = [];
-  let current = "";
-  let inSingleQuote = false;
-  let inDoubleQuote = false;
-  let inLineComment = false;
-  let inBlockComment = false;
-  let dollarTag = null;
-  let index = 0;
-  while (index < sql.length) {
-    const char = sql[index];
-    const next = index + 1 < sql.length ? sql[index + 1] : "";
-    if (inLineComment) {
-      current += char;
-      if (char === "\n") {
-        inLineComment = false;
-      }
-      index++;
-      continue;
-    }
-    if (inBlockComment) {
-      current += char;
-      if (char === "*" && next === "/") {
-        current += next;
-        inBlockComment = false;
-        index += 2;
-        continue;
-      }
-      index++;
-      continue;
-    }
-    if (!inSingleQuote && !inDoubleQuote && dollarTag === null) {
-      if (char === "-" && next === "-") {
-        current += char + next;
-        inLineComment = true;
-        index += 2;
-        continue;
-      }
-      if (char === "/" && next === "*") {
-        current += char + next;
-        inBlockComment = true;
-        index += 2;
-        continue;
-      }
-    }
-    if (!inDoubleQuote && dollarTag === null && char === "'") {
-      current += char;
-      if (inSingleQuote && next === "'") {
-        current += next;
-        index += 2;
-        continue;
-      }
-      inSingleQuote = !inSingleQuote;
-      index++;
-      continue;
-    }
-    if (!inSingleQuote && dollarTag === null && char === '"') {
-      current += char;
-      if (inDoubleQuote && next === '"') {
-        current += next;
-        index += 2;
-        continue;
-      }
-      inDoubleQuote = !inDoubleQuote;
-      index++;
-      continue;
-    }
-    if (!inSingleQuote && !inDoubleQuote) {
-      if (dollarTag === null && char === "$") {
-        const remainder = sql.slice(index);
-        const match = remainder.match(/^\$[a-zA-Z_][a-zA-Z0-9_]*\$|^\$\$/);
-        if (match) {
-          dollarTag = match[0];
-          current += match[0];
-          index += match[0].length;
-          continue;
-        }
-      }
-      if (dollarTag !== null && sql.startsWith(dollarTag, index)) {
-        current += dollarTag;
-        index += dollarTag.length;
-        dollarTag = null;
-        continue;
-      }
-    }
-    if (!inSingleQuote && !inDoubleQuote && dollarTag === null && char === ";") {
-      const statement = current.trim();
-      if (statement.length > 0) {
-        statements.push(statement);
-      }
-      current = "";
-      index++;
-      continue;
-    }
-    current += char;
-    index++;
-  }
-  const tail = current.trim();
-  if (tail.length > 0) {
-    statements.push(tail);
-  }
-  return statements;
-}
-
-// src/core/sql/parse-migration.ts
-var COLUMN_CONSTRAINT_KEYWORDS = /* @__PURE__ */ new Set([
-  "primary",
-  "unique",
-  "not",
-  "null",
-  "default",
-  "constraint",
-  "references",
-  "check"
-]);
-function normalizeSqlType(type) {
-  return type.trim().toLowerCase().replace(/\s+/g, " ").replace(/\s*\(\s*/g, "(").replace(/\s*,\s*/g, ",").replace(/\s*\)\s*/g, ")");
-}
-function unquoteIdentifier(value) {
-  const trimmed = value.trim();
-  if (trimmed.startsWith('"') && trimmed.endsWith('"') && trimmed.length >= 2) {
-    return trimmed.slice(1, -1).replace(/""/g, '"');
-  }
-  return trimmed;
-}
-function normalizeIdentifier(identifier) {
-  const parts = identifier.trim().split(".").map((part) => unquoteIdentifier(part)).filter((part) => part.length > 0);
-  const leaf = parts.length > 0 ? parts[parts.length - 1] : identifier.trim();
-  return leaf.toLowerCase();
-}
-function removeSqlComments(statement) {
-  let result = "";
-  let inSingleQuote = false;
-  let inDoubleQuote = false;
-  let inLineComment = false;
-  let inBlockComment = false;
-  for (let index = 0; index < statement.length; index++) {
-    const char = statement[index];
-    const next = index + 1 < statement.length ? statement[index + 1] : "";
-    if (inLineComment) {
-      if (char === "\n") {
-        inLineComment = false;
-        result += char;
-      }
-      continue;
-    }
-    if (inBlockComment) {
-      if (char === "*" && next === "/") {
-        inBlockComment = false;
-        index++;
-      }
-      continue;
-    }
-    if (!inSingleQuote && !inDoubleQuote) {
-      if (char === "-" && next === "-") {
-        inLineComment = true;
-        index++;
-        continue;
-      }
-      if (char === "/" && next === "*") {
-        inBlockComment = true;
-        index++;
-        continue;
-      }
-    }
-    if (char === "'" && !inDoubleQuote) {
-      if (inSingleQuote && next === "'") {
-        result += "''";
-        index++;
-        continue;
-      }
-      inSingleQuote = !inSingleQuote;
-      result += char;
-      continue;
-    }
-    if (char === '"' && !inSingleQuote) {
-      if (inDoubleQuote && next === '"') {
-        result += '""';
-        index++;
-        continue;
-      }
-      inDoubleQuote = !inDoubleQuote;
-      result += char;
-      continue;
-    }
-    result += char;
-  }
-  return result.trim();
-}
-function splitTopLevelComma(input) {
-  const parts = [];
-  let current = "";
-  let depth = 0;
-  let inSingleQuote = false;
-  let inDoubleQuote = false;
-  for (let index = 0; index < input.length; index++) {
-    const char = input[index];
-    const next = index + 1 < input.length ? input[index + 1] : "";
-    if (char === "'" && !inDoubleQuote) {
-      current += char;
-      if (inSingleQuote && next === "'") {
-        current += next;
-        index++;
-        continue;
-      }
-      inSingleQuote = !inSingleQuote;
-      continue;
-    }
-    if (char === '"' && !inSingleQuote) {
-      current += char;
-      if (inDoubleQuote && next === '"') {
-        current += next;
-        index++;
-        continue;
-      }
-      inDoubleQuote = !inDoubleQuote;
-      continue;
-    }
-    if (!inSingleQuote && !inDoubleQuote) {
-      if (char === "(") {
-        depth++;
-      } else if (char === ")") {
-        depth = Math.max(0, depth - 1);
-      } else if (char === "," && depth === 0) {
-        const segment = current.trim();
-        if (segment.length > 0) {
-          parts.push(segment);
-        }
-        current = "";
-        continue;
-      }
-    }
-    current += char;
-  }
-  const tail = current.trim();
-  if (tail.length > 0) {
-    parts.push(tail);
-  }
-  return parts;
-}
-function tokenize(segment) {
-  const tokens = [];
-  let current = "";
-  let depth = 0;
-  let inSingleQuote = false;
-  let inDoubleQuote = false;
-  for (let index = 0; index < segment.length; index++) {
-    const char = segment[index];
-    const next = index + 1 < segment.length ? segment[index + 1] : "";
-    if (char === "'" && !inDoubleQuote) {
-      current += char;
-      if (inSingleQuote && next === "'") {
-        current += next;
-        index++;
-        continue;
-      }
-      inSingleQuote = !inSingleQuote;
-      continue;
-    }
-    if (char === '"' && !inSingleQuote) {
-      current += char;
-      if (inDoubleQuote && next === '"') {
-        current += next;
-        index++;
-        continue;
-      }
-      inDoubleQuote = !inDoubleQuote;
-      continue;
-    }
-    if (!inSingleQuote && !inDoubleQuote) {
-      if (char === "(") {
-        depth++;
-      } else if (char === ")") {
-        depth = Math.max(0, depth - 1);
-      }
-      if (/\s/.test(char) && depth === 0) {
-        if (current.length > 0) {
-          tokens.push(current);
-          current = "";
-        }
-        continue;
-      }
-    }
-    current += char;
-  }
-  if (current.length > 0) {
-    tokens.push(current);
-  }
-  return tokens;
-}
-function parseColumnDefinition(segment) {
-  const tokens = tokenize(segment);
-  if (tokens.length < 2) {
-    return null;
-  }
-  const name = normalizeIdentifier(tokens[0]);
-  let cursor = 1;
-  const typeTokens = [];
-  while (cursor < tokens.length) {
-    const lower = tokens[cursor].toLowerCase();
-    if (COLUMN_CONSTRAINT_KEYWORDS.has(lower)) {
-      break;
-    }
-    typeTokens.push(tokens[cursor]);
-    cursor++;
-  }
-  if (typeTokens.length === 0) {
-    return null;
-  }
-  const parsed = {
-    name,
-    type: normalizeSqlType(typeTokens.join(" ")),
-    nullable: true
-  };
-  while (cursor < tokens.length) {
-    const lower = tokens[cursor].toLowerCase();
-    if (lower === "primary" && tokens[cursor + 1]?.toLowerCase() === "key") {
-      parsed.primaryKey = true;
-      parsed.nullable = false;
-      cursor += 2;
-      continue;
-    }
-    if (lower === "unique") {
-      parsed.unique = true;
-      cursor++;
-      continue;
-    }
-    if (lower === "not" && tokens[cursor + 1]?.toLowerCase() === "null") {
-      parsed.nullable = false;
-      cursor += 2;
-      continue;
-    }
-    if (lower === "null") {
-      parsed.nullable = true;
-      cursor++;
-      continue;
-    }
-    if (lower === "default") {
-      cursor++;
-      const defaultTokens = [];
-      while (cursor < tokens.length) {
-        const probe = tokens[cursor].toLowerCase();
-        if (probe === "constraint" || probe === "references" || probe === "check" || probe === "not" && tokens[cursor + 1]?.toLowerCase() === "null" || probe === "null" || probe === "unique" || probe === "primary" && tokens[cursor + 1]?.toLowerCase() === "key") {
-          break;
-        }
-        defaultTokens.push(tokens[cursor]);
-        cursor++;
-      }
-      parsed.default = normalizeDefault(defaultTokens.join(" "));
-      continue;
-    }
-    cursor++;
-  }
-  return parsed;
-}
-function parseCreateTableConstraint(segment) {
-  const normalized = segment.trim().replace(/\s+/g, " ");
-  const constraintMatch = normalized.match(/^constraint\s+([^\s]+)\s+(primary\s+key|unique)\s*\((.+)\)$/i);
-  if (constraintMatch) {
-    const [, rawName, kind, rawColumns] = constraintMatch;
-    const columns = splitTopLevelComma(rawColumns).map((item) => normalizeIdentifier(item));
-    if (kind.toLowerCase().includes("primary")) {
-      return { type: "PRIMARY_KEY", name: normalizeIdentifier(rawName), columns };
-    }
-    return { type: "UNIQUE", name: normalizeIdentifier(rawName), columns };
-  }
-  const barePk = normalized.match(/^primary\s+key\s*\((.+)\)$/i);
-  if (barePk) {
-    const columns = splitTopLevelComma(barePk[1]).map((item) => normalizeIdentifier(item));
-    return { type: "PRIMARY_KEY", columns };
-  }
-  const bareUnique = normalized.match(/^unique\s*\((.+)\)$/i);
-  if (bareUnique) {
-    const columns = splitTopLevelComma(bareUnique[1]).map((item) => normalizeIdentifier(item));
-    return { type: "UNIQUE", columns };
-  }
-  return null;
-}
-function parseAlterTablePrefix(stmt) {
-  const match = stmt.match(/^alter\s+table\s+(?:if\s+exists\s+)?(?:only\s+)?(.+)$/i);
-  if (!match) {
-    return null;
-  }
-  const remainder = match[1].trim();
-  const tokens = tokenize(remainder);
-  if (tokens.length < 2) {
-    return null;
-  }
-  const tableToken = tokens[0];
-  const table = normalizeIdentifier(tableToken);
-  const rest = remainder.slice(tableToken.length).trim();
-  return { table, rest };
-}
-function parseCreateTable(stmt) {
-  const match = stmt.match(/^create\s+table\s+(?:if\s+not\s+exists\s+)?(.+?)\s*\((.*)\)$/is);
-  if (!match) {
-    return null;
-  }
-  const table = normalizeIdentifier(match[1]);
-  const body = match[2];
-  const segments = splitTopLevelComma(body);
-  const columns = [];
-  const constraints = [];
-  for (const segment of segments) {
-    const constraint = parseCreateTableConstraint(segment);
-    if (constraint) {
-      constraints.push(constraint);
-      continue;
-    }
-    const column = parseColumnDefinition(segment);
-    if (column) {
-      columns.push(column);
-    }
-  }
-  return {
-    kind: "CREATE_TABLE",
-    table,
-    columns,
-    constraints
-  };
-}
-function parseAlterTableAddColumn(stmt) {
-  const prefix = parseAlterTablePrefix(stmt);
-  if (!prefix) {
-    return null;
-  }
-  const match = prefix.rest.match(/^add\s+column\s+(?:if\s+not\s+exists\s+)?(.+)$/i);
-  if (!match) {
-    return null;
-  }
-  const column = parseColumnDefinition(match[1]);
-  if (!column) {
-    return null;
-  }
-  return { kind: "ADD_COLUMN", table: prefix.table, column };
-}
-function parseAlterColumnType(stmt) {
-  const prefix = parseAlterTablePrefix(stmt);
-  if (!prefix) {
-    return null;
-  }
-  const match = prefix.rest.match(/^alter\s+column\s+([^\s]+)\s+type\s+(.+)$/i);
-  if (!match) {
-    return null;
-  }
-  const column = normalizeIdentifier(match[1]);
-  const toType = normalizeSqlType(match[2].replace(/\s+using\s+[\s\S]*$/i, "").trim());
-  return {
-    kind: "ALTER_COLUMN_TYPE",
-    table: prefix.table,
-    column,
-    toType
-  };
-}
-function parseSetDropNotNull(stmt) {
-  const prefix = parseAlterTablePrefix(stmt);
-  if (!prefix) {
-    return null;
-  }
-  const setMatch = prefix.rest.match(/^alter\s+column\s+([^\s]+)\s+set\s+not\s+null$/i);
-  if (setMatch) {
-    return {
-      kind: "SET_NOT_NULL",
-      table: prefix.table,
-      column: normalizeIdentifier(setMatch[1])
-    };
-  }
-  const dropMatch = prefix.rest.match(/^alter\s+column\s+([^\s]+)\s+drop\s+not\s+null$/i);
-  if (dropMatch) {
-    return {
-      kind: "DROP_NOT_NULL",
-      table: prefix.table,
-      column: normalizeIdentifier(dropMatch[1])
-    };
-  }
-  return null;
-}
-function parseSetDropDefault(stmt) {
-  const prefix = parseAlterTablePrefix(stmt);
-  if (!prefix) {
-    return null;
-  }
-  const setMatch = prefix.rest.match(/^alter\s+column\s+([^\s]+)\s+set\s+default\s+(.+)$/i);
-  if (setMatch) {
-    return {
-      kind: "SET_DEFAULT",
-      table: prefix.table,
-      column: normalizeIdentifier(setMatch[1]),
-      expr: normalizeDefault(setMatch[2].trim()) ?? setMatch[2].trim()
-    };
-  }
-  const dropMatch = prefix.rest.match(/^alter\s+column\s+([^\s]+)\s+drop\s+default$/i);
-  if (dropMatch) {
-    return {
-      kind: "DROP_DEFAULT",
-      table: prefix.table,
-      column: normalizeIdentifier(dropMatch[1])
-    };
-  }
-  return null;
-}
-function parseAddDropConstraint(stmt) {
-  const prefix = parseAlterTablePrefix(stmt);
-  if (!prefix) {
-    return null;
-  }
-  const addMatch = prefix.rest.match(/^add\s+constraint\s+([^\s]+)\s+(primary\s+key|unique)\s*\((.+)\)$/i);
-  if (addMatch) {
-    const [, rawName, kind, rawColumns] = addMatch;
-    const columns = splitTopLevelComma(rawColumns).map((item) => normalizeIdentifier(item));
-    const constraint = kind.toLowerCase().includes("primary") ? { type: "PRIMARY_KEY", name: normalizeIdentifier(rawName), columns } : { type: "UNIQUE", name: normalizeIdentifier(rawName), columns };
-    return {
-      kind: "ADD_CONSTRAINT",
-      table: prefix.table,
-      constraint
-    };
-  }
-  const dropMatch = prefix.rest.match(/^drop\s+constraint\s+(?:if\s+exists\s+)?([^\s]+)(?:\s+cascade)?$/i);
-  if (dropMatch) {
-    return {
-      kind: "DROP_CONSTRAINT",
-      table: prefix.table,
-      name: normalizeIdentifier(dropMatch[1])
-    };
-  }
-  return null;
-}
-function parseDropColumn(stmt) {
-  const prefix = parseAlterTablePrefix(stmt);
-  if (!prefix) {
-    return null;
-  }
-  const match = prefix.rest.match(/^drop\s+column\s+(?:if\s+exists\s+)?([^\s]+)(?:\s+cascade)?$/i);
-  if (!match) {
-    return null;
-  }
-  return {
-    kind: "DROP_COLUMN",
-    table: prefix.table,
-    column: normalizeIdentifier(match[1])
-  };
-}
-function parseDropTable(stmt) {
-  const match = stmt.match(/^drop\s+table\s+(?:if\s+exists\s+)?([^\s]+)(?:\s+cascade)?$/i);
-  if (!match) {
-    return null;
-  }
-  return {
-    kind: "DROP_TABLE",
-    table: normalizeIdentifier(match[1])
-  };
-}
-var PARSERS = [
-  parseCreateTable,
-  parseAlterTableAddColumn,
-  parseAlterColumnType,
-  parseSetDropNotNull,
-  parseSetDropDefault,
-  parseAddDropConstraint,
-  parseDropColumn,
-  parseDropTable
-];
-function parseMigrationSql(sql) {
-  const statements = splitSqlStatements(sql);
-  const ops = [];
-  const warnings = [];
-  for (const raw of statements) {
-    const stmt = removeSqlComments(raw).trim();
-    if (!stmt) {
-      continue;
-    }
-    let parsed = null;
-    for (const parseFn of PARSERS) {
-      parsed = parseFn(stmt);
-      if (parsed) {
-        break;
-      }
-    }
-    if (parsed) {
-      ops.push(parsed);
-    } else {
-      warnings.push({
-        statement: stmt,
-        reason: "Unsupported or unrecognized statement"
-      });
-    }
-  }
-  return { ops, warnings };
-}
-
-// src/core/sql/schema-to-dsl.ts
-function renderColumn(column) {
-  const parts = [column.name, column.type];
-  if (column.primaryKey) {
-    parts.push("pk");
-  }
-  if (column.unique) {
-    parts.push("unique");
-  }
-  if (column.nullable === false && !column.primaryKey) {
-    parts.push("not null");
-  }
-  if (column.default !== void 0 && column.default !== null) {
-    parts.push(`default ${column.default}`);
-  }
-  return `  ${parts.join(" ")}`;
-}
-function schemaToDsl(schema) {
-  const tableNames = Object.keys(schema.tables).sort((left, right) => left.localeCompare(right));
-  const blocks = tableNames.map((tableName) => {
-    const table = schema.tables[tableName];
-    const lines = [`table ${table.name} {`];
-    for (const column of table.columns) {
-      lines.push(renderColumn(column));
-    }
-    lines.push("}");
-    return lines.join("\n");
-  });
-  if (blocks.length === 0) {
-    return "# SchemaForge schema definition\n";
-  }
-  return `# SchemaForge schema definition
-
-${blocks.join("\n\n")}
-`;
-}
-
-// src/commands/import.ts
+var import_path5 = __toESM(require("path"));
 function resolveConfigPath3(root, targetPath) {
-  return import_path7.default.isAbsolute(targetPath) ? targetPath : import_path7.default.join(root, targetPath);
+  return import_path5.default.isAbsolute(targetPath) ? targetPath : import_path5.default.join(root, targetPath);
 }
 async function runImport(inputPath, options = {}) {
   const root = getProjectRoot();
@@ -2380,15 +414,15 @@ async function runImport(inputPath, options = {}) {
   const allOps = [];
   const parseWarnings = [];
   for (const input of inputs) {
-    const result = parseMigrationSql(input.sql);
+    const result = await parseMigrationSql(input.sql);
     allOps.push(...result.ops);
     parseWarnings.push(...result.warnings.map((item) => ({
-      statement: `[${import_path7.default.basename(input.filePath)}] ${item.statement}`,
+      statement: `[${import_path5.default.basename(input.filePath)}] ${item.statement}`,
       reason: item.reason
     })));
   }
-  const applied = applySqlOps(allOps);
-  const dsl = schemaToDsl(applied.schema);
+  const applied = await applySqlOps(allOps);
+  const dsl = await schemaToDsl(applied.schema);
   let targetPath = options.out;
   if (!targetPath) {
     const configPath = getConfigPath(root);
@@ -2453,8 +487,8 @@ table users {
   await writeTextFile(schemaFilePath, schemaContent);
   success(`Created ${schemaFilePath}`);
   const config = {
-    provider: "supabase",
-    outputDir: "supabase/migrations",
+    provider: "postgres",
+    outputDir: "migrations",
     schemaFile: "schemaforge/schema.sf",
     stateFile: "schemaforge/state.json",
     sql: {
@@ -2470,7 +504,7 @@ table users {
   };
   await writeJsonFile(statePath, state);
   success(`Created ${statePath}`);
-  const outputDir = "supabase/migrations";
+  const outputDir = "migrations";
   await ensureDir(outputDir);
   success(`Created ${outputDir}`);
   success("Project initialized successfully");
@@ -2481,160 +515,10 @@ table users {
 
 // src/commands/validate.ts
 var import_commander5 = require("commander");
-var import_path8 = __toESM(require("path"));
-
-// src/core/validate.ts
-function normalizeColumnType2(type) {
-  return type.toLowerCase().trim().replace(/\s+/g, " ").replace(/\s*\(\s*/g, "(").replace(/\s*,\s*/g, ",").replace(/\s*\)\s*/g, ")");
-}
-function parseVarcharLength(type) {
-  const match = normalizeColumnType2(type).match(/^varchar\((\d+)\)$/);
-  return match ? Number(match[1]) : null;
-}
-function parseNumericType(type) {
-  const match = normalizeColumnType2(type).match(/^numeric\((\d+),(\d+)\)$/);
-  if (!match) {
-    return null;
-  }
-  return {
-    precision: Number(match[1]),
-    scale: Number(match[2])
-  };
-}
-function classifyTypeChange(from, to) {
-  const fromType = normalizeColumnType2(from);
-  const toType = normalizeColumnType2(to);
-  const uuidInvolved = fromType === "uuid" || toType === "uuid";
-  if (uuidInvolved && fromType !== toType) {
-    return {
-      severity: "error",
-      message: `Type changed from ${fromType} to ${toType} (likely incompatible cast)`
-    };
-  }
-  if (fromType === "int" && toType === "bigint") {
-    return {
-      severity: "warning",
-      message: "Type widened from int to bigint"
-    };
-  }
-  if (fromType === "bigint" && toType === "int") {
-    return {
-      severity: "error",
-      message: "Type narrowed from bigint to int (likely incompatible cast)"
-    };
-  }
-  if (fromType === "text" && parseVarcharLength(toType) !== null) {
-    return {
-      severity: "error",
-      message: `Type changed from text to ${toType} (may truncate existing values)`
-    };
-  }
-  if (parseVarcharLength(fromType) !== null && toType === "text") {
-    return {
-      severity: "warning",
-      message: "Type widened from varchar(n) to text"
-    };
-  }
-  const fromVarcharLength = parseVarcharLength(fromType);
-  const toVarcharLength = parseVarcharLength(toType);
-  if (fromVarcharLength !== null && toVarcharLength !== null) {
-    if (toVarcharLength >= fromVarcharLength) {
-      return {
-        severity: "warning",
-        message: `Type widened from varchar(${fromVarcharLength}) to varchar(${toVarcharLength})`
-      };
-    }
-    return {
-      severity: "error",
-      message: `Type narrowed from varchar(${fromVarcharLength}) to varchar(${toVarcharLength})`
-    };
-  }
-  const fromNumeric = parseNumericType(fromType);
-  const toNumeric = parseNumericType(toType);
-  if (fromNumeric && toNumeric && fromNumeric.scale === toNumeric.scale) {
-    if (toNumeric.precision >= fromNumeric.precision) {
-      return {
-        severity: "warning",
-        message: `Type widened from numeric(${fromNumeric.precision},${fromNumeric.scale}) to numeric(${toNumeric.precision},${toNumeric.scale})`
-      };
-    }
-    return {
-      severity: "error",
-      message: `Type narrowed from numeric(${fromNumeric.precision},${fromNumeric.scale}) to numeric(${toNumeric.precision},${toNumeric.scale})`
-    };
-  }
-  return {
-    severity: "warning",
-    message: `Type changed from ${fromType} to ${toType} (compatibility unknown)`
-  };
-}
-function validateSchemaChanges(previousState, currentSchema) {
-  const findings = [];
-  const diff = diffSchemas(previousState, currentSchema);
-  for (const operation of diff.operations) {
-    switch (operation.kind) {
-      case "drop_table":
-        findings.push({
-          severity: "error",
-          code: "DROP_TABLE",
-          table: operation.tableName,
-          message: "Table removed"
-        });
-        break;
-      case "drop_column":
-        findings.push({
-          severity: "error",
-          code: "DROP_COLUMN",
-          table: operation.tableName,
-          column: operation.columnName,
-          message: "Column removed"
-        });
-        break;
-      case "column_type_changed": {
-        const classification = classifyTypeChange(operation.fromType, operation.toType);
-        findings.push({
-          severity: classification.severity,
-          code: "ALTER_COLUMN_TYPE",
-          table: operation.tableName,
-          column: operation.columnName,
-          from: normalizeColumnType2(operation.fromType),
-          to: normalizeColumnType2(operation.toType),
-          message: classification.message
-        });
-        break;
-      }
-      case "column_nullability_changed":
-        if (operation.from && !operation.to) {
-          findings.push({
-            severity: "warning",
-            code: "SET_NOT_NULL",
-            table: operation.tableName,
-            column: operation.columnName,
-            message: "Column changed to NOT NULL (may fail if data contains NULLs)"
-          });
-        }
-        break;
-      default:
-        break;
-    }
-  }
-  return findings;
-}
-function toValidationReport(findings) {
-  const errors = findings.filter((finding) => finding.severity === "error");
-  const warnings = findings.filter((finding) => finding.severity === "warning");
-  return {
-    hasErrors: errors.length > 0,
-    hasWarnings: warnings.length > 0,
-    errors: errors.map(({ severity, ...finding }) => finding),
-    warnings: warnings.map(({ severity, ...finding }) => finding)
-  };
-}
-
-// src/commands/validate.ts
+var import_path6 = __toESM(require("path"));
 var REQUIRED_CONFIG_FIELDS3 = ["schemaFile", "stateFile"];
 function resolveConfigPath4(root, targetPath) {
-  return import_path8.default.isAbsolute(targetPath) ? targetPath : import_path8.default.join(root, targetPath);
+  return import_path6.default.isAbsolute(targetPath) ? targetPath : import_path6.default.join(root, targetPath);
 }
 async function runValidate(options = {}) {
   const root = getProjectRoot();
@@ -2652,18 +536,18 @@ async function runValidate(options = {}) {
   const schemaPath = resolveConfigPath4(root, config.schemaFile);
   const statePath = resolveConfigPath4(root, config.stateFile);
   const schemaSource = await readTextFile(schemaPath);
-  const schema = parseSchema(schemaSource);
+  const schema = await parseSchema(schemaSource);
   try {
-    validateSchema(schema);
+    await validateSchema(schema);
   } catch (error2) {
     if (error2 instanceof Error) {
-      throw new SchemaValidationError(error2.message);
+      throw await createSchemaValidationError(error2.message);
     }
     throw error2;
   }
   const previousState = await loadState(statePath);
-  const findings = validateSchemaChanges(previousState, schema);
-  const report = toValidationReport(findings);
+  const findings = await validateSchemaChanges(previousState, schema);
+  const report = await toValidationReport(findings);
   if (options.json) {
     console.log(JSON.stringify(report, null, 2));
     process.exitCode = report.hasErrors ? 1 : 0;
@@ -2694,8 +578,8 @@ async function runValidate(options = {}) {
 // src/cli.ts
 var program = new import_commander6.Command();
 program.name("schema-forge").description("CLI tool for schema management and SQL generation").version(package_default.version);
-function handleError(error2) {
-  if (error2 instanceof SchemaValidationError) {
+async function handleError(error2) {
+  if (await isSchemaValidationError(error2) && error2 instanceof Error) {
     error(error2.message);
     process.exitCode = 2;
     return;
@@ -2711,35 +595,35 @@ program.command("init").description("Initialize a new schema project").action(as
   try {
     await runInit();
   } catch (error2) {
-    handleError(error2);
+    await handleError(error2);
   }
 });
 program.command("generate").description("Generate SQL from schema files").option("--name <string>", "Schema name to generate").action(async (options) => {
   try {
     await runGenerate(options);
   } catch (error2) {
-    handleError(error2);
+    await handleError(error2);
   }
 });
 program.command("diff").description("Compare two schema versions and generate migration SQL").action(async () => {
   try {
     await runDiff();
   } catch (error2) {
-    handleError(error2);
+    await handleError(error2);
   }
 });
 program.command("import").description("Import schema from SQL migrations").argument("<path>", "Path to .sql file or migrations directory").option("--out <path>", "Output schema file path").action(async (targetPath, options) => {
   try {
     await runImport(targetPath, options);
   } catch (error2) {
-    handleError(error2);
+    await handleError(error2);
   }
 });
 program.command("validate").description("Detect destructive or risky schema changes").option("--json", "Output structured JSON").action(async (options) => {
   try {
     await runValidate(options);
   } catch (error2) {
-    handleError(error2);
+    await handleError(error2);
   }
 });
 program.parse(process.argv);