@xubylele/schema-forge 1.2.0 → 1.4.0

package/dist/cli.js

@@ -24,12 +24,12 @@ var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__ge
 ));
 
 // src/cli.ts
-var import_commander4 = require("commander");
+var import_commander6 = require("commander");
 
 // package.json
 var package_default = {
   name: "@xubylele/schema-forge",
-  version: "1.2.0",
+  version: "1.4.0",
   description: "Universal migration generator from schema DSL",
   main: "dist/cli.js",
   type: "commonjs",
@@ -87,6 +87,149 @@ var package_default = {
 var import_commander = require("commander");
 var import_path4 = __toESM(require("path"));
 
+// src/core/normalize.ts
+function normalizeIdent(input) {
+  return input.trim().toLowerCase().replace(/[^a-z0-9]+/g, "_").replace(/_+/g, "_").replace(/^_+|_+$/g, "");
+}
+function pkName(table) {
+  return `pk_${normalizeIdent(table)}`;
+}
+function uqName(table, column) {
+  return `uq_${normalizeIdent(table)}_${normalizeIdent(column)}`;
+}
+function legacyPkName(table) {
+  return `${normalizeIdent(table)}_pkey`;
+}
+function legacyUqName(table, column) {
+  return `${normalizeIdent(table)}_${normalizeIdent(column)}_key`;
+}
+function normalizeSpacesOutsideQuotes(value) {
+  let result = "";
+  let inSingleQuote = false;
+  let inDoubleQuote = false;
+  let pendingSpace = false;
+  for (const char of value) {
+    if (char === "'" && !inDoubleQuote) {
+      if (pendingSpace && result.length > 0 && result[result.length - 1] !== " ") {
+        result += " ";
+      }
+      pendingSpace = false;
+      inSingleQuote = !inSingleQuote;
+      result += char;
+      continue;
+    }
+    if (char === '"' && !inSingleQuote) {
+      if (pendingSpace && result.length > 0 && result[result.length - 1] !== " ") {
+        result += " ";
+      }
+      pendingSpace = false;
+      inDoubleQuote = !inDoubleQuote;
+      result += char;
+      continue;
+    }
+    if (!inSingleQuote && !inDoubleQuote && /\s/.test(char)) {
+      pendingSpace = true;
+      continue;
+    }
+    if (pendingSpace && result.length > 0 && result[result.length - 1] !== " ") {
+      result += " ";
+    }
+    pendingSpace = false;
+    result += char;
+  }
+  return result.trim();
+}
+function normalizeKnownFunctionsOutsideQuotes(value) {
+  let result = "";
+  let inSingleQuote = false;
+  let inDoubleQuote = false;
+  let buffer = "";
+  function flushBuffer() {
+    if (!buffer) {
+      return;
+    }
+    result += buffer.replace(/\bnow\s*\(\s*\)/gi, "now()").replace(/\bgen_random_uuid\s*\(\s*\)/gi, "gen_random_uuid()");
+    buffer = "";
+  }
+  for (const char of value) {
+    if (char === "'" && !inDoubleQuote) {
+      flushBuffer();
+      inSingleQuote = !inSingleQuote;
+      result += char;
+      continue;
+    }
+    if (char === '"' && !inSingleQuote) {
+      flushBuffer();
+      inDoubleQuote = !inDoubleQuote;
+      result += char;
+      continue;
+    }
+    if (inSingleQuote || inDoubleQuote) {
+      result += char;
+      continue;
+    }
+    buffer += char;
+  }
+  flushBuffer();
+  return result;
+}
+function normalizePunctuationOutsideQuotes(value) {
+  let result = "";
+  let inSingleQuote = false;
+  let inDoubleQuote = false;
+  for (let index = 0; index < value.length; index++) {
+    const char = value[index];
+    if (char === "'" && !inDoubleQuote) {
+      inSingleQuote = !inSingleQuote;
+      result += char;
+      continue;
+    }
+    if (char === '"' && !inSingleQuote) {
+      inDoubleQuote = !inDoubleQuote;
+      result += char;
+      continue;
+    }
+    if (!inSingleQuote && !inDoubleQuote && (char === "(" || char === ")")) {
+      while (result.endsWith(" ")) {
+        result = result.slice(0, -1);
+      }
+      result += char;
+      let lookahead = index + 1;
+      while (lookahead < value.length && value[lookahead] === " ") {
+        lookahead++;
+      }
+      index = lookahead - 1;
+      continue;
+    }
+    if (!inSingleQuote && !inDoubleQuote && char === ",") {
+      while (result.endsWith(" ")) {
+        result = result.slice(0, -1);
+      }
+      result += ", ";
+      let lookahead = index + 1;
+      while (lookahead < value.length && value[lookahead] === " ") {
+        lookahead++;
+      }
+      index = lookahead - 1;
+      continue;
+    }
+    result += char;
+  }
+  return result;
+}
+function normalizeDefault(expr) {
+  if (expr === void 0 || expr === null) {
+    return null;
+  }
+  const trimmed = expr.trim();
+  if (trimmed.length === 0) {
+    return null;
+  }
+  const normalizedSpacing = normalizeSpacesOutsideQuotes(trimmed);
+  const normalizedPunctuation = normalizePunctuationOutsideQuotes(normalizedSpacing);
+  return normalizeKnownFunctionsOutsideQuotes(normalizedPunctuation);
+}
+
 // src/core/diff.ts
 function getTableNamesFromState(state) {
   return new Set(Object.keys(state.tables));
@@ -106,6 +249,15 @@ function getSortedNames(names) {
 function normalizeColumnType(type) {
   return type.toLowerCase().trim().replace(/\s+/g, " ").replace(/\s*\(\s*/g, "(").replace(/\s*,\s*/g, ",").replace(/\s*\)\s*/g, ")");
 }
+function resolveStatePrimaryKey(table) {
+  return table.primaryKey ?? Object.entries(table.columns).find(([, column]) => column.primaryKey)?.[0] ?? null;
+}
+function resolveSchemaPrimaryKey(table) {
+  return table.primaryKey ?? table.columns.find((column) => column.primaryKey)?.name ?? null;
+}
+function normalizeNullable(nullable) {
+  return nullable ?? true;
+}
 function diffSchemas(oldState, newSchema) {
   const operations = [];
   const oldTableNames = getTableNamesFromState(oldState);
@@ -147,6 +299,93 @@ function diffSchemas(oldState, newSchema) {
       }
     }
   }
+  for (const tableName of commonTableNames) {
+    const newTable = newSchema.tables[tableName];
+    const oldTable = oldState.tables[tableName];
+    if (!newTable || !oldTable) {
+      continue;
+    }
+    const previousPrimaryKey = resolveStatePrimaryKey(oldTable);
+    const currentPrimaryKey = resolveSchemaPrimaryKey(newTable);
+    if (previousPrimaryKey !== null && previousPrimaryKey !== currentPrimaryKey) {
+      operations.push({
+        kind: "drop_primary_key_constraint",
+        tableName
+      });
+    }
+  }
+  for (const tableName of commonTableNames) {
+    const newTable = newSchema.tables[tableName];
+    const oldTable = oldState.tables[tableName];
+    if (!newTable || !oldTable) {
+      continue;
+    }
+    for (const column of newTable.columns) {
+      const previousColumn = oldTable.columns[column.name];
+      if (!previousColumn) {
+        continue;
+      }
+      const previousUnique = previousColumn.unique ?? false;
+      const currentUnique = column.unique ?? false;
+      if (previousUnique !== currentUnique) {
+        operations.push({
+          kind: "column_unique_changed",
+          tableName,
+          columnName: column.name,
+          from: previousUnique,
+          to: currentUnique
+        });
+      }
+    }
+  }
+  for (const tableName of commonTableNames) {
+    const newTable = newSchema.tables[tableName];
+    const oldTable = oldState.tables[tableName];
+    if (!newTable || !oldTable) {
+      continue;
+    }
+    for (const column of newTable.columns) {
+      const previousColumn = oldTable.columns[column.name];
+      if (!previousColumn) {
+        continue;
+      }
+      const previousNullable = normalizeNullable(previousColumn.nullable);
+      const currentNullable = normalizeNullable(column.nullable);
+      if (previousNullable !== currentNullable) {
+        operations.push({
+          kind: "column_nullability_changed",
+          tableName,
+          columnName: column.name,
+          from: previousNullable,
+          to: currentNullable
+        });
+      }
+    }
+  }
+  for (const tableName of commonTableNames) {
+    const newTable = newSchema.tables[tableName];
+    const oldTable = oldState.tables[tableName];
+    if (!newTable || !oldTable) {
+      continue;
+    }
+    for (const column of newTable.columns) {
+      const previousColumn = oldTable.columns[column.name];
+      if (!previousColumn) {
+        continue;
+      }
+      const previousDefault = normalizeDefault(previousColumn.default);
+      const currentDefault = normalizeDefault(column.default);
+      if (previousDefault !== currentDefault) {
+        operations.push({
+          kind: "column_default_changed",
+          tableName,
+          columnName: column.name,
+          fromDefault: previousDefault,
+          toDefault: currentDefault
+        });
+      }
+    }
+  }
   for (const tableName of commonTableNames) {
     const newTable = newSchema.tables[tableName];
     const oldTable = oldState.tables[tableName];
@@ -164,6 +403,22 @@ function diffSchemas(oldState, newSchema) {
       }
     }
   }
+  for (const tableName of commonTableNames) {
+    const newTable = newSchema.tables[tableName];
+    const oldTable = oldState.tables[tableName];
+    if (!newTable || !oldTable) {
+      continue;
+    }
+    const previousPrimaryKey = resolveStatePrimaryKey(oldTable);
+    const currentPrimaryKey = resolveSchemaPrimaryKey(newTable);
+    if (currentPrimaryKey !== null && previousPrimaryKey !== currentPrimaryKey) {
+      operations.push({
+        kind: "add_primary_key_constraint",
+        tableName,
+        columnName: currentPrimaryKey
+      });
+    }
+  }
   for (const tableName of commonTableNames) {
     const newTable = newSchema.tables[tableName];
     const oldTable = oldState.tables[tableName];
@@ -421,11 +676,11 @@ function parseSchema(source) {
     "timestamptz",
     "date"
   ]);
-  function normalizeColumnType2(type) {
+  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 = normalizeColumnType2(type);
+    const normalizedType = normalizeColumnType3(type);
     if (validBaseColumnTypes.has(normalizedType)) {
       return true;
     }
@@ -450,11 +705,12 @@ function parseSchema(source) {
   }
   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 = normalizeColumnType2(tokens[1]);
+    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)`
@@ -462,7 +718,8 @@ function parseSchema(source) {
     }
     const column = {
       name: colName,
-      type: colType
+      type: colType,
+      nullable: true
     };
     let i = 2;
     while (i < tokens.length) {
@@ -480,13 +737,29 @@ function parseSchema(source) {
           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`);
           }
