drizzle-multitenant 1.0.4 → 1.0.6

package/dist/cli/index.js

@@ -1,15 +1,111 @@
 #!/usr/bin/env node
 import { Command } from 'commander';
+import { checkbox, confirm, select, input } from '@inquirer/prompts';
 import { mkdir, readdir, writeFile, readFile } from 'fs/promises';
 import { resolve, join, extname, basename } from 'path';
+import { createHash } from 'crypto';
 import { Pool } from 'pg';
 import ora from 'ora';
-import chalk2 from 'chalk';
 import Table from 'cli-table3';
+import chalk from 'chalk';
 import { pathToFileURL } from 'url';
-import { existsSync } from 'fs';
+import { existsSync, writeFileSync, mkdirSync } from 'fs';
+import cliProgress from 'cli-progress';
 import { createInterface } from 'readline';
 
+// src/migrator/table-format.ts
+async function detectTableFormat(pool, schemaName, tableName) {
+  const tableExists = await pool.query(
+    `SELECT EXISTS (
+      SELECT 1 FROM information_schema.tables
+      WHERE table_schema = $1 AND table_name = $2
+    ) as exists`,
+    [schemaName, tableName]
+  );
+  if (!tableExists.rows[0]?.exists) {
+    return null;
+  }
+  const columnsResult = await pool.query(
+    `SELECT column_name, data_type
+     FROM information_schema.columns
+     WHERE table_schema = $1 AND table_name = $2`,
+    [schemaName, tableName]
+  );
+  const columnMap = new Map(
+    columnsResult.rows.map((r) => [r.column_name, r.data_type])
+  );
+  if (columnMap.has("name")) {
+    return {
+      format: "name",
+      tableName,
+      columns: {
+        identifier: "name",
+        timestamp: columnMap.has("applied_at") ? "applied_at" : "created_at",
+        timestampType: "timestamp"
+      }
+    };
+  }
+  if (columnMap.has("hash")) {
+    const createdAtType = columnMap.get("created_at");
+    if (createdAtType === "bigint") {
+      return {
+        format: "drizzle-kit",
+        tableName,
+        columns: {
+          identifier: "hash",
+          timestamp: "created_at",
+          timestampType: "bigint"
+        }
+      };
+    }
+    return {
+      format: "hash",
+      tableName,
+      columns: {
+        identifier: "hash",
+        timestamp: "created_at",
+        timestampType: "timestamp"
+      }
+    };
+  }
+  return null;
+}
+function getFormatConfig(format, tableName = "__drizzle_migrations") {
+  switch (format) {
+    case "name":
+      return {
+        format: "name",
+        tableName,
+        columns: {
+          identifier: "name",
+          timestamp: "applied_at",
+          timestampType: "timestamp"
+        }
+      };
+    case "hash":
+      return {
+        format: "hash",
+        tableName,
+        columns: {
+          identifier: "hash",
+          timestamp: "created_at",
+          timestampType: "timestamp"
+        }
+      };
+    case "drizzle-kit":
+      return {
+        format: "drizzle-kit",
+        tableName,
+        columns: {
+          identifier: "hash",
+          timestamp: "created_at",
+          timestampType: "bigint"
+        }
+      };
+  }
+}
+
+// src/migrator/migrator.ts
 var DEFAULT_MIGRATIONS_TABLE = "__drizzle_migrations";
 var Migrator = class {
   constructor(tenantConfig, migratorConfig) {
@@ -44,13 +140,13 @@ var Migrator = class {
             const result = await this.migrateTenant(tenantId, migrations, { dryRun, onProgress });
             onProgress?.(tenantId, result.success ? "completed" : "failed");
             return result;
-          } catch (error6) {
+          } catch (error2) {
             onProgress?.(tenantId, "failed");
-            const action = onError?.(tenantId, error6);
+            const action = onError?.(tenantId, error2);
             if (action === "abort") {
               aborted = true;
             }
-            return this.createErrorResult(tenantId, error6);
+            return this.createErrorResult(tenantId, error2);
           }
         })
       );
@@ -74,25 +170,29 @@ var Migrator = class {
     const pool = await this.createPool(schemaName);
     try {
       await this.migratorConfig.hooks?.beforeTenant?.(tenantId);
-      await this.ensureMigrationsTable(pool, schemaName);
+      const format = await this.getOrDetectFormat(pool, schemaName);
+      await this.ensureMigrationsTable(pool, schemaName, format);
       const allMigrations = migrations ?? await this.loadMigrations();
-      const applied = await this.getAppliedMigrations(pool, schemaName);
-      const appliedSet = new Set(applied.map((m) => m.name));
-      const pending = allMigrations.filter((m) => !appliedSet.has(m.name));
+      const applied = await this.getAppliedMigrations(pool, schemaName, format);
+      const appliedSet = new Set(applied.map((m) => m.identifier));
+      const pending = allMigrations.filter(
+        (m) => !this.isMigrationApplied(m, appliedSet, format)
+      );
       if (options.dryRun) {
         return {
           tenantId,
           schemaName,
           success: true,
           appliedMigrations: pending.map((m) => m.name),
-          durationMs: Date.now() - startTime
+          durationMs: Date.now() - startTime,
+          format: format.format
         };
       }
       for (const migration of pending) {
         const migrationStart = Date.now();
         options.onProgress?.(tenantId, "migrating", migration.name);
         await this.migratorConfig.hooks?.beforeMigration?.(tenantId, migration.name);
-        await this.applyMigration(pool, schemaName, migration);
+        await this.applyMigration(pool, schemaName, migration, format);
         await this.migratorConfig.hooks?.afterMigration?.(
           tenantId,
           migration.name,
@@ -105,17 +205,18 @@ var Migrator = class {
         schemaName,
         success: true,
         appliedMigrations,
-        durationMs: Date.now() - startTime
+        durationMs: Date.now() - startTime,
+        format: format.format
       };
       await this.migratorConfig.hooks?.afterTenant?.(tenantId, result);
       return result;
-    } catch (error6) {
+    } catch (error2) {
       const result = {
         tenantId,
         schemaName,
         success: false,
         appliedMigrations,
-        error: error6.message,
+        error: error2.message,
         durationMs: Date.now() - startTime
       };
       await this.migratorConfig.hooks?.afterTenant?.(tenantId, result);
@@ -140,10 +241,10 @@ var Migrator = class {
             const result = await this.migrateTenant(tenantId, migrations, { dryRun: options.dryRun ?? false, onProgress });
             onProgress?.(tenantId, result.success ? "completed" : "failed");
             return result;
-          } catch (error6) {
+          } catch (error2) {
             onProgress?.(tenantId, "failed");
-            onError?.(tenantId, error6);
-            return this.createErrorResult(tenantId, error6);
+            onError?.(tenantId, error2);
+            return this.createErrorResult(tenantId, error2);
           }
         })
       );
@@ -179,21 +280,27 @@ var Migrator = class {
           appliedCount: 0,
           pendingCount: allMigrations.length,
           pendingMigrations: allMigrations.map((m) => m.name),
-          status: allMigrations.length > 0 ? "behind" : "ok"
+          status: allMigrations.length > 0 ? "behind" : "ok",
+          format: null
+          // New tenant, no table yet
         };
       }
-      const applied = await this.getAppliedMigrations(pool, schemaName);
-      const appliedSet = new Set(applied.map((m) => m.name));
-      const pending = allMigrations.filter((m) => !appliedSet.has(m.name));
+      const format = await this.getOrDetectFormat(pool, schemaName);
+      const applied = await this.getAppliedMigrations(pool, schemaName, format);
+      const appliedSet = new Set(applied.map((m) => m.identifier));
+      const pending = allMigrations.filter(
+        (m) => !this.isMigrationApplied(m, appliedSet, format)
+      );
       return {
         tenantId,
         schemaName,
         appliedCount: applied.length,
         pendingCount: pending.length,
         pendingMigrations: pending.map((m) => m.name),
-        status: pending.length > 0 ? "behind" : "ok"
+        status: pending.length > 0 ? "behind" : "ok",
+        format: format.format
       };
-    } catch (error6) {
+    } catch (error2) {
       return {
         tenantId,
         schemaName,
@@ -201,7 +308,8 @@ var Migrator = class {
         pendingCount: 0,
         pendingMigrations: [],
         status: "error",
-        error: error6.message
+        error: error2.message,
+        format: null
       };
     } finally {
       await pool.end();
@@ -274,11 +382,13 @@ var Migrator = class {
       const content = await readFile(filePath, "utf-8");
       const match = file.match(/^(\d+)_/);
       const timestamp = match?.[1] ? parseInt(match[1], 10) : 0;
+      const hash = createHash("sha256").update(content).digest("hex");
       migrations.push({
         name: basename(file, ".sql"),
         path: filePath,
         sql: content,
-        timestamp
+        timestamp,
+        hash
       });
     }
     return migrations.sort((a, b) => a.timestamp - b.timestamp);
@@ -294,14 +404,17 @@ var Migrator = class {
     });
   }
   /**
-   * Ensure migrations table exists
+   * Ensure migrations table exists with the correct format
    */
