@xubylele/schema-forge 1.4.0 → 1.5.1

package/dist/cli.js

@@ -6,6 +6,13 @@ var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
 var __getOwnPropNames = Object.getOwnPropertyNames;
 var __getProtoOf = Object.getPrototypeOf;
 var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __esm = (fn, res) => function __init() {
+  return fn && (res = (0, fn[__getOwnPropNames(fn)[0]])(fn = 0)), res;
+};
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
 var __copyProps = (to, from, except, desc) => {
   if (from && typeof from === "object" || typeof from === "function") {
     for (let key of __getOwnPropNames(from))
@@ -23,71 +30,182 @@ var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__ge
   mod
 ));
 
-// src/cli.ts
-var import_commander6 = require("commander");
-
-// package.json
-var package_default = {
-  name: "@xubylele/schema-forge",
-  version: "1.4.0",
-  description: "Universal migration generator from schema DSL",
-  main: "dist/cli.js",
-  type: "commonjs",
-  bin: {
-    "schema-forge": "dist/cli.js"
-  },
-  scripts: {
-    build: "tsup src/cli.ts --format cjs --dts",
-    dev: "ts-node src/cli.ts",
-    test: "vitest",
-    prepublishOnly: "npm run build",
-    "publish:public": "npm publish --access public",
-    changeset: "changeset",
-    "version-packages": "changeset version",
-    release: "changeset publish"
-  },
-  keywords: [
-    "cli",
-    "schema",
-    "sql",
-    "generator",
-    "migration",
-    "database"
-  ],
-  author: "Xuby",
-  license: "ISC",
-  repository: {
-    type: "git",
-    url: "git+https://github.com/xubylele/schema-forge.git"
-  },
-  bugs: "https://github.com/xubylele/schema-forge/issues",
-  homepage: "https://github.com/xubylele/schema-forge#readme",
-  files: [
-    "dist"
-  ],
-  engines: {
-    node: ">=18.0.0"
-  },
-  dependencies: {
-    boxen: "^8.0.1",
-    chalk: "^5.6.2",
-    commander: "^14.0.3"
-  },
-  devDependencies: {
-    "@changesets/cli": "^2.29.8",
-    "@types/node": "^25.2.3",
-    "ts-node": "^10.9.2",
-    tsup: "^8.5.1",
-    typescript: "^5.9.3",
-    vitest: "^4.0.18"
+// node_modules/@xubylele/schema-forge-core/dist/core/parser.js
+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, ")");
   }
-};
-
-// src/commands/diff.ts
-var import_commander = require("commander");
-var import_path4 = __toESM(require("path"));
+  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 };
+}
+var init_parser = __esm({
+  "node_modules/@xubylele/schema-forge-core/dist/core/parser.js"() {
+    "use strict";
+  }
+});
 
-// src/core/normalize.ts
+// node_modules/@xubylele/schema-forge-core/dist/core/normalize.js
 function normalizeIdent(input) {
   return input.trim().toLowerCase().replace(/[^a-z0-9]+/g, "_").replace(/_+/g, "_").replace(/^_+|_+$/g, "");
 }
@@ -229,8 +347,13 @@ function normalizeDefault(expr) {
   const normalizedPunctuation = normalizePunctuationOutsideQuotes(normalizedSpacing);
   return normalizeKnownFunctionsOutsideQuotes(normalizedPunctuation);
 }
+var init_normalize = __esm({
+  "node_modules/@xubylele/schema-forge-core/dist/core/normalize.js"() {
+    "use strict";
+  }
+});
 
-// src/core/diff.ts
+// node_modules/@xubylele/schema-forge-core/dist/core/diff.js
 function getTableNamesFromState(state) {
   return new Set(Object.keys(state.tables));
 }
@@ -272,9 +395,7 @@ function diffSchemas(oldState, newSchema) {
       });
     }
   }
-  const commonTableNames = sortedNewTableNames.filter(
-    (tableName) => oldTableNames.has(tableName)
-  );
+  const commonTableNames = sortedNewTableNames.filter((tableName) => oldTableNames.has(tableName));
   for (const tableName of commonTableNames) {
     const newTable = newSchema.tables[tableName];
     const oldTable = oldState.tables[tableName];
@@ -446,65 +567,301 @@ function diffSchemas(oldState, newSchema) {
   }
   return { operations };
 }