-          column.default = tokens[i];
-          i++;
+          {
+            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++;
@@ -536,9 +809,11 @@ function parseSchema(source) {
     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
+      columns,
+      ...primaryKeyColumn !== null && { primaryKey: primaryKeyColumn }
     };
     return lineIdx;
   }
@@ -706,17 +981,21 @@ async function schemaToState(schema) {
   const tables = {};
   for (const [tableName, table] of Object.entries(schema.tables)) {
     const columns = {};
+    const primaryKeyColumn = table.primaryKey ?? table.columns.find((column) => column.primaryKey)?.name ?? null;
     for (const column of table.columns) {
       columns[column.name] = {
         type: column.type,
         ...column.primaryKey !== void 0 && { primaryKey: column.primaryKey },
         ...column.unique !== void 0 && { unique: column.unique },
-        ...column.nullable !== void 0 && { nullable: column.nullable },
+        nullable: column.nullable ?? true,
         ...column.default !== void 0 && { default: column.default },
         ...column.foreignKey !== void 0 && { foreignKey: column.foreignKey }
       };
     }
-    tables[tableName] = { columns };
+    tables[tableName] = {
+      columns,
+      ...primaryKeyColumn !== null && { primaryKey: primaryKeyColumn }
+    };
   }
   return {
     version: 1,
@@ -948,14 +1227,14 @@ function validateDuplicateTables(schema) {
 }
 function validateTableColumns(tableName, table, allTables) {
   const columnNames = /* @__PURE__ */ new Set();
-  let primaryKeyCount = 0;
+  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) {
-      primaryKeyCount++;
+      primaryKeyColumns.push(column.name);
     }
     if (!isValidColumnType(column.type)) {
       throw new Error(
@@ -979,8 +1258,27 @@ function validateTableColumns(tableName, table, allTables) {
       }
     }
   }
-  if (primaryKeyCount > 1) {
-    throw new Error(`Table '${tableName}': can only have one primary key (found ${primaryKeyCount})`);
+  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`
+      );
+    }
   }
 }
 
@@ -1007,10 +1305,28 @@ function generateOperation(operation, provider, sqlConfig) {
         operation.columnName,
         operation.toType
       );
+    case "column_nullability_changed":
+      return generateAlterColumnNullability(
+        operation.tableName,
+        operation.columnName,
+        operation.to
+      );
     case "add_column":
       return generateAddColumn(operation.tableName, operation.column, provider, sqlConfig);
+    case "column_default_changed":
+      return generateAlterColumnDefault(
+        operation.tableName,
+        operation.columnName,
+        operation.toDefault
+      );
     case "drop_column":
       return generateDropColumn(operation.tableName, operation.columnName);
+    case "column_unique_changed":
+      return operation.to ? generateAddUniqueConstraint(operation.tableName, operation.columnName) : generateDropUniqueConstraint(operation.tableName, operation.columnName);
+    case "drop_primary_key_constraint":
+      return generateDropPrimaryKeyConstraint(operation.tableName);
+    case "add_primary_key_constraint":
+      return generateAddPrimaryKeyConstraint(operation.tableName, operation.columnName);
   }
 }
 function generateCreateTable(table, provider, sqlConfig) {
@@ -1061,6 +1377,42 @@ function generateDropColumn(tableName, columnName) {
 function generateAlterColumnType(tableName, columnName, newType) {
   return `ALTER TABLE ${tableName} ALTER COLUMN ${columnName} TYPE ${newType} USING ${columnName}::${newType};`;
 }
+function generateAddUniqueConstraint(tableName, columnName) {
+  const deterministicConstraintName = uqName(tableName, columnName);
+  return `ALTER TABLE ${tableName} ADD CONSTRAINT ${deterministicConstraintName} UNIQUE (${columnName});`;
+}
+function generateDropUniqueConstraint(tableName, columnName) {
+  const deterministicConstraintName = uqName(tableName, columnName);
+  const fallbackConstraintName = legacyUqName(tableName, columnName);
+  return generateDropConstraintStatements(tableName, [deterministicConstraintName, fallbackConstraintName]);
+}
+function generateDropPrimaryKeyConstraint(tableName) {
+  const deterministicConstraintName = pkName(tableName);
+  const fallbackConstraintName = legacyPkName(tableName);
+  return generateDropConstraintStatements(tableName, [deterministicConstraintName, fallbackConstraintName]);
+}
+function generateAddPrimaryKeyConstraint(tableName, columnName) {
+  const deterministicConstraintName = pkName(tableName);
+  return `ALTER TABLE ${tableName} ADD CONSTRAINT ${deterministicConstraintName} PRIMARY KEY (${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");
+}
+function generateAlterColumnDefault(tableName, columnName, newDefault) {
+  if (newDefault === null) {
+    return `ALTER TABLE ${tableName} ALTER COLUMN ${columnName} DROP DEFAULT;`;
+  }
+  return `ALTER TABLE ${tableName} ALTER COLUMN ${columnName} SET DEFAULT ${newDefault};`;
+}
+function generateAlterColumnNullability(tableName, columnName, toNullable) {
+  if (toNullable) {
+    return `ALTER TABLE ${tableName} ALTER COLUMN ${columnName} DROP NOT NULL;`;
+  }
+  return `ALTER TABLE ${tableName} ALTER COLUMN ${columnName} SET NOT NULL;`;
+}
 
 // src/commands/diff.ts
 var REQUIRED_CONFIG_FIELDS = ["schemaFile", "stateFile"];
@@ -1181,103 +1533,1211 @@ async function runGenerate(options) {
   success(`SQL generated successfully: ${migrationPath}`);
 }
 
-// src/commands/init.ts
+// src/commands/import.ts
 var import_commander3 = require("commander");
-async function runInit() {
-  const root = getProjectRoot();
-  const schemaForgeDir = getSchemaForgeDir(root);
-  if (await fileExists(schemaForgeDir)) {
-    error("schemaforge/ directory already exists");
-    error("Please remove it or run init in a different directory");
-    process.exit(1);
-  }
-  const schemaFilePath = getSchemaFilePath(root);
-  const configPath = getConfigPath(root);
-  const statePath = getStatePath(root);
-  if (await fileExists(schemaFilePath)) {
-    error(`${schemaFilePath} already exists`);
-    process.exit(1);
+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;
   }
-  if (await fileExists(configPath)) {
-    error(`${configPath} already exists`);
-    process.exit(1);
+  const targetColumn = table.columns.find((column) => column.name === constraint.columns[0]);
+  if (!targetColumn) {
+    return false;
   }
-  if (await fileExists(statePath)) {
-    error(`${statePath} already exists`);
-    process.exit(1);
+  if (constraint.type === "PRIMARY_KEY") {
+    table.primaryKey = targetColumn.name;
+    targetColumn.primaryKey = true;
+    targetColumn.nullable = false;
+    return true;
   }
-  info("Initializing schema project...");
-  await ensureDir(schemaForgeDir);
-  const schemaContent = `# SchemaForge schema definition
-# Run: schema-forge generate
-
-table users {
-  id uuid pk
-  created_at timestamptz default now()
+  targetColumn.unique = true;
+  return true;
 }
-`;
-  await writeTextFile(schemaFilePath, schemaContent);
-  success(`Created ${schemaFilePath}`);
-  const config = {
-    provider: "supabase",
-    outputDir: "supabase/migrations",
-    schemaFile: "schemaforge/schema.sf",
-    stateFile: "schemaforge/state.json",
-    sql: {
-      uuidDefault: "gen_random_uuid()",
-      timestampDefault: "now()"
+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;
     }
-  };
-  await writeJsonFile(configPath, config);
-  success(`Created ${configPath}`);
-  const state = {
-    version: 1,
-    tables: {}
-  };
-  await writeJsonFile(statePath, state);
-  success(`Created ${statePath}`);
-  const outputDir = "supabase/migrations";
-  await ensureDir(outputDir);
-  success(`Created ${outputDir}`);
-  success("Project initialized successfully");
-  info("Next steps:");
-  info("  1. Edit schemaforge/schema.sf to define your schema");
-  info("  2. Run: schema-forge generate");
-}
-
-// src/cli.ts
-var program = new import_commander4.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) {
-    error(error2.message);
-    process.exitCode = 2;
     return;
   }
-  if (error2 instanceof Error) {
-    error(error2.message);
-  } else {
-    error("Unexpected error");
+  if (name.endsWith("_key") || name.startsWith("uq_")) {
+    for (const column of table.columns) {
+      if (column.unique) {
+        column.unique = false;
+      }
+    }
   }
-  process.exitCode = 1;
 }
-program.command("init").description("Initialize a new schema project").action(async () => {
-  try {
-    await runInit();
-  } catch (error2) {
-    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);
+function getOrCreateTable(tables, name) {
+  if (!tables[name]) {
+    tables[name] = { name, columns: [] };
   }
-});
-program.command("diff").description("Compare two schema versions and generate migration SQL").action(async () => {
-  try {
-    await runDiff();
+  return tables[name];
+}
+function applySqlOps(ops) {
+  const tables = {};
+  const warnings = [];
+  for (const op of ops) {
+    switch (op.kind) {
+      case "CREATE_TABLE": {
+        const table = {
+          name: op.table,
+          columns: op.columns.map(toSchemaColumn)
+        };
+        for (const column of table.columns) {
+          if (column.primaryKey) {
+            table.primaryKey = column.name;
+          }
+        }
+        for (const constraint of op.constraints) {
+          const applied = applySingleColumnConstraint(table, constraint);
+          if (!applied) {
+            warnings.push({
+              statement: `CREATE TABLE ${op.table}`,
+              reason: `Constraint ${constraint.type}${constraint.name ? ` (${constraint.name})` : ""} is unsupported for schema reconstruction`
+            });
+          }
+        }
+        tables[op.table] = table;
+        break;
+      }
+      case "ADD_COLUMN": {
+        const table = getOrCreateTable(tables, op.table);
+        table.columns = table.columns.filter((column) => column.name !== op.column.name);
+        table.columns.push(toSchemaColumn(op.column));
+        if (op.column.primaryKey) {
+          table.primaryKey = op.column.name;
+        }
+        break;
+      }
+      case "ALTER_COLUMN_TYPE": {
+        const table = tables[op.table];
+        if (!table) {
+          break;
+        }
+        const column = table.columns.find((item) => item.name === op.column);
+        if (column) {
+          column.type = op.toType;
+        }
+        break;
+      }
+      case "SET_NOT_NULL": {
+        const table = tables[op.table];
+        const column = table?.columns.find((item) => item.name === op.column);
+        if (column) {
+          column.nullable = false;
+        }
+        break;
+      }
+      case "DROP_NOT_NULL": {
+        const table = tables[op.table];
+        const column = table?.columns.find((item) => item.name === op.column);
+        if (column) {
+          column.nullable = true;
+        }
+        break;
+      }
+      case "SET_DEFAULT": {
+        const table = tables[op.table];
+        const column = table?.columns.find((item) => item.name === op.column);
+        if (column) {
+          column.default = op.expr;
+        }
+        break;
+      }
+      case "DROP_DEFAULT": {
+        const table = tables[op.table];
+        const column = table?.columns.find((item) => item.name === op.column);
+        if (column) {
+          column.default = null;
+        }
+        break;
+      }
+      case "ADD_CONSTRAINT": {
+        const table = tables[op.table];
+        if (!table) {
+          break;
+        }
+        const applied = applySingleColumnConstraint(table, op.constraint);
+        if (!applied) {
+          warnings.push({
+            statement: `ALTER TABLE ${op.table} ADD CONSTRAINT ${op.constraint.name ?? "<unnamed>"}`,
+            reason: `Constraint ${op.constraint.type} is unsupported for schema reconstruction`
+          });
+        }
+        break;
+      }
+      case "DROP_CONSTRAINT": {
+        const table = tables[op.table];
+        if (!table) {
+          break;
+        }
+        clearConstraintByName(table, op.name);
+        break;
+      }
+      case "DROP_COLUMN": {
+        const table = tables[op.table];
+        if (!table) {
+          break;
+        }
+        table.columns = table.columns.filter((column) => column.name !== op.column);
+        if (table.primaryKey === op.column) {
+          table.primaryKey = null;
+        }
+        break;
+      }
+      case "DROP_TABLE": {
+        delete tables[op.table];
+        break;
+      }
+    }
+  }
+  const schema = { tables };
+  return { schema, warnings };
+}
+
+// src/core/sql/load-migrations.ts
+var import_fs6 = require("fs");
+var import_path6 = __toESM(require("path"));
+async function loadMigrationSqlInput(inputPath) {
+  const stats = await import_fs6.promises.stat(inputPath);
+  if (stats.isFile()) {
+    if (!inputPath.toLowerCase().endsWith(".sql")) {
+      throw new Error(`Input file must be a .sql file: ${inputPath}`);
+    }
+    return [{ filePath: inputPath, sql: await readTextFile(inputPath) }];
+  }
+  if (!stats.isDirectory()) {
+    throw new Error(`Input path must be a .sql file or directory: ${inputPath}`);
+  }
+  const sqlFiles = await findFiles(inputPath, /\.sql$/i);
+  sqlFiles.sort((left, right) => import_path6.default.basename(left).localeCompare(import_path6.default.basename(right)));
+  const result = [];
+  for (const filePath of sqlFiles) {
+    result.push({
+      filePath,
+      sql: await readTextFile(filePath)
+    });
+  }
+  return result;
+}
+
+// src/core/sql/split-statements.ts
+function splitSqlStatements(sql) {
+  const statements = [];
+  let current = "";
+  let inSingleQuote = false;
+  let inDoubleQuote = false;
+  let inLineComment = false;
+  let inBlockComment = false;
+  let dollarTag = null;
+  let index = 0;
+  while (index < sql.length) {
+    const char = sql[index];
+    const next = index + 1 < sql.length ? sql[index + 1] : "";
+    if (inLineComment) {
+      current += char;
+      if (char === "\n") {
+        inLineComment = false;
+      }
+      index++;
+      continue;
+    }
+    if (inBlockComment) {
+      current += char;
+      if (char === "*" && next === "/") {
+        current += next;
+        inBlockComment = false;
+        index += 2;
+        continue;
+      }
+      index++;
+      continue;
+    }
+    if (!inSingleQuote && !inDoubleQuote && dollarTag === null) {
+      if (char === "-" && next === "-") {
+        current += char + next;
+        inLineComment = true;
+        index += 2;
+        continue;
+      }
+      if (char === "/" && next === "*") {
+        current += char + next;
+        inBlockComment = true;
+        index += 2;
+        continue;
+      }
+    }
+    if (!inDoubleQuote && dollarTag === null && char === "'") {
+      current += char;
+      if (inSingleQuote && next === "'") {
+        current += next;
+        index += 2;
+        continue;
+      }
+      inSingleQuote = !inSingleQuote;
+      index++;
+      continue;
+    }
+    if (!inSingleQuote && dollarTag === null && char === '"') {
+      current += char;
+      if (inDoubleQuote && next === '"') {
+        current += next;
+        index += 2;
+        continue;
+      }
+      inDoubleQuote = !inDoubleQuote;
+      index++;
+      continue;
+    }
+    if (!inSingleQuote && !inDoubleQuote) {
+      if (dollarTag === null && char === "$") {
+        const remainder = sql.slice(index);
+        const match = remainder.match(/^\$[a-zA-Z_][a-zA-Z0-9_]*\$|^\$\$/);
+        if (match) {
+          dollarTag = match[0];
+          current += match[0];
+          index += match[0].length;
+          continue;
+        }
+      }
+      if (dollarTag !== null && sql.startsWith(dollarTag, index)) {
+        current += dollarTag;
+        index += dollarTag.length;
+        dollarTag = null;
+        continue;
+      }
+    }
+    if (!inSingleQuote && !inDoubleQuote && dollarTag === null && char === ";") {
+      const statement = current.trim();
+      if (statement.length > 0) {
+        statements.push(statement);
+      }
+      current = "";
+      index++;
+      continue;
+    }
+    current += char;
+    index++;
+  }
+  const tail = current.trim();
+  if (tail.length > 0) {
+    statements.push(tail);
+  }
+  return statements;
+}
+
+// src/core/sql/parse-migration.ts
+var COLUMN_CONSTRAINT_KEYWORDS = /* @__PURE__ */ new Set([
+  "primary",
+  "unique",
+  "not",
+  "null",
+  "default",
+  "constraint",
+  "references",
+  "check"
+]);
+function normalizeSqlType(type) {
+  return type.trim().toLowerCase().replace(/\s+/g, " ").replace(/\s*\(\s*/g, "(").replace(/\s*,\s*/g, ",").replace(/\s*\)\s*/g, ")");
+}
+function unquoteIdentifier(value) {
+  const trimmed = value.trim();
+  if (trimmed.startsWith('"') && trimmed.endsWith('"') && trimmed.length >= 2) {
+    return trimmed.slice(1, -1).replace(/""/g, '"');
+  }
+  return trimmed;
+}
+function normalizeIdentifier(identifier) {
+  const parts = identifier.trim().split(".").map((part) => unquoteIdentifier(part)).filter((part) => part.length > 0);
+  const leaf = parts.length > 0 ? parts[parts.length - 1] : identifier.trim();
+  return leaf.toLowerCase();
+}
+function removeSqlComments(statement) {
+  let result = "";
+  let inSingleQuote = false;
+  let inDoubleQuote = false;
+  let inLineComment = false;
+  let inBlockComment = false;
+  for (let index = 0; index < statement.length; index++) {
+    const char = statement[index];
+    const next = index + 1 < statement.length ? statement[index + 1] : "";
+    if (inLineComment) {
+      if (char === "\n") {
+        inLineComment = false;
+        result += char;
+      }
+      continue;
+    }
+    if (inBlockComment) {
+      if (char === "*" && next === "/") {
+        inBlockComment = false;
+        index++;
+      }
+      continue;
+    }
+    if (!inSingleQuote && !inDoubleQuote) {
+      if (char === "-" && next === "-") {
+        inLineComment = true;
+        index++;
+        continue;
+      }
+      if (char === "/" && next === "*") {
+        inBlockComment = true;
+        index++;
+        continue;
+      }
+    }
+    if (char === "'" && !inDoubleQuote) {
+      if (inSingleQuote && next === "'") {
+        result += "''";
+        index++;
+        continue;
+      }
+      inSingleQuote = !inSingleQuote;
+      result += char;
+      continue;
+    }
+    if (char === '"' && !inSingleQuote) {
+      if (inDoubleQuote && next === '"') {
+        result += '""';
+        index++;
+        continue;
+      }
+      inDoubleQuote = !inDoubleQuote;
+      result += char;
+      continue;
+    }
+    result += char;
+  }
+  return result.trim();
+}
+function splitTopLevelComma(input) {
+  const parts = [];
+  let current = "";
+  let depth = 0;
+  let inSingleQuote = false;
+  let inDoubleQuote = false;
+  for (let index = 0; index < input.length; index++) {
+    const char = input[index];
+    const next = index + 1 < input.length ? input[index + 1] : "";
+    if (char === "'" && !inDoubleQuote) {
+      current += char;
+      if (inSingleQuote && next === "'") {
+        current += next;
+        index++;
+        continue;
+      }
+      inSingleQuote = !inSingleQuote;
+      continue;
+    }
+    if (char === '"' && !inSingleQuote) {
+      current += char;
+      if (inDoubleQuote && next === '"') {
+        current += next;
+        index++;
+        continue;
+      }
+      inDoubleQuote = !inDoubleQuote;
+      continue;
+    }
+    if (!inSingleQuote && !inDoubleQuote) {
+      if (char === "(") {
+        depth++;
+      } else if (char === ")") {
+        depth = Math.max(0, depth - 1);
+      } else if (char === "," && depth === 0) {
+        const segment = current.trim();
+        if (segment.length > 0) {
+          parts.push(segment);
+        }
+        current = "";
+        continue;
+      }
+    }
+    current += char;
+  }
+  const tail = current.trim();
+  if (tail.length > 0) {
+    parts.push(tail);
+  }
+  return parts;
+}
+function tokenize(segment) {
+  const tokens = [];
+  let current = "";
+  let depth = 0;
+  let inSingleQuote = false;
+  let inDoubleQuote = false;
+  for (let index = 0; index < segment.length; index++) {
+    const char = segment[index];
+    const next = index + 1 < segment.length ? segment[index + 1] : "";
+    if (char === "'" && !inDoubleQuote) {
+      current += char;
+      if (inSingleQuote && next === "'") {
+        current += next;
+        index++;
+        continue;
+      }
+      inSingleQuote = !inSingleQuote;
+      continue;
+    }
+    if (char === '"' && !inSingleQuote) {
+      current += char;
+      if (inDoubleQuote && next === '"') {
+        current += next;
+        index++;
+        continue;
+      }
+      inDoubleQuote = !inDoubleQuote;
+      continue;
+    }
+    if (!inSingleQuote && !inDoubleQuote) {
+      if (char === "(") {
+        depth++;
+      } else if (char === ")") {
+        depth = Math.max(0, depth - 1);
+      }
+      if (/\s/.test(char) && depth === 0) {
+        if (current.length > 0) {
+          tokens.push(current);
+          current = "";
+        }
+        continue;
+      }
+    }
+    current += char;
+  }
+  if (current.length > 0) {
+    tokens.push(current);
+  }
+  return tokens;
+}
+function parseColumnDefinition(segment) {
+  const tokens = tokenize(segment);
+  if (tokens.length < 2) {
+    return null;
+  }
+  const name = normalizeIdentifier(tokens[0]);
+  let cursor = 1;
+  const typeTokens = [];
+  while (cursor < tokens.length) {
+    const lower = tokens[cursor].toLowerCase();
+    if (COLUMN_CONSTRAINT_KEYWORDS.has(lower)) {
+      break;
+    }
+    typeTokens.push(tokens[cursor]);
+    cursor++;
+  }
+  if (typeTokens.length === 0) {
+    return null;
+  }
+  const parsed = {
+    name,
+    type: normalizeSqlType(typeTokens.join(" ")),
+    nullable: true
+  };
+  while (cursor < tokens.length) {
+    const lower = tokens[cursor].toLowerCase();
+    if (lower === "primary" && tokens[cursor + 1]?.toLowerCase() === "key") {
+      parsed.primaryKey = true;
+      parsed.nullable = false;
+      cursor += 2;
+      continue;
+    }
+    if (lower === "unique") {
+      parsed.unique = true;
+      cursor++;
+      continue;
+    }
+    if (lower === "not" && tokens[cursor + 1]?.toLowerCase() === "null") {
+      parsed.nullable = false;
+      cursor += 2;
+      continue;
+    }
+    if (lower === "null") {
+      parsed.nullable = true;
+      cursor++;
+      continue;
+    }
+    if (lower === "default") {
+      cursor++;
+      const defaultTokens = [];
+      while (cursor < tokens.length) {
+        const probe = tokens[cursor].toLowerCase();
+        if (probe === "constraint" || probe === "references" || probe === "check" || probe === "not" && tokens[cursor + 1]?.toLowerCase() === "null" || probe === "null" || probe === "unique" || probe === "primary" && tokens[cursor + 1]?.toLowerCase() === "key") {
+          break;
+        }
+        defaultTokens.push(tokens[cursor]);
+        cursor++;
+      }
+      parsed.default = normalizeDefault(defaultTokens.join(" "));
+      continue;
+    }
+    cursor++;
+  }
+  return parsed;
+}
+function parseCreateTableConstraint(segment) {
+  const normalized = segment.trim().replace(/\s+/g, " ");
+  const constraintMatch = normalized.match(/^constraint\s+([^\s]+)\s+(primary\s+key|unique)\s*\((.+)\)$/i);
+  if (constraintMatch) {
+    const [, rawName, kind, rawColumns] = constraintMatch;
+    const columns = splitTopLevelComma(rawColumns).map((item) => normalizeIdentifier(item));
+    if (kind.toLowerCase().includes("primary")) {
+      return { type: "PRIMARY_KEY", name: normalizeIdentifier(rawName), columns };
+    }
+    return { type: "UNIQUE", name: normalizeIdentifier(rawName), columns };
+  }
+  const barePk = normalized.match(/^primary\s+key\s*\((.+)\)$/i);
+  if (barePk) {
+    const columns = splitTopLevelComma(barePk[1]).map((item) => normalizeIdentifier(item));
+    return { type: "PRIMARY_KEY", columns };
+  }
+  const bareUnique = normalized.match(/^unique\s*\((.+)\)$/i);
+  if (bareUnique) {
+    const columns = splitTopLevelComma(bareUnique[1]).map((item) => normalizeIdentifier(item));
+    return { type: "UNIQUE", columns };
+  }
+  return null;
+}
+function parseAlterTablePrefix(stmt) {
+  const match = stmt.match(/^alter\s+table\s+(?:if\s+exists\s+)?(?:only\s+)?(.+)$/i);
+  if (!match) {
+    return null;
+  }
+  const remainder = match[1].trim();
+  const tokens = tokenize(remainder);
+  if (tokens.length < 2) {
+    return null;
+  }
+  const tableToken = tokens[0];
+  const table = normalizeIdentifier(tableToken);
+  const rest = remainder.slice(tableToken.length).trim();
+  return { table, rest };
+}
+function parseCreateTable(stmt) {
+  const match = stmt.match(/^create\s+table\s+(?:if\s+not\s+exists\s+)?(.+?)\s*\((.*)\)$/is);
+  if (!match) {
+    return null;
+  }
+  const table = normalizeIdentifier(match[1]);
+  const body = match[2];
+  const segments = splitTopLevelComma(body);
+  const columns = [];
+  const constraints = [];
+  for (const segment of segments) {
+    const constraint = parseCreateTableConstraint(segment);
+    if (constraint) {
+      constraints.push(constraint);
+      continue;
+    }
+    const column = parseColumnDefinition(segment);
+    if (column) {
+      columns.push(column);
+    }
+  }
+  return {
+    kind: "CREATE_TABLE",
+    table,
+    columns,
+    constraints
+  };
+}
+function parseAlterTableAddColumn(stmt) {
+  const prefix = parseAlterTablePrefix(stmt);
+  if (!prefix) {
+    return null;
+  }
+  const match = prefix.rest.match(/^add\s+column\s+(?:if\s+not\s+exists\s+)?(.+)$/i);
+  if (!match) {
+    return null;
+  }
+  const column = parseColumnDefinition(match[1]);
+  if (!column) {
+    return null;
+  }
+  return { kind: "ADD_COLUMN", table: prefix.table, column };
+}
+function parseAlterColumnType(stmt) {
+  const prefix = parseAlterTablePrefix(stmt);
+  if (!prefix) {
+    return null;
+  }
+  const match = prefix.rest.match(/^alter\s+column\s+([^\s]+)\s+type\s+(.+)$/i);
+  if (!match) {
+    return null;
+  }
+  const column = normalizeIdentifier(match[1]);
+  const toType = normalizeSqlType(match[2].replace(/\s+using\s+[\s\S]*$/i, "").trim());
+  return {
+    kind: "ALTER_COLUMN_TYPE",
+    table: prefix.table,
+    column,
+    toType
+  };
+}
+function parseSetDropNotNull(stmt) {
+  const prefix = parseAlterTablePrefix(stmt);
+  if (!prefix) {
+    return null;
+  }
+  const setMatch = prefix.rest.match(/^alter\s+column\s+([^\s]+)\s+set\s+not\s+null$/i);
+  if (setMatch) {
+    return {
+      kind: "SET_NOT_NULL",
+      table: prefix.table,
+      column: normalizeIdentifier(setMatch[1])
+    };
+  }
+  const dropMatch = prefix.rest.match(/^alter\s+column\s+([^\s]+)\s+drop\s+not\s+null$/i);
+  if (dropMatch) {
+    return {
+      kind: "DROP_NOT_NULL",
+      table: prefix.table,
+      column: normalizeIdentifier(dropMatch[1])
+    };
+  }
+  return null;
+}
+function parseSetDropDefault(stmt) {
+  const prefix = parseAlterTablePrefix(stmt);
+  if (!prefix) {
+    return null;
+  }
+  const setMatch = prefix.rest.match(/^alter\s+column\s+([^\s]+)\s+set\s+default\s+(.+)$/i);
+  if (setMatch) {
+    return {
+      kind: "SET_DEFAULT",
+      table: prefix.table,
+      column: normalizeIdentifier(setMatch[1]),
+      expr: normalizeDefault(setMatch[2].trim()) ?? setMatch[2].trim()
+    };
+  }
+  const dropMatch = prefix.rest.match(/^alter\s+column\s+([^\s]+)\s+drop\s+default$/i);
+  if (dropMatch) {
+    return {
+      kind: "DROP_DEFAULT",
+      table: prefix.table,
+      column: normalizeIdentifier(dropMatch[1])
+    };
+  }
+  return null;
+}
+function parseAddDropConstraint(stmt) {
+  const prefix = parseAlterTablePrefix(stmt);
+  if (!prefix) {
+    return null;
+  }
+  const addMatch = prefix.rest.match(/^add\s+constraint\s+([^\s]+)\s+(primary\s+key|unique)\s*\((.+)\)$/i);
+  if (addMatch) {
+    const [, rawName, kind, rawColumns] = addMatch;
+    const columns = splitTopLevelComma(rawColumns).map((item) => normalizeIdentifier(item));
+    const constraint = kind.toLowerCase().includes("primary") ? { type: "PRIMARY_KEY", name: normalizeIdentifier(rawName), columns } : { type: "UNIQUE", name: normalizeIdentifier(rawName), columns };
+    return {
+      kind: "ADD_CONSTRAINT",
+      table: prefix.table,
+      constraint
+    };
+  }
+  const dropMatch = prefix.rest.match(/^drop\s+constraint\s+(?:if\s+exists\s+)?([^\s]+)(?:\s+cascade)?$/i);
+  if (dropMatch) {
+    return {
+      kind: "DROP_CONSTRAINT",
+      table: prefix.table,
+      name: normalizeIdentifier(dropMatch[1])
+    };
+  }
+  return null;
+}
+function parseDropColumn(stmt) {
+  const prefix = parseAlterTablePrefix(stmt);
+  if (!prefix) {
+    return null;
+  }
+  const match = prefix.rest.match(/^drop\s+column\s+(?:if\s+exists\s+)?([^\s]+)(?:\s+cascade)?$/i);
+  if (!match) {
+    return null;
+  }
+  return {
+    kind: "DROP_COLUMN",
+    table: prefix.table,
+    column: normalizeIdentifier(match[1])
+  };
+}
+function parseDropTable(stmt) {
+  const match = stmt.match(/^drop\s+table\s+(?:if\s+exists\s+)?([^\s]+)(?:\s+cascade)?$/i);
+  if (!match) {
+    return null;
+  }
+  return {
+    kind: "DROP_TABLE",
+    table: normalizeIdentifier(match[1])
+  };
+}
+var PARSERS = [
+  parseCreateTable,
+  parseAlterTableAddColumn,
+  parseAlterColumnType,
+  parseSetDropNotNull,
+  parseSetDropDefault,
+  parseAddDropConstraint,
+  parseDropColumn,
+  parseDropTable
+];
+function parseMigrationSql(sql) {
+  const statements = splitSqlStatements(sql);
+  const ops = [];
+  const warnings = [];
+  for (const raw of statements) {
+    const stmt = removeSqlComments(raw).trim();
+    if (!stmt) {
+      continue;
+    }
+    let parsed = null;
+    for (const parseFn of PARSERS) {
+      parsed = parseFn(stmt);
+      if (parsed) {
+        break;
+      }
+    }
+    if (parsed) {
+      ops.push(parsed);
+    } else {
+      warnings.push({
+        statement: stmt,
+        reason: "Unsupported or unrecognized statement"
+      });
+    }
+  }
+  return { ops, warnings };
+}
+
+// src/core/sql/schema-to-dsl.ts
+function renderColumn(column) {
+  const parts = [column.name, column.type];
+  if (column.primaryKey) {
+    parts.push("pk");
+  }
+  if (column.unique) {
+    parts.push("unique");
+  }
+  if (column.nullable === false && !column.primaryKey) {
+    parts.push("not null");
+  }
+  if (column.default !== void 0 && column.default !== null) {
+    parts.push(`default ${column.default}`);
+  }
+  return `  ${parts.join(" ")}`;
+}
+function schemaToDsl(schema) {
+  const tableNames = Object.keys(schema.tables).sort((left, right) => left.localeCompare(right));
+  const blocks = tableNames.map((tableName) => {
+    const table = schema.tables[tableName];
+    const lines = [`table ${table.name} {`];
+    for (const column of table.columns) {
+      lines.push(renderColumn(column));
+    }
+    lines.push("}");
+    return lines.join("\n");
+  });
+  if (blocks.length === 0) {
+    return "# SchemaForge schema definition\n";
+  }
+  return `# SchemaForge schema definition
+
+${blocks.join("\n\n")}
+`;
+}
+
+// src/commands/import.ts
+function resolveConfigPath3(root, targetPath) {
+  return import_path7.default.isAbsolute(targetPath) ? targetPath : import_path7.default.join(root, targetPath);
+}
+async function runImport(inputPath, options = {}) {
+  const root = getProjectRoot();
+  const absoluteInputPath = resolveConfigPath3(root, inputPath);
+  const inputs = await loadMigrationSqlInput(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);
+    allOps.push(...result.ops);
+    parseWarnings.push(...result.warnings.map((item) => ({
+      statement: `[${import_path7.default.basename(input.filePath)}] ${item.statement}`,
+      reason: item.reason
+    })));
+  }
+  const applied = applySqlOps(allOps);
+  const dsl = schemaToDsl(applied.schema);
+  let targetPath = options.out;
+  if (!targetPath) {
+    const configPath = getConfigPath(root);
+    if (await fileExists(configPath)) {
+      const config = await readJsonFile(configPath, {});
+      if (typeof config.schemaFile === "string" && config.schemaFile.length > 0) {
+        targetPath = config.schemaFile;
+      }
+    }
+  }
+  const schemaPath = targetPath ? resolveConfigPath3(root, targetPath) : getSchemaFilePath(root);
+  await writeTextFile(schemaPath, dsl);
+  success(`Imported ${inputs.length} migration file(s) into ${schemaPath}`);
+  info(`Parsed ${allOps.length} supported DDL operation(s)`);
+  const warnings = [...parseWarnings, ...applied.warnings];
+  if (warnings.length > 0) {
+    warning(`Ignored ${warnings.length} unsupported item(s)`);
+    for (const item of warnings.slice(0, 10)) {
+      warning(`${item.reason}: ${item.statement}`);
+    }
+    if (warnings.length > 10) {
+      warning(`...and ${warnings.length - 10} more`);
+    }
+  }
+}
+
+// src/commands/init.ts
+var import_commander4 = require("commander");
+async function runInit() {
+  const root = getProjectRoot();
+  const schemaForgeDir = getSchemaForgeDir(root);
+  if (await fileExists(schemaForgeDir)) {
+    error("schemaforge/ directory already exists");
+    error("Please remove it or run init in a different directory");
+    process.exit(1);
+  }
+  const schemaFilePath = getSchemaFilePath(root);
+  const configPath = getConfigPath(root);
+  const statePath = getStatePath(root);
+  if (await fileExists(schemaFilePath)) {
+    error(`${schemaFilePath} already exists`);
+    process.exit(1);
+  }
+  if (await fileExists(configPath)) {
+    error(`${configPath} already exists`);
+    process.exit(1);
+  }
+  if (await fileExists(statePath)) {
+    error(`${statePath} already exists`);
+    process.exit(1);
+  }
+  info("Initializing schema project...");
+  await ensureDir(schemaForgeDir);
+  const schemaContent = `# SchemaForge schema definition
+# Run: schema-forge generate
+
+table users {
+  id uuid pk
+  created_at timestamptz default now()
+}
+`;
+  await writeTextFile(schemaFilePath, schemaContent);
+  success(`Created ${schemaFilePath}`);
+  const config = {
+    provider: "supabase",
+    outputDir: "supabase/migrations",
+    schemaFile: "schemaforge/schema.sf",
+    stateFile: "schemaforge/state.json",
+    sql: {
+      uuidDefault: "gen_random_uuid()",
+      timestampDefault: "now()"
+    }
+  };
+  await writeJsonFile(configPath, config);
+  success(`Created ${configPath}`);
+  const state = {
+    version: 1,
+    tables: {}
+  };
+  await writeJsonFile(statePath, state);
+  success(`Created ${statePath}`);
+  const outputDir = "supabase/migrations";
+  await ensureDir(outputDir);
+  success(`Created ${outputDir}`);
+  success("Project initialized successfully");
+  info("Next steps:");
+  info("  1. Edit schemaforge/schema.sf to define your schema");
+  info("  2. Run: schema-forge generate");
+}
+
+// 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 REQUIRED_CONFIG_FIELDS3 = ["schemaFile", "stateFile"];
+function resolveConfigPath4(root, targetPath) {
+  return import_path8.default.isAbsolute(targetPath) ? targetPath : import_path8.default.join(root, targetPath);
+}
+async function runValidate(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_FIELDS3) {
+    const value = config[field];
+    if (!value || typeof value !== "string") {
+      throw new Error(`Invalid config: '${field}' is required`);
+    }
+  }
+  const schemaPath = resolveConfigPath4(root, config.schemaFile);
+  const statePath = resolveConfigPath4(root, config.stateFile);
+  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 findings = validateSchemaChanges(previousState, schema);
+  const report = toValidationReport(findings);
+  if (options.json) {
+    console.log(JSON.stringify(report, null, 2));
+    process.exitCode = report.hasErrors ? 1 : 0;
+    return;
+  }
+  if (findings.length === 0) {
+    success("No destructive changes detected");
+    process.exitCode = 0;
+    return;
+  }
+  console.log(
+    `Validation Summary: ${report.errors.length} error(s), ${report.warnings.length} warning(s)`
+  );
+  const tableOrder = Array.from(new Set(findings.map((finding) => finding.table)));
+  for (const tableName of tableOrder) {
+    console.log(tableName);
+    for (const finding of findings.filter((entry) => entry.table === tableName)) {
+      const target = finding.column ? `${finding.table}.${finding.column}` : finding.table;
+      const typeRange = finding.from && finding.to ? ` (${finding.from} -> ${finding.to})` : "";
+      console.log(
+        `${finding.severity.toUpperCase()}: ${finding.code} ${target}${typeRange} - ${finding.message}`
+      );
+    }
+  }
+  process.exitCode = report.hasErrors ? 1 : 0;
+}
+
+// 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) {
+    error(error2.message);
+    process.exitCode = 2;
+    return;
+  }
+  if (error2 instanceof Error) {
+    error(error2.message);
+  } else {
+    error("Unexpected error");
+  }
+  process.exitCode = 1;
+}
+program.command("init").description("Initialize a new schema project").action(async () => {
+  try {
+    await runInit();
+  } catch (error2) {
+    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);
+  }
+});
+program.command("diff").description("Compare two schema versions and generate migration SQL").action(async () => {
+  try {
+    await runDiff();
+  } catch (error2) {
+    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);
+  }
+});
+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);
   }