-  async ensureMigrationsTable(pool, schemaName) {
+  async ensureMigrationsTable(pool, schemaName, format) {
+    const { identifier, timestamp, timestampType } = format.columns;
+    const identifierCol = identifier === "name" ? "name VARCHAR(255) NOT NULL UNIQUE" : "hash TEXT NOT NULL";
+    const timestampCol = timestampType === "bigint" ? `${timestamp} BIGINT NOT NULL` : `${timestamp} TIMESTAMP WITH TIME ZONE DEFAULT CURRENT_TIMESTAMP`;
     await pool.query(`
-      CREATE TABLE IF NOT EXISTS "${schemaName}"."${this.migrationsTable}" (
+      CREATE TABLE IF NOT EXISTS "${schemaName}"."${format.tableName}" (
         id SERIAL PRIMARY KEY,
-        name VARCHAR(255) NOT NULL UNIQUE,
-        applied_at TIMESTAMP WITH TIME ZONE DEFAULT CURRENT_TIMESTAMP
+        ${identifierCol},
+        ${timestampCol}
       )
     `);
   }
@@ -319,32 +432,69 @@ var Migrator = class {
   /**
    * Get applied migrations for a schema
    */
-  async getAppliedMigrations(pool, schemaName) {
+  async getAppliedMigrations(pool, schemaName, format) {
+    const identifierColumn = format.columns.identifier;
+    const timestampColumn = format.columns.timestamp;
     const result = await pool.query(
-      `SELECT id, name, applied_at FROM "${schemaName}"."${this.migrationsTable}" ORDER BY id`
+      `SELECT id, "${identifierColumn}" as identifier, "${timestampColumn}" as applied_at
+       FROM "${schemaName}"."${format.tableName}"
+       ORDER BY id`
     );
-    return result.rows.map((row) => ({
-      id: row.id,
-      name: row.name,
-      appliedAt: row.applied_at
-    }));
+    return result.rows.map((row) => {
+      const appliedAt = format.columns.timestampType === "bigint" ? new Date(Number(row.applied_at)) : new Date(row.applied_at);
+      return {
+        id: row.id,
+        identifier: row.identifier,
+        // Set name or hash based on format
+        ...format.columns.identifier === "name" ? { name: row.identifier } : { hash: row.identifier },
+        appliedAt
+      };
+    });
+  }
+  /**
+   * Check if a migration has been applied
+   */
+  isMigrationApplied(migration, appliedIdentifiers, format) {
+    if (format.columns.identifier === "name") {
+      return appliedIdentifiers.has(migration.name);
+    }
+    return appliedIdentifiers.has(migration.hash) || appliedIdentifiers.has(migration.name);
+  }
+  /**
+   * Get or detect the format for a schema
+   * Returns the configured format or auto-detects from existing table
+   */
+  async getOrDetectFormat(pool, schemaName) {
+    const configuredFormat = this.migratorConfig.tableFormat ?? "auto";
+    if (configuredFormat !== "auto") {
+      return getFormatConfig(configuredFormat, this.migrationsTable);
+    }
+    const detected = await detectTableFormat(pool, schemaName, this.migrationsTable);
+    if (detected) {
+      return detected;
+    }
+    const defaultFormat = this.migratorConfig.defaultFormat ?? "name";
+    return getFormatConfig(defaultFormat, this.migrationsTable);
   }
   /**
    * Apply a migration to a schema
    */
-  async applyMigration(pool, schemaName, migration) {
+  async applyMigration(pool, schemaName, migration, format) {
     const client = await pool.connect();
     try {
       await client.query("BEGIN");
       await client.query(migration.sql);
+      const { identifier, timestamp, timestampType } = format.columns;
+      const identifierValue = identifier === "name" ? migration.name : migration.hash;
+      const timestampValue = timestampType === "bigint" ? Date.now() : /* @__PURE__ */ new Date();
       await client.query(
-        `INSERT INTO "${schemaName}"."${this.migrationsTable}" (name) VALUES ($1)`,
-        [migration.name]
+        `INSERT INTO "${schemaName}"."${format.tableName}" ("${identifier}", "${timestamp}") VALUES ($1, $2)`,
+        [identifierValue, timestampValue]
       );
       await client.query("COMMIT");
-    } catch (error6) {
+    } catch (error2) {
       await client.query("ROLLBACK");
-      throw error6;
+      throw error2;
     } finally {
       client.release();
     }
@@ -365,13 +515,13 @@ var Migrator = class {
   /**
    * Create an error result
    */
-  createErrorResult(tenantId, error6) {
+  createErrorResult(tenantId, error2) {
     return {
       tenantId,
       schemaName: this.tenantConfig.isolation.schemaNameTemplate(tenantId),
       success: false,
       appliedMigrations: [],
-      error: error6.message,
+      error: error2.message,
       durationMs: 0
     };
   }
@@ -397,35 +547,28 @@ function createSpinner(text) {
     color: "cyan"
   });
 }
-function success(message) {
-  return chalk2.green("\u2713 ") + message;
-}
-function error(message) {
-  return chalk2.red("\u2717 ") + message;
-}
-function warning(message) {
-  return chalk2.yellow("\u26A0 ") + message;
-}
-function info(message) {
-  return chalk2.blue("\u2139 ") + message;
-}
-function dim(message) {
-  return chalk2.dim(message);
-}
-function bold(message) {
-  return chalk2.bold(message);
-}
-function red(message) {
-  return chalk2.red(message);
+function getFormatText(format) {
+  if (format === null) {
+    return chalk.dim("(new)");
+  }
+  switch (format) {
+    case "name":
+      return chalk.blue("name");
+    case "hash":
+      return chalk.magenta("hash");
+    case "drizzle-kit":
+      return chalk.cyan("drizzle-kit");
+  }
 }
 function createStatusTable(statuses) {
   const table = new Table({
     head: [
-      chalk2.cyan("Tenant"),
-      chalk2.cyan("Schema"),
-      chalk2.cyan("Applied"),
-      chalk2.cyan("Pending"),
-      chalk2.cyan("Status")
+      chalk.cyan("Tenant"),
+      chalk.cyan("Schema"),
+      chalk.cyan("Format"),
+      chalk.cyan("Applied"),
+      chalk.cyan("Pending"),
+      chalk.cyan("Status")
     ],
     style: {
       head: [],
@@ -437,9 +580,10 @@ function createStatusTable(statuses) {
     const statusText = getStatusText(status.status);
     table.push([
       status.tenantId,
-      chalk2.dim(status.schemaName),
-      chalk2.green(status.appliedCount.toString()),
-      status.pendingCount > 0 ? chalk2.yellow(status.pendingCount.toString()) : chalk2.dim("0"),
+      chalk.dim(status.schemaName),
+      getFormatText(status.format),
+      chalk.green(status.appliedCount.toString()),
+      status.pendingCount > 0 ? chalk.yellow(status.pendingCount.toString()) : chalk.dim("0"),
       `${statusIcon} ${statusText}`
     ]);
   }
@@ -448,10 +592,11 @@ function createStatusTable(statuses) {
 function createResultsTable(results) {
   const table = new Table({
     head: [
-      chalk2.cyan("Tenant"),
-      chalk2.cyan("Migrations"),
-      chalk2.cyan("Duration"),
-      chalk2.cyan("Status")
+      chalk.cyan("Tenant"),
+      chalk.cyan("Format"),
+      chalk.cyan("Migrations"),
+      chalk.cyan("Duration"),
+      chalk.cyan("Status")
     ],
     style: {
       head: [],
@@ -459,10 +604,11 @@ function createResultsTable(results) {
     }
   });
   for (const result of results) {
-    const statusIcon = result.success ? chalk2.green("\u2713") : chalk2.red("\u2717");
-    const statusText = result.success ? chalk2.green("OK") : chalk2.red(result.error ?? "Failed");
+    const statusIcon = result.success ? chalk.green("\u2713") : chalk.red("\u2717");
+    const statusText = result.success ? chalk.green("OK") : chalk.red(result.error ?? "Failed");
     table.push([
       result.tenantId,
+      getFormatText(result.format ?? null),
       result.appliedMigrations.length.toString(),
       `${result.durationMs}ms`,
       `${statusIcon} ${statusText}`
@@ -478,37 +624,37 @@ function createPendingSummary(statuses) {
     }
   }
   if (pendingMap.size === 0) {
-    return chalk2.green("\nAll tenants are up to date.");
+    return chalk.green("\nAll tenants are up to date.");
   }
-  const lines = [chalk2.yellow("\nPending migrations:")];
+  const lines = [chalk.yellow("\nPending migrations:")];
   for (const [migration, count] of pendingMap.entries()) {
     lines.push(
-      `  ${chalk2.dim("-")} ${migration} ${chalk2.dim(`(${count} tenant${count > 1 ? "s" : ""})`)}`
+      `  ${chalk.dim("-")} ${migration} ${chalk.dim(`(${count} tenant${count > 1 ? "s" : ""})`)}`
     );
   }
   lines.push(
-    chalk2.dim("\nRun 'drizzle-multitenant migrate --all' to apply pending migrations.")
+    chalk.dim("\nRun 'drizzle-multitenant migrate --all' to apply pending migrations.")
   );
   return lines.join("\n");
 }
 function getStatusIcon(status) {
   switch (status) {
     case "ok":
-      return chalk2.green("\u2713");
+      return chalk.green("\u2713");
     case "behind":
-      return chalk2.yellow("\u26A0");
+      return chalk.yellow("\u26A0");
     case "error":
-      return chalk2.red("\u2717");
+      return chalk.red("\u2717");
   }
 }
 function getStatusText(status) {
   switch (status) {
     case "ok":
-      return chalk2.green("OK");
+      return chalk.green("OK");
     case "behind":
-      return chalk2.yellow("Behind");
+      return chalk.yellow("Behind");
     case "error":
-      return chalk2.red("Error");
+      return chalk.red("Error");
   }
 }
 var CONFIG_FILE_NAMES = [
@@ -582,122 +728,465 @@ function resolveMigrationsFolder(folder) {
   }
   return resolved;
 }
+var globalContext = {
+  isInteractive: process.stdout.isTTY ?? false,
+  jsonMode: false,
+  verbose: false,
+  quiet: false,
+  noColor: false
+};
+function initOutputContext(options) {
+  globalContext = {
+    isInteractive: process.stdout.isTTY ?? false,
+    jsonMode: options.json ?? false,
+    verbose: options.verbose ?? false,
+    quiet: options.quiet ?? false,
+    noColor: options.noColor ?? !process.stdout.isTTY
+  };
+  if (globalContext.noColor) {
+    chalk.level = 0;
+  }
+}
+function getOutputContext() {
+  return globalContext;
+}
+function shouldShowInteractive() {
+  return globalContext.isInteractive && !globalContext.jsonMode && !globalContext.quiet;
+}
+function shouldShowLog() {
+  return !globalContext.jsonMode && !globalContext.quiet;
+}
+function shouldShowVerbose() {
+  return globalContext.verbose && !globalContext.jsonMode;
+}
+function log(message) {
+  if (shouldShowLog()) {
+    console.log(message);
+  }
+}
+function debug(message) {
+  if (shouldShowVerbose()) {
+    console.log(chalk.dim(`[debug] ${message}`));
+  }
+}
+function outputJson(data) {
+  if (globalContext.jsonMode) {
+    console.log(JSON.stringify(data, null, 2));
+  }
+}
+function success(message) {
+  return chalk.green("\u2713 ") + message;
+}
+function error(message) {
+  return chalk.red("\u2717 ") + message;
+}
+function warning(message) {
+  return chalk.yellow("\u26A0 ") + message;
+}
+function info(message) {
+  return chalk.blue("\u2139 ") + message;
+}
+function dim(message) {
+  return chalk.dim(message);
+}
+function bold(message) {
+  return chalk.bold(message);
+}
+function cyan(message) {
+  return chalk.cyan(message);
+}
+function green(message) {
+  return chalk.green(message);
+}
+function red(message) {
+  return chalk.red(message);
+}
+function createProgressBar(options) {
+  const { total } = options;
+  if (!shouldShowInteractive()) {
+    return {
+      start: () => {
+      },
+      update: () => {
+      },
+      increment: () => {
+      },
+      stop: () => {
+      }
+    };
+  }
+  const format = options.format || `${chalk.cyan("Migrating")} ${chalk.cyan("{bar}")} ${chalk.yellow("{percentage}%")} | {value}/{total} | {tenant} | ${dim("{eta}s")}`;
+  const bar = new cliProgress.SingleBar(
+    {
+      format,
+      barCompleteChar: "\u2588",
+      barIncompleteChar: "\u2591",
+      hideCursor: true,
+      clearOnComplete: false,
+      stopOnComplete: true,
+      etaBuffer: 10
+    },
+    cliProgress.Presets.shades_classic
+  );
+  let currentValue = 0;
+  return {
+    start() {
+      bar.start(total, 0, { tenant: "starting...", status: "" });
+    },
+    update(current, payload) {
+      currentValue = current;
+      const statusIcon = payload?.status === "success" ? green("\u2713") : payload?.status === "error" ? red("\u2717") : "";
+      bar.update(current, {
+        tenant: payload?.tenant ? `${statusIcon} ${payload.tenant}` : ""
+      });
+    },
+    increment(payload) {
+      currentValue++;
+      const statusIcon = payload?.status === "success" ? green("\u2713") : payload?.status === "error" ? red("\u2717") : "";
+      bar.update(currentValue, {
+        tenant: payload?.tenant ? `${statusIcon} ${payload.tenant}` : ""
+      });
+    },
+    stop() {
+      bar.stop();
+    }
+  };
+}
+
+// src/cli/utils/errors.ts
+var CLIError = class extends Error {
+  constructor(message, suggestion, example, docs) {
+    super(message);
+    this.suggestion = suggestion;
+    this.example = example;
+    this.docs = docs;
+    this.name = "CLIError";
+  }
+  /**
+   * Format the error for display
+   */
+  format() {
+    const lines = [error(this.message)];
+    if (this.suggestion) {
+      lines.push("");
+      lines.push(dim("  Suggestion: ") + this.suggestion);
+    }
+    if (this.example) {
+      lines.push("");
+      lines.push(dim("  Example:"));
+      lines.push(cyan("    " + this.example));
+    }
+    if (this.docs) {
+      lines.push("");
+      lines.push(dim("  Docs: ") + this.docs);
+    }
+    return lines.join("\n");
+  }
+  /**
+   * Format as JSON for machine-readable output
+   */
+  toJSON() {
+    return {
+      error: this.message,
+      suggestion: this.suggestion,
+      example: this.example,
+      docs: this.docs
+    };
+  }
+};
+var CLIErrors = {
+  configNotFound: (searchPaths) => new CLIError(
+    "Configuration file not found",
+    "Create a tenant.config.ts file or use --config <path>",
+    `export default defineConfig({
+  connection: process.env.DATABASE_URL,
+  isolation: { type: 'schema', schemaNameTemplate: (id) => \`tenant_\${id}\` },
+  schemas: {
+    tenant: { ... },
+  },
+})`,
+    searchPaths ? `Searched: ${searchPaths.join(", ")}` : void 0
+  ),
+  noTenantDiscovery: () => new CLIError(
+    "No tenant discovery function configured",
+    "Add a tenantDiscovery function to your config migrations settings",
+    `migrations: {
+  tenantDiscovery: async () => {
+    const tenants = await db.select().from(tenantsTable);
+    return tenants.map(t => t.id);
+  },
+}`
+  ),
+  noTenantSpecified: () => new CLIError(
+    "No tenant specified",
+    "Use --all, --tenant <id>, or --tenants <ids> to specify which tenants to migrate",
+    `npx drizzle-multitenant migrate --all
+npx drizzle-multitenant migrate --tenant=my-tenant
+npx drizzle-multitenant migrate --tenants=tenant-1,tenant-2`
+  ),
+  tenantNotFound: (tenantId) => new CLIError(
+    `Tenant '${tenantId}' not found`,
+    "Check if the tenant exists in your database",
+    "npx drizzle-multitenant status"
+  ),
+  migrationsFolderNotFound: (path) => new CLIError(
+    `Migrations folder not found: ${path}`,
+    "Create the migrations folder or specify a different path with --migrations-folder",
+    `mkdir -p ${path}
+npx drizzle-multitenant generate --name initial`
+  ),
+  invalidFormat: (format, validFormats) => new CLIError(
+    `Invalid format: '${format}'`,
+    `Valid formats are: ${validFormats.join(", ")}`,
+    `npx drizzle-multitenant convert-format --to=${validFormats[0]}`
+  ),
+  connectionFailed: (reason) => new CLIError(
+    `Database connection failed: ${reason}`,
+    "Check your DATABASE_URL and ensure the database is running",
+    'export DATABASE_URL="postgresql://user:pass@localhost:5432/mydb"'
+  ),
+  migrationFailed: (tenantId, reason) => new CLIError(
+    `Migration failed for tenant '${tenantId}': ${reason}`,
+    "Check the migration SQL for syntax errors or constraint violations"
+  )
+};
+function handleError(err) {
+  const ctx = getOutputContext();
+  if (ctx.jsonMode) {
+    if (err instanceof CLIError) {
+      console.log(JSON.stringify(err.toJSON(), null, 2));
+    } else {
+      console.log(JSON.stringify({ error: err.message }, null, 2));
+    }
+    process.exit(1);
+  }
+  if (err instanceof CLIError) {
+    console.error(err.format());
+  } else {
+    console.error(error(err.message));
+  }
+  process.exit(1);
+}
 
 // src/cli/commands/migrate.ts
-var migrateCommand = new Command("migrate").description("Apply pending migrations to tenant schemas").option("-c, --config <path>", "Path to config file").option("-a, --all", "Migrate all tenants").option("-t, --tenant <id>", "Migrate a specific tenant").option("--tenants <ids>", "Migrate specific tenants (comma-separated)").option("--concurrency <number>", "Number of concurrent migrations", "10").option("--dry-run", "Show what would be applied without executing").option("--migrations-folder <path>", "Path to migrations folder").action(async (options) => {
+var migrateCommand = new Command("migrate").description("Apply pending migrations to tenant schemas").option("-c, --config <path>", "Path to config file").option("-a, --all", "Migrate all tenants").option("-t, --tenant <id>", "Migrate a specific tenant").option("--tenants <ids>", "Migrate specific tenants (comma-separated)").option("--concurrency <number>", "Number of concurrent migrations", "10").option("--dry-run", "Show what would be applied without executing").option("--migrations-folder <path>", "Path to migrations folder").addHelpText("after", `
+Examples:
+  $ drizzle-multitenant migrate --all
+  $ drizzle-multitenant migrate --tenant=my-tenant
+  $ drizzle-multitenant migrate --tenants=tenant-1,tenant-2
+  $ drizzle-multitenant migrate --all --dry-run
+  $ drizzle-multitenant migrate --all --concurrency=5
+  $ drizzle-multitenant migrate --all --json
+`).action(async (options) => {
+  const startTime = Date.now();
+  const ctx = getOutputContext();
   const spinner = createSpinner("Loading configuration...");
   try {
     spinner.start();
     const { config, migrationsFolder, migrationsTable, tenantDiscovery } = await loadConfig(options.config);
     const folder = options.migrationsFolder ? resolveMigrationsFolder(options.migrationsFolder) : resolveMigrationsFolder(migrationsFolder);
+    debug(`Using migrations folder: ${folder}`);
     let discoveryFn;
+    let tenantIds;
     if (options.tenant) {
       discoveryFn = async () => [options.tenant];
+      tenantIds = [options.tenant];
     } else if (options.tenants) {
-      const tenantIds2 = options.tenants.split(",").map((id) => id.trim());
-      discoveryFn = async () => tenantIds2;
+      const ids = options.tenants.split(",").map((id) => id.trim());
+      discoveryFn = async () => ids;
+      tenantIds = ids;
     } else if (options.all) {
       if (!tenantDiscovery) {
-        throw new Error(
-          "No tenant discovery function configured. Add migrations.tenantDiscovery to your config."
-        );
+        throw CLIErrors.noTenantDiscovery();
       }
       discoveryFn = tenantDiscovery;
+      spinner.text = "Discovering tenants...";
+      tenantIds = await tenantDiscovery();
     } else {
       spinner.stop();
-      console.log(error("Please specify --all, --tenant, or --tenants"));
-      console.log(dim("\nExamples:"));
-      console.log(dim("  npx drizzle-multitenant migrate --all"));
-      console.log(dim("  npx drizzle-multitenant migrate --tenant=tenant-uuid"));
-      console.log(dim("  npx drizzle-multitenant migrate --tenants=tenant-1,tenant-2"));
-      process.exit(1);
+      if (shouldShowInteractive() && tenantDiscovery) {
+        log(info("No tenants specified. Fetching available tenants...\n"));
+        const availableTenants = await tenantDiscovery();
+        if (availableTenants.length === 0) {
+          log(warning("No tenants found."));
+          return;
+        }
+        const selectedTenants = await checkbox({
+          message: "Select tenants to migrate:",
+          choices: availableTenants.map((id) => ({ name: id, value: id })),
+          pageSize: 15
+        });
+        if (selectedTenants.length === 0) {
+          log(warning("No tenants selected. Aborting."));
+          return;
+        }
+        discoveryFn = async () => selectedTenants;
+        tenantIds = selectedTenants;
+      } else {
+        throw CLIErrors.noTenantSpecified();
+      }
     }
-    spinner.text = "Discovering tenants...";
-    const migrator = createMigrator(config, {
-      migrationsFolder: folder,
-      migrationsTable,
-      tenantDiscovery: discoveryFn
-    });
-    const tenantIds = await discoveryFn();
     if (tenantIds.length === 0) {
       spinner.stop();
-      console.log(warning("No tenants found."));
+      log(warning("No tenants found."));
       return;
     }
     spinner.text = `Found ${tenantIds.length} tenant${tenantIds.length > 1 ? "s" : ""}`;
     spinner.succeed();
     if (options.dryRun) {
-      console.log(info(bold("\nDry run mode - no changes will be made\n")));
+      log(info(bold("\nDry run mode - no changes will be made\n")));
     }
-    console.log(info(`Migrating ${tenantIds.length} tenant${tenantIds.length > 1 ? "s" : ""}...
+    log(info(`Migrating ${tenantIds.length} tenant${tenantIds.length > 1 ? "s" : ""}...
 `));
-    const concurrency = parseInt(options.concurrency, 10);
-    let completed = 0;
+    const migrator = createMigrator(config, {
+      migrationsFolder: folder,
+      ...migrationsTable && { migrationsTable },
+      tenantDiscovery: discoveryFn
+    });
+    const concurrency = parseInt(options.concurrency || "10", 10);
+    const progressBar = createProgressBar({ total: tenantIds.length });
+    progressBar.start();
     const results = await migrator.migrateAll({
       concurrency,
-      dryRun: options.dryRun,
+      dryRun: !!options.dryRun,
       onProgress: (tenantId, status, migrationName) => {
         if (status === "completed") {
-          completed++;
-          const progress = `[${completed}/${tenantIds.length}]`;
-          console.log(`${dim(progress)} ${success(tenantId)}`);
+          progressBar.increment({ tenant: tenantId, status: "success" });
+          debug(`Completed: ${tenantId}`);
         } else if (status === "failed") {
-          completed++;
-          const progress = `[${completed}/${tenantIds.length}]`;
-          console.log(`${dim(progress)} ${error(tenantId)}`);
+          progressBar.increment({ tenant: tenantId, status: "error" });
+          debug(`Failed: ${tenantId}`);
         } else if (status === "migrating" && migrationName) {
+          debug(`${tenantId}: Applying ${migrationName}`);
         }
       },
       onError: (tenantId, err) => {
-        console.log(error(`${tenantId}: ${err.message}`));
+        debug(`Error on ${tenantId}: ${err.message}`);
         return "continue";
       }
     });
-    console.log("\n" + bold("Results:"));
-    console.log(createResultsTable(results.details));
-    console.log("\n" + bold("Summary:"));
-    console.log(`  Total:     ${results.total}`);
-    console.log(`  Succeeded: ${success(results.succeeded.toString())}`);
+    progressBar.stop();
+    const totalDuration = Date.now() - startTime;
+    if (ctx.jsonMode) {
+      const jsonOutput = {
+        results: results.details.map((r) => ({
+          tenantId: r.tenantId,
+          schema: r.schemaName,
+          success: r.success,
+          appliedMigrations: r.appliedMigrations,
+          durationMs: r.durationMs,
+          format: r.format,
+          error: r.error
+        })),
+        summary: {
+          total: results.total,
+          succeeded: results.succeeded,
+          failed: results.failed,
+          skipped: results.skipped,
+          durationMs: totalDuration,
+          averageMs: results.total > 0 ? Math.round(totalDuration / results.total) : void 0
+        }
+      };
+      outputJson(jsonOutput);
+      process.exit(results.failed > 0 ? 1 : 0);
+    }
+    log("\n" + bold("Results:"));
+    log(createResultsTable(results.details));
+    log("\n" + bold("Summary:"));
+    log(`  Total:      ${results.total}`);
+    log(`  Succeeded:  ${success(results.succeeded.toString())}`);
     if (results.failed > 0) {
-      console.log(`  Failed:    ${error(results.failed.toString())}`);
+      log(`  Failed:     ${error(results.failed.toString())}`);
     }
     if (results.skipped > 0) {
-      console.log(`  Skipped:   ${warning(results.skipped.toString())}`);
+      log(`  Skipped:    ${warning(results.skipped.toString())}`);
+    }
+    log(`  Duration:   ${dim(formatDuration(totalDuration))}`);
+    if (results.total > 0) {
+      log(`  Average:    ${dim(formatDuration(Math.round(totalDuration / results.total)) + "/tenant")}`);
+    }
+    if (results.failed > 0) {
+      log("\n" + bold("Failed tenants:"));
+      for (const detail of results.details.filter((d) => !d.success)) {
+        log(`  ${error(detail.tenantId)}: ${dim(detail.error || "Unknown error")}`);
+      }
+      log("\n" + dim("Run with --verbose to see more details."));
     }
     if (results.failed > 0) {
       process.exit(1);
     }
   } catch (err) {
     spinner.fail(err.message);
-    process.exit(1);
+    handleError(err);
   }
 });
-var statusCommand = new Command("status").description("Show migration status for all tenants").option("-c, --config <path>", "Path to config file").option("--migrations-folder <path>", "Path to migrations folder").action(async (options) => {
+function formatDuration(ms) {
+  if (ms < 1e3) {
+    return `${ms}ms`;
+  }
+  if (ms < 6e4) {
+    return `${(ms / 1e3).toFixed(1)}s`;
+  }
+  const mins = Math.floor(ms / 6e4);
+  const secs = Math.round(ms % 6e4 / 1e3);
+  return `${mins}m ${secs}s`;
+}
+var statusCommand = new Command("status").description("Show migration status for all tenants").option("-c, --config <path>", "Path to config file").option("--migrations-folder <path>", "Path to migrations folder").addHelpText("after", `
+Examples:
+  $ drizzle-multitenant status
+  $ drizzle-multitenant status --json
+  $ drizzle-multitenant status --json | jq '.tenants[] | select(.pending > 0)'
+  $ drizzle-multitenant status --verbose
+`).action(async (options) => {
+  const ctx = getOutputContext();
   const spinner = createSpinner("Loading configuration...");
   try {
     spinner.start();
     const { config, migrationsFolder, migrationsTable, tenantDiscovery } = await loadConfig(options.config);
     if (!tenantDiscovery) {
-      throw new Error(
-        "No tenant discovery function configured. Add migrations.tenantDiscovery to your config."
-      );
+      throw CLIErrors.noTenantDiscovery();
     }
     const folder = options.migrationsFolder ? resolveMigrationsFolder(options.migrationsFolder) : resolveMigrationsFolder(migrationsFolder);
+    debug(`Using migrations folder: ${folder}`);
     spinner.text = "Discovering tenants...";
     const migrator = createMigrator(config, {
       migrationsFolder: folder,
-      migrationsTable,
+      ...migrationsTable && { migrationsTable },
       tenantDiscovery
     });
     spinner.text = "Fetching migration status...";
     const statuses = await migrator.getStatus();
     spinner.succeed(`Found ${statuses.length} tenant${statuses.length > 1 ? "s" : ""}`);
-    console.log("\n" + bold("Migration Status:"));
-    console.log(createStatusTable(statuses));
-    console.log(createPendingSummary(statuses));
+    const summary = {
+      total: statuses.length,
+      upToDate: statuses.filter((s) => s.status === "ok").length,
+      behind: statuses.filter((s) => s.status === "behind").length,
+      error: statuses.filter((s) => s.status === "error").length
+    };
+    debug(`Summary: ${summary.upToDate} up-to-date, ${summary.behind} behind, ${summary.error} errors`);
+    if (ctx.jsonMode) {
+      const jsonOutput = {
+        tenants: statuses.map((s) => ({
+          id: s.tenantId,
+          schema: s.schemaName,
+          format: s.format,
+          applied: s.appliedCount,
+          pending: s.pendingCount,
+          status: s.status,
+          pendingMigrations: s.pendingMigrations,
+          error: s.error
+        })),
+        summary
+      };
+      outputJson(jsonOutput);
+      return;
+    }
+    log("\n" + bold("Migration Status:"));
+    log(createStatusTable(statuses));
+    log(createPendingSummary(statuses));
   } catch (err) {
     spinner.fail(err.message);
-    process.exit(1);
+    handleError(err);
   }
 });
 var generateCommand = new Command("generate").description("Generate a new migration file").requiredOption("-n, --name <name>", "Migration name").option("-c, --config <path>", "Path to config file").option("--type <type>", "Migration type: tenant or shared", "tenant").option("--migrations-folder <path>", "Path to migrations folder").action(async (options) => {
@@ -724,7 +1213,7 @@ var generateCommand = new Command("generate").description("Generate a new migrat
     let maxSequence = 0;
     for (const file of sqlFiles) {
       const match = file.match(/^(\d+)_/);
-      if (match) {
+      if (match?.[1]) {
         const seq = parseInt(match[1], 10);
         if (seq > maxSequence) {
           maxSequence = seq;
@@ -759,7 +1248,7 @@ var tenantCreateCommand = new Command("tenant:create").description("Create a new
     const folder = options.migrationsFolder ? resolveMigrationsFolder(options.migrationsFolder) : resolveMigrationsFolder(migrationsFolder);
     const migrator = createMigrator(config, {
       migrationsFolder: folder,
-      migrationsTable,
+      ...migrationsTable && { migrationsTable },
       tenantDiscovery: async () => []
     });
     const schemaName = config.isolation.schemaNameTemplate(options.id);
@@ -808,7 +1297,7 @@ var tenantDropCommand = new Command("tenant:drop").description("Drop a tenant sc
     const folder = options.migrationsFolder ? resolveMigrationsFolder(options.migrationsFolder) : resolveMigrationsFolder(migrationsFolder);
     const migrator = createMigrator(config, {
       migrationsFolder: folder,
-      migrationsTable,
+      ...migrationsTable && { migrationsTable },
       tenantDiscovery: async () => []
     });
     const schemaName = config.isolation.schemaNameTemplate(options.id);
@@ -857,15 +1346,732 @@ async function askConfirmation(question, expected) {
     });
   });
 }
+async function loadMigrationFiles(folder) {
+  const files = await readdir(folder);
+  const migrations = [];
+  for (const file of files) {
+    if (!file.endsWith(".sql")) continue;
+    const filePath = join(folder, file);
+    const content = await readFile(filePath, "utf-8");
+    const hash = createHash("sha256").update(content).digest("hex");
+    migrations.push({
+      name: basename(file, ".sql"),
+      hash
+    });
+  }
+  return migrations;
+}
+async function convertTenantFormat(pool, schemaName, tableName, migrations, currentFormat, targetFormat, dryRun) {
+  const hashToName = new Map(migrations.map((m) => [m.hash, m.name]));
+  const nameToHash = new Map(migrations.map((m) => [m.name, m.hash]));
+  const client = await pool.connect();
+  try {
+    const identifierCol = currentFormat.columns.identifier;
+    const current = await client.query(
+      `SELECT id, "${identifierCol}" as identifier FROM "${schemaName}"."${tableName}" ORDER BY id`
+    );
+    if (dryRun) {
+      const conversions = [];
+      for (const row of current.rows) {
+        if (targetFormat === "name" && currentFormat.columns.identifier === "hash") {
+          const name = hashToName.get(row.identifier);
+          if (name) {
+            conversions.push(`  ${dim(row.identifier.slice(0, 8))}... -> ${name}`);
+          } else {
+            conversions.push(`  ${warning(row.identifier.slice(0, 8))}... -> ${error("unknown")}`);
+          }
+        } else if (targetFormat !== "name" && currentFormat.columns.identifier === "name") {
+          const hash = nameToHash.get(row.identifier);
+          if (hash) {
+            conversions.push(`  ${row.identifier} -> ${dim(hash.slice(0, 16))}...`);
+          } else {
+            conversions.push(`  ${row.identifier} -> ${error("unknown")}`);
+          }
+        }
+      }
+      return {
+        success: true,
+        message: conversions.length > 0 ? conversions.join("\n") : "  No conversions needed"
+      };
+    }
+    await client.query("BEGIN");
+    try {
+      if (targetFormat === "name" && currentFormat.columns.identifier === "hash") {
+        await client.query(`
+          ALTER TABLE "${schemaName}"."${tableName}"
+          ADD COLUMN IF NOT EXISTS name VARCHAR(255)
+        `);
+        let converted = 0;
+        for (const row of current.rows) {
+          const name = hashToName.get(row.identifier);
+          if (name) {
+            await client.query(
+              `UPDATE "${schemaName}"."${tableName}" SET name = $1 WHERE id = $2`,
+              [name, row.id]
+            );
+            converted++;
+          }
+        }
+        await client.query(`
+          ALTER TABLE "${schemaName}"."${tableName}"
+          ALTER COLUMN name SET NOT NULL
+        `);
+        await client.query(`
+          DO $$
+          BEGIN
+            IF NOT EXISTS (
+              SELECT 1 FROM pg_constraint
+              WHERE conname = '${tableName}_name_unique'
+            ) THEN
+              ALTER TABLE "${schemaName}"."${tableName}"
+              ADD CONSTRAINT ${tableName}_name_unique UNIQUE (name);
+            END IF;
+          END $$;
+        `);
+        if (currentFormat.columns.timestamp === "created_at") {
+          await client.query(`
+            ALTER TABLE "${schemaName}"."${tableName}"
+            RENAME COLUMN created_at TO applied_at
+          `);
+          if (currentFormat.columns.timestampType === "bigint") {
+            await client.query(`
+              ALTER TABLE "${schemaName}"."${tableName}"
+              ALTER COLUMN applied_at TYPE TIMESTAMP WITH TIME ZONE
+              USING to_timestamp(applied_at / 1000.0)
+            `);
+          }
+        }
+        await client.query("COMMIT");
+        return { success: true, message: `Converted ${converted} records to name format` };
+      } else if (targetFormat !== "name" && currentFormat.columns.identifier === "name") {
+        await client.query(`
+          ALTER TABLE "${schemaName}"."${tableName}"
+          ADD COLUMN IF NOT EXISTS hash TEXT
+        `);
+        let converted = 0;
+        for (const row of current.rows) {
+          const hash = nameToHash.get(row.identifier);
+          if (hash) {
+            await client.query(
+              `UPDATE "${schemaName}"."${tableName}" SET hash = $1 WHERE id = $2`,
+              [hash, row.id]
+            );
+            converted++;
+          }
+        }
+        await client.query(`
+          ALTER TABLE "${schemaName}"."${tableName}"
+          ALTER COLUMN hash SET NOT NULL
+        `);
+        if (currentFormat.columns.timestamp === "applied_at") {
+          await client.query(`
+            ALTER TABLE "${schemaName}"."${tableName}"
+            RENAME COLUMN applied_at TO created_at
+          `);
+          if (targetFormat === "drizzle-kit") {
+            await client.query(`
+              ALTER TABLE "${schemaName}"."${tableName}"
+              ALTER COLUMN created_at TYPE BIGINT
+              USING (EXTRACT(EPOCH FROM created_at) * 1000)::BIGINT
+            `);
+          }
+        }
+        await client.query("COMMIT");
+        return { success: true, message: `Converted ${converted} records to ${targetFormat} format` };
+      }
+      await client.query("COMMIT");
+      return { success: true, message: "No conversion needed" };
+    } catch (err) {
+      await client.query("ROLLBACK");
+      throw err;
+    }
+  } finally {
+    client.release();
+  }
+}
+var convertFormatCommand = new Command("convert-format").description("Convert migration table format between name/hash/drizzle-kit").requiredOption("--to <format>", "Target format: name, hash, or drizzle-kit").option("-c, --config <path>", "Path to config file").option("-t, --tenant <id>", "Convert a specific tenant only").option("--dry-run", "Preview changes without applying").option("--migrations-folder <path>", "Path to migrations folder").action(async (options) => {
+  const spinner = createSpinner("Loading configuration...");
+  try {
+    const targetFormat = options.to;
+    if (!["name", "hash", "drizzle-kit"].includes(targetFormat)) {
+      throw new Error(`Invalid format: ${options.to}. Use: name, hash, or drizzle-kit`);
+    }
+    spinner.start();
+    const { config, migrationsFolder, migrationsTable, tenantDiscovery } = await loadConfig(options.config);
+    const tableName = migrationsTable ?? "__drizzle_migrations";
+    const folder = options.migrationsFolder ? resolveMigrationsFolder(options.migrationsFolder) : resolveMigrationsFolder(migrationsFolder);
+    spinner.text = "Loading migration files...";
+    const migrations = await loadMigrationFiles(folder);
+    spinner.text = "Discovering tenants...";
+    let tenantIds;
+    if (options.tenant) {
+      tenantIds = [options.tenant];
+    } else {
+      if (!tenantDiscovery) {
+        throw new Error(
+          "No tenant discovery function configured. Add migrations.tenantDiscovery to your config."
+        );
+      }
+      tenantIds = await tenantDiscovery();
+    }
+    spinner.succeed(`Found ${tenantIds.length} tenant${tenantIds.length > 1 ? "s" : ""}`);
+    if (options.dryRun) {
+      console.log(warning(bold("\nDry run mode - no changes will be made\n")));
+    }
+    console.log(bold(`
+Converting to ${targetFormat} format:
+`));
+    let successCount = 0;
+    let skipCount = 0;
+    let failCount = 0;
+    for (const tenantId of tenantIds) {
+      const schemaName = config.isolation.schemaNameTemplate(tenantId);
+      const pool = new Pool({
+        connectionString: config.connection.url,
+        ...config.connection.poolConfig
+      });
+      try {
+        const currentFormat = await detectTableFormat(pool, schemaName, tableName);
+        if (!currentFormat) {
+          console.log(`${dim(tenantId)}: ${dim("No migrations table found, skipping")}`);
+          skipCount++;
+          continue;
+        }
+        if (currentFormat.format === targetFormat) {
+          console.log(`${dim(tenantId)}: ${dim(`Already using ${targetFormat} format`)}`);
+          skipCount++;
+          continue;
+        }
+        console.log(`${bold(tenantId)}: ${currentFormat.format} -> ${targetFormat}`);
+        const result = await convertTenantFormat(
+          pool,
+          schemaName,
+          tableName,
+          migrations,
+          currentFormat,
+          targetFormat,
+          options.dryRun
+        );
+        if (result.success) {
+          if (options.dryRun) {
+            console.log(result.message);
+          } else {
+            console.log(`  ${success(result.message)}`);
+          }
+          successCount++;
+        } else {
+          console.log(`  ${error(result.message)}`);
+          failCount++;
+        }
+      } catch (err) {
+        console.log(`  ${error(err.message)}`);
+        failCount++;
+      } finally {
+        await pool.end();
+      }
+    }
+    console.log(bold("\nSummary:"));
+    console.log(`  Converted: ${success(successCount.toString())}`);
+    console.log(`  Skipped:   ${dim(skipCount.toString())}`);
+    if (failCount > 0) {
+      console.log(`  Failed:    ${error(failCount.toString())}`);
+      process.exit(1);
+    }
+  } catch (err) {
+    spinner.fail(err.message);
+    process.exit(1);
+  }
+});
+var initCommand = new Command("init").description("Initialize a new drizzle-multitenant configuration").option("--force", "Overwrite existing configuration").addHelpText("after", `
+Examples:
+  $ drizzle-multitenant init
+  $ drizzle-multitenant init --force
+`).action(async (options) => {
+  try {
+    if (!shouldShowInteractive()) {
+      log(warning("Interactive mode required. Please run in a terminal."));
+      process.exit(1);
+    }
+    log(bold("\n\u{1F680} drizzle-multitenant Setup Wizard\n"));
+    const configFiles = [
+      "tenant.config.ts",
+      "tenant.config.js",
+      "drizzle-multitenant.config.ts",
+      "drizzle-multitenant.config.js"
+    ];
+    const existingConfig = configFiles.find((f) => existsSync(join(process.cwd(), f)));
+    if (existingConfig && !options.force) {
+      log(warning(`Configuration file already exists: ${existingConfig}`));
+      const overwrite = await confirm({
+        message: "Do you want to overwrite it?",
+        default: false
+      });
+      if (!overwrite) {
+        log(info("Setup cancelled."));
+        return;
+      }
+    }
+    const isolationType = await select({
+      message: "Which isolation strategy do you want to use?",
+      choices: [
+        {
+          name: "Schema-based isolation (recommended)",
+          value: "schema",
+          description: "Each tenant has its own PostgreSQL schema"
+        },
+        {
+          name: "Row-level security (RLS)",
+          value: "rls",
+          description: "Shared tables with tenant_id column and RLS policies"
+        }
+      ]
+    });
+    const dbEnvVar = await input({
+      message: "Environment variable for database connection:",
+      default: "DATABASE_URL"
+    });
+    const migrationsFolder = await input({
+      message: "Migrations folder path:",
+      default: "./drizzle/tenant-migrations"
+    });
+    let schemaTemplate = "tenant_${id}";
+    if (isolationType === "schema") {
+      schemaTemplate = await input({
+        message: "Schema name template (use ${id} for tenant ID):",
+        default: "tenant_${id}"
+      });
+    }
+    const useTypeScript = await confirm({
+      message: "Use TypeScript for configuration?",
+      default: true
+    });
+    const configContent = generateConfigContent({
+      isolationType,
+      dbEnvVar,
+      migrationsFolder,
+      schemaTemplate,
+      useTypeScript
+    });
+    const configFileName = useTypeScript ? "tenant.config.ts" : "tenant.config.js";
+    const configPath = join(process.cwd(), configFileName);
+    writeFileSync(configPath, configContent);
+    log(success(`Created ${configFileName}`));
+    const fullMigrationsPath = join(process.cwd(), migrationsFolder);
+    if (!existsSync(fullMigrationsPath)) {
+      mkdirSync(fullMigrationsPath, { recursive: true });
+      log(success(`Created migrations folder: ${migrationsFolder}`));
+    }
+    const gitkeepPath = join(fullMigrationsPath, ".gitkeep");
+    if (!existsSync(gitkeepPath)) {
+      writeFileSync(gitkeepPath, "");
+    }
+    log("\n" + bold("\u2728 Setup complete!\n"));
+    log("Next steps:\n");
+    log(dim("1. Update your schema definitions in the config file"));
+    log(dim("2. Set up tenant discovery function"));
+    log(dim("3. Generate your first migration:"));
+    log(cyan(`   npx drizzle-multitenant generate --name initial`));
+    log(dim("4. Create a tenant:"));
+    log(cyan(`   npx drizzle-multitenant tenant:create --id my-first-tenant`));
+    log(dim("5. Check status:"));
+    log(cyan(`   npx drizzle-multitenant status`));
+    log("");
+  } catch (err) {
+    handleError(err);
+  }
+});
+function generateConfigContent(options) {
+  const { isolationType, dbEnvVar, migrationsFolder, schemaTemplate, useTypeScript } = options;
+  if (useTypeScript) {
+    return `import { defineConfig } from 'drizzle-multitenant';
+import { pgTable, text, timestamp, uuid } from 'drizzle-orm/pg-core';
+
+// Example tenant schema - customize this for your needs
+const users = pgTable('users', {
+  id: uuid('id').primaryKey().defaultRandom(),
+  email: text('email').notNull().unique(),
+  name: text('name'),
+  createdAt: timestamp('created_at').defaultNow().notNull(),
+});
+
+export default defineConfig({
+  // Database connection
+  connection: process.env.${dbEnvVar}!,
+
+  // Isolation strategy
+  isolation: {
+    type: '${isolationType}',
+    ${isolationType === "schema" ? `schemaNameTemplate: (id) => \`${schemaTemplate.replace("${id}", "${id}")}\`,` : ""}
+  },
+
+  // Schema definitions
+  schemas: {
+    tenant: {
+      users,
+      // Add more tables here...
+    },
+  },
+
+  // Migration settings
+  migrations: {
+    folder: '${migrationsFolder}',
+    table: '__drizzle_migrations',
+
+    // Tenant discovery function - customize this!
+    // This should return an array of tenant IDs from your database
+    tenantDiscovery: async () => {
+      // Example: Query your tenants table
+      // const tenants = await db.select().from(tenantsTable);
+      // return tenants.map(t => t.id);
+
+      // For now, return empty array - update this!
+      console.warn('\u26A0\uFE0F  tenantDiscovery not configured - returning empty array');
+      return [];
+    },
+  },
+});
+`;
+  }
+  return `// @ts-check
+const { defineConfig } = require('drizzle-multitenant');
+const { pgTable, text, timestamp, uuid } = require('drizzle-orm/pg-core');
+
+// Example tenant schema - customize this for your needs
+const users = pgTable('users', {
+  id: uuid('id').primaryKey().defaultRandom(),
+  email: text('email').notNull().unique(),
+  name: text('name'),
+  createdAt: timestamp('created_at').defaultNow().notNull(),
+});
+
+module.exports = defineConfig({
+  // Database connection
+  connection: process.env.${dbEnvVar},
+
+  // Isolation strategy
+  isolation: {
+    type: '${isolationType}',
+    ${isolationType === "schema" ? `schemaNameTemplate: (id) => \`${schemaTemplate.replace("${id}", "${id}")}\`,` : ""}
+  },
+
+  // Schema definitions
+  schemas: {
+    tenant: {
+      users,
+      // Add more tables here...
+    },
+  },
+
+  // Migration settings
+  migrations: {
+    folder: '${migrationsFolder}',
+    table: '__drizzle_migrations',
+
+    // Tenant discovery function - customize this!
+    tenantDiscovery: async () => {
+      // Example: Query your tenants table
+      // For now, return empty array - update this!
+      console.warn('\u26A0\uFE0F  tenantDiscovery not configured - returning empty array');
+      return [];
+    },
+  },
+});
+`;
+}
+var completionCommand = new Command("completion").description("Generate shell completion scripts").argument("<shell>", "Shell type: bash, zsh, or fish").addHelpText("after", `
+Examples:
+  $ drizzle-multitenant completion bash >> ~/.bashrc
+  $ drizzle-multitenant completion zsh >> ~/.zshrc
+  $ drizzle-multitenant completion fish > ~/.config/fish/completions/drizzle-multitenant.fish
+
+After adding the completion script, restart your shell or run:
+  $ source ~/.bashrc  # for bash
+  $ source ~/.zshrc   # for zsh
+`).action((shell) => {
+  const shellLower = shell.toLowerCase();
+  switch (shellLower) {
+    case "bash":
+      console.log(generateBashCompletion());
+      break;
+    case "zsh":
+      console.log(generateZshCompletion());
+      break;
+    case "fish":
+      console.log(generateFishCompletion());
+      break;
+    default:
+      log(warning(`Unknown shell: ${shell}`));
+      log(info("Supported shells: bash, zsh, fish"));
+      process.exit(1);
+  }
+});
+function generateBashCompletion() {
+  return `# drizzle-multitenant bash completion
+# Add this to ~/.bashrc or ~/.bash_completion
+
+_drizzle_multitenant() {
+    local cur prev opts commands
+    COMPREPLY=()
+    cur="\${COMP_WORDS[COMP_CWORD]}"
+    prev="\${COMP_WORDS[COMP_CWORD-1]}"
+
+    commands="migrate status generate tenant:create tenant:drop convert-format init completion"
+
+    global_opts="--json --verbose --quiet --no-color --help --version"
+
+    migrate_opts="-c --config -a --all -t --tenant --tenants --concurrency --dry-run --migrations-folder"
+    status_opts="-c --config --migrations-folder"
+    generate_opts="-n --name -c --config --type --migrations-folder"
+    tenant_create_opts="--id -c --config --migrations-folder --no-migrate"
+    tenant_drop_opts="--id -c --config --migrations-folder -f --force --no-cascade"
+    convert_opts="--to -c --config -t --tenant --dry-run --migrations-folder"
+
+    case "\${COMP_WORDS[1]}" in
+        migrate)
+            COMPREPLY=( $(compgen -W "\${migrate_opts} \${global_opts}" -- \${cur}) )
+            return 0
+            ;;
+        status)
+            COMPREPLY=( $(compgen -W "\${status_opts} \${global_opts}" -- \${cur}) )
+            return 0
+            ;;
+        generate)
+            COMPREPLY=( $(compgen -W "\${generate_opts} \${global_opts}" -- \${cur}) )
+            return 0
+            ;;
+        tenant:create)
+            COMPREPLY=( $(compgen -W "\${tenant_create_opts} \${global_opts}" -- \${cur}) )
+            return 0
+            ;;
+        tenant:drop)
+            COMPREPLY=( $(compgen -W "\${tenant_drop_opts} \${global_opts}" -- \${cur}) )
+            return 0
+            ;;
+        convert-format)
+            COMPREPLY=( $(compgen -W "\${convert_opts} \${global_opts}" -- \${cur}) )
+            return 0
+            ;;
+        completion)
+            COMPREPLY=( $(compgen -W "bash zsh fish" -- \${cur}) )
+            return 0
+            ;;
+    esac
+
+    if [[ \${cur} == -* ]] ; then
+        COMPREPLY=( $(compgen -W "\${global_opts}" -- \${cur}) )
+        return 0
+    fi
+
+    COMPREPLY=( $(compgen -W "\${commands}" -- \${cur}) )
+    return 0
+}
+
+complete -F _drizzle_multitenant drizzle-multitenant
+complete -F _drizzle_multitenant npx drizzle-multitenant
+`;
+}
+function generateZshCompletion() {
+  return `#compdef drizzle-multitenant
+# drizzle-multitenant zsh completion
+# Add this to ~/.zshrc or place in a file in your $fpath
+
+_drizzle_multitenant() {
+    local -a commands
+    local -a global_opts
+
+    commands=(
+        'migrate:Apply pending migrations to tenant schemas'
+        'status:Show migration status for all tenants'
+        'generate:Generate a new migration file'
+        'tenant\\:create:Create a new tenant schema'
+        'tenant\\:drop:Drop a tenant schema (DESTRUCTIVE)'
+        'convert-format:Convert migration table format'
+        'init:Initialize a new configuration'
+        'completion:Generate shell completion scripts'
+    )
+
+    global_opts=(
+        '--json[Output as JSON]'
+        '(-v --verbose)'{-v,--verbose}'[Show verbose output]'
+        '(-q --quiet)'{-q,--quiet}'[Only show errors]'
+        '--no-color[Disable colored output]'
+        '(-h --help)'{-h,--help}'[Show help]'
+        '(-V --version)'{-V,--version}'[Show version]'
+    )
+
+    _arguments -C \\
+        "\${global_opts[@]}" \\
+        '1: :->command' \\
+        '*:: :->args'
+
+    case $state in
+        command)
+            _describe -t commands 'command' commands
+            ;;
+        args)
+            case $words[1] in
+                migrate)
+                    _arguments \\
+                        '(-c --config)'{-c,--config}'[Path to config file]:file:_files' \\
+                        '(-a --all)'{-a,--all}'[Migrate all tenants]' \\
+                        '(-t --tenant)'{-t,--tenant}'[Migrate specific tenant]:tenant id:' \\
+                        '--tenants[Migrate specific tenants (comma-separated)]:tenant ids:' \\
+                        '--concurrency[Number of concurrent migrations]:number:' \\
+                        '--dry-run[Show what would be applied]' \\
+                        '--migrations-folder[Path to migrations folder]:folder:_directories' \\
+                        "\${global_opts[@]}"
+                    ;;
+                status)
+                    _arguments \\
+                        '(-c --config)'{-c,--config}'[Path to config file]:file:_files' \\
+                        '--migrations-folder[Path to migrations folder]:folder:_directories' \\
+                        "\${global_opts[@]}"
+                    ;;
+                generate)
+                    _arguments \\
+                        '(-n --name)'{-n,--name}'[Migration name]:name:' \\
+                        '(-c --config)'{-c,--config}'[Path to config file]:file:_files' \\
+                        '--type[Migration type]:type:(tenant shared)' \\
+                        '--migrations-folder[Path to migrations folder]:folder:_directories' \\
+                        "\${global_opts[@]}"
+                    ;;
+                tenant:create)
+                    _arguments \\
+                        '--id[Tenant ID]:tenant id:' \\
+                        '(-c --config)'{-c,--config}'[Path to config file]:file:_files' \\
+                        '--migrations-folder[Path to migrations folder]:folder:_directories' \\
+                        '--no-migrate[Skip running migrations]' \\
+                        "\${global_opts[@]}"
+                    ;;
+                tenant:drop)
+                    _arguments \\
+                        '--id[Tenant ID]:tenant id:' \\
+                        '(-c --config)'{-c,--config}'[Path to config file]:file:_files' \\
+                        '--migrations-folder[Path to migrations folder]:folder:_directories' \\
+                        '(-f --force)'{-f,--force}'[Skip confirmation]' \\
+                        '--no-cascade[Use RESTRICT instead of CASCADE]' \\
+                        "\${global_opts[@]}"
+                    ;;
+                convert-format)
+                    _arguments \\
+                        '--to[Target format]:format:(name hash drizzle-kit)' \\
+                        '(-c --config)'{-c,--config}'[Path to config file]:file:_files' \\
+                        '(-t --tenant)'{-t,--tenant}'[Convert specific tenant]:tenant id:' \\
+                        '--dry-run[Show what would be converted]' \\
+                        '--migrations-folder[Path to migrations folder]:folder:_directories' \\
+                        "\${global_opts[@]}"
+                    ;;
+                completion)
+                    _arguments '1:shell:(bash zsh fish)'
+                    ;;
+            esac
+            ;;
+    esac
+}
+
+_drizzle_multitenant "$@"
+`;
+}
+function generateFishCompletion() {
+  return `# drizzle-multitenant fish completion
+# Save to ~/.config/fish/completions/drizzle-multitenant.fish
+
+# Disable file completion by default
+complete -c drizzle-multitenant -f
+
+# Commands
+complete -c drizzle-multitenant -n "__fish_use_subcommand" -a "migrate" -d "Apply pending migrations"
+complete -c drizzle-multitenant -n "__fish_use_subcommand" -a "status" -d "Show migration status"
+complete -c drizzle-multitenant -n "__fish_use_subcommand" -a "generate" -d "Generate new migration"
+complete -c drizzle-multitenant -n "__fish_use_subcommand" -a "tenant:create" -d "Create tenant schema"
+complete -c drizzle-multitenant -n "__fish_use_subcommand" -a "tenant:drop" -d "Drop tenant schema"
+complete -c drizzle-multitenant -n "__fish_use_subcommand" -a "convert-format" -d "Convert migration format"
+complete -c drizzle-multitenant -n "__fish_use_subcommand" -a "init" -d "Initialize configuration"
+complete -c drizzle-multitenant -n "__fish_use_subcommand" -a "completion" -d "Generate completions"
+
+# Global options
+complete -c drizzle-multitenant -l json -d "Output as JSON"
+complete -c drizzle-multitenant -s v -l verbose -d "Verbose output"
+complete -c drizzle-multitenant -s q -l quiet -d "Only show errors"
+complete -c drizzle-multitenant -l no-color -d "Disable colors"
+complete -c drizzle-multitenant -s h -l help -d "Show help"
+complete -c drizzle-multitenant -s V -l version -d "Show version"
+
+# migrate options
+complete -c drizzle-multitenant -n "__fish_seen_subcommand_from migrate" -s c -l config -r -d "Config file"
+complete -c drizzle-multitenant -n "__fish_seen_subcommand_from migrate" -s a -l all -d "Migrate all tenants"
+complete -c drizzle-multitenant -n "__fish_seen_subcommand_from migrate" -s t -l tenant -r -d "Specific tenant"
+complete -c drizzle-multitenant -n "__fish_seen_subcommand_from migrate" -l tenants -r -d "Multiple tenants"
+complete -c drizzle-multitenant -n "__fish_seen_subcommand_from migrate" -l concurrency -r -d "Concurrent migrations"
+complete -c drizzle-multitenant -n "__fish_seen_subcommand_from migrate" -l dry-run -d "Dry run mode"
+complete -c drizzle-multitenant -n "__fish_seen_subcommand_from migrate" -l migrations-folder -r -d "Migrations folder"
+
+# status options
+complete -c drizzle-multitenant -n "__fish_seen_subcommand_from status" -s c -l config -r -d "Config file"
+complete -c drizzle-multitenant -n "__fish_seen_subcommand_from status" -l migrations-folder -r -d "Migrations folder"
+
+# generate options
+complete -c drizzle-multitenant -n "__fish_seen_subcommand_from generate" -s n -l name -r -d "Migration name"
+complete -c drizzle-multitenant -n "__fish_seen_subcommand_from generate" -s c -l config -r -d "Config file"
+complete -c drizzle-multitenant -n "__fish_seen_subcommand_from generate" -l type -r -a "tenant shared" -d "Migration type"
+complete -c drizzle-multitenant -n "__fish_seen_subcommand_from generate" -l migrations-folder -r -d "Migrations folder"
+
+# tenant:create options
+complete -c drizzle-multitenant -n "__fish_seen_subcommand_from tenant:create" -l id -r -d "Tenant ID"
+complete -c drizzle-multitenant -n "__fish_seen_subcommand_from tenant:create" -s c -l config -r -d "Config file"
+complete -c drizzle-multitenant -n "__fish_seen_subcommand_from tenant:create" -l migrations-folder -r -d "Migrations folder"
+complete -c drizzle-multitenant -n "__fish_seen_subcommand_from tenant:create" -l no-migrate -d "Skip migrations"
+
+# tenant:drop options
+complete -c drizzle-multitenant -n "__fish_seen_subcommand_from tenant:drop" -l id -r -d "Tenant ID"
+complete -c drizzle-multitenant -n "__fish_seen_subcommand_from tenant:drop" -s c -l config -r -d "Config file"
+complete -c drizzle-multitenant -n "__fish_seen_subcommand_from tenant:drop" -l migrations-folder -r -d "Migrations folder"
+complete -c drizzle-multitenant -n "__fish_seen_subcommand_from tenant:drop" -s f -l force -d "Skip confirmation"
+complete -c drizzle-multitenant -n "__fish_seen_subcommand_from tenant:drop" -l no-cascade -d "Use RESTRICT"
+
+# convert-format options
+complete -c drizzle-multitenant -n "__fish_seen_subcommand_from convert-format" -l to -r -a "name hash drizzle-kit" -d "Target format"
+complete -c drizzle-multitenant -n "__fish_seen_subcommand_from convert-format" -s c -l config -r -d "Config file"
+complete -c drizzle-multitenant -n "__fish_seen_subcommand_from convert-format" -s t -l tenant -r -d "Specific tenant"
+complete -c drizzle-multitenant -n "__fish_seen_subcommand_from convert-format" -l dry-run -d "Dry run mode"
+complete -c drizzle-multitenant -n "__fish_seen_subcommand_from convert-format" -l migrations-folder -r -d "Migrations folder"
+
+# completion options
+complete -c drizzle-multitenant -n "__fish_seen_subcommand_from completion" -a "bash zsh fish" -d "Shell type"
+`;
+}
 
 // src/cli/index.ts
 var program = new Command();
-program.name("drizzle-multitenant").description("Multi-tenancy toolkit for Drizzle ORM").version("0.3.0");
+program.name("drizzle-multitenant").description("Multi-tenancy toolkit for Drizzle ORM").version("0.3.0").option("--json", "Output as JSON (machine-readable)").option("-v, --verbose", "Show verbose output").option("-q, --quiet", "Only show errors").option("--no-color", "Disable colored output").hook("preAction", (thisCommand) => {
+  const opts = thisCommand.opts();
+  initOutputContext({
+    json: opts.json,
+    verbose: opts.verbose,
+    quiet: opts.quiet,
+    noColor: opts.color === false
+  });
+});
+program.addHelpText("after", `
+Examples:
+  $ drizzle-multitenant status
+  $ drizzle-multitenant migrate --all
+  $ drizzle-multitenant migrate --tenant=my-tenant --dry-run
+  $ drizzle-multitenant generate --name add-users-table
+  $ drizzle-multitenant tenant:create --id new-tenant
+  $ drizzle-multitenant status --json | jq '.summary'
+
+Documentation:
+  https://github.com/your-repo/drizzle-multitenant
+`);
 program.addCommand(migrateCommand);
 program.addCommand(statusCommand);
 program.addCommand(generateCommand);
 program.addCommand(tenantCreateCommand);
 program.addCommand(tenantDropCommand);
+program.addCommand(convertFormatCommand);
+program.addCommand(initCommand);
+program.addCommand(completionCommand);
 program.parse();
 //# sourceMappingURL=index.js.map
 //# sourceMappingURL=index.js.map