-
-// src/core/errors.ts
-var SchemaValidationError = class extends Error {
-  constructor(message) {
-    super(message);
-    this.name = "SchemaValidationError";
+var init_diff = __esm({
+  "node_modules/@xubylele/schema-forge-core/dist/core/diff.js"() {
+    "use strict";
+    init_normalize();
   }
-};
+});
 
-// src/core/fs.ts
-var import_fs = require("fs");
-var import_path = __toESM(require("path"));
-async function ensureDir(dirPath) {
-  try {
-    await import_fs.promises.mkdir(dirPath, { recursive: true });
-  } catch (error2) {
-    throw new Error(`Failed to create directory ${dirPath}: ${error2}`);
-  }
-}
-async function fileExists(filePath) {
-  try {
-    await import_fs.promises.access(filePath);
+// node_modules/@xubylele/schema-forge-core/dist/core/validator.js
+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;
-  } catch {
-    return false;
   }
+  return /^varchar\(\d+\)$/.test(normalizedType) || /^numeric\(\d+,\d+\)$/.test(normalizedType);
 }
-async function readTextFile(filePath) {
+function validateSchema(schema) {
+  validateDuplicateTables(schema);
+  for (const tableName in schema.tables) {
+    const table = schema.tables[tableName];
+    validateTableColumns(tableName, table, schema.tables);
+  }
+}
+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);
+  }
+}
+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`);
+    }
+  }
+}
+var VALID_BASE_COLUMN_TYPES;
+var init_validator = __esm({
+  "node_modules/@xubylele/schema-forge-core/dist/core/validator.js"() {
+    "use strict";
+    VALID_BASE_COLUMN_TYPES = [
+      "uuid",
+      "varchar",
+      "text",
+      "int",
+      "bigint",
+      "boolean",
+      "timestamptz",
+      "date"
+    ];
+  }
+});
+
+// node_modules/@xubylele/schema-forge-core/dist/core/validate.js
+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)
+  };
+}
+var init_validate = __esm({
+  "node_modules/@xubylele/schema-forge-core/dist/core/validate.js"() {
+    "use strict";
+    init_diff();
+  }
+});
+
+// node_modules/@xubylele/schema-forge-core/dist/core/fs.js
+async function ensureDir2(dirPath) {
   try {
-    return await import_fs.promises.readFile(filePath, "utf-8");
+    await import_fs2.promises.mkdir(dirPath, { recursive: true });
+  } catch (error2) {
+    throw new Error(`Failed to create directory ${dirPath}: ${error2}`);
+  }
+}
+async function fileExists2(filePath) {
+  try {
+    await import_fs2.promises.access(filePath);
+    return true;
+  } catch {
+    return false;
+  }
+}
+async function readTextFile2(filePath) {
+  try {
+    return await import_fs2.promises.readFile(filePath, "utf-8");
   } catch (error2) {
     throw new Error(`Failed to read file ${filePath}: ${error2}`);
   }
 }
-async function writeTextFile(filePath, content) {
+async function writeTextFile2(filePath, content) {
   try {
-    const dir = import_path.default.dirname(filePath);
-    await ensureDir(dir);
-    await import_fs.promises.writeFile(filePath, content, "utf-8");
+    const dir = import_path3.default.dirname(filePath);
+    await ensureDir2(dir);
+    await import_fs2.promises.writeFile(filePath, content, "utf-8");
   } catch (error2) {
     throw new Error(`Failed to write file ${filePath}: ${error2}`);
   }
 }
-async function readJsonFile(filePath, fallback) {
+async function readJsonFile2(filePath, fallback) {
   try {
-    const exists = await fileExists(filePath);
+    const exists = await fileExists2(filePath);
     if (!exists) {
       return fallback;
     }
-    const content = await readTextFile(filePath);
+    const content = await readTextFile2(filePath);
     return JSON.parse(content);
   } catch (error2) {
     throw new Error(`Failed to read JSON file ${filePath}: ${error2}`);
   }
 }
-async function writeJsonFile(filePath, data) {
+async function writeJsonFile2(filePath, data) {
   try {
     const content = JSON.stringify(data, null, 2);
-    await writeTextFile(filePath, content);
+    await writeTextFile2(filePath, content);
   } catch (error2) {
     throw new Error(`Failed to write JSON file ${filePath}: ${error2}`);
   }
@@ -512,9 +869,9 @@ async function writeJsonFile(filePath, data) {
 async function findFiles(dirPath, pattern) {
   const results = [];
   try {
-    const items = await import_fs.promises.readdir(dirPath, { withFileTypes: true });
+    const items = await import_fs2.promises.readdir(dirPath, { withFileTypes: true });
     for (const item of items) {
-      const fullPath = import_path.default.join(dirPath, item.name);
+      const fullPath = import_path3.default.join(dirPath, item.name);
       if (item.isDirectory()) {
         const subResults = await findFiles(fullPath, pattern);
         results.push(...subResults);
@@ -527,456 +884,16 @@ async function findFiles(dirPath, pattern) {
   }
   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;
+var import_fs2, import_path3;
+var init_fs = __esm({
+  "node_modules/@xubylele/schema-forge-core/dist/core/fs.js"() {
+    "use strict";
+    import_fs2 = require("fs");
+    import_path3 = __toESM(require("path"), 1);
   }
-  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"));
-function getProjectRoot(cwd = process.cwd()) {
-  return cwd;
-}
-function getSchemaForgeDir(root) {
-  return import_path2.default.join(root, "schemaforge");
-}
-function getSchemaFilePath(root, config) {
-  const schemaForgeDir = getSchemaForgeDir(root);
-  const fileName = config?.schemaFile || "schema.sf";
-  return import_path2.default.join(schemaForgeDir, fileName);
-}
-function getConfigPath(root) {
-  const schemaForgeDir = getSchemaForgeDir(root);
-  return import_path2.default.join(schemaForgeDir, "config.json");
-}
-function getStatePath(root, config) {
-  const schemaForgeDir = getSchemaForgeDir(root);
-  const fileName = config?.stateFile || "state.json";
-  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 };
-  }
-  /**
-   * 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);
-  }
-};
+// node_modules/@xubylele/schema-forge-core/dist/core/state-manager.js
 async function schemaToState(schema) {
   const tables = {};
   for (const [tableName, table] of Object.entries(schema.tables)) {
@@ -1003,292 +920,29 @@ async function schemaToState(schema) {
   };
 }
 async function loadState(statePath) {
-  return await readJsonFile(statePath, { version: 1, tables: {} });
+  return await readJsonFile2(statePath, { version: 1, tables: {} });
 }
 async function saveState(statePath, state) {
-  const dirPath = import_path3.default.dirname(statePath);
-  await ensureDir(dirPath);
-  await writeJsonFile(statePath, state);
+  const dirPath = import_path4.default.dirname(statePath);
+  await ensureDir2(dirPath);
+  await writeJsonFile2(statePath, state);
 }
-var defaultStateManager = new StateManager();
+var import_path4;
+var init_state_manager = __esm({
+  "node_modules/@xubylele/schema-forge-core/dist/core/state-manager.js"() {
+    "use strict";
+    import_path4 = __toESM(require("path"), 1);
+    init_fs();
+  }
+});
 
-// 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);
-  }
-}
-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);
-  }
-}
-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`
-      );
-    }
-  }
-}
-
-// 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);
+// node_modules/@xubylele/schema-forge-core/dist/generator/sql-generator.js
+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");
@@ -1300,25 +954,13 @@ function generateOperation(operation, provider, sqlConfig) {
     case "drop_table":
       return generateDropTable(operation.tableName);
     case "column_type_changed":
-      return generateAlterColumnType(
-        operation.tableName,
-        operation.columnName,
-        operation.toType
-      );
+      return generateAlterColumnType(operation.tableName, operation.columnName, operation.toType);
     case "column_nullability_changed":
-      return generateAlterColumnNullability(
-        operation.tableName,
-        operation.columnName,
-        operation.to
-      );
+      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
-      );
+      return generateAlterColumnDefault(operation.tableName, operation.columnName, operation.toDefault);
     case "drop_column":
       return generateDropColumn(operation.tableName, operation.columnName);
     case "column_unique_changed":
