@xubylele/schema-forge 1.2.0 → 1.5.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.5.0",
   description: "Universal migration generator from schema DSL",
   main: "dist/cli.js",
   type: "commonjs",
@@ -69,6 +69,7 @@ var package_default = {
     node: ">=18.0.0"
   },
   dependencies: {
+    "@xubylele/schema-forge-core": "^1.0.4",
     boxen: "^8.0.1",
     chalk: "^5.6.2",
     commander: "^14.0.3"
@@ -85,120 +86,7 @@ var package_default = {
 
 // src/commands/diff.ts
 var import_commander = require("commander");
-var import_path4 = __toESM(require("path"));
-
-// src/core/diff.ts
-function getTableNamesFromState(state) {
-  return new Set(Object.keys(state.tables));
-}
-function getTableNamesFromSchema(schema) {
-  return new Set(Object.keys(schema.tables));
-}
-function getColumnNamesFromState(stateColumns) {
-  return new Set(Object.keys(stateColumns));
-}
-function getColumnNamesFromSchema(dbColumns) {
-  return new Set(dbColumns.map((column) => column.name));
-}
-function getSortedNames(names) {
-  return Array.from(names).sort((a, b) => a.localeCompare(b));
-}
-function normalizeColumnType(type) {
-  return type.toLowerCase().trim().replace(/\s+/g, " ").replace(/\s*\(\s*/g, "(").replace(/\s*,\s*/g, ",").replace(/\s*\)\s*/g, ")");
-}
-function diffSchemas(oldState, newSchema) {
-  const operations = [];
-  const oldTableNames = getTableNamesFromState(oldState);
-  const newTableNames = getTableNamesFromSchema(newSchema);
-  const sortedNewTableNames = getSortedNames(newTableNames);
-  const sortedOldTableNames = getSortedNames(oldTableNames);
-  for (const tableName of sortedNewTableNames) {
-    if (!oldTableNames.has(tableName)) {
-      operations.push({
-        kind: "create_table",
-        table: newSchema.tables[tableName]
-      });
-    }
-  }
-  const commonTableNames = sortedNewTableNames.filter(
-    (tableName) => oldTableNames.has(tableName)
-  );
-  for (const tableName of commonTableNames) {
-    const newTable = newSchema.tables[tableName];
-    const oldTable = oldState.tables[tableName];
-    if (!newTable || !oldTable) {
-      continue;
-    }
-    for (const column of newTable.columns) {
-      const previousColumn = oldTable.columns[column.name];
-      if (!previousColumn) {
-        continue;
-      }
-      const previousType = normalizeColumnType(previousColumn.type);
-      const currentType = normalizeColumnType(column.type);
-      if (previousType !== currentType) {
-        operations.push({
-          kind: "column_type_changed",
-          tableName,
-          columnName: column.name,
-          fromType: previousColumn.type,
-          toType: column.type
-        });
-      }
-    }
-  }
-  for (const tableName of commonTableNames) {
-    const newTable = newSchema.tables[tableName];
-    const oldTable = oldState.tables[tableName];
-    if (!newTable || !oldTable) {
-      continue;
-    }
-    const oldColumnNames = getColumnNamesFromState(oldTable.columns);
-    for (const column of newTable.columns) {
-      if (!oldColumnNames.has(column.name)) {
-        operations.push({
-          kind: "add_column",
-          tableName,
-          column
-        });
-      }
-    }
-  }
-  for (const tableName of commonTableNames) {
-    const newTable = newSchema.tables[tableName];
-    const oldTable = oldState.tables[tableName];
-    if (!newTable || !oldTable) {
-      continue;
-    }
-    const newColumnNames = getColumnNamesFromSchema(newTable.columns);
-    for (const columnName of Object.keys(oldTable.columns)) {
-      if (!newColumnNames.has(columnName)) {
-        operations.push({
-          kind: "drop_column",
-          tableName,
-          columnName
-        });
-      }
-    }
-  }
-  for (const tableName of sortedOldTableNames) {
-    if (!newTableNames.has(tableName)) {
-      operations.push({
-        kind: "drop_table",
-        tableName
-      });
-    }
-  }
-  return { operations };
-}
-
-// src/core/errors.ts
-var SchemaValidationError = class extends Error {
-  constructor(message) {
-    super(message);
-    this.name = "SchemaValidationError";
-  }
-};
+var import_path3 = __toESM(require("path"));
 
 // src/core/fs.ts
 var import_fs = require("fs");
@@ -254,309 +142,6 @@ async function writeJsonFile(filePath, data) {
     throw new Error(`Failed to write JSON file ${filePath}: ${error2}`);
   }
 }
-async function findFiles(dirPath, pattern) {
-  const results = [];
-  try {
-    const items = await import_fs.promises.readdir(dirPath, { withFileTypes: true });
-    for (const item of items) {
-      const fullPath = import_path.default.join(dirPath, item.name);
-      if (item.isDirectory()) {
-        const subResults = await findFiles(fullPath, pattern);
-        results.push(...subResults);
-      } else if (item.isFile() && pattern.test(item.name)) {
-        results.push(fullPath);
-      }
-    }
-  } catch (error2) {
-    throw new Error(`Failed to find files in ${dirPath}: ${error2}`);
-  }
-  return results;
-}
-
-// src/utils/output.ts
-var import_boxen = __toESM(require("boxen"));
-var import_chalk = require("chalk");
-var isInteractive = Boolean(process.stdout?.isTTY);
-var colorsEnabled = isInteractive && process.env.FORCE_COLOR !== "0" && !("NO_COLOR" in process.env);
-var color = new import_chalk.Chalk({ level: colorsEnabled ? 3 : 0 });
-var theme = {
-  primary: color.cyanBright,
-  success: color.hex("#00FF88"),
-  warning: color.hex("#FFD166"),
-  error: color.hex("#EF476F"),
-  accent: color.magentaBright
-};
-function success(message) {
-  const text = theme.success(`[OK] ${message}`);
-  if (!isInteractive) {
-    console.log(text);
-    return;
-  }
-  try {
-    console.log(
-      (0, import_boxen.default)(text, {
-        padding: 1,
-        borderColor: "cyan",
-        borderStyle: "round"
-      })
-    );
-  } catch {
-    console.log(text);
-  }
-}
-function info(message) {
-  console.log(theme.primary(message));
-}
-function warning(message) {
-  console.warn(theme.warning(`[WARN] ${message}`));
-}
-function error(message) {
-  console.error(theme.error(`[ERROR] ${message}`));
-}
-
-// src/core/parser.ts
-var SchemaParser = class {
-  /**
-   * Parse a schema from a JSON file
-   */
-  async parseSchemaFile(filePath) {
-    try {
-      const schema = await readJsonFile(filePath, {});
-      return this.normalizeSchema(schema);
-    } catch (error2) {
-      throw new Error(`Failed to parse schema file ${filePath}: ${error2}`);
-    }
-  }
-  /**
-   * Parse multiple schema files from a directory
-   */
-  async parseSchemaDirectory(dirPath) {
-    const schemaFiles = await findFiles(dirPath, /\.schema\.json$/);
-    const schemas = [];
-    for (const file of schemaFiles) {
-      try {
-        const schema = await this.parseSchemaFile(file);
-        schemas.push(schema);
-      } catch (error2) {
-        const reason = error2 instanceof Error ? error2.message : String(error2);
-        warning(`Could not parse ${file}: ${reason}`);
-      }
-    }
-    return schemas;
-  }
-  /**
-   * Merge multiple schemas into one
-   */
-  mergeSchemas(schemas) {
-    if (schemas.length === 0) {
-      throw new Error("Cannot merge empty schema array");
-    }
-    const baseSchema = schemas[0];
-    const mergedTables = [];
-    for (const schema of schemas) {
-      for (const table of schema.tables) {
-        const existingIndex = mergedTables.findIndex((t) => t.name === table.name);
-        if (existingIndex >= 0) {
-          warning(`Duplicate table '${table.name}' found, using first occurrence`);
-        } else {
-          mergedTables.push(table);
-        }
-      }
-    }
-    return {
-      version: baseSchema.version,
-      database: baseSchema.database,
-      tables: mergedTables
-    };
-  }
-  /**
-   * Normalize schema to ensure consistent structure
-   */
-  normalizeSchema(schema) {
-    return {
-      version: schema.version || "1.0.0",
-      database: schema.database || "postgres",
-      tables: schema.tables.map((table) => ({
-        ...table,
-        fields: table.fields.map((field) => ({
-          ...field,
-          required: field.required ?? false,
-          unique: field.unique ?? false
-        })),
-        indexes: table.indexes || [],
-        constraints: table.constraints || []
-      }))
-    };
-  }
-  /**
-   * Convert schema to JSON string
-   */
-  schemaToJson(schema, pretty = true) {
-    return pretty ? JSON.stringify(schema, null, 2) : JSON.stringify(schema);
-  }
-  /**
-   * Parse schema from JSON string
-   */
-  parseSchemaString(jsonString) {
-    try {
-      const schema = JSON.parse(jsonString);
-      return this.normalizeSchema(schema);
-    } catch (error2) {
-      throw new Error(`Failed to parse schema JSON: ${error2}`);
-    }
-  }
-};
-var defaultParser = new SchemaParser();
-function parseSchema(source) {
-  const lines = source.split("\n");
-  const tables = {};
-  let currentLine = 0;
-  const validBaseColumnTypes = /* @__PURE__ */ new Set([
-    "uuid",
-    "varchar",
-    "text",
-    "int",
-    "bigint",
-    "boolean",
-    "timestamptz",
-    "date"
-  ]);
-  function normalizeColumnType2(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);
-    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);
-    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]);
-    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
-    };
-    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 "default":
-          i++;
-          if (i >= tokens.length) {
-            throw new Error(`Line ${lineNum}: 'default' modifier requires a value`);
-          }
-          column.default = tokens[i];
-          i++;
-          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 '}')`);
-    }
-    tables[tableName] = {
-      name: tableName,
-      columns
-    };
-    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"));
@@ -581,491 +166,129 @@ function getStatePath(root, config) {
   return import_path2.default.join(schemaForgeDir, fileName);
 }
 
-// src/core/state-manager.ts
-var import_path3 = __toESM(require("path"));
-var StateManager = class {
-  constructor(root = process.cwd()) {
-    this.config = null;
-    this.root = root;
-  }
-  /**
-   * Initialize a new SchemaForge project
-   */
-  async initializeProject(directory = ".", force = false) {
-    const configPath = import_path3.default.join(directory, "schemaforge.config.json");
-    if (await fileExists(configPath) && !force) {
-      throw new Error("SchemaForge project already initialized. Use --force to overwrite.");
-    }
-    const defaultConfig = {
-      version: "1.0.0",
-      database: "postgres",
-      schemaDir: "schemas",
-      outputDir: "output",
-      migrationDir: "migrations"
-    };
-    await writeJsonFile(configPath, defaultConfig);
-    await ensureDir(import_path3.default.join(directory, defaultConfig.schemaDir));
-    await ensureDir(import_path3.default.join(directory, defaultConfig.outputDir));
-    await ensureDir(import_path3.default.join(directory, defaultConfig.migrationDir));
-    const exampleSchema = {
-      version: "1.0.0",
-      database: "postgres",
-      tables: [
-        {
-          name: "users",
-          fields: [
-            { name: "id", type: "uuid", required: true, unique: true },
-            { name: "email", type: "string", required: true, unique: true, length: 255 },
-            { name: "name", type: "string", required: true, length: 255 },
-            { name: "created_at", type: "datetime", required: true }
-          ],
-          indexes: [
-            { name: "idx_users_email", fields: ["email"], unique: true }
-          ]
-        }
-      ]
-    };
-    const exampleSchemaPath = import_path3.default.join(
-      directory,
-      defaultConfig.schemaDir,
-      "example.schema.json"
-    );
-    await writeJsonFile(exampleSchemaPath, exampleSchema);
-    this.config = defaultConfig;
-  }
-  /**
-   * Load configuration from file
-   */
-  async loadConfig(directory = ".") {
-    const configPath = import_path3.default.join(directory, "schemaforge.config.json");
-    if (!await fileExists(configPath)) {
-      throw new Error('SchemaForge project not initialized. Run "schemaforge init" first.');
-    }
-    this.config = await readJsonFile(configPath, {});
-    return this.config;
-  }
-  /**
-   * Save configuration to file
-   */
-  async saveConfig(config, directory = ".") {
-    const configPath = import_path3.default.join(directory, "schemaforge.config.json");
-    await writeJsonFile(configPath, config);
-    this.config = config;
-  }
-  /**
-   * Get current configuration
-   */
-  getConfig() {
-    return this.config;
-  }
-  /**
-   * Update configuration
-   */
-  updateConfig(updates) {
-    if (!this.config) {
-      throw new Error("No configuration loaded");
-    }
-    this.config = { ...this.config, ...updates };
+// src/core/provider.ts
+var DEFAULT_PROVIDER = "postgres";
+function resolveProvider(provider) {
+  if (!provider) {
+    return { provider: DEFAULT_PROVIDER, usedDefault: true };
   }
-  /**
-   * Check if project is initialized
-   */
-  async isInitialized(directory = ".") {
-    const configPath = import_path3.default.join(directory, "schemaforge.config.json");
-    return await fileExists(configPath);
-  }
-  /**
-   * Get schema directory path
-   */
-  getSchemaDir() {
-    if (!this.config) {
-      throw new Error("No configuration loaded");
-    }
-    return import_path3.default.join(this.root, this.config.schemaDir);
-  }
-  /**
-   * Get output directory path
-   */
-  getOutputDir() {
-    if (!this.config) {
-      throw new Error("No configuration loaded");
-    }
-    return import_path3.default.join(this.root, this.config.outputDir);
-  }
-  /**
-   * Get migration directory path
-   */
-  getMigrationDir() {
-    if (!this.config) {
-      throw new Error("No configuration loaded");
-    }
-    return import_path3.default.join(this.root, this.config.migrationDir);
+  return { provider, usedDefault: false };
+}
+
+// src/domain.ts
+var corePromise;
+async function loadCore() {
+  if (!corePromise) {
+    corePromise = import("@xubylele/schema-forge-core");
   }
-};
+  return corePromise;
+}
+async function parseSchema(source) {
+  const core = await loadCore();
+  return core.parseSchema(source);
+}
+async function validateSchema(schema) {
+  const core = await loadCore();
+  core.validateSchema(schema);
+}
+async function diffSchemas(previousState, currentSchema) {
+  const core = await loadCore();
+  return core.diffSchemas(previousState, currentSchema);
+}
+async function generateSql(diff, provider, config) {
+  const core = await loadCore();
+  return core.generateSql(diff, provider, config);
+}
 async function schemaToState(schema) {
-  const tables = {};
-  for (const [tableName, table] of Object.entries(schema.tables)) {
-    const columns = {};
-    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 },
-        ...column.default !== void 0 && { default: column.default },
-        ...column.foreignKey !== void 0 && { foreignKey: column.foreignKey }
-      };
-    }
-    tables[tableName] = { columns };
-  }
-  return {
-    version: 1,
-    tables
-  };
+  const core = await loadCore();
+  return core.schemaToState(schema);
 }
 async function loadState(statePath) {
-  return await readJsonFile(statePath, { version: 1, tables: {} });
+  const core = await loadCore();
+  return core.loadState(statePath);
 }
 async function saveState(statePath, state) {
-  const dirPath = import_path3.default.dirname(statePath);
-  await ensureDir(dirPath);
-  await writeJsonFile(statePath, state);
+  const core = await loadCore();
+  return core.saveState(statePath, state);
 }
-var defaultStateManager = new StateManager();
-
-// src/core/validator.ts
-var SchemaValidator = class {
-  /**
-   * Validate a complete schema
-   */
-  validateSchema(schema) {
-    const errors = [];
-    if (!schema.version) {
-      errors.push({
-        path: "schema.version",
-        message: "Schema version is required",
-        severity: "error"
-      });
-    }
-    if (!schema.database) {
-      errors.push({
-        path: "schema.database",
-        message: "Database type is required",
-        severity: "error"
-      });
-    }
-    if (!schema.tables || schema.tables.length === 0) {
-      errors.push({
-        path: "schema.tables",
-        message: "Schema must contain at least one table",
-        severity: "error"
-      });
-    }
-    if (schema.tables) {
-      const tableNames = /* @__PURE__ */ new Set();
-      for (let i = 0; i < schema.tables.length; i++) {
-        const table = schema.tables[i];
-        const tableErrors = this.validateTable(table, i);
-        errors.push(...tableErrors);
-        if (tableNames.has(table.name)) {
-          errors.push({
-            path: `schema.tables[${i}].name`,
-            message: `Duplicate table name: ${table.name}`,
-            severity: "error"
-          });
-        }
-        tableNames.add(table.name);
-      }
-      errors.push(...this.validateReferences(schema));
-    }
-    return {
-      valid: errors.filter((e) => e.severity === "error").length === 0,
-      errors
-    };
-  }
-  /**
-   * Validate a table
-   */
-  validateTable(table, tableIndex) {
-    const errors = [];
-    const basePath = `schema.tables[${tableIndex}]`;
-    if (!table.name || table.name.trim() === "") {
-      errors.push({
-        path: `${basePath}.name`,
-        message: "Table name is required",
-        severity: "error"
-      });
-    }
-    if (table.name && !/^[a-zA-Z_][a-zA-Z0-9_]*$/.test(table.name)) {
-      errors.push({
-        path: `${basePath}.name`,
-        message: `Invalid table name '${table.name}': must start with letter or underscore and contain only alphanumeric characters and underscores`,
-        severity: "error"
-      });
-    }
-    if (!table.fields || table.fields.length === 0) {
-      errors.push({
-        path: `${basePath}.fields`,
-        message: `Table '${table.name}' must have at least one field`,
-        severity: "error"
-      });
-    }
-    if (table.fields) {
-      const fieldNames = /* @__PURE__ */ new Set();
-      for (let i = 0; i < table.fields.length; i++) {
-        const field = table.fields[i];
-        const fieldErrors = this.validateField(field, basePath, i);
-        errors.push(...fieldErrors);
-        if (fieldNames.has(field.name)) {
-          errors.push({
-            path: `${basePath}.fields[${i}].name`,
-            message: `Duplicate field name: ${field.name}`,
-            severity: "error"
-          });
-        }
-        fieldNames.add(field.name);
-      }
-    }
-    return errors;
-  }
-  /**
-   * Validate a field
-   */
-  validateField(field, tablePath, fieldIndex) {
-    const errors = [];
-    const basePath = `${tablePath}.fields[${fieldIndex}]`;
-    if (!field.name || field.name.trim() === "") {
-      errors.push({
-        path: `${basePath}.name`,
-        message: "Field name is required",
-        severity: "error"
-      });
-    }
-    if (field.name && !/^[a-zA-Z_][a-zA-Z0-9_]*$/.test(field.name)) {
-      errors.push({
-        path: `${basePath}.name`,
-        message: `Invalid field name '${field.name}': must start with letter or underscore and contain only alphanumeric characters and underscores`,
-        severity: "error"
-      });
-    }
-    if (!field.type) {
-      errors.push({
-        path: `${basePath}.type`,
-        message: "Field type is required",
-        severity: "error"
-      });
-    }
-    if (field.type === "enum") {
-      if (!field.enumValues || field.enumValues.length === 0) {
-        errors.push({
-          path: `${basePath}.enumValues`,
-          message: "Enum type requires enumValues array",
-          severity: "error"
-        });
-      }
-    }
-    if (field.type === "string" && field.length && field.length <= 0) {
-      errors.push({
-        path: `${basePath}.length`,
-        message: "String length must be greater than 0",
-        severity: "error"
-      });
-    }
-    return errors;
-  }
-  /**
-   * Validate foreign key references
-   */
-  validateReferences(schema) {
-    const errors = [];
-    const tableNames = new Set(schema.tables.map((t) => t.name));
-    for (let i = 0; i < schema.tables.length; i++) {
-      const table = schema.tables[i];
-      for (let j = 0; j < table.fields.length; j++) {
-        const field = table.fields[j];
-        if (field.references) {
-          const refTable = field.references.table;
-          const refField = field.references.field;
-          if (!tableNames.has(refTable)) {
-            errors.push({
-              path: `schema.tables[${i}].fields[${j}].references.table`,
-              message: `Referenced table '${refTable}' does not exist`,
-              severity: "error"
-            });
-          } else {
-            const referencedTable = schema.tables.find((t) => t.name === refTable);
-            if (referencedTable) {
-              const referencedField = referencedTable.fields.find((f) => f.name === refField);
-              if (!referencedField) {
-                errors.push({
-                  path: `schema.tables[${i}].fields[${j}].references.field`,
-                  message: `Referenced field '${refField}' does not exist in table '${refTable}'`,
-                  severity: "error"
-                });
-              }
-            }
-          }
-        }
-      }
-    }
-    return errors;
-  }
-};
-var defaultValidator = new SchemaValidator();
-var VALID_BASE_COLUMN_TYPES = [
-  "uuid",
-  "varchar",
-  "text",
-  "int",
-  "bigint",
-  "boolean",
-  "timestamptz",
-  "date"
-];
-function isValidColumnType(type) {
-  const normalizedType = type.toLowerCase().trim().replace(/\s+/g, " ").replace(/\s*\(\s*/g, "(").replace(/\s*,\s*/g, ",").replace(/\s*\)\s*/g, ")");
-  if (VALID_BASE_COLUMN_TYPES.includes(normalizedType)) {
-    return true;
-  }
-  return /^varchar\(\d+\)$/.test(normalizedType) || /^numeric\(\d+,\d+\)$/.test(normalizedType);
+async function validateSchemaChanges(previousState, currentSchema) {
+  const core = await loadCore();
+  return core.validateSchemaChanges(previousState, currentSchema);
 }
-function validateSchema(schema) {
-  validateDuplicateTables(schema);
-  for (const tableName in schema.tables) {
-    const table = schema.tables[tableName];
-    validateTableColumns(tableName, table, schema.tables);
-  }
+async function toValidationReport(findings) {
+  const core = await loadCore();
+  return core.toValidationReport(findings);
 }
-function validateDuplicateTables(schema) {
-  const tableNames = Object.keys(schema.tables);
-  const seen = /* @__PURE__ */ new Set();
-  for (const tableName of tableNames) {
-    if (seen.has(tableName)) {
-      throw new Error(`Duplicate table: '${tableName}'`);
-    }
-    seen.add(tableName);
-  }
+async function parseMigrationSql(sql) {
+  const core = await loadCore();
+  return core.parseMigrationSql(sql);
 }
-function validateTableColumns(tableName, table, allTables) {
-  const columnNames = /* @__PURE__ */ new Set();
-  let primaryKeyCount = 0;
-  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++;
-    }
-    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 (primaryKeyCount > 1) {
-    throw new Error(`Table '${tableName}': can only have one primary key (found ${primaryKeyCount})`);
-  }
+async function applySqlOps(ops) {
+  const core = await loadCore();
+  return core.applySqlOps(ops);
 }
-
-// src/generator/sql-generator.ts
-function generateSql(diff, provider, sqlConfig) {
-  const statements = [];
-  for (const operation of diff.operations) {
-    const sql = generateOperation(operation, provider, sqlConfig);
-    if (sql) {
-      statements.push(sql);
-    }
-  }
-  return statements.join("\n\n");
+async function schemaToDsl(schema) {
+  const core = await loadCore();
+  return core.schemaToDsl(schema);
 }
-function generateOperation(operation, provider, sqlConfig) {
-  switch (operation.kind) {
-    case "create_table":
-      return generateCreateTable(operation.table, provider, sqlConfig);
-    case "drop_table":
-      return generateDropTable(operation.tableName);
-    case "column_type_changed":
-      return generateAlterColumnType(
-        operation.tableName,
-        operation.columnName,
-        operation.toType
-      );
-    case "add_column":
-      return generateAddColumn(operation.tableName, operation.column, provider, sqlConfig);
-    case "drop_column":
-      return generateDropColumn(operation.tableName, operation.columnName);
-  }
+async function loadMigrationSqlInput(inputPath) {
+  const core = await loadCore();
+  return core.loadMigrationSqlInput(inputPath);
 }
-function generateCreateTable(table, provider, sqlConfig) {
-  const columnDefs = table.columns.map(
-    (col) => generateColumnDefinition(col, provider, sqlConfig)
-  );
-  const lines = ["CREATE TABLE " + table.name + " ("];
-  columnDefs.forEach((colDef, index) => {
-    const isLast = index === columnDefs.length - 1;
-    lines.push("  " + colDef + (isLast ? "" : ","));
-  });
-  lines.push(");");
-  return lines.join("\n");
+async function createSchemaValidationError(message) {
+  const core = await loadCore();
+  return new core.SchemaValidationError(message);
 }
-function generateColumnDefinition(column, provider, sqlConfig) {
-  const parts = [column.name, column.type];
-  if (column.foreignKey) {
-    parts.push(
-      `references ${column.foreignKey.table}(${column.foreignKey.column})`
-    );
-  }
-  if (column.primaryKey) {
-    parts.push("primary key");
-  }
-  if (column.unique) {
-    parts.push("unique");
-  }
-  if (column.nullable === false) {
-    parts.push("not null");
+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;
   }
-  if (column.default !== void 0) {
-    parts.push("default " + column.default);
-  } else if (column.type === "uuid" && column.primaryKey && provider === "supabase") {
-    parts.push("default gen_random_uuid()");
+  try {
+    console.log(
+      (0, import_boxen.default)(text, {
+        padding: 1,
+        borderColor: "cyan",
+        borderStyle: "round"
+      })
+    );
+  } catch {
+    console.log(text);
   }
-  return parts.join(" ");
-}
-function generateDropTable(tableName) {
-  return `DROP TABLE ${tableName};`;
 }
-function generateAddColumn(tableName, column, provider, sqlConfig) {
-  const colDef = generateColumnDefinition(column, provider, sqlConfig);
-  return `ALTER TABLE ${tableName} ADD COLUMN ${colDef};`;
+function info(message) {
+  console.log(theme.primary(message));
 }
-function generateDropColumn(tableName, columnName) {
-  return `ALTER TABLE ${tableName} DROP COLUMN ${columnName};`;
+function warning(message) {
+  console.warn(theme.warning(`[WARN] ${message}`));
 }
-function generateAlterColumnType(tableName, columnName, newType) {
-  return `ALTER TABLE ${tableName} ALTER COLUMN ${columnName} TYPE ${newType} USING ${columnName}::${newType};`;
+function error(message) {
+  console.error(theme.error(`[ERROR] ${message}`));
 }
 
 // src/commands/diff.ts
 var REQUIRED_CONFIG_FIELDS = ["schemaFile", "stateFile"];
 function resolveConfigPath(root, targetPath) {
-  return import_path4.default.isAbsolute(targetPath) ? targetPath : import_path4.default.join(root, targetPath);
+  return import_path3.default.isAbsolute(targetPath) ? targetPath : import_path3.default.join(root, targetPath);
 }
 async function runDiff() {
   const root = getProjectRoot();
@@ -1082,33 +305,30 @@ async function runDiff() {
   }
   const schemaPath = resolveConfigPath(root, config.schemaFile);
   const statePath = resolveConfigPath(root, config.stateFile);
-  if (config.provider && config.provider !== "postgres" && config.provider !== "supabase") {
-    throw new Error(`Unsupported provider '${config.provider}'.`);
-  }
-  const provider = config.provider ?? "postgres";
+  const { provider } = resolveProvider(config.provider);
   const schemaSource = await readTextFile(schemaPath);
-  const schema = parseSchema(schemaSource);
+  const schema = await parseSchema(schemaSource);
   try {
-    validateSchema(schema);
+    await validateSchema(schema);
   } catch (error2) {
     if (error2 instanceof Error) {
-      throw new SchemaValidationError(error2.message);
+      throw await createSchemaValidationError(error2.message);
     }
     throw error2;
   }
   const previousState = await loadState(statePath);
-  const diff = diffSchemas(previousState, schema);
+  const diff = await diffSchemas(previousState, schema);
   if (diff.operations.length === 0) {
     success("No changes detected");
     return;
   }
-  const sql = generateSql(diff, provider, config.sql);
+  const sql = await generateSql(diff, provider, config.sql);
   console.log(sql);
 }
 
 // src/commands/generate.ts
 var import_commander2 = require("commander");
-var import_path5 = __toESM(require("path"));
+var import_path4 = __toESM(require("path"));
 
 // src/core/utils.ts
 function nowTimestamp() {
@@ -1127,7 +347,7 @@ var REQUIRED_CONFIG_FIELDS2 = [
   "outputDir"
 ];
 function resolveConfigPath2(root, targetPath) {
-  return import_path5.default.isAbsolute(targetPath) ? targetPath : import_path5.default.join(root, targetPath);
+  return import_path4.default.isAbsolute(targetPath) ? targetPath : import_path4.default.join(root, targetPath);
 }
 async function runGenerate(options) {
   const root = getProjectRoot();
@@ -1145,44 +365,92 @@ async function runGenerate(options) {
   const schemaPath = resolveConfigPath2(root, config.schemaFile);
   const statePath = resolveConfigPath2(root, config.stateFile);
   const outputDir = resolveConfigPath2(root, config.outputDir);
-  if (config.provider && config.provider !== "postgres" && config.provider !== "supabase") {
-    throw new Error(`Unsupported provider '${config.provider}'.`);
-  }
-  const provider = config.provider ?? "postgres";
-  if (!config.provider) {
+  const { provider, usedDefault } = resolveProvider(config.provider);
+  if (usedDefault) {
     info("Provider not set; defaulting to postgres.");
   }
   info("Generating SQL...");
   const schemaSource = await readTextFile(schemaPath);
-  const schema = parseSchema(schemaSource);
+  const schema = await parseSchema(schemaSource);
   try {
-    validateSchema(schema);
+    await validateSchema(schema);
   } catch (error2) {
     if (error2 instanceof Error) {
-      throw new SchemaValidationError(error2.message);
+      throw await createSchemaValidationError(error2.message);
     }
     throw error2;
   }
   const previousState = await loadState(statePath);
-  const diff = diffSchemas(previousState, schema);
+  const diff = await diffSchemas(previousState, schema);
   if (diff.operations.length === 0) {
     info("No changes detected");
     return;
   }
-  const sql = generateSql(diff, provider, config.sql);
+  const sql = await generateSql(diff, provider, config.sql);
   const timestamp = nowTimestamp();
   const slug = slugifyName(options.name ?? "migration");
   const fileName = `${timestamp}-${slug}.sql`;
   await ensureDir(outputDir);
-  const migrationPath = import_path5.default.join(outputDir, fileName);
+  const migrationPath = import_path4.default.join(outputDir, fileName);
   await writeTextFile(migrationPath, sql + "\n");
   const nextState = await schemaToState(schema);
   await saveState(statePath, nextState);
   success(`SQL generated successfully: ${migrationPath}`);
 }
 
-// src/commands/init.ts
+// src/commands/import.ts
 var import_commander3 = require("commander");
+var import_path5 = __toESM(require("path"));
+function resolveConfigPath3(root, targetPath) {
+  return import_path5.default.isAbsolute(targetPath) ? targetPath : import_path5.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 = await parseMigrationSql(input.sql);
+    allOps.push(...result.ops);
+    parseWarnings.push(...result.warnings.map((item) => ({
+      statement: `[${import_path5.default.basename(input.filePath)}] ${item.statement}`,
+      reason: item.reason
+    })));
+  }
+  const applied = await applySqlOps(allOps);
+  const dsl = await 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);
@@ -1219,8 +487,8 @@ table users {
   await writeTextFile(schemaFilePath, schemaContent);
   success(`Created ${schemaFilePath}`);
   const config = {
-    provider: "supabase",
-    outputDir: "supabase/migrations",
+    provider: "postgres",
+    outputDir: "migrations",
     schemaFile: "schemaforge/schema.sf",
     stateFile: "schemaforge/state.json",
     sql: {
@@ -1236,7 +504,7 @@ table users {
   };
   await writeJsonFile(statePath, state);
   success(`Created ${statePath}`);
-  const outputDir = "supabase/migrations";
+  const outputDir = "migrations";
   await ensureDir(outputDir);
   success(`Created ${outputDir}`);
   success("Project initialized successfully");
@@ -1245,11 +513,73 @@ table users {
   info("  2. Run: schema-forge generate");
 }
 
+// src/commands/validate.ts
+var import_commander5 = require("commander");
+var import_path6 = __toESM(require("path"));
+var REQUIRED_CONFIG_FIELDS3 = ["schemaFile", "stateFile"];
+function resolveConfigPath4(root, targetPath) {
+  return import_path6.default.isAbsolute(targetPath) ? targetPath : import_path6.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 = await parseSchema(schemaSource);
+  try {
+    await validateSchema(schema);
+  } catch (error2) {
+    if (error2 instanceof Error) {
+      throw await createSchemaValidationError(error2.message);
+    }
+    throw error2;
+  }
+  const previousState = await loadState(statePath);
+  const findings = await validateSchemaChanges(previousState, schema);
+  const report = await toValidationReport(findings);
+  if (options.json) {
+    console.log(JSON.stringify(report, null, 2));
+    process.exitCode = report.hasErrors ? 1 : 0;
+    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_commander4.Command();
+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;
@@ -1265,21 +595,35 @@ program.command("init").description("Initialize a new schema project").action(as
   try {
     await runInit();
   } catch (error2) {
-    handleError(error2);
+    await handleError(error2);
   }
 });
 program.command("generate").description("Generate SQL from schema files").option("--name <string>", "Schema name to generate").action(async (options) => {
   try {
     await runGenerate(options);
   } catch (error2) {
-    handleError(error2);
+    await handleError(error2);
   }
 });
 program.command("diff").description("Compare two schema versions and generate migration SQL").action(async () => {
   try {
     await runDiff();
   } catch (error2) {
-    handleError(error2);
+    await handleError(error2);
+  }
+});
+program.command("import").description("Import schema from SQL migrations").argument("<path>", "Path to .sql file or migrations directory").option("--out <path>", "Output schema file path").action(async (targetPath, options) => {
+  try {
+    await runImport(targetPath, options);
+  } catch (error2) {
+    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) {
+    await handleError(error2);
   }
 });
 program.parse(process.argv);