@dbsp/cli 1.0.0

package/dist/index.js

@@ -0,0 +1,1138 @@
+#!/usr/bin/env node
+import {
+  createDbConnection,
+  generateSchemaFile,
+  redactDbUrl
+} from "./chunk-UZEMCTNH.js";
+import {
+  loadSchema,
+  loadSchemaFromCwd
+} from "./chunk-AQC34IO5.js";
+import {
+  config
+} from "./chunk-U5DSGBS2.js";
+
+// src/index.ts
+import { Command as Command7, CommanderError } from "commander";
+
+// src/commands/generate.ts
+import { mkdirSync, writeFileSync } from "fs";
+import { dirname, resolve } from "path";
+import { Command } from "commander";
+var generateCommand = new Command("generate").description("Generate code from schema").argument("<target>", "Target to generate: ddl").option("-s, --schema <path>", "Path to schema file (default: auto-detect)").option("-o, --out <dir>", "Output directory (default: ./generated/<target>)").option("--output <dir>", "Output directory (alias for --out)").option("--drop", "Include DROP TABLE IF EXISTS statements (ddl only)").option("--schema-name <name>", "Database schema name (ddl only)").option(
+  "--dialect <name>",
+  "Database dialect: postgresql | mysql | sqlite | mssql (default: postgresql)"
+).option(
+  "--casing <type>",
+  "Column naming: snake | camel | none (default: based on dialect)"
+).action(
+  async (target, options) => {
+    try {
+      let schema;
+      let schemaPath;
+      if (options.schema) {
+        schema = await loadSchema(options.schema);
+        schemaPath = options.schema;
+      } else {
+        const result = await loadSchemaFromCwd();
+        schema = result.schema;
+        schemaPath = result.path;
+      }
+      const outputPath = options.out ?? options.output;
+      const useStdout = target === "ddl" && !outputPath;
+      const log = useStdout ? console.error : console.log;
+      log(`\u{1F4C4} Loaded schema from: ${schemaPath}`);
+      const dialect = options.dialect ?? "postgresql";
+      if (dialect !== "postgresql") {
+        console.error(
+          `\u26A0\uFE0F  Warning: Only 'postgresql' dialect is currently supported. Using postgresql.`
+        );
+      }
+      switch (target) {
+        case "ddl": {
+          const casing = options.casing ?? "snake";
+          const { createPgsqlCompileOnlyAdapter } = await import("@dbsp/adapter-pgsql");
+          const dbCasing = casing === "snake" ? "snake_case" : "preserve";
+          const adapter = createPgsqlCompileOnlyAdapter({
+            dbCasing,
+            ...options.schemaName ? { schemaName: options.schemaName } : {}
+          });
+          {
+            const ddlStatements = adapter.generateDDL(schema.model, {
+              ...options.drop !== void 0 && {
+                includeDropStatements: options.drop
+              }
+            });
+            const ddlContent = ddlStatements.join("\n\n");
+            const outputPath2 = options.out ?? options.output;
+            if (outputPath2) {
+              const outPath = outputPath2.endsWith(".sql") ? resolve(process.cwd(), outputPath2) : resolve(process.cwd(), outputPath2, "schema.sql");
+              mkdirSync(dirname(outPath), { recursive: true });
+              writeFileSync(outPath, ddlContent, "utf-8");
+              console.log(`\u2705 Generated DDL: ${outPath}`);
+              console.log(`   Tables: ${schema.tableNames.length}`);
+              console.log(`   Statements: ${ddlStatements.length}`);
+              console.log(`   Casing: ${casing}`);
+              if (options.drop) {
+                console.log(`   Includes DROP statements`);
+              }
+              if (options.schemaName) {
+                console.log(`   Schema: ${options.schemaName}`);
+              }
+            } else {
+              console.log(ddlContent);
+            }
+          }
+          break;
+        }
+        case "manifest":
+        case "kysely":
+          throw new Error(
+            `Target '${target}' has been removed in ARCH-005. These generators required the legacy defineSchema() format. Use 'ddl' target for SQL generation.`
+          );
+        default:
+          throw new Error(
+            `Unknown target: ${target}. Available targets: ddl`
+          );
+      }
+    } catch (error) {
+      const message = error instanceof Error ? error.message : String(error);
+      console.error(`\u274C ${message}`);
+      process.exit(1);
+    }
+  }
+);
+
+// src/commands/introspect.ts
+import { mkdirSync as mkdirSync2, writeFileSync as writeFileSync2 } from "fs";
+import { dirname as dirname2, resolve as resolve2 } from "path";
+import { Command as Command2 } from "commander";
+var introspectCommand = new Command2("introspect").description("Generate schema.ts from database introspection").requiredOption("-d, --db <url>", "Database connection URL (required)").option("-o, --out <file>", "Output schema file", "./dbsp.schema.ts").option("--schema-name <name>", "Database schema name", "public").option(
+  "--exclude <patterns>",
+  "Tables to exclude (comma-separated glob patterns)",
+  "_migrations,_prisma*,pg_*"
+).option("--include <patterns>", "Tables to include (comma-separated)").option("--no-db-type-comments", "Omit original DB type comments").option(
+  "--db-casing <casing>",
+  "Database column casing (snake_case \u2192 camelCase in generated code)",
+  "snake_case"
+).action(
+  async (options) => {
+    const redactedUrl = redactDbUrl(options.db);
+    console.log(`\u{1F50D} Introspecting database: ${redactedUrl}`);
+    console.log(`   Schema: ${options.schemaName}`);
+    if (options.exclude) {
+      console.log(`   Excluding: ${options.exclude}`);
+    }
+    console.log("");
+    try {
+      const { pool } = await createDbConnection(options.db);
+      try {
+        const { introspect: introspect4 } = await import("@dbsp/adapter-pgsql");
+        const excludePatterns = options.exclude ? options.exclude.split(",").map((s) => s.trim()) : void 0;
+        const includePatterns = options.include ? options.include.split(",").map((s) => s.trim()) : void 0;
+        const model = await introspect4(pool, {
+          schema: options.schemaName,
+          ...excludePatterns ? { exclude: excludePatterns } : {},
+          ...includePatterns ? { include: includePatterns } : {}
+        });
+        const tableCount = model.tables.size;
+        const relationCount = model.relations.size;
+        const hierarchyCount = model.hierarchies?.length ?? 0;
+        console.log(
+          `\u{1F4CA} Found ${tableCount} tables, ${relationCount} relations, ${hierarchyCount} hierarchies`
+        );
+        if (model.warnings?.length) {
+          for (const w of model.warnings) {
+            console.log(`   \u26A0\uFE0F  ${w}`);
+          }
+        }
+        console.log("");
+        const codegenOptions = {
+          sourceUrl: options.db,
+          includeDbTypeComments: options.dbTypeComments,
+          warnings: model.warnings,
+          introspectedAt: model.introspectedAt,
+          dbCasing: options.dbCasing
+        };
+        const schemaCode = generateSchemaFile(model, codegenOptions);
+        const outPath = resolve2(process.cwd(), options.out);
+        mkdirSync2(dirname2(outPath), { recursive: true });
+        writeFileSync2(outPath, schemaCode, "utf-8");
+        console.log(`\u2705 Generated schema: ${outPath}`);
+        console.log(`   Tables: ${tableCount}`);
+        console.log(`   Relations: ${relationCount}`);
+      } finally {
+        await pool.end();
+      }
+    } catch (error) {
+      const message = error instanceof Error ? error.message : String(error);
+      console.error(`\u274C ${message}`);
+      process.exit(1);
+    }
+  }
+);
+
+// src/commands/migrate.ts
+import {
+  compareSchemata,
+  ensureMigrationsTable,
+  generateMigrationFile,
+  generateMigrationSQL,
+  getAppliedMigrations,
+  getNextSchemaVersion,
+  introspect,
+  isDestructiveDown,
+  parseMigrationFile,
+  recordMigration,
+  removeMigrationRecord,
+  withMigrationLock
+} from "@dbsp/adapter-pgsql";
+import { Command as Command3 } from "commander";
+
+// src/migration-file.ts
+import { createHash } from "crypto";
+import {
+  existsSync,
+  mkdirSync as mkdirSync3,
+  readdirSync,
+  readFileSync,
+  writeFileSync as writeFileSync3
+} from "fs";
+import { join, resolve as resolve3 } from "path";
+var DEFAULT_MIGRATIONS_DIR = "migrations";
+var MIGRATION_FILENAME_PATTERN = /^\d{4}_[\w-]+\.sql$/;
+function computeChecksum(content) {
+  return createHash("sha256").update(content, "utf-8").digest("hex");
+}
+function generateMigrationFilename(existingFiles, description) {
+  const maxNum = existingFiles.reduce((max, f) => {
+    const match = f.match(/^(\d{4})/);
+    return match?.[1] ? Math.max(max, Number.parseInt(match[1], 10)) : max;
+  }, 0);
+  const nextNum = String(maxNum + 1).padStart(4, "0");
+  const sanitized = description.toLowerCase().replace(/[^a-z0-9_-]/g, "_").replace(/_+/g, "_").replace(/^_|_$/g, "");
+  return `${nextNum}_${sanitized || "migration"}.sql`;
+}
+function ensureMigrationsDir(dir) {
+  const fullPath = resolve3(dir);
+  if (!existsSync(fullPath)) {
+    mkdirSync3(fullPath, { recursive: true });
+  }
+  return fullPath;
+}
+function scanMigrationFiles(dir) {
+  const fullPath = resolve3(dir);
+  if (!existsSync(fullPath)) {
+    return [];
+  }
+  const entries = readdirSync(fullPath).filter((f) => MIGRATION_FILENAME_PATTERN.test(f)).sort();
+  return entries.map((name) => {
+    const filePath = join(fullPath, name);
+    const content = readFileSync(filePath, "utf-8");
+    return {
+      name,
+      path: filePath,
+      content,
+      checksum: computeChecksum(content)
+    };
+  });
+}
+function writeMigrationFile(dir, filename, content) {
+  const fullDir = ensureMigrationsDir(dir);
+  const filePath = join(fullDir, filename);
+  writeFileSync3(filePath, content, "utf-8");
+  return {
+    name: filename,
+    path: filePath,
+    content,
+    checksum: computeChecksum(content)
+  };
+}
+
+// src/commands/migrate.ts
+var MigrationError = class extends Error {
+  constructor(message) {
+    super(message);
+    this.name = "MigrationError";
+  }
+};
+function sanitizePgError(err) {
+  if (err instanceof Error) {
+    const code = err.code;
+    if (typeof code === "string" && /^[0-9A-Z]{5}$/.test(code)) {
+      if (process.env.DEBUG?.includes("dbsp")) {
+        console.error(`[DEBUG] pg error detail: ${err.message}`);
+      }
+      return new MigrationError(`Migration failed: database error ${code}`);
+    }
+    return err;
+  }
+  return new Error(String(err));
+}
+async function withMigratePool(dbUrl, fn) {
+  const { pool } = await createDbConnection(dbUrl);
+  try {
+    return await fn(pool);
+  } finally {
+    let endError;
+    try {
+      await pool.end();
+    } catch (e) {
+      endError = e;
+    }
+    if (endError !== void 0) {
+      console.error(
+        `Warning: pool.end() failed: ${endError instanceof Error ? endError.message : String(endError)}`
+      );
+    }
+  }
+}
+async function runMigrateAction(fn) {
+  try {
+    await fn();
+  } catch (error) {
+    if (error instanceof Error) {
+      console.error(`\u274C Error: ${error.message}`);
+    } else {
+      console.error("\u274C Unknown error occurred");
+    }
+    process.exit(1);
+  }
+}
+var devCommand = new Command3("dev").description("Generate a migration from schema changes").option(
+  "-s, --schema <path>",
+  "Path to schema file (default: dbsp.schema.ts)"
+).requiredOption("-d, --db <url>", "Database connection URL (required)").option("--schema-name <name>", "Database schema name (default: public)").option("--dir <path>", "Migrations directory", DEFAULT_MIGRATIONS_DIR).option("-n, --name <description>", "Migration description", "migration").option("--allow-destructive", "Include destructive changes (drops)").action(
+  (options) => runMigrateAction(async () => {
+    const schemaPath = options.schema ?? "dbsp.schema.ts";
+    console.log(`\u{1F4DD} Generating migration: ${schemaPath}`);
+    console.log(`   Database: ${redactDbUrl(options.db)}`);
+    console.log("");
+    const loaded = await loadSchema(schemaPath);
+    const schemaModel = loaded.model;
+    await withMigratePool(options.db, async (pool) => {
+      const dbModel = await introspect(pool, {
+        ...options.schemaName ? { schema: options.schemaName } : {}
+      });
+      const diff = compareSchemata(schemaModel, dbModel);
+      if (diff.changes.length === 0) {
+        console.log("\u2705 No changes detected \u2014 database matches schema.");
+        return;
+      }
+      if (diff.hasDestructive && !options.allowDestructive) {
+        const destructive = diff.changes.filter((c) => c.destructive);
+        throw new MigrationError(
+          `${destructive.length} destructive change(s) detected:
+` + destructive.map((c) => `   - ${c.details}`).join("\n") + "\n\nUse --allow-destructive to include these changes."
+        );
+      }
+      const sqlOptions = {
+        includeDestructive: options.allowDestructive ?? false,
+        ...options.schemaName ? { schemaName: options.schemaName } : {}
+      };
+      const statements = generateMigrationSQL(diff, sqlOptions);
+      if (statements.length === 0) {
+        console.log(
+          "\u2705 No migration needed \u2014 all changes are non-actionable."
+        );
+        return;
+      }
+      const existingFiles = scanMigrationFiles(options.dir).map(
+        (f) => f.name
+      );
+      const filename = generateMigrationFilename(
+        existingFiles,
+        options.name
+      );
+      const content = generateMigrationFile(diff, {
+        ...sqlOptions,
+        name: filename
+      });
+      const file = writeMigrationFile(options.dir, filename, content);
+      console.log(`\u2705 Migration created: ${file.path}`);
+      console.log(`   Statements: ${statements.length}`);
+      console.log(`   Checksum: ${file.checksum.slice(0, 12)}...`);
+    });
+  })
+);
+var applyCommand = new Command3("apply").description("Apply pending migrations").requiredOption("-d, --db <url>", "Database connection URL (required)").option("--dir <path>", "Migrations directory", DEFAULT_MIGRATIONS_DIR).option("--dry-run", "Show pending migrations without applying").action(
+  (options) => runMigrateAction(async () => {
+    console.log("\u{1F504} Applying migrations");
+    console.log(`   Database: ${redactDbUrl(options.db)}`);
+    console.log(`   Directory: ${options.dir}`);
+    console.log("");
+    await withMigratePool(options.db, async (pool) => {
+      await ensureMigrationsTable(pool);
+      await withMigrationLock(pool, async (client) => {
+        const applied = await getAppliedMigrations(client);
+        const appliedMap = new Map(applied.map((m) => [m.name, m.checksum]));
+        const files = scanMigrationFiles(options.dir);
+        if (files.length === 0) {
+          console.log(`No migration files found in ${options.dir}`);
+          return;
+        }
+        for (const file of files) {
+          const existingChecksum = appliedMap.get(file.name);
+          if (existingChecksum !== void 0 && existingChecksum !== file.checksum) {
+            throw new MigrationError(
+              `Checksum mismatch for ${file.name}
+   Expected: ${existingChecksum}
+   Got:      ${file.checksum}
+
+Migration file has been tampered with after being applied.`
+            );
+          }
+        }
+        const pending = files.filter((f) => !appliedMap.has(f.name));
+        if (pending.length === 0) {
+          console.log("\u2705 All migrations already applied.");
+          return;
+        }
+        if (options.dryRun) {
+          console.log(`${pending.length} pending migration(s):`);
+          for (const file of pending) {
+            console.log(`   - ${file.name}`);
+          }
+          return;
+        }
+        let appliedCount = 0;
+        for (const file of pending) {
+          console.log(`  Applying: ${file.name}...`);
+          const parsed = parseMigrationFile(file.content);
+          const statements = parsed.upStatements.filter(
+            (s) => s.length > 0 && !s.startsWith("-- ")
+          );
+          const version = await getNextSchemaVersion(
+            client
+          );
+          const destructive = isDestructiveDown(parsed.downStatements);
+          try {
+            await client.query("BEGIN");
+            for (const stmt of statements) {
+              await client.query(stmt);
+            }
+            await recordMigration(
+              client,
+              file.name,
+              file.checksum,
+              version,
+              destructive
+            );
+            await client.query("COMMIT");
+          } catch (applyError) {
+            let rollbackError;
+            try {
+              await client.query("ROLLBACK");
+            } catch (e) {
+              rollbackError = e;
+            }
+            const primary = sanitizePgError(applyError);
+            if (rollbackError !== void 0) {
+              console.error(
+                `   Note: rollback also failed: ${sanitizePgError(rollbackError).message}`
+              );
+            }
+            throw primary;
+          }
+          appliedCount++;
+          console.log(`  \u2705 Applied: ${file.name}`);
+        }
+        console.log(
+          `
+\u2705 ${appliedCount} migration(s) applied successfully.`
+        );
+      });
+    });
+  })
+);
+var rollbackCommand = new Command3("rollback").description("Roll back applied migrations").argument("<count>", "Number of migrations to roll back").requiredOption("-d, --db <url>", "Database connection URL (required)").option("--dir <path>", "Migrations directory", DEFAULT_MIGRATIONS_DIR).option("--force", "Force rollback of destructive or empty DOWN migrations").action(
+  (countArg, options) => {
+    const count = Number.parseInt(countArg, 10);
+    if (Number.isNaN(count) || count < 1) {
+      console.error("\u274C Count must be a positive integer");
+      process.exit(1);
+    }
+    return runMigrateAction(async () => {
+      console.log(`\u23EA Rolling back ${count} migration(s)`);
+      console.log(`   Database: ${redactDbUrl(options.db)}`);
+      console.log(`   Directory: ${options.dir}`);
+      console.log("");
+      await withMigratePool(options.db, async (pool) => {
+        await ensureMigrationsTable(pool);
+        await withMigrationLock(pool, async (client) => {
+          const applied = await getAppliedMigrations(
+            client
+          );
+          const sortedDesc = [...applied].sort(
+            (a, b) => b.name.localeCompare(a.name)
+          );
+          if (count > sortedDesc.length) {
+            throw new MigrationError(
+              `Cannot roll back ${count} migration(s) \u2014 only ${sortedDesc.length} applied`
+            );
+          }
+          const toRollback = sortedDesc.slice(0, count);
+          const files = scanMigrationFiles(options.dir);
+          const fileMap = new Map(files.map((f) => [f.name, f]));
+          let rolledBack = 0;
+          for (const record of toRollback) {
+            const file = fileMap.get(record.name);
+            if (!file) {
+              throw new MigrationError(
+                `Migration file not found on disk: ${record.name}`
+              );
+            }
+            if (file.checksum !== record.checksum) {
+              throw new MigrationError(
+                `Checksum mismatch for ${record.name}
+   Expected: ${record.checksum}
+   Got:      ${file.checksum}
+
+Migration file has been modified since it was applied.`
+              );
+            }
+            const parsed = parseMigrationFile(file.content);
+            if (!parsed.hasDown) {
+              throw new MigrationError(
+                `Migration ${record.name} has no DOWN section
+   Cannot roll back a migration without a DOWN section.`
+              );
+            }
+            const downStmts = parsed.downStatements.filter(
+              (s) => s.length > 0 && !s.startsWith("-- ")
+            );
+            if (downStmts.length === 0 && !options.force) {
+              throw new MigrationError(
+                `Migration ${record.name} has an empty DOWN section
+   Use --force to roll back anyway.`
+              );
+            }
+            if (isDestructiveDown(parsed.downStatements) && !options.force) {
+              throw new MigrationError(
+                `Migration ${record.name} has destructive DOWN operations
+   Use --force to proceed with destructive rollback.`
+              );
+            }
+            if (downStmts.length > 0 || options.force) {
+              console.log(`  Rolling back: ${record.name}...`);
+            }
+            try {
+              await client.query("BEGIN");
+              for (const stmt of downStmts) {
+                await client.query(stmt);
+              }
+              await removeMigrationRecord(
+                client,
+                record.name
+              );
+              await client.query("COMMIT");
+            } catch (rollbackError) {
+              let rollbackCleanupError;
+              try {
+                await client.query("ROLLBACK");
+              } catch (e) {
+                rollbackCleanupError = e;
+              }
+              const primary = sanitizePgError(rollbackError);
+              if (rollbackCleanupError !== void 0) {
+                console.error(
+                  `   Note: rollback also failed: ${sanitizePgError(rollbackCleanupError).message}`
+                );
+              }
+              throw primary;
+            }
+            rolledBack++;
+            console.log(`  \u2705 Rolled back: ${record.name}`);
+          }
+          console.log(
+            `
+\u2705 ${rolledBack} migration(s) rolled back successfully.`
+          );
+        });
+      });
+    });
+  }
+);
+var statusCommand = new Command3("status").description("Show migration status").requiredOption("-d, --db <url>", "Database connection URL (required)").option("--dir <path>", "Migrations directory", DEFAULT_MIGRATIONS_DIR).option("--json", "Output as JSON").action(
+  (options) => runMigrateAction(async () => {
+    await withMigratePool(options.db, async (pool) => {
+      await ensureMigrationsTable(pool);
+      const applied = await getAppliedMigrations(pool);
+      const appliedMap = new Map(applied.map((m) => [m.name, m]));
+      const files = scanMigrationFiles(options.dir);
+      const statuses = files.map((file) => {
+        const record = appliedMap.get(file.name);
+        if (record === void 0) {
+          return {
+            name: file.name,
+            status: "pending"
+          };
+        }
+        if (record.checksum !== file.checksum) {
+          return {
+            name: file.name,
+            status: "checksum_mismatch",
+            appliedAt: record.appliedAt
+          };
+        }
+        return {
+          name: file.name,
+          status: "applied",
+          appliedAt: record.appliedAt
+        };
+      });
+      for (const record of applied) {
+        if (!files.some((f) => f.name === record.name)) {
+          statuses.push({
+            name: record.name,
+            status: "missing_file",
+            appliedAt: record.appliedAt
+          });
+        }
+      }
+      if (options.json) {
+        console.log(JSON.stringify(statuses, null, 2));
+      } else {
+        console.log("Migration Status");
+        console.log(`   Database: ${redactDbUrl(options.db)}`);
+        console.log(`   Directory: ${options.dir}`);
+        console.log("");
+        if (statuses.length === 0) {
+          console.log("No migrations found.");
+        } else {
+          for (const s of statuses) {
+            const icon = s.status === "applied" ? "\u2705" : s.status === "pending" ? "\u23F3" : s.status === "checksum_mismatch" ? "\u26A0\uFE0F" : "\u2753";
+            const detail = "appliedAt" in s && s.appliedAt ? ` (applied: ${s.appliedAt.toISOString()})` : "";
+            console.log(`  ${icon} ${s.name} \u2014 ${s.status}${detail}`);
+          }
+          const pendingCount = statuses.filter(
+            (s) => s.status === "pending"
+          ).length;
+          const appliedCount = statuses.filter(
+            (s) => s.status === "applied"
+          ).length;
+          console.log("");
+          console.log(
+            `Total: ${statuses.length} | Applied: ${appliedCount} | Pending: ${pendingCount}`
+          );
+        }
+      }
+    });
+  })
+);
+var migrateCommand = new Command3("migrate").description("Database migration management").addCommand(devCommand).addCommand(applyCommand).addCommand(rollbackCommand).addCommand(statusCommand);
+
+// src/commands/push.ts
+import {
+  compareSchemata as compareSchemata2,
+  generateDDL,
+  generateMigrationSQL as generateMigrationSQL2,
+  introspect as introspect2
+} from "@dbsp/adapter-pgsql";
+import { Command as Command4 } from "commander";
+
+// src/ddl-executor.ts
+async function executeDdl(pool, statements, options) {
+  if (statements.length === 0) {
+    return { statementsExecuted: 0, dryRun: options?.dryRun ?? false };
+  }
+  if (options?.dryRun) {
+    return { statementsExecuted: statements.length, dryRun: true };
+  }
+  let client;
+  try {
+    client = await pool.connect();
+    await client.query("BEGIN");
+    for (const stmt of statements) {
+      await client.query(stmt);
+    }
+    await client.query("COMMIT");
+    return { statementsExecuted: statements.length, dryRun: false };
+  } catch (error) {
+    if (client) {
+      await client.query("ROLLBACK");
+    }
+    throw error;
+  } finally {
+    if (client) {
+      client.release();
+    }
+  }
+}
+
+// src/commands/push.ts
+var MIGRATIONS_TABLE = "_dbsp_migrations";
+var pushCommand = new Command4("push").description("Push schema to database (additive by default)").option(
+  "-s, --schema <path>",
+  "Path to schema file (default: dbsp.schema.ts)"
+).requiredOption("-d, --db <url>", "Database connection URL (required)").option("--schema-name <name>", "Database schema name (default: public)").option("--drop", "Drop and recreate all objects (preserves migrations)").option("--dry-run", "Print SQL without executing").option("--json", "Output as JSON").action(
+  async (options) => {
+    const schemaPath = options.schema ?? "dbsp.schema.ts";
+    const redactedUrl = redactDbUrl(options.db);
+    if (!options.json) {
+      console.log(
+        `\u{1F680} Pushing schema: ${schemaPath}${options.drop ? " (with --drop)" : ""}`
+      );
+      console.log(`   Database: ${redactedUrl}`);
+      if (options.schemaName) {
+        console.log(`   Schema: ${options.schemaName}`);
+      }
+      if (options.dryRun) {
+        console.log(`   Mode: DRY RUN (no changes will be applied)`);
+      }
+      console.log("");
+    }
+    try {
+      const loaded = await loadSchema(schemaPath);
+      const schemaModel = loaded.model;
+      const { pool } = await createDbConnection(options.db);
+      try {
+        if (options.drop) {
+          const statements = generateDDL(schemaModel, {
+            includeDropStatements: true,
+            ...options.schemaName ? { schemaName: options.schemaName } : {}
+          });
+          const escapedTable = MIGRATIONS_TABLE.replace(
+            /[.*+?^${}()|[\]\\]/g,
+            "\\$&"
+          );
+          const migrationsPattern = new RegExp(
+            `DROP\\s+TABLE(?:\\s+IF\\s+EXISTS)?(?:\\s+"[^"]*"\\s*\\.)?\\s*"${escapedTable}"`,
+            "i"
+          );
+          const filtered = statements.filter(
+            (stmt) => !migrationsPattern.test(stmt)
+          );
+          outputResult(filtered, options);
+          const result = await executeDdl(pool, filtered, {
+            ...options.dryRun !== void 0 ? { dryRun: options.dryRun } : {}
+          });
+          if (options.json) {
+            const droppedTables = statements.filter((s) => /DROP\s+TABLE/i.test(s)).filter((s) => !migrationsPattern.test(s)).map((s) => {
+              const m = s.match(/"([^"]+)"\s*(?:CASCADE\s*)?;?\s*$/i);
+              return m ? m[1] : s;
+            }).filter((t) => t !== void 0);
+            console.log(
+              JSON.stringify(
+                {
+                  status: options.dryRun ? "dry-run" : "dropped",
+                  tables: droppedTables,
+                  tablesDropped: droppedTables.length,
+                  statementsExecuted: result.statementsExecuted
+                },
+                null,
+                2
+              )
+            );
+          } else if (!options.dryRun) {
+            console.log(
+              `
+\u2705 Push complete: ${result.statementsExecuted} statements executed`
+            );
+          }
+        } else {
+          const dbModel = await introspect2(pool, {
+            ...options.schemaName ? { schema: options.schemaName } : {}
+          });
+          const diff = compareSchemata2(schemaModel, dbModel);
+          const statements = generateMigrationSQL2(diff, {
+            includeDestructive: false,
+            ...options.schemaName ? { schemaName: options.schemaName } : {}
+          });
+          const skippedChanges = diff.changes.filter((c) => c.destructive);
+          if (!options.json && skippedChanges.length > 0) {
+            console.log(
+              `\u26A0\uFE0F  ${skippedChanges.length} non-additive change(s) skipped:`
+            );
+            for (const change of skippedChanges) {
+              console.log(`   - ${change.details}`);
+            }
+            console.log("");
+          }
+          if (statements.length === 0) {
+            if (options.json) {
+              console.log(
+                JSON.stringify(
+                  {
+                    status: "up-to-date",
+                    statementsExecuted: 0,
+                    skippedChanges: skippedChanges.length
+                  },
+                  null,
+                  2
+                )
+              );
+            } else {
+              console.log("\u2705 Database is up to date \u2014 nothing to push.");
+            }
+            return;
+          }
+          outputResult(statements, options);
+          const result = await executeDdl(pool, statements, {
+            ...options.dryRun !== void 0 ? { dryRun: options.dryRun } : {}
+          });
+          if (options.json) {
+            console.log(
+              JSON.stringify(
+                {
+                  status: options.dryRun ? "dry-run" : "applied",
+                  statementsExecuted: result.statementsExecuted,
+                  skippedChanges: skippedChanges.length
+                },
+                null,
+                2
+              )
+            );
+          } else if (!options.dryRun) {
+            console.log(
+              `
+\u2705 Push complete: ${result.statementsExecuted} statement(s) executed`
+            );
+          }
+        }
+      } finally {
+        await pool.end();
+      }
+    } catch (error) {
+      const message = error instanceof Error ? error.message : "Unknown error occurred";
+      if (options.json) {
+        console.log(
+          JSON.stringify({ status: "error", error: message }, null, 2)
+        );
+      } else {
+        console.error(`\u274C Error: ${message}`);
+      }
+      process.exit(1);
+    }
+  }
+);
+function outputResult(statements, options) {
+  if (options.dryRun && !options.json) {
+    console.log(`-- Dry run: ${statements.length} statement(s)
+`);
+    for (const stmt of statements) {
+      console.log(`${stmt};
+`);
+    }
+  }
+}
+
+// src/commands/repl.ts
+import { readFileSync as readFileSync2 } from "fs";
+import { Command as Command5 } from "commander";
+var replCommand = new Command5("repl").description("Launch interactive REPL for exploring schema and queries").option("-s, --schema <path>", "Path to schema file (default: auto-detect)").option(
+  "-d, --db <url>",
+  "PostgreSQL connection URL for execution mode (e.g., postgres://localhost/mydb)"
+).option("-e, --eval <query>", "Execute a single query and exit (batch mode)").option(
+  "-i, --input <file>",
+  "Execute queries from file, one per line (batch mode)"
+).option(
+  "-f, --format <format>",
+  "Output format for batch mode: text (default) or json",
+  "text"
+).option(
+  "-a, --assert <file>",
+  "Assertion file to validate query output (requires --input)"
+).option(
+  "--import <files...>",
+  "SQL files to import before queries (equivalent to .import commands)"
+).option(
+  "--use <schema>",
+  "PostgreSQL schema to use (equivalent to .use command)"
+).option("--parse", "Start REPL with parse mode enabled (.parse toggle)").option("--exec", "Start REPL with exec mode enabled (.exec toggle)").option(
+  "--casing <type>",
+  "Column naming convention: snake (DB uses snake_case), camel (DB uses camelCase), none (preserve as-is)"
+).option(
+  "-c, --config <path>",
+  "Custom config file path (default: ~/.dbsp/config.json)"
+).action(async (options) => {
+  if (options.config) {
+    config.setConfigPath(options.config);
+  }
+  config.load();
+  try {
+    let schemaPath;
+    let schema;
+    if (options.schema) {
+      schema = await loadSchema(options.schema);
+      schemaPath = options.schema;
+    } else {
+      const result = await loadSchemaFromCwd();
+      schema = result.schema;
+      schemaPath = result.path;
+    }
+    if (options.assert && !options.input) {
+      throw new Error(
+        "--assert requires --input (assertion files validate query output from input files)"
+      );
+    }
+    if (options.import && !options.eval && !options.input) {
+      throw new Error("--import requires batch mode (--eval or --input)");
+    }
+    const dbCasing = options.casing === "snake" ? "snake_case" : options.casing === "camel" ? "camelCase" : options.casing === "none" ? "preserve" : void 0;
+    if (options.eval || options.input) {
+      const { runBatchMode } = await import("./repl/batch.js");
+      const queries = [];
+      if (options.use) {
+        queries.push(`.use ${options.use}`);
+      }
+      if (options.import) {
+        for (const file of options.import) {
+          queries.push(`.import ${file}`);
+        }
+      }
+      if (options.eval) {
+        queries.push(options.eval);
+      }
+      if (options.input) {
+        let content;
+        try {
+          content = readFileSync2(options.input, "utf-8");
+        } catch (err) {
+          const isNotFound = err instanceof Error && "code" in err && err.code === "ENOENT";
+          throw new Error(
+            isNotFound ? `Input file not found: ${options.input}` : `Failed to read input file: ${err instanceof Error ? err.message : String(err)}`
+          );
+        }
+        queries.push(...content.split("\n"));
+      }
+      await runBatchMode({
+        queries,
+        schema,
+        schemaPath,
+        format: options.format ?? "text",
+        ...options.db && { databaseUrl: options.db },
+        ...options.assert && { assertFile: options.assert },
+        ...dbCasing && { dbCasing }
+      });
+      return;
+    }
+    const { startRepl } = await import("./repl-4OFERLKZ.js");
+    await startRepl({
+      schema,
+      schemaPath,
+      ...options.db && { databaseUrl: options.db },
+      ...options.use && { initialSchemaName: options.use },
+      ...options.parse && { initialParseMode: true },
+      ...options.exec && { initialExecMode: true },
+      ...dbCasing && { dbCasing }
+    });
+  } catch (error) {
+    const message = error instanceof Error ? error.message : String(error);
+    console.error(`\u274C ${message}`);
+    process.exit(1);
+  }
+});
+
+// src/commands/verify.ts
+import { compareSchemata as compareSchemata3, introspect as introspect3 } from "@dbsp/adapter-pgsql";
+import { Command as Command6 } from "commander";
+
+// src/verifier.ts
+var CHANGE_TO_DRIFT = {
+  create_table: { type: "missing_table_in_db", severity: "error" },
+  drop_table: { type: "missing_table_in_schema", severity: "warning" },
+  add_column: { type: "missing_column_in_db", severity: "error" },
+  drop_column: { type: "missing_column_in_schema", severity: "info" },
+  alter_column_type: { type: "type_mismatch", severity: "error" },
+  alter_column_nullable: { type: "nullable_mismatch", severity: "warning" },
+  alter_column_default: { type: "default_mismatch", severity: "warning" },
+  add_primary_key: { type: "primary_key_mismatch", severity: "error" },
+  drop_primary_key: { type: "primary_key_mismatch", severity: "error" },
+  add_foreign_key: { type: "missing_fk_in_db", severity: "error" },
+  drop_foreign_key: { type: "missing_fk_in_schema", severity: "warning" },
+  alter_foreign_key: { type: "fk_on_delete_mismatch", severity: "warning" },
+  create_index: { type: "missing_index_in_db", severity: "warning" },
+  drop_index: { type: "missing_index_in_schema", severity: "info" },
+  // CHECK constraints
+  add_check_constraint: { type: "missing_check_in_db", severity: "warning" },
+  drop_check_constraint: { type: "missing_check_in_schema", severity: "info" },
+  // ENUM types
+  create_enum: { type: "missing_enum_in_db", severity: "error" },
+  alter_enum_add_value: { type: "enum_value_mismatch", severity: "warning" },
+  drop_enum: { type: "missing_enum_in_schema", severity: "warning" },
+  // Column enhancements
+  alter_column_collation: { type: "collation_mismatch", severity: "warning" },
+  alter_column_identity: { type: "identity_mismatch", severity: "warning" },
+  // Comments
+  add_comment: { type: "comment_mismatch", severity: "info" },
+  drop_comment: { type: "comment_mismatch", severity: "info" },
+  // Extensions & Sequences
+  create_extension: { type: "missing_extension", severity: "error" },
+  drop_extension: { type: "missing_extension", severity: "info" },
+  create_sequence: { type: "missing_sequence", severity: "warning" },
+  alter_sequence: { type: "sequence_mismatch", severity: "warning" },
+  drop_sequence: { type: "missing_sequence", severity: "info" },
+  // Constraints
+  validate_constraint: {
+    type: "constraint_validation_mismatch",
+    severity: "warning"
+  },
+  // Row-Level Security
+  enable_rls: { type: "rls_enabled_mismatch", severity: "warning" },
+  disable_rls: { type: "rls_enabled_mismatch", severity: "warning" },
+  create_policy: { type: "missing_policy_in_db", severity: "warning" },
+  drop_policy: { type: "missing_policy_in_schema", severity: "warning" }
+};
+function changeToDriftIssue(change) {
+  const mapping = CHANGE_TO_DRIFT[change.kind] ?? {
+    type: "type_mismatch",
+    severity: "warning"
+  };
+  return {
+    severity: mapping.severity,
+    type: mapping.type,
+    table: change.table,
+    ...change.column !== void 0 ? { column: change.column } : {},
+    message: change.details
+  };
+}
+function verifyFromDiff(diff, schemaTables, dbTables) {
+  const issues = diff.changes.map(changeToDriftIssue);
+  const severityOrder = {
+    error: 0,
+    warning: 1,
+    info: 2
+  };
+  issues.sort(
+    (a, b) => severityOrder[a.severity] - severityOrder[b.severity]
+  );
+  const hasErrors = issues.some((i) => i.severity === "error");
+  return {
+    valid: !hasErrors,
+    issues,
+    schemaTables,
+    dbTables,
+    diff
+  };
+}
+function formatVerifyResult(result) {
+  const lines = [];
+  if (result.valid) {
+    lines.push("\u2705 Schema matches database");
+  } else {
+    lines.push("\u274C Schema drift detected");
+  }
+  lines.push("");
+  lines.push(`Tables in schema: ${result.schemaTables.length}`);
+  lines.push(`Tables in database: ${result.dbTables.length}`);
+  lines.push("");
+  if (result.issues.length === 0) {
+    lines.push("No issues found.");
+  } else {
+    const errors = result.issues.filter((i) => i.severity === "error");
+    const warnings = result.issues.filter((i) => i.severity === "warning");
+    const infos = result.issues.filter((i) => i.severity === "info");
+    if (errors.length > 0) {
+      lines.push(`\u274C ${errors.length} error(s):`);
+      for (const issue of errors) {
+        lines.push(`   ${issue.message}`);
+      }
+      lines.push("");
+    }
+    if (warnings.length > 0) {
+      lines.push(`\u26A0\uFE0F  ${warnings.length} warning(s):`);
+      for (const issue of warnings) {
+        lines.push(`   ${issue.message}`);
+      }
+      lines.push("");
+    }
+    if (infos.length > 0) {
+      lines.push(`\u2139\uFE0F  ${infos.length} info:`);
+      for (const issue of infos) {
+        lines.push(`   ${issue.message}`);
+      }
+      lines.push("");
+    }
+  }
+  return lines.join("\n");
+}
+
+// src/commands/verify.ts
+var verifyCommand = new Command6("verify").description("Compare schema vs real database (drift detection)").option(
+  "-s, --schema <path>",
+  "Path to schema file (default: dbsp.schema.ts)"
+).requiredOption("-d, --db <url>", "Database connection URL (required)").option("--schema-name <name>", "Database schema name (default: public)").option("--json", "Output as JSON").action(
+  async (options) => {
+    const schemaPath = options.schema ?? "dbsp.schema.ts";
+    const redactedUrl = redactDbUrl(options.db);
+    if (!options.json) {
+      console.log(`\u{1F50D} Verifying schema: ${schemaPath}`);
+      console.log(`   Database: ${redactedUrl}`);
+      if (options.schemaName) {
+        console.log(`   Schema: ${options.schemaName}`);
+      }
+      console.log("");
+    }
+    try {
+      const loaded = await loadSchema(schemaPath);
+      const schemaModel = loaded.model;
+      const { pool } = await createDbConnection(options.db);
+      try {
+        const dbModel = await introspect3(pool, {
+          ...options.schemaName ? { schema: options.schemaName } : {}
+        });
+        const diff = compareSchemata3(schemaModel, dbModel);
+        const schemaTables = Array.from(schemaModel.tables.keys());
+        const dbTables = Array.from(dbModel.tables.keys());
+        const result = verifyFromDiff(diff, schemaTables, dbTables);
+        if (options.json) {
+          const { diff: _diff, ...jsonResult } = result;
+          console.log(
+            JSON.stringify(
+              {
+                ...jsonResult,
+                summary: diff.summary,
+                hasDestructive: diff.hasDestructive
+              },
+              null,
+              2
+            )
+          );
+        } else {
+          console.log(formatVerifyResult(result));
+        }
+        process.exitCode = result.valid ? 0 : 1;
+        return;
+      } finally {
+        await pool.end();
+      }
+    } catch (error) {
+      const message = error instanceof Error ? error.message : "Unknown error occurred";
+      if (options.json) {
+        console.log(
+          JSON.stringify({ status: "error", error: message }, null, 2)
+        );
+      } else {
+        console.error(`\u274C Error: ${message}`);
+      }
+      process.exit(1);
+    }
+  }
+);
+
+// src/index.ts
+var program = new Command7();
+program.name("dbsp").description("Schema-first code generation for db-semantic-planner").version("0.0.1");
+program.addCommand(generateCommand);
+program.addCommand(introspectCommand);
+program.addCommand(migrateCommand);
+program.addCommand(pushCommand);
+program.addCommand(replCommand);
+program.addCommand(verifyCommand);
+program.exitOverride();
+try {
+  program.parse();
+} catch (err) {
+  if (err instanceof CommanderError && err.exitCode === 0) {
+    process.exit(0);
+  }
+  const message = err instanceof Error ? err.message : "Command parse error";
+  if (process.argv.includes("--json")) {
+    console.log(JSON.stringify({ status: "error", error: message }, null, 2));
+  } else {
+    console.error(`\u274C ${message}`);
+  }
+  process.exit(1);
+}
+//# sourceMappingURL=index.js.map