@@ -1330,9 +972,7 @@ function generateOperation(operation, provider, sqlConfig) {
   }
 }
 function generateCreateTable(table, provider, sqlConfig) {
-  const columnDefs = table.columns.map(
-    (col) => generateColumnDefinition(col, 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;
@@ -1344,9 +984,7 @@ function generateCreateTable(table, provider, sqlConfig) {
 function generateColumnDefinition(column, provider, sqlConfig) {
   const parts = [column.name, column.type];
   if (column.foreignKey) {
-    parts.push(
-      `references ${column.foreignKey.table}(${column.foreignKey.column})`
-    );
+    parts.push(`references ${column.foreignKey.table}(${column.foreignKey.column})`);
   }
   if (column.primaryKey) {
     parts.push("primary key");
@@ -1397,9 +1035,7 @@ function generateAddPrimaryKeyConstraint(tableName, columnName) {
 }
 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");
+  return uniqueConstraintNames.map((constraintName) => `ALTER TABLE ${tableName} DROP CONSTRAINT IF EXISTS ${constraintName};`).join("\n");
 }
 function generateAlterColumnDefault(tableName, columnName, newDefault) {
   if (newDefault === null) {
@@ -1413,461 +1049,136 @@ function generateAlterColumnNullability(tableName, columnName, toNullable) {
   }
   return `ALTER TABLE ${tableName} ALTER COLUMN ${columnName} SET NOT NULL;`;
 }
-
-// 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);
-}
-async function runDiff() {
-  const root = getProjectRoot();
-  const configPath = getConfigPath(root);
-  if (!await fileExists(configPath)) {
-    throw new Error('SchemaForge project not initialized. Run "schema-forge init" first.');
+var init_sql_generator = __esm({
+  "node_modules/@xubylele/schema-forge-core/dist/generator/sql-generator.js"() {
+    "use strict";
+    init_normalize();
   }
-  const config = await readJsonFile(configPath, {});
-  for (const field of REQUIRED_CONFIG_FIELDS) {
-    const value = config[field];
-    if (!value || typeof value !== "string") {
-      throw new Error(`Invalid config: '${field}' is required`);
+});
+
+// node_modules/@xubylele/schema-forge-core/dist/core/sql/split-statements.js
+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;
     }
-  }
-  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 schemaSource = await readTextFile(schemaPath);
-  const schema = parseSchema(schemaSource);
-  try {
-    validateSchema(schema);
-  } catch (error2) {
-    if (error2 instanceof Error) {
-      throw new SchemaValidationError(error2.message);
+    if (inBlockComment) {
+      current += char;
+      if (char === "*" && next === "/") {
+        current += next;
+        inBlockComment = false;
+        index += 2;
+        continue;
+      }
+      index++;
+      continue;
     }
-    throw error2;
+    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 === ";") {
+      if (current.trim().length > 0) {
+        statements.push(current.trim());
+      }
+      current = "";
+      index++;
+      continue;
+    }
+    current += char;
+    index++;
   }
-  const previousState = await loadState(statePath);
-  const diff = diffSchemas(previousState, schema);
-  if (diff.operations.length === 0) {
-    success("No changes detected");
-    return;
+  if (current.trim().length > 0) {
+    statements.push(current.trim());
   }
-  const sql = generateSql(diff, provider, config.sql);
-  console.log(sql);
+  return statements;
 }
+var init_split_statements = __esm({
+  "node_modules/@xubylele/schema-forge-core/dist/core/sql/split-statements.js"() {
+    "use strict";
+  }
+});
 
-// src/commands/generate.ts
-var import_commander2 = require("commander");
-var import_path5 = __toESM(require("path"));
-
-// src/core/utils.ts
-function nowTimestamp() {
-  const date = /* @__PURE__ */ new Date();
-  const pad = (value) => String(value).padStart(2, "0");
-  return String(date.getFullYear()) + pad(date.getMonth() + 1) + pad(date.getDate()) + pad(date.getHours()) + pad(date.getMinutes()) + pad(date.getSeconds());
+// node_modules/@xubylele/schema-forge-core/dist/core/sql/parse-migration.js
+function normalizeSqlType(type) {
+  return type.trim().toLowerCase().replace(/\s+/g, " ").replace(/\s*\(\s*/g, "(").replace(/\s*,\s*/g, ",").replace(/\s*\)\s*/g, ")");
 }
-function slugifyName(name) {
-  return name.trim().toLowerCase().replace(/[^a-z0-9]+/g, "-").replace(/^-+|-+$/g, "") || "migration";
+function unquoteIdentifier(value) {
+  const trimmed = value.trim();
+  if (trimmed.startsWith('"') && trimmed.endsWith('"') && trimmed.length >= 2) {
+    return trimmed.slice(1, -1).replace(/""/g, '"');
+  }
+  return trimmed;
 }
-
-// src/commands/generate.ts
-var REQUIRED_CONFIG_FIELDS2 = [
-  "schemaFile",
-  "stateFile",
-  "outputDir"
-];
-function resolveConfigPath2(root, targetPath) {
-  return import_path5.default.isAbsolute(targetPath) ? targetPath : import_path5.default.join(root, targetPath);
-}
-async function runGenerate(options) {
-  const root = getProjectRoot();
-  const configPath = getConfigPath(root);
-  if (!await fileExists(configPath)) {
-    throw new Error('SchemaForge project not initialized. Run "schema-forge init" first.');
-  }
-  const config = await readJsonFile(configPath, {});
-  for (const field of REQUIRED_CONFIG_FIELDS2) {
-    const value = config[field];
-    if (!value || typeof value !== "string") {
-      throw new Error(`Invalid config: '${field}' is required`);
-    }
-  }
-  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) {
-    info("Provider not set; defaulting to postgres.");
-  }
-  info("Generating SQL...");
-  const schemaSource = await readTextFile(schemaPath);
-  const schema = parseSchema(schemaSource);
-  try {
-    validateSchema(schema);
-  } catch (error2) {
-    if (error2 instanceof Error) {
-      throw new SchemaValidationError(error2.message);
-    }
-    throw error2;
-  }
-  const previousState = await loadState(statePath);
-  const diff = diffSchemas(previousState, schema);
-  if (diff.operations.length === 0) {
-    info("No changes detected");
-    return;
-  }
-  const sql = 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);
-  await writeTextFile(migrationPath, sql + "\n");
-  const nextState = await schemaToState(schema);
-  await saveState(statePath, nextState);
-  success(`SQL generated successfully: ${migrationPath}`);
-}
-
-// 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 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 = "";
@@ -1962,433 +1273,1177 @@ function splitTopLevelComma(input) {
         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);
+      } 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 = "";
         }
-        current = "";
         continue;
       }
     }
     current += char;
   }
-  const tail = current.trim();
-  if (tail.length > 0) {
-    parts.push(tail);
+  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 parts;
+  return {
+    kind: "DROP_COLUMN",
+    table: prefix.table,
+    column: normalizeIdentifier(match[1])
+  };
 }
-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;
+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])
+  };
+}
+function parseMigrationSql(sql) {
+  const statements = splitSqlStatements(sql);
+  const ops = [];
+  const warnings = [];
+  for (const raw of statements) {
+    const stmt = removeSqlComments(raw).trim();
+    if (!stmt) {
       continue;
     }
-    if (char === '"' && !inSingleQuote) {
-      current += char;
-      if (inDoubleQuote && next === '"') {
-        current += next;
-        index++;
-        continue;
+    let parsed = null;
+    for (const parseFn of PARSERS) {
+      parsed = parseFn(stmt);
+      if (parsed) {
+        break;
       }
-      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;
-      }
+    if (parsed) {
+      ops.push(parsed);
+    } else {
+      warnings.push({
+        statement: stmt,
+        reason: "Unsupported or unrecognized statement"
+      });
     }
-    current += char;
   }
-  if (current.length > 0) {
-    tokens.push(current);
+  return { ops, warnings };
+}
+var COLUMN_CONSTRAINT_KEYWORDS, PARSERS;
+var init_parse_migration = __esm({
+  "node_modules/@xubylele/schema-forge-core/dist/core/sql/parse-migration.js"() {
+    "use strict";
+    init_normalize();
+    init_split_statements();
+    COLUMN_CONSTRAINT_KEYWORDS = /* @__PURE__ */ new Set([
+      "primary",
+      "unique",
+      "not",
+      "null",
+      "default",
+      "constraint",
+      "references",
+      "check"
+    ]);
+    PARSERS = [
+      parseCreateTable,
+      parseAlterTableAddColumn,
+      parseAlterColumnType,
+      parseSetDropNotNull,
+      parseSetDropDefault,
+      parseAddDropConstraint,
+      parseDropColumn,
+      parseDropTable
+    ];
   }
-  return tokens;
+});
+
+// node_modules/@xubylele/schema-forge-core/dist/core/sql/apply-ops.js
+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 parseColumnDefinition(segment) {
-  const tokens = tokenize(segment);
-  if (tokens.length < 2) {
-    return null;
+function applySingleColumnConstraint(table, constraint) {
+  if (constraint.columns.length !== 1) {
+    return false;
   }
-  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++;
+  const targetColumn = table.columns.find((column) => column.name === constraint.columns[0]);
+  if (!targetColumn) {
+    return false;
   }
-  if (typeTokens.length === 0) {
-    return null;
+  if (constraint.type === "PRIMARY_KEY") {
+    table.primaryKey = targetColumn.name;
+    targetColumn.primaryKey = true;
+    targetColumn.nullable = false;
+    return true;
   }
-  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;
+  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;
     }
-    if (lower === "null") {
-      parsed.nullable = true;
-      cursor++;
-      continue;
+    return;
+  }
+  if (name.endsWith("_key") || name.startsWith("uq_")) {
+    for (const column of table.columns) {
+      if (column.unique) {
+        column.unique = false;
+      }
     }
-    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") {
+  }
+}
+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;
         }
-        defaultTokens.push(tokens[cursor]);
-        cursor++;
+        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;
       }
-      parsed.default = normalizeDefault(defaultTokens.join(" "));
-      continue;
     }
-    cursor++;
   }
-  return parsed;
+  const schema = { tables };
+  return { schema, warnings };
 }
-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 };
+var init_apply_ops = __esm({
+  "node_modules/@xubylele/schema-forge-core/dist/core/sql/apply-ops.js"() {
+    "use strict";
   }
-  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 };
+});
+
+// node_modules/@xubylele/schema-forge-core/dist/core/sql/schema-to-dsl.js
+function renderColumn(column) {
+  const parts = [column.name, column.type];
+  if (column.primaryKey) {
+    parts.push("pk");
   }
-  const bareUnique = normalized.match(/^unique\s*\((.+)\)$/i);
-  if (bareUnique) {
-    const columns = splitTopLevelComma(bareUnique[1]).map((item) => normalizeIdentifier(item));
-    return { type: "UNIQUE", columns };
+  if (column.unique) {
+    parts.push("unique");
   }
-  return null;
-}
-function parseAlterTablePrefix(stmt) {
-  const match = stmt.match(/^alter\s+table\s+(?:if\s+exists\s+)?(?:only\s+)?(.+)$/i);
-  if (!match) {
-    return null;
+  if (column.nullable === false && !column.primaryKey) {
+    parts.push("not null");
   }
-  const remainder = match[1].trim();
-  const tokens = tokenize(remainder);
-  if (tokens.length < 2) {
-    return null;
+  if (column.default !== void 0 && column.default !== null) {
+    parts.push(`default ${column.default}`);
   }
-  const tableToken = tokens[0];
-  const table = normalizeIdentifier(tableToken);
-  const rest = remainder.slice(tableToken.length).trim();
-  return { table, rest };
+  return `  ${parts.join(" ")}`;
 }
-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);
+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 {
-    kind: "CREATE_TABLE",
-    table,
-    columns,
-    constraints
-  };
+  return `# SchemaForge schema definition
+
+${blocks.join("\n\n")}
+`;
 }
-function parseAlterTableAddColumn(stmt) {
-  const prefix = parseAlterTablePrefix(stmt);
-  if (!prefix) {
-    return null;
+var init_schema_to_dsl = __esm({
+  "node_modules/@xubylele/schema-forge-core/dist/core/sql/schema-to-dsl.js"() {
+    "use strict";
   }
-  const match = prefix.rest.match(/^add\s+column\s+(?:if\s+not\s+exists\s+)?(.+)$/i);
-  if (!match) {
-    return null;
+});
+
+// node_modules/@xubylele/schema-forge-core/dist/core/sql/load-migrations.js
+async function loadMigrationSqlInput(inputPath) {
+  const stats = await import_fs4.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 readTextFile2(inputPath) }];
   }
-  const column = parseColumnDefinition(match[1]);
-  if (!column) {
-    return null;
+  if (!stats.isDirectory()) {
+    throw new Error(`Input path must be a .sql file or directory: ${inputPath}`);
   }
-  return { kind: "ADD_COLUMN", table: prefix.table, column };
+  const sqlFiles = await findFiles(inputPath, /\.sql$/i);
+  sqlFiles.sort((left, right) => import_path5.default.basename(left).localeCompare(import_path5.default.basename(right)));
+  const result = [];
+  for (const filePath of sqlFiles) {
+    result.push({
+      filePath,
+      sql: await readTextFile2(filePath)
+    });
+  }
+  return result;
 }
-function parseAlterColumnType(stmt) {
-  const prefix = parseAlterTablePrefix(stmt);
-  if (!prefix) {
-    return null;
+var import_fs4, import_path5;
+var init_load_migrations = __esm({
+  "node_modules/@xubylele/schema-forge-core/dist/core/sql/load-migrations.js"() {
+    "use strict";
+    import_fs4 = require("fs");
+    import_path5 = __toESM(require("path"), 1);
+    init_fs();
+  }
+});
+
+// node_modules/@xubylele/schema-forge-core/dist/core/paths.js
+function getProjectRoot2(cwd = process.cwd()) {
+  return cwd;
+}
+function getSchemaForgeDir2(root) {
+  return import_path6.default.join(root, "schemaforge");
+}
+function getSchemaFilePath2(root, config) {
+  const schemaForgeDir = getSchemaForgeDir2(root);
+  const fileName = config?.schemaFile || "schema.sf";
+  return import_path6.default.join(schemaForgeDir, fileName);
+}
+function getConfigPath2(root) {
+  const schemaForgeDir = getSchemaForgeDir2(root);
+  return import_path6.default.join(schemaForgeDir, "config.json");
+}
+function getStatePath2(root, config) {
+  const schemaForgeDir = getSchemaForgeDir2(root);
+  const fileName = config?.stateFile || "state.json";
+  return import_path6.default.join(schemaForgeDir, fileName);
+}
+var import_path6;
+var init_paths = __esm({
+  "node_modules/@xubylele/schema-forge-core/dist/core/paths.js"() {
+    "use strict";
+    import_path6 = __toESM(require("path"), 1);
+  }
+});
+
+// node_modules/@xubylele/schema-forge-core/dist/core/utils.js
+function nowTimestamp() {
+  const date = /* @__PURE__ */ new Date();
+  const pad = (value) => String(value).padStart(2, "0");
+  return String(date.getFullYear()) + pad(date.getMonth() + 1) + pad(date.getDate()) + pad(date.getHours()) + pad(date.getMinutes()) + pad(date.getSeconds());
+}
+function slugifyName(name) {
+  return name.trim().toLowerCase().replace(/[^a-z0-9]+/g, "-").replace(/^-+|-+$/g, "") || "migration";
+}
+var init_utils = __esm({
+  "node_modules/@xubylele/schema-forge-core/dist/core/utils.js"() {
+    "use strict";
+  }
+});
+
+// node_modules/@xubylele/schema-forge-core/dist/core/errors.js
+var SchemaValidationError;
+var init_errors = __esm({
+  "node_modules/@xubylele/schema-forge-core/dist/core/errors.js"() {
+    "use strict";
+    SchemaValidationError = class extends Error {
+      constructor(message) {
+        super(message);
+        this.name = "SchemaValidationError";
+      }
+    };
+  }
+});
+
+// node_modules/@xubylele/schema-forge-core/dist/index.js
+var dist_exports = {};
+__export(dist_exports, {
+  SchemaValidationError: () => SchemaValidationError,
+  applySqlOps: () => applySqlOps,
+  diffSchemas: () => diffSchemas,
+  ensureDir: () => ensureDir2,
+  fileExists: () => fileExists2,
+  findFiles: () => findFiles,
+  generateSql: () => generateSql,
+  getColumnNamesFromSchema: () => getColumnNamesFromSchema,
+  getColumnNamesFromState: () => getColumnNamesFromState,
+  getConfigPath: () => getConfigPath2,
+  getProjectRoot: () => getProjectRoot2,
+  getSchemaFilePath: () => getSchemaFilePath2,
+  getSchemaForgeDir: () => getSchemaForgeDir2,
+  getStatePath: () => getStatePath2,
+  getTableNamesFromSchema: () => getTableNamesFromSchema,
+  getTableNamesFromState: () => getTableNamesFromState,
+  legacyPkName: () => legacyPkName,
+  legacyUqName: () => legacyUqName,
+  loadMigrationSqlInput: () => loadMigrationSqlInput,
+  loadState: () => loadState,
+  normalizeDefault: () => normalizeDefault,
+  normalizeIdent: () => normalizeIdent,
+  nowTimestamp: () => nowTimestamp,
+  parseAddDropConstraint: () => parseAddDropConstraint,
+  parseAlterColumnType: () => parseAlterColumnType,
+  parseAlterTableAddColumn: () => parseAlterTableAddColumn,
+  parseCreateTable: () => parseCreateTable,
+  parseDropColumn: () => parseDropColumn,
+  parseDropTable: () => parseDropTable,
+  parseMigrationSql: () => parseMigrationSql,
+  parseSchema: () => parseSchema,
+  parseSetDropDefault: () => parseSetDropDefault,
+  parseSetDropNotNull: () => parseSetDropNotNull,
+  pkName: () => pkName,
+  readJsonFile: () => readJsonFile2,
+  readTextFile: () => readTextFile2,
+  saveState: () => saveState,
+  schemaToDsl: () => schemaToDsl,
+  schemaToState: () => schemaToState,
+  slugifyName: () => slugifyName,
+  splitSqlStatements: () => splitSqlStatements,
+  toValidationReport: () => toValidationReport,
+  uqName: () => uqName,
+  validateSchema: () => validateSchema,
+  validateSchemaChanges: () => validateSchemaChanges,
+  writeJsonFile: () => writeJsonFile2,
+  writeTextFile: () => writeTextFile2
+});
+var init_dist = __esm({
+  "node_modules/@xubylele/schema-forge-core/dist/index.js"() {
+    "use strict";
+    init_parser();
+    init_diff();
+    init_validator();
+    init_validate();
+    init_state_manager();
+    init_sql_generator();
+    init_parse_migration();
+    init_apply_ops();
+    init_schema_to_dsl();
+    init_load_migrations();
+    init_split_statements();
+    init_fs();
+    init_normalize();
+    init_paths();
+    init_utils();
+    init_errors();
+  }
+});
+
+// src/cli.ts
+var import_commander6 = require("commander");
+
+// package.json
+var package_default = {
+  name: "@xubylele/schema-forge",
+  version: "1.5.1",
+  description: "Universal migration generator from schema DSL",
+  main: "dist/cli.js",
+  type: "commonjs",
+  bin: {
+    "schema-forge": "dist/cli.js"
+  },
+  scripts: {
+    build: "tsup src/cli.ts --format cjs --dts",
+    dev: "ts-node src/cli.ts",
+    test: "vitest",
+    prepublishOnly: "npm run build",
+    "publish:public": "npm publish --access public",
+    changeset: "changeset",
+    "version-packages": "changeset version",
+    release: "changeset publish"
+  },
+  keywords: [
+    "cli",
+    "schema",
+    "sql",
+    "generator",
+    "migration",
+    "database"
+  ],
+  author: "Xuby",
+  license: "ISC",
+  repository: {
+    type: "git",
+    url: "git+https://github.com/xubylele/schema-forge.git"
+  },
+  bugs: "https://github.com/xubylele/schema-forge/issues",
+  homepage: "https://github.com/xubylele/schema-forge#readme",
+  files: [
+    "dist"
+  ],
+  engines: {
+    node: ">=18.0.0"
+  },
+  dependencies: {
+    boxen: "^8.0.1",
+    chalk: "^5.6.2",
+    commander: "^14.0.3"
+  },
+  devDependencies: {
+    "@changesets/cli": "^2.29.8",
+    "@types/node": "^25.2.3",
+    "@xubylele/schema-forge-core": "^1.0.5",
+    "ts-node": "^10.9.2",
+    tsup: "^8.5.1",
+    typescript: "^5.9.3",
+    vitest: "^4.0.18"
   }
-  const match = prefix.rest.match(/^alter\s+column\s+([^\s]+)\s+type\s+(.+)$/i);
-  if (!match) {
-    return null;
+};
+
+// src/commands/diff.ts
+var import_commander = require("commander");
+var import_path7 = __toESM(require("path"));
+
+// src/core/fs.ts
+var import_fs = require("fs");
+var import_path = __toESM(require("path"));
+async function ensureDir(dirPath) {
+  try {
+    await import_fs.promises.mkdir(dirPath, { recursive: true });
+  } catch (error2) {
+    throw new Error(`Failed to create directory ${dirPath}: ${error2}`);
   }
-  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])
-    };
+async function fileExists(filePath) {
+  try {
+    await import_fs.promises.access(filePath);
+    return true;
+  } catch {
+    return false;
   }
-  return null;
 }
-function parseSetDropDefault(stmt) {
-  const prefix = parseAlterTablePrefix(stmt);
-  if (!prefix) {
-    return null;
+async function readTextFile(filePath) {
+  try {
+    return await import_fs.promises.readFile(filePath, "utf-8");
+  } catch (error2) {
+    throw new Error(`Failed to read file ${filePath}: ${error2}`);
   }
-  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()
-    };
+}
+async function writeTextFile(filePath, content) {
+  try {
+    const dir = import_path.default.dirname(filePath);
+    await ensureDir(dir);
+    await import_fs.promises.writeFile(filePath, content, "utf-8");
+  } catch (error2) {
+    throw new Error(`Failed to write file ${filePath}: ${error2}`);
   }
-  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])
-    };
+}
+async function readJsonFile(filePath, fallback) {
+  try {
+    const exists = await fileExists(filePath);
+    if (!exists) {
+      return fallback;
+    }
+    const content = await readTextFile(filePath);
+    return JSON.parse(content);
+  } catch (error2) {
+    throw new Error(`Failed to read JSON file ${filePath}: ${error2}`);
   }
-  return null;
 }
-function parseAddDropConstraint(stmt) {
-  const prefix = parseAlterTablePrefix(stmt);
-  if (!prefix) {
-    return null;
+async function writeJsonFile(filePath, data) {
+  try {
+    const content = JSON.stringify(data, null, 2);
+    await writeTextFile(filePath, content);
+  } catch (error2) {
+    throw new Error(`Failed to write JSON file ${filePath}: ${error2}`);
   }
-  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
-    };
+}
+
+// src/core/paths.ts
+var import_path2 = __toESM(require("path"));
+function getProjectRoot(cwd = process.cwd()) {
+  return cwd;
+}
+function getSchemaForgeDir(root) {
+  return import_path2.default.join(root, "schemaforge");
+}
+function getSchemaFilePath(root, config) {
+  const schemaForgeDir = getSchemaForgeDir(root);
+  const fileName = config?.schemaFile || "schema.sf";
+  return import_path2.default.join(schemaForgeDir, fileName);
+}
+function getConfigPath(root) {
+  const schemaForgeDir = getSchemaForgeDir(root);
+  return import_path2.default.join(schemaForgeDir, "config.json");
+}
+function getStatePath(root, config) {
+  const schemaForgeDir = getSchemaForgeDir(root);
+  const fileName = config?.stateFile || "state.json";
+  return import_path2.default.join(schemaForgeDir, fileName);
+}
+
+// src/core/provider.ts
+var DEFAULT_PROVIDER = "postgres";
+function resolveProvider(provider) {
+  if (!provider) {
+    return { provider: DEFAULT_PROVIDER, usedDefault: true };
   }
-  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 { provider, usedDefault: false };
+}
+
+// src/domain.ts
+var corePromise;
+async function loadCore() {
+  if (!corePromise) {
+    corePromise = Promise.resolve().then(() => (init_dist(), dist_exports));
   }
-  return null;
+  return corePromise;
 }
-function parseDropColumn(stmt) {
-  const prefix = parseAlterTablePrefix(stmt);
-  if (!prefix) {
-    return null;
+async function parseSchema2(source) {
+  const core = await loadCore();
+  return core.parseSchema(source);
+}
+async function validateSchema2(schema) {
+  const core = await loadCore();
+  core.validateSchema(schema);
+}
+async function diffSchemas2(previousState, currentSchema) {
+  const core = await loadCore();
+  return core.diffSchemas(previousState, currentSchema);
+}
+async function generateSql2(diff, provider, config) {
+  const core = await loadCore();
+  return core.generateSql(diff, provider, config);
+}
+async function schemaToState2(schema) {
+  const core = await loadCore();
+  return core.schemaToState(schema);
+}
+async function loadState2(statePath) {
+  const core = await loadCore();
+  return core.loadState(statePath);
+}
+async function saveState2(statePath, state) {
+  const core = await loadCore();
+  return core.saveState(statePath, state);
+}
+async function validateSchemaChanges2(previousState, currentSchema) {
+  const core = await loadCore();
+  return core.validateSchemaChanges(previousState, currentSchema);
+}
+async function toValidationReport2(findings) {
+  const core = await loadCore();
+  return core.toValidationReport(findings);
+}
+async function parseMigrationSql2(sql) {
+  const core = await loadCore();
+  return core.parseMigrationSql(sql);
+}
+async function applySqlOps2(ops) {
+  const core = await loadCore();
+  return core.applySqlOps(ops);
+}
+async function schemaToDsl2(schema) {
+  const core = await loadCore();
+  return core.schemaToDsl(schema);
+}
+async function loadMigrationSqlInput2(inputPath) {
+  const core = await loadCore();
+  return core.loadMigrationSqlInput(inputPath);
+}
+async function createSchemaValidationError(message) {
+  const core = await loadCore();
+  return new core.SchemaValidationError(message);
+}
+async function isSchemaValidationError(error2) {
+  const core = await loadCore();
+  return error2 instanceof core.SchemaValidationError;
+}
+
+// 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;
   }
-  const match = prefix.rest.match(/^drop\s+column\s+(?:if\s+exists\s+)?([^\s]+)(?:\s+cascade)?$/i);
-  if (!match) {
-    return null;
+  try {
+    console.log(
+      (0, import_boxen.default)(text, {
+        padding: 1,
+        borderColor: "cyan",
+        borderStyle: "round"
+      })
+    );
+  } catch {
+    console.log(text);
   }
-  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])
-  };
+function info(message) {
+  console.log(theme.primary(message));
 }
-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;
-      }
+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_path7.default.isAbsolute(targetPath) ? targetPath : import_path7.default.join(root, targetPath);
+}
+async function runDiff() {
+  const root = getProjectRoot();
+  const configPath = getConfigPath(root);
+  if (!await fileExists(configPath)) {
+    throw new Error('SchemaForge project not initialized. Run "schema-forge init" first.');
+  }
+  const config = await readJsonFile(configPath, {});
+  for (const field of REQUIRED_CONFIG_FIELDS) {
+    const value = config[field];
+    if (!value || typeof value !== "string") {
+      throw new Error(`Invalid config: '${field}' is required`);
     }
-    if (parsed) {
-      ops.push(parsed);
-    } else {
-      warnings.push({
-        statement: stmt,
-        reason: "Unsupported or unrecognized statement"
-      });
+  }
+  const schemaPath = resolveConfigPath(root, config.schemaFile);
+  const statePath = resolveConfigPath(root, config.stateFile);
+  const { provider } = resolveProvider(config.provider);
+  const schemaSource = await readTextFile(schemaPath);
+  const schema = await parseSchema2(schemaSource);
+  try {
+    await validateSchema2(schema);
+  } catch (error2) {
+    if (error2 instanceof Error) {
+      throw await createSchemaValidationError(error2.message);
     }
+    throw error2;
   }
-  return { ops, warnings };
+  const previousState = await loadState2(statePath);
+  const diff = await diffSchemas2(previousState, schema);
+  if (diff.operations.length === 0) {
+    success("No changes detected");
+    return;
+  }
+  const sql = await generateSql2(diff, provider, config.sql);
+  console.log(sql);
 }
 
-// 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");
+// src/commands/generate.ts
+var import_commander2 = require("commander");
+var import_path8 = __toESM(require("path"));
+
+// src/core/utils.ts
+function nowTimestamp2() {
+  const date = /* @__PURE__ */ new Date();
+  const pad = (value) => String(value).padStart(2, "0");
+  return String(date.getFullYear()) + pad(date.getMonth() + 1) + pad(date.getDate()) + pad(date.getHours()) + pad(date.getMinutes()) + pad(date.getSeconds());
+}
+function slugifyName2(name) {
+  return name.trim().toLowerCase().replace(/[^a-z0-9]+/g, "-").replace(/^-+|-+$/g, "") || "migration";
+}
+
+// src/commands/generate.ts
+var REQUIRED_CONFIG_FIELDS2 = [
+  "schemaFile",
+  "stateFile",
+  "outputDir"
+];
+function resolveConfigPath2(root, targetPath) {
+  return import_path8.default.isAbsolute(targetPath) ? targetPath : import_path8.default.join(root, targetPath);
+}
+async function runGenerate(options) {
+  const root = getProjectRoot();
+  const configPath = getConfigPath(root);
+  if (!await fileExists(configPath)) {
+    throw new Error('SchemaForge project not initialized. Run "schema-forge init" first.');
   }
-  if (column.nullable === false && !column.primaryKey) {
-    parts.push("not null");
+  const config = await readJsonFile(configPath, {});
+  for (const field of REQUIRED_CONFIG_FIELDS2) {
+    const value = config[field];
+    if (!value || typeof value !== "string") {
+      throw new Error(`Invalid config: '${field}' is required`);
+    }
   }
-  if (column.default !== void 0 && column.default !== null) {
-    parts.push(`default ${column.default}`);
+  const schemaPath = resolveConfigPath2(root, config.schemaFile);
+  const statePath = resolveConfigPath2(root, config.stateFile);
+  const outputDir = resolveConfigPath2(root, config.outputDir);
+  const { provider, usedDefault } = resolveProvider(config.provider);
+  if (usedDefault) {
+    info("Provider not set; defaulting to postgres.");
   }
-  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));
+  info("Generating SQL...");
+  const schemaSource = await readTextFile(schemaPath);
+  const schema = await parseSchema2(schemaSource);
+  try {
+    await validateSchema2(schema);
+  } catch (error2) {
+    if (error2 instanceof Error) {
+      throw await createSchemaValidationError(error2.message);
     }
-    lines.push("}");
-    return lines.join("\n");
-  });
-  if (blocks.length === 0) {
-    return "# SchemaForge schema definition\n";
+    throw error2;
   }
-  return `# SchemaForge schema definition
-
-${blocks.join("\n\n")}
-`;
+  const previousState = await loadState2(statePath);
+  const diff = await diffSchemas2(previousState, schema);
+  if (diff.operations.length === 0) {
+    info("No changes detected");
+    return;
+  }
+  const sql = await generateSql2(diff, provider, config.sql);
+  const timestamp = nowTimestamp2();
+  const slug = slugifyName2(options.name ?? "migration");
+  const fileName = `${timestamp}-${slug}.sql`;
+  await ensureDir(outputDir);
+  const migrationPath = import_path8.default.join(outputDir, fileName);
+  await writeTextFile(migrationPath, sql + "\n");
+  const nextState = await schemaToState2(schema);
+  await saveState2(statePath, nextState);
+  success(`SQL generated successfully: ${migrationPath}`);
 }
 
 // src/commands/import.ts
+var import_commander3 = require("commander");
+var import_path9 = __toESM(require("path"));
 function resolveConfigPath3(root, targetPath) {
-  return import_path7.default.isAbsolute(targetPath) ? targetPath : import_path7.default.join(root, targetPath);
+  return import_path9.default.isAbsolute(targetPath) ? targetPath : import_path9.default.join(root, targetPath);
 }
 async function runImport(inputPath, options = {}) {
   const root = getProjectRoot();
   const absoluteInputPath = resolveConfigPath3(root, inputPath);
-  const inputs = await loadMigrationSqlInput(absoluteInputPath);
+  const inputs = await loadMigrationSqlInput2(absoluteInputPath);
   if (inputs.length === 0) {
     throw new Error(`No .sql migration files found in: ${absoluteInputPath}`);
   }
   const allOps = [];
   const parseWarnings = [];
   for (const input of inputs) {
-    const result = parseMigrationSql(input.sql);
+    const result = await parseMigrationSql2(input.sql);
     allOps.push(...result.ops);
     parseWarnings.push(...result.warnings.map((item) => ({
-      statement: `[${import_path7.default.basename(input.filePath)}] ${item.statement}`,
+      statement: `[${import_path9.default.basename(input.filePath)}] ${item.statement}`,
       reason: item.reason
     })));
   }
-  const applied = applySqlOps(allOps);
-  const dsl = schemaToDsl(applied.schema);
+  const applied = await applySqlOps2(allOps);
+  const dsl = await schemaToDsl2(applied.schema);
   let targetPath = options.out;
   if (!targetPath) {
     const configPath = getConfigPath(root);
@@ -2453,8 +2508,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 +2525,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 +2536,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_path10 = __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_path10.default.isAbsolute(targetPath) ? targetPath : import_path10.default.join(root, targetPath);
 }
 async function runValidate(options = {}) {
   const root = getProjectRoot();
@@ -2652,18 +2557,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 parseSchema2(schemaSource);
   try {
-    validateSchema(schema);
+    await validateSchema2(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 previousState = await loadState2(statePath);
+  const findings = await validateSchemaChanges2(previousState, schema);
+  const report = await toValidationReport2(findings);
   if (options.json) {
     console.log(JSON.stringify(report, null, 2));
     process.exitCode = report.hasErrors ? 1 : 0;
@@ -2694,8 +2599,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 +2616,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);