prisma-flow 0.1.0

package/dist/index.js

@@ -0,0 +1,3737 @@
+#!/usr/bin/env node
+
+// src/index.ts
+import { Command as Command14 } from "commander";
+
+// src/commands/check.ts
+import chalk from "chalk";
+import { Command } from "commander";
+
+// src/core/audit.ts
+import fs from "fs/promises";
+import path from "path";
+
+// src/logger.ts
+import { createRequire } from "module";
+function makeConsoleLogger(level) {
+  const levels = {
+    trace: 10,
+    debug: 20,
+    info: 30,
+    warn: 40,
+    error: 50
+  };
+  const activeLevel = levels[level] ?? 30;
+  function write(severity, lvl, args) {
+    if (lvl < activeLevel) return;
+    const obj = typeof args[0] === "object" && args[0] !== null ? args[0] : {};
+    const msg = typeof args[0] === "string" ? args[0] : args[1] ?? "";
+    const line = JSON.stringify({
+      time: (/* @__PURE__ */ new Date()).toISOString(),
+      level: severity,
+      ...obj,
+      msg
+    });
+    if (lvl >= 40) process.stderr.write(`${line}
+`);
+    else process.stdout.write(`${line}
+`);
+  }
+  return {
+    trace: (...a) => write("TRACE", 10, a),
+    debug: (...a) => write("DEBUG", 20, a),
+    info: (...a) => write("INFO", 30, a),
+    warn: (...a) => write("WARN", 40, a),
+    error: (...a) => write("ERROR", 50, a),
+    child: (_bindings) => makeConsoleLogger(level)
+  };
+}
+function buildLogger() {
+  const level = (process.env.PRISMAFLOW_LOG_LEVEL ?? "info").toLowerCase();
+  const pretty = process.env.NODE_ENV !== "production";
+  try {
+    const req = createRequire(import.meta.url);
+    const pino = req("pino");
+    if (pretty) {
+      try {
+        const transport = pino.transport({
+          target: "pino-pretty",
+          options: {
+            colorize: true,
+            translateTime: "SYS:standard",
+            ignore: "pid,hostname"
+          }
+        });
+        return pino({ level }, transport);
+      } catch {
+      }
+    }
+    return pino({ level });
+  } catch {
+    return makeConsoleLogger(level);
+  }
+}
+var logger = buildLogger();
+
+// src/core/audit.ts
+var AUDIT_DIR = ".prismaflow";
+var AUDIT_FILE = "audit.jsonl";
+var AUDIT_ROTATED = "audit.1.jsonl";
+var DEFAULT_MAX_BYTES = 10 * 1024 * 1024;
+async function ensureAuditDir(cwd) {
+  const dir = path.join(cwd, AUDIT_DIR);
+  await fs.mkdir(dir, { recursive: true });
+  return path.join(dir, AUDIT_FILE);
+}
+async function rotateIfNeeded(filePath, maxBytes) {
+  try {
+    const stat = await fs.stat(filePath);
+    if (stat.size >= maxBytes) {
+      const rotated = path.join(path.dirname(filePath), AUDIT_ROTATED);
+      await fs.rename(filePath, rotated);
+      logger.debug({ filePath, rotated }, "Audit log rotated");
+    }
+  } catch {
+  }
+}
+async function writeAuditEntry(cwd, action, result, detail, maxMb = DEFAULT_MAX_BYTES / (1024 * 1024)) {
+  try {
+    const filePath = await ensureAuditDir(cwd);
+    await rotateIfNeeded(filePath, maxMb * 1024 * 1024);
+    const entry = {
+      timestamp: (/* @__PURE__ */ new Date()).toISOString(),
+      action,
+      cwd,
+      result,
+      ...detail !== void 0 ? { detail } : {}
+    };
+    await fs.appendFile(filePath, `${JSON.stringify(entry)}
+`, "utf-8");
+  } catch (err) {
+    logger.warn({ err }, "Audit log write failed (non-fatal)");
+  }
+}
+
+// src/core/migration-analyzer.ts
+import fs4 from "fs/promises";
+
+// src/core/prisma-cli.ts
+import { execFile } from "child_process";
+import fs2 from "fs/promises";
+import path2 from "path";
+import { promisify } from "util";
+var execFileAsync = promisify(execFile);
+async function fileExists(filePath) {
+  try {
+    await fs2.access(filePath);
+    return true;
+  } catch {
+    return false;
+  }
+}
+async function resolveLocalPrismaCli(cwd) {
+  let current = path2.resolve(cwd);
+  while (true) {
+    const candidate = path2.join(current, "node_modules", "prisma", "build", "index.js");
+    if (await fileExists(candidate)) return candidate;
+    const parent = path2.dirname(current);
+    if (parent === current) return null;
+    current = parent;
+  }
+}
+async function resolveBundledNpxCli() {
+  const candidate = path2.join(
+    path2.dirname(process.execPath),
+    "node_modules",
+    "npm",
+    "bin",
+    "npx-cli.js"
+  );
+  return await fileExists(candidate) ? candidate : null;
+}
+async function execPrisma(cwd, args, options = {}) {
+  const localCli = await resolveLocalPrismaCli(cwd);
+  if (localCli) {
+    return execFileAsync(process.execPath, [localCli, ...args], {
+      cwd,
+      env: options.env,
+      timeout: options.timeout
+    });
+  }
+  if (process.platform === "win32") {
+    const npxCli = await resolveBundledNpxCli();
+    if (npxCli) {
+      return execFileAsync(process.execPath, [npxCli, "prisma", ...args], {
+        cwd,
+        env: options.env,
+        timeout: options.timeout
+      });
+    }
+  }
+  const command = process.platform === "win32" ? "npx.cmd" : "npx";
+  return execFileAsync(command, ["prisma", ...args], {
+    cwd,
+    env: options.env,
+    timeout: options.timeout
+  });
+}
+
+// src/core/prisma-detector.ts
+import fs3 from "fs/promises";
+import path3 from "path";
+import dotenv from "dotenv";
+function detectProviderFromSchema(schemaContent) {
+  const match = schemaContent.match(/datasource\s+\w+\s*\{[^}]*provider\s*=\s*"([^"]+)"/s);
+  if (!match) return null;
+  const raw = match[1]?.toLowerCase();
+  const providerMap = {
+    postgresql: "postgresql",
+    postgres: "postgresql",
+    mysql: "mysql",
+    sqlite: "sqlite",
+    sqlserver: "sqlserver",
+    mongodb: "mongodb"
+  };
+  return providerMap[raw ?? ""] ?? null;
+}
+async function tryAccess(p) {
+  try {
+    await fs3.access(p);
+    return true;
+  } catch {
+    return false;
+  }
+}
+async function findSchemaPath(cwd) {
+  const candidates = [path3.join(cwd, "prisma", "schema.prisma"), path3.join(cwd, "schema.prisma")];
+  for (const p of candidates) {
+    if (await tryAccess(p)) return p;
+  }
+  const schemaDir = path3.join(cwd, "prisma", "schema");
+  if (await tryAccess(schemaDir)) {
+    const entries = await fs3.readdir(schemaDir).catch(() => []);
+    const prismaFiles = entries.filter((e) => e.endsWith(".prisma"));
+    if (prismaFiles.length > 0) {
+      return schemaDir;
+    }
+  }
+  return null;
+}
+async function readSchemaContent(schemaPath) {
+  try {
+    const stat = await fs3.stat(schemaPath);
+    if (stat.isDirectory()) {
+      const files = (await fs3.readdir(schemaPath)).filter((f) => f.endsWith(".prisma")).sort();
+      const parts = await Promise.all(
+        files.map((f) => fs3.readFile(path3.join(schemaPath, f), "utf-8"))
+      );
+      return parts.join("\n");
+    }
+    return fs3.readFile(schemaPath, "utf-8");
+  } catch {
+    return "";
+  }
+}
+async function detectPackageManager(cwd) {
+  const lockfiles = [
+    { file: "package-lock.json", manager: "npm" },
+    { file: "pnpm-lock.yaml", manager: "pnpm" },
+    { file: "yarn.lock", manager: "yarn" },
+    { file: "bun.lockb", manager: "bun" }
+  ];
+  for (const { file, manager } of lockfiles) {
+    if (await tryAccess(path3.join(cwd, file))) return manager;
+  }
+  return null;
+}
+async function detectPrismaVersion(cwd) {
+  try {
+    const content = await fs3.readFile(path3.join(cwd, "package.json"), "utf-8");
+    const pkg = JSON.parse(content);
+    return pkg.dependencies?.prisma ?? pkg.devDependencies?.prisma ?? null;
+  } catch {
+    return null;
+  }
+}
+async function detectPrismaProject(cwd) {
+  const schemaPath = await findSchemaPath(cwd);
+  if (!schemaPath) return null;
+  const schemaContent = await readSchemaContent(schemaPath);
+  let databaseUrl = "";
+  for (const envFile of [path3.join(cwd, ".env"), path3.join(cwd, "prisma", ".env")]) {
+    try {
+      const envContent = await fs3.readFile(envFile, "utf-8");
+      const parsed = dotenv.parse(envContent);
+      if (parsed.DATABASE_URL) {
+        databaseUrl = parsed.DATABASE_URL;
+        break;
+      }
+    } catch {
+    }
+  }
+  const schemaDir = await fs3.stat(schemaPath).then((s) => s.isDirectory()).catch(() => false) ? schemaPath : path3.dirname(schemaPath);
+  const migrationsPath = path3.join(schemaDir, "migrations");
+  const migrations = [];
+  try {
+    const entries = await fs3.readdir(migrationsPath, { withFileTypes: true });
+    for (const entry of entries) {
+      if (!entry.isDirectory() || entry.name === "migration_lock.toml") continue;
+      const migrationDir = path3.join(migrationsPath, entry.name);
+      const sqlPath = path3.join(migrationDir, "migration.sql");
+      if (!await tryAccess(sqlPath)) continue;
+      const timestampStr = entry.name.slice(0, 14);
+      const year = Number.parseInt(timestampStr.slice(0, 4), 10);
+      const month = Number.parseInt(timestampStr.slice(4, 6), 10) - 1;
+      const day = Number.parseInt(timestampStr.slice(6, 8), 10);
+      const hour = Number.parseInt(timestampStr.slice(8, 10), 10);
+      const minute = Number.parseInt(timestampStr.slice(10, 12), 10);
+      const second = Number.parseInt(timestampStr.slice(12, 14), 10);
+      const timestamp = new Date(Date.UTC(year, month, day, hour, minute, second));
+      migrations.push({
+        name: entry.name,
+        timestamp: (Number.isNaN(timestamp.getTime()) ? /* @__PURE__ */ new Date() : timestamp).toISOString(),
+        createdAt: (Number.isNaN(timestamp.getTime()) ? /* @__PURE__ */ new Date() : timestamp).toISOString(),
+        status: "pending",
+        // overridden by getMigrations() after status check
+        sqlPath
+      });
+    }
+  } catch {
+  }
+  migrations.sort((a, b) => new Date(a.timestamp).getTime() - new Date(b.timestamp).getTime());
+  const provider = detectProviderFromSchema(schemaContent);
+  const [packageManager, prismaVersion] = await Promise.all([
+    detectPackageManager(cwd),
+    detectPrismaVersion(cwd)
+  ]);
+  return {
+    schemaPath,
+    migrationsPath,
+    databaseUrl,
+    migrations,
+    schemaContent,
+    provider,
+    packageManager,
+    prismaVersion
+  };
+}
+
+// src/core/drift-detector.ts
+function classifyDriftSql(sql) {
+  const upper = sql.toUpperCase().trimStart();
+  if (upper.startsWith("CREATE TABLE")) return "table-missing";
+  if (upper.startsWith("DROP TABLE")) return "table-extra";
+  if (upper.startsWith("CREATE INDEX") || upper.startsWith("DROP INDEX")) return "index-change";
+  if (upper.startsWith("ALTER INDEX")) return "index-change";
+  if (upper.includes("CONSTRAINT")) return "constraint-change";
+  if (upper.startsWith("ALTER TABLE")) return "column-mismatch";
+  return "unknown";
+}
+function labelDriftType(type) {
+  const labels = {
+    "table-missing": "Table missing in database",
+    "table-extra": "Table exists in database but not in schema",
+    "column-mismatch": "Column or table structure mismatch",
+    "index-change": "Index difference detected",
+    "constraint-change": "Constraint difference detected",
+    unknown: "Unknown schema change",
+    missing_migration: "Migration applied to DB but missing from history",
+    extra_column: "Extra column present in DB not in schema",
+    extra_table: "Extra table present in DB not in schema",
+    modified_migration: "Migration SQL was modified after being applied"
+  };
+  return labels[type];
+}
+function parseSqlStatements(sql) {
+  const statements = [];
+  let current = "";
+  let inSingleQuote = false;
+  let inLineComment = false;
+  let inBlockComment = false;
+  let i = 0;
+  while (i < sql.length) {
+    const ch = sql[i];
+    const next = sql[i + 1] ?? "";
+    if (inLineComment) {
+      if (ch === "\n") inLineComment = false;
+      i++;
+      continue;
+    }
+    if (inBlockComment) {
+      if (ch === "*" && next === "/") {
+        inBlockComment = false;
+        i += 2;
+      } else i++;
+      continue;
+    }
+    if (!inSingleQuote && ch === "-" && next === "-") {
+      inLineComment = true;
+      i += 2;
+      continue;
+    }
+    if (!inSingleQuote && ch === "/" && next === "*") {
+      inBlockComment = true;
+      i += 2;
+      continue;
+    }
+    if (ch === "'" && !inBlockComment && !inLineComment) inSingleQuote = !inSingleQuote;
+    if (ch === ";" && !inSingleQuote) {
+      const trimmed2 = current.trim();
+      if (trimmed2.length > 0) statements.push(trimmed2);
+      current = "";
+      i++;
+      continue;
+    }
+    current += ch;
+    i++;
+  }
+  const trimmed = current.trim();
+  if (trimmed.length > 0) statements.push(trimmed);
+  return statements;
+}
+async function detectDrift(cwd) {
+  const project = await detectPrismaProject(cwd);
+  if (!project) {
+    return {
+      items: [],
+      status: "error",
+      errorMessage: "No Prisma project found"
+    };
+  }
+  try {
+    const { stdout } = await execPrisma(
+      cwd,
+      [
+        "migrate",
+        "diff",
+        "--from-schema-datamodel",
+        project.schemaPath,
+        "--to-schema-datasource",
+        project.schemaPath,
+        "--script"
+      ],
+      { timeout: 3e4 }
+    );
+    const output = stdout.trim();
+    if (!output) return { items: [], status: "clean" };
+    const items = parseSqlStatements(output).filter((s) => !s.toUpperCase().trimStart().startsWith("--")).map((sql) => {
+      const type = classifyDriftSql(sql);
+      return { sql, type, description: labelDriftType(type) };
+    });
+    return { items, status: items.length > 0 ? "drifted" : "clean" };
+  } catch (err) {
+    const error = err;
+    const stderr = error.stderr ?? "";
+    if (stderr.includes("P1001") || stderr.includes("Can't reach database server") || stderr.includes("Connection refused")) {
+      logger.debug("Drift detection skipped: database unreachable");
+      return {
+        items: [],
+        status: "error",
+        errorMessage: "Database unreachable"
+      };
+    }
+    const message = error instanceof Error ? error.message : String(error);
+    logger.warn({ err }, "Drift detection failed");
+    return { items: [], status: "error", errorMessage: message };
+  }
+}
+
+// src/core/migration-analyzer.ts
+var RISK_PATTERNS = [
+  {
+    pattern: /DROP\s+TABLE/i,
+    label: "Drops table \u2014 irreversible data loss",
+    severity: "critical",
+    description: "Drops an entire table and all its data permanently.",
+    recommendation: "Ensure data has been migrated or backed up before applying.",
+    weight: 75
+  },
+  {
+    pattern: /TRUNCATE/i,
+    label: "Truncates table \u2014 full data loss",
+    severity: "critical",
+    description: "Removes all rows from a table. Cannot be rolled back with standard SQL.",
+    recommendation: "Export table data before applying this migration.",
+    weight: 65
+  },
+  {
+    pattern: /DROP\s+COLUMN/i,
+    label: "Drops column \u2014 potential data loss",
+    severity: "critical",
+    description: "Removes a column and all data stored in it.",
+    recommendation: "Verify no application code reads this column before deploying.",
+    weight: 60
+  },
+  {
+    pattern: /ALTER\s+COLUMN.+NOT\s+NULL/i,
+    label: "Adds NOT NULL constraint",
+    severity: "high",
+    description: "Adding a NOT NULL constraint will fail if any existing rows have NULL values.",
+    recommendation: "Backfill NULL values before adding the constraint.",
+    weight: 25
+  },
+  {
+    pattern: /ALTER\s+TABLE.+TYPE|ALTER\s+COLUMN.+TYPE/i,
+    label: "Changes column type",
+    severity: "high",
+    description: "Changing a column type can cause data loss or conversion failures.",
+    recommendation: "Test type conversion on a staging database first.",
+    weight: 25
+  },
+  {
+    pattern: /DELETE\s+FROM/i,
+    label: "Bulk data deletion",
+    severity: "medium",
+    description: "Deletes rows from a table. Scope depends on the WHERE clause.",
+    recommendation: "Review the WHERE clause carefully and test on staging first.",
+    weight: 20
+  },
+  {
+    pattern: /DROP\s+CONSTRAINT/i,
+    label: "Removes constraint \u2014 may allow invalid data",
+    severity: "medium",
+    description: "Removing a constraint allows data that was previously rejected.",
+    recommendation: "Audit existing data for constraint violations after applying.",
+    weight: 15
+  },
+  {
+    pattern: /DROP\s+INDEX/i,
+    label: "Removes index \u2014 may impact performance",
+    severity: "low",
+    description: "Dropping an index can degrade query performance on the affected table.",
+    recommendation: "Monitor query performance after applying in production.",
+    weight: 10
+  },
+  {
+    pattern: /ALTER\s+TABLE/i,
+    label: "Alters table structure",
+    severity: "low",
+    description: "Modifies table structure. Long-running on large tables.",
+    recommendation: "Consider table size and run during low-traffic windows.",
+    weight: 8
+  }
+];
+function extractTableName(sql) {
+  const match = sql.match(/(?:DROP|TRUNCATE|ALTER)\s+TABLE\s+(?:"?(\w+)"?\.)?"?(\w+)"?/i);
+  return match?.[2];
+}
+function analyzeMigrationRisks(sql) {
+  return RISK_PATTERNS.filter(({ pattern }) => pattern.test(sql)).map(({ label }) => label);
+}
+function scoreMigrationRisk(sql) {
+  const matchedPatterns = RISK_PATTERNS.filter(({ pattern }) => pattern.test(sql));
+  const factors = matchedPatterns.map((p) => {
+    const affectedTable = extractTableName(sql);
+    return {
+      pattern: p.pattern.source,
+      severity: p.severity,
+      description: p.description,
+      ...affectedTable !== void 0 ? { affectedTable } : {},
+      recommendation: p.recommendation
+    };
+  });
+  const rawScore = matchedPatterns.reduce((acc, p) => acc + p.weight, 0);
+  const score = Math.min(100, rawScore);
+  let level = "low";
+  if (score >= 75) level = "critical";
+  else if (score >= 50) level = "high";
+  else if (score >= 20) level = "medium";
+  return { score, level, factors };
+}
+function calculateHealthScore(input) {
+  let score = 100;
+  if (!input.connected) score -= 35;
+  score -= Math.min(30, input.migrationsFailed * 25);
+  score -= Math.min(20, input.driftCount * 10);
+  score -= Math.min(15, input.migrationsPending * 5);
+  if (input.maxRiskScore >= 75) score -= 25;
+  else if (input.maxRiskScore >= 50) score -= 18;
+  else if (input.maxRiskScore >= 20) score -= 8;
+  return Math.max(0, Math.min(100, Math.round(score)));
+}
+function buildDeploymentReadiness(input) {
+  const hasCriticalRisk = input.maxRiskScore >= 75;
+  const checks = [
+    {
+      id: "database",
+      label: "Database reachable",
+      passed: input.connected,
+      message: input.connected ? "PrismaFlow can reach the configured datasource." : "Check DATABASE_URL and database network access before deploying."
+    },
+    {
+      id: "drift",
+      label: "No schema drift",
+      passed: input.driftCount === 0,
+      message: input.driftCount === 0 ? "The live database matches the Prisma schema." : `${input.driftCount} drift item${input.driftCount === 1 ? "" : "s"} must be reviewed.`
+    },
+    {
+      id: "failed-migrations",
+      label: "No failed migrations",
+      passed: input.migrationsFailed === 0,
+      message: input.migrationsFailed === 0 ? "Migration history has no failed entries." : `${input.migrationsFailed} failed migration${input.migrationsFailed === 1 ? "" : "s"} need recovery.`
+    },
+    {
+      id: "pending-migrations",
+      label: "No pending migrations",
+      passed: input.migrationsPending === 0,
+      message: input.migrationsPending === 0 ? "All local migrations are applied." : `${input.migrationsPending} migration${input.migrationsPending === 1 ? "" : "s"} still pending.`
+    },
+    {
+      id: "critical-risks",
+      label: "No critical migration risks",
+      passed: !hasCriticalRisk,
+      message: hasCriticalRisk ? "At least one migration contains a critical data-loss operation." : "No critical data-loss operations were detected."
+    }
+  ];
+  const blockers = checks.filter(
+    (check) => !check.passed && ["database", "drift", "failed-migrations", "critical-risks"].includes(check.id)
+  );
+  const warnings = checks.filter((check) => !check.passed);
+  if (blockers.length > 0) {
+    return {
+      status: "blocked",
+      score: input.healthScore,
+      summary: "Not ready for deployment",
+      checks
+    };
+  }
+  if (warnings.length > 0) {
+    return {
+      status: "attention",
+      score: input.healthScore,
+      summary: "Review pending work before deployment",
+      checks
+    };
+  }
+  return {
+    status: "ready",
+    score: input.healthScore,
+    summary: "Ready for deployment",
+    checks
+  };
+}
+async function getMigrationStatusMap(cwd, schemaPath) {
+  const map = /* @__PURE__ */ new Map();
+  let stdout = "";
+  try {
+    const result = await execPrisma(cwd, ["migrate", "status", "--schema", schemaPath], {
+      timeout: 3e4
+    });
+    stdout = result.stdout;
+    return map;
+  } catch (err) {
+    const error = err;
+    stdout = error.stdout ?? "";
+    const stderr = error.stderr ?? "";
+    if (stderr.includes("P1001") || stderr.includes("Can't reach database server") || stderr.includes("Connection refused")) {
+      throw new Error("DATABASE_UNREACHABLE");
+    }
+    logger.debug({ stdout, stderr }, "prisma migrate status exited non-zero \u2014 parsing output");
+  }
+  const lines = stdout.split("\n");
+  let mode = "none";
+  for (const rawLine of lines) {
+    const line = rawLine.trim();
+    if (line.includes("have not yet been applied")) {
+      mode = "pending";
+      continue;
+    }
+    if (line.match(/failed to apply|rolled back|migration.*failed/i)) {
+      mode = "failed";
+      continue;
+    }
+    if (line === "" || line.startsWith("\u2500") || line.startsWith("The following")) {
+      mode = "none";
+      continue;
+    }
+    if (mode === "none") continue;
+    const cleaned = line.replace(/^[•\-*]\s*/, "").trim();
+    if (cleaned.match(/^\d{14}/)) {
+      map.set(cleaned, mode === "pending" ? "pending" : "failed");
+    }
+  }
+  return map;
+}
+async function getMigrationDetails(cwd, name) {
+  const project = await detectPrismaProject(cwd);
+  if (!project) return null;
+  const migration = project.migrations.find((m) => m.name === name);
+  if (!migration) return null;
+  let sql = "";
+  try {
+    sql = await fs4.readFile(migration.sqlPath, "utf-8");
+  } catch {
+    sql = "-- Could not read migration file";
+  }
+  const risks = analyzeMigrationRisks(sql);
+  const riskScore = scoreMigrationRisk(sql);
+  return { ...migration, sql, risks, riskScore };
+}
+async function getMigrations(cwd) {
+  const project = await detectPrismaProject(cwd);
+  if (!project) return [];
+  let statusMap;
+  try {
+    statusMap = await getMigrationStatusMap(cwd, project.schemaPath);
+  } catch {
+    statusMap = /* @__PURE__ */ new Map();
+  }
+  return Promise.all(
+    project.migrations.map(async (m) => {
+      const status = statusMap.get(m.name) ?? "applied";
+      let sql = "";
+      try {
+        sql = await fs4.readFile(m.sqlPath, "utf-8");
+      } catch {
+      }
+      const risks = analyzeMigrationRisks(sql);
+      const riskScore = scoreMigrationRisk(sql);
+      return { ...m, status, risks, riskScore };
+    })
+  );
+}
+async function getProjectStatus(cwd) {
+  const project = await detectPrismaProject(cwd);
+  if (!project) throw new Error("No Prisma project found");
+  let connected = false;
+  try {
+    await execPrisma(cwd, ["migrate", "status", "--schema", project.schemaPath], {
+      timeout: 3e4
+    });
+    connected = true;
+  } catch (err) {
+    const error = err;
+    const stderr = error.stderr ?? "";
+    if (stderr.includes("P1001") || stderr.includes("Can't reach database server") || stderr.includes("Connection refused")) {
+      connected = false;
+    } else {
+      connected = true;
+    }
+  }
+  const migrations = await getMigrations(cwd);
+  const migrationsPending = migrations.filter((m) => m.status === "pending").length;
+  const migrationsFailed = migrations.filter((m) => m.status === "failed").length;
+  const migrationsApplied = migrations.filter((m) => m.status === "applied").length;
+  let driftResult = { items: [], status: "clean" };
+  if (connected) {
+    driftResult = await detectDrift(cwd);
+  }
+  const hasDrift = driftResult.status === "drifted";
+  let riskLevel = "low";
+  if (migrationsFailed > 0) riskLevel = "high";
+  else if (hasDrift) riskLevel = "medium";
+  else if (migrationsPending > 0) riskLevel = "low";
+  const maxRiskScore = Math.max(0, ...migrations.map((m) => m.riskScore.score));
+  if (maxRiskScore >= 75) riskLevel = "critical";
+  else if (maxRiskScore >= 50) riskLevel = "high";
+  else if (maxRiskScore >= 20 && riskLevel === "low") riskLevel = "medium";
+  const healthScore = calculateHealthScore({
+    connected,
+    migrationsPending,
+    migrationsFailed,
+    driftCount: driftResult.items.length,
+    maxRiskScore
+  });
+  const deploymentReadiness = buildDeploymentReadiness({
+    connected,
+    migrationsPending,
+    migrationsFailed,
+    driftCount: driftResult.items.length,
+    maxRiskScore,
+    healthScore
+  });
+  return {
+    connected,
+    migrationsApplied: connected ? migrationsApplied : 0,
+    migrationsPending: connected ? migrationsPending : migrations.length,
+    migrationsFailed,
+    driftDetected: hasDrift,
+    driftCount: driftResult.items.length,
+    riskLevel,
+    healthScore,
+    deploymentReadiness,
+    lastSync: (/* @__PURE__ */ new Date()).toISOString(),
+    ...project.provider ? { provider: project.provider } : {},
+    schemaPath: project.schemaPath,
+    migrationsPath: project.migrationsPath,
+    ...project.prismaVersion ? { prismaVersion: project.prismaVersion } : {},
+    ...project.packageManager ? { packageManager: project.packageManager } : {},
+    hasDatabaseUrl: project.databaseUrl.length > 0
+  };
+}
+
+// src/core/telemetry.ts
+var TELEMETRY_ENDPOINT = "https://telemetry.prismaflow.dev/v1/event";
+function isEnabled() {
+  const val = process.env.PRISMAFLOW_TELEMETRY;
+  if (!val) return false;
+  return val.toLowerCase() === "on" || val.toLowerCase() === "true" || val === "1";
+}
+function bucketCount(n) {
+  if (n === 0) return "0";
+  if (n <= 10) return "1-10";
+  if (n <= 50) return "11-50";
+  return "50+";
+}
+async function trackEvent(event, migrationCount) {
+  if (!isEnabled()) return;
+  const payload = {
+    event,
+    migrationCountBucket: bucketCount(migrationCount),
+    nodeVersion: process.versions.node.split(".")[0] ?? "unknown",
+    platform: process.platform
+  };
+  try {
+    await fetch(TELEMETRY_ENDPOINT, {
+      method: "POST",
+      headers: { "Content-Type": "application/json" },
+      body: JSON.stringify(payload),
+      signal: AbortSignal.timeout(3e3)
+      // never block more than 3 s
+    });
+  } catch {
+    logger.debug("Telemetry event failed (non-fatal)");
+  }
+}
+
+// src/commands/check.ts
+function checkCommand() {
+  return new Command("check").description("Validate database migration state (CI-friendly)").option("--ci", "Exit with a non-zero code when issues are found (for CI pipelines)").option("--json", "Output result as JSON to stdout").option(
+    "--fail-on-risk <level>",
+    "Exit code 5 when risk meets or exceeds this level (low|medium|high|critical)"
+  ).option("--quiet", "Suppress non-essential output").action(
+    async (options) => {
+      const cwd = process.cwd();
+      try {
+        const project = await detectPrismaProject(cwd);
+        if (!project) {
+          if (options.json) {
+            process.stdout.write(
+              `${JSON.stringify({ ok: false, error: "No Prisma project found" })}
+`
+            );
+          } else if (!options.quiet) {
+            console.error(chalk.red("\u2716 No Prisma project found."));
+            console.error(chalk.dim("  Run prisma init to create a schema, then try again."));
+          }
+          process.exit(4);
+        }
+        const [status, migrations] = await Promise.all([
+          getProjectStatus(cwd),
+          getMigrations(cwd)
+        ]);
+        const ok = status.migrationsFailed === 0 && !status.driftDetected && status.migrationsPending === 0;
+        const result = {
+          ok,
+          connected: status.connected,
+          pendingCount: status.migrationsPending,
+          failedCount: status.migrationsFailed,
+          driftDetected: status.driftDetected,
+          driftCount: status.driftCount,
+          riskLevel: status.riskLevel,
+          healthScore: status.healthScore,
+          deploymentReadiness: status.deploymentReadiness,
+          lastSync: status.lastSync,
+          provider: status.provider
+        };
+        if (options.json) {
+          process.stdout.write(`${JSON.stringify(result, null, 2)}
+`);
+        } else if (!options.quiet) {
+          const bar = chalk.dim("\u2501".repeat(50));
+          console.log();
+          console.log(chalk.bold.cyan(" \u{1F50D}  PrismaFlow Check"));
+          console.log(bar);
+          if (status.connected) {
+            console.log(
+              chalk.green(" \u2714  Database connected") + (status.provider ? chalk.dim(` (${status.provider})`) : "")
+            );
+          } else {
+            console.log(chalk.red(" \u2716  Database unreachable \u2014 check DATABASE_URL"));
+          }
+          console.log(
+            chalk.green(" \u2714  Applied migrations: ") + chalk.bold(String(status.migrationsApplied))
+          );
+          if (status.migrationsPending > 0) {
+            console.log(
+              chalk.yellow(" \u26A0  Pending migrations: ") + chalk.bold.yellow(String(status.migrationsPending))
+            );
+            const pendingMigrations = migrations.filter((m) => m.status === "pending").slice(0, 3);
+            for (const m of pendingMigrations) {
+              console.log(chalk.dim(`     \u2022 ${m.name}`));
+            }
+            if (status.migrationsPending > 3) {
+              console.log(chalk.dim(`     \u2026 and ${status.migrationsPending - 3} more`));
+            }
+          } else {
+            console.log(chalk.green(" \u2714  No pending migrations"));
+          }
+          if (status.migrationsFailed > 0) {
+            console.log(
+              chalk.red(" \u2716  Failed migrations: ") + chalk.bold.red(String(status.migrationsFailed))
+            );
+            const failedMigrations = migrations.filter((m) => m.status === "failed").slice(0, 3);
+            for (const m of failedMigrations) {
+              console.log(chalk.dim(`     \u2022 ${m.name}`));
+            }
+          } else {
+            console.log(chalk.green(" \u2714  No failed migrations"));
+          }
+          if (status.driftDetected) {
+            console.log(
+              chalk.red(" \u2716  Schema drift detected: ") + chalk.bold.red(
+                `${status.driftCount} difference${status.driftCount !== 1 ? "s" : ""}`
+              )
+            );
+            console.log(chalk.dim("     Review the dashboard Drift page before deploying"));
+          } else {
+            console.log(chalk.green(" \u2714  No schema drift detected"));
+          }
+          const riskColors = {
+            low: chalk.green,
+            medium: chalk.yellow,
+            high: chalk.red,
+            critical: chalk.red
+          };
+          const riskColor = riskColors[status.riskLevel] ?? chalk.white;
+          console.log(` \u{1F512}  Risk level: ${riskColor(chalk.bold(status.riskLevel.toUpperCase()))}`);
+          console.log(
+            ` \u{1F6A6}  Readiness: ${riskColor(chalk.bold(`${status.healthScore}/100`))}${chalk.dim(
+              ` \u2014 ${status.deploymentReadiness.summary}`
+            )}`
+          );
+          const highestRiskMigration = migrations.filter((m) => m.riskScore.score > 0).sort((a, b) => b.riskScore.score - a.riskScore.score)[0];
+          if (highestRiskMigration?.riskScore.factors.length) {
+            console.log(chalk.dim(`
+     Top risk in ${highestRiskMigration.name}:`));
+            for (const factor of highestRiskMigration.riskScore.factors.slice(0, 2)) {
+              console.log(chalk.dim(`       \u2022 ${factor.description}`));
+            }
+          }
+          console.log(bar);
+          if (ok) {
+            console.log(chalk.bold.green(" \u2714  All checks passed"));
+          } else {
+            console.log(chalk.bold.red(" \u2716  Issues detected \u2014 review above"));
+            if (status.migrationsFailed > 0) {
+              console.log(chalk.dim("     \u2192 Fix: Run prisma migrate resolve"));
+            }
+            if (status.migrationsPending > 0) {
+              console.log(chalk.dim("     \u2192 Fix: Run prisma migrate deploy"));
+            }
+            if (status.driftDetected) {
+              console.log(
+                chalk.dim("     \u2192 Fix: Review drift details and reconcile Prisma schema")
+              );
+            }
+          }
+          console.log();
+        }
+        await Promise.all([
+          writeAuditEntry(cwd, "migration.check", ok ? "success" : "warning", {
+            pendingCount: status.migrationsPending,
+            failedCount: status.migrationsFailed,
+            driftDetected: status.driftDetected,
+            riskLevel: status.riskLevel
+          }),
+          trackEvent("check", migrations.length)
+        ]).catch(() => {
+        });
+        if (options.failOnRisk) {
+          const riskOrder = {
+            low: 1,
+            medium: 2,
+            high: 3,
+            critical: 4
+          };
+          const threshold = riskOrder[options.failOnRisk] ?? 2;
+          const current = riskOrder[status.riskLevel] ?? 1;
+          if (current >= threshold) process.exit(5);
+        }
+        if (options.ci) {
+          if (status.migrationsFailed > 0) process.exit(3);
+          if (status.driftDetected) process.exit(2);
+          if (status.migrationsPending > 0) process.exit(1);
+          process.exit(0);
+        }
+      } catch (error) {
+        const message = error instanceof Error ? error.message : String(error);
+        if (options.json) {
+          process.stdout.write(`${JSON.stringify({ ok: false, error: message })}
+`);
+        } else if (!options.quiet) {
+          console.error(chalk.red(`\u2716 Error: ${message}`));
+        }
+        await writeAuditEntry(cwd, "migration.check", "failure", {
+          error: message
+        }).catch(() => {
+        });
+        process.exit(4);
+      }
+    }
+  );
+}
+
+// src/commands/compare.ts
+import chalk2 from "chalk";
+import { Command as Command2 } from "commander";
+
+// src/core/config-loader.ts
+import fs5 from "fs";
+import path4 from "path";
+import { pathToFileURL } from "url";
+import { PrismaFlowConfigSchema } from "@prisma-flow/shared";
+var _cached = null;
+var _cachedCwd = null;
+function applyEnvOverrides(config) {
+  const overrides = {};
+  const port = process.env.PRISMAFLOW_PORT;
+  if (port) {
+    const parsed = Number.parseInt(port, 10);
+    if (!Number.isNaN(parsed) && parsed > 0 && parsed < 65536) {
+      overrides.port = parsed;
+    }
+  }
+  const logLevel = process.env.PRISMAFLOW_LOG_LEVEL;
+  if (logLevel) {
+    const result = PrismaFlowConfigSchema.shape.logLevel.safeParse(logLevel);
+    if (result.success) overrides.logLevel = result.data;
+  }
+  const openBrowser = process.env.PRISMAFLOW_NO_OPEN;
+  if (openBrowser === "1" || openBrowser?.toLowerCase() === "true") {
+    overrides.openBrowser = false;
+  }
+  const riskThreshold = process.env.PRISMAFLOW_RISK_THRESHOLD;
+  if (riskThreshold) {
+    const result = PrismaFlowConfigSchema.shape.riskThreshold.safeParse(riskThreshold);
+    if (result.success) overrides.riskThreshold = result.data;
+  }
+  if (process.env.SLACK_WEBHOOK_URL || process.env.DISCORD_WEBHOOK_URL) {
+    const envWebhooks = [];
+    if (process.env.SLACK_WEBHOOK_URL) {
+      envWebhooks.push({ type: "slack", url: process.env.SLACK_WEBHOOK_URL });
+    }
+    if (process.env.DISCORD_WEBHOOK_URL) {
+      envWebhooks.push({
+        type: "discord",
+        url: process.env.DISCORD_WEBHOOK_URL
+      });
+    }
+    overrides.webhooks = [...config.webhooks, ...envWebhooks];
+  }
+  return { ...config, ...overrides };
+}
+var CONFIG_CANDIDATES = [
+  "prismaflow.config.js",
+  "prismaflow.config.mjs",
+  "prismaflow.config.cjs",
+  // .ts is handled via tsx / ts-node at runtime (best-effort)
+  "prismaflow.config.ts"
+];
+async function findConfigFile(cwd) {
+  for (const name of CONFIG_CANDIDATES) {
+    const candidate = path4.join(cwd, name);
+    if (fs5.existsSync(candidate)) return candidate;
+  }
+  return null;
+}
+async function loadConfigFile(filePath) {
+  try {
+    const url = pathToFileURL(filePath).href;
+    const mod = await import(url);
+    return mod?.default ?? mod;
+  } catch (err) {
+    logger.debug({ err, filePath }, "Could not load config file \u2014 using defaults");
+    return null;
+  }
+}
+async function getConfig(cwd = process.cwd()) {
+  if (_cached && _cachedCwd === cwd) return _cached;
+  const configFile = await findConfigFile(cwd);
+  let rawConfig = {};
+  if (configFile) {
+    logger.debug({ configFile }, "Loading PrismaFlow config file");
+    rawConfig = await loadConfigFile(configFile);
+  } else {
+    logger.debug("No prismaflow.config.* found \u2014 using defaults");
+  }
+  const result = PrismaFlowConfigSchema.safeParse(rawConfig ?? {});
+  if (!result.success) {
+    logger.warn(
+      { errors: result.error.errors },
+      "prismaflow.config.* has validation errors \u2014 falling back to defaults"
+    );
+    const defaults = PrismaFlowConfigSchema.parse({});
+    const overridden2 = applyEnvOverrides(defaults);
+    _cached = overridden2;
+    _cachedCwd = cwd;
+    return overridden2;
+  }
+  const overridden = applyEnvOverrides(result.data);
+  _cached = overridden;
+  _cachedCwd = cwd;
+  return overridden;
+}
+function getConfigSync() {
+  if (!_cached) {
+    return PrismaFlowConfigSchema.parse({});
+  }
+  return _cached;
+}
+
+// src/core/env-comparator.ts
+import { EnvironmentComparisonError } from "@prisma-flow/shared";
+function parseStatusOutput(output) {
+  const applied = [];
+  const pending = [];
+  const failed = [];
+  let section = null;
+  for (const line of output.split("\n")) {
+    const trimmed = line.trim();
+    if (/have been applied/i.test(trimmed)) {
+      section = "applied";
+      continue;
+    }
+    if (/have not yet been applied/i.test(trimmed)) {
+      section = "pending";
+      continue;
+    }
+    if (/failed/i.test(trimmed)) {
+      section = "failed";
+      continue;
+    }
+    if (/^\d{14}_/.test(trimmed)) {
+      if (section === "applied") applied.push(trimmed);
+      else if (section === "pending") pending.push(trimmed);
+      else if (section === "failed") failed.push(trimmed);
+    }
+  }
+  return { applied, pending, failed };
+}
+async function queryMigrationStatus(envName, databaseUrl, schemaPath, cwd) {
+  try {
+    const env = { ...process.env, DATABASE_URL: databaseUrl };
+    const { stdout } = await execPrisma(cwd, ["migrate", "status", "--schema", schemaPath], {
+      env,
+      timeout: 3e4
+    });
+    return { ...parseStatusOutput(stdout), reachable: true };
+  } catch (err) {
+    const error = err instanceof Error ? err : new Error(String(err));
+    if ("stdout" in err) {
+      const output = err.stdout ?? "";
+      if (output.length > 0) {
+        return { ...parseStatusOutput(output), reachable: true };
+      }
+    }
+    if (error.message.includes("P1001") || error.message.includes("Connection refused") || error.message.includes("Can't reach database server")) {
+      return { applied: [], pending: [], failed: [], reachable: false };
+    }
+    throw new EnvironmentComparisonError(envName, "source", error);
+  }
+}
+async function fetchEnvironmentStates(environments, schemaPath, cwd) {
+  const states = [];
+  for (const env of environments) {
+    const status = await queryMigrationStatus(env.name, env.databaseUrl, schemaPath, cwd);
+    states.push({ name: env.name, databaseUrl: env.databaseUrl, ...status });
+  }
+  return states;
+}
+function diffEnvironments(source, target) {
+  const sourceSet = new Set(source.applied);
+  const targetSet = new Set(target.applied);
+  const onlyInSource = source.applied.filter((m) => !targetSet.has(m));
+  const onlyInTarget = target.applied.filter((m) => !sourceSet.has(m));
+  let divergencePoint;
+  for (let i = Math.min(source.applied.length, target.applied.length) - 1; i >= 0; i--) {
+    if (source.applied[i] === target.applied[i]) {
+      divergencePoint = source.applied[i];
+      break;
+    }
+  }
+  return {
+    sourceEnv: source.name,
+    targetEnv: target.name,
+    sourceApplied: source.applied.length,
+    targetApplied: target.applied.length,
+    onlyInSource,
+    onlyInTarget,
+    ...divergencePoint !== void 0 ? { divergencePoint } : {},
+    inSync: onlyInSource.length === 0 && onlyInTarget.length === 0
+  };
+}
+async function compareEnvironments(environments, schemaPath, cwd) {
+  if (environments.length < 2) {
+    throw new EnvironmentComparisonError(
+      "configuration",
+      "comparison",
+      new Error("At least 2 environments are required for comparison")
+    );
+  }
+  const states = await fetchEnvironmentStates(environments, schemaPath, cwd);
+  const [reference, ...targets] = states;
+  if (!reference) {
+    throw new EnvironmentComparisonError(
+      "configuration",
+      "comparison",
+      new Error("No environment states were returned")
+    );
+  }
+  const diffs = [];
+  for (const target of targets) {
+    diffs.push(diffEnvironments(reference, target));
+  }
+  const allInSync = diffs.every((d) => d.inSync);
+  return {
+    referenceEnv: reference.name,
+    environments: states.map((s) => ({
+      name: s.name,
+      reachable: s.reachable,
+      appliedCount: s.applied.length,
+      pendingCount: s.pending.length,
+      failedCount: s.failed.length
+    })),
+    diffs,
+    allInSync,
+    comparedAt: (/* @__PURE__ */ new Date()).toISOString()
+  };
+}
+
+// src/commands/compare.ts
+function compareCommand() {
+  return new Command2("compare").description("Compare migration state across multiple environments").option("--envs <names>", "Comma-separated env names from config (e.g. dev,staging,prod)").option("--json", "Output as JSON").action(async (options) => {
+    const cwd = process.cwd();
+    try {
+      const project = await detectPrismaProject(cwd);
+      if (!project) {
+        console.error(chalk2.red("\u2716  No Prisma project found."));
+        process.exit(1);
+      }
+      const config = await getConfig(cwd);
+      const configEnvList = config.environments ?? [];
+      let envList = [];
+      if (options.envs) {
+        for (const name of options.envs.split(",").map((s) => s.trim())) {
+          const envEntry = configEnvList.find((e) => e.name === name);
+          const url = envEntry?.databaseUrl ?? process.env[`DATABASE_URL_${name.toUpperCase()}`] ?? process.env.DATABASE_URL;
+          if (!url) {
+            console.error(chalk2.red(`\u2716  No database URL for environment "${name}".`));
+            console.error(
+              chalk2.dim(
+                `   Add it to prismaflow.config.ts or set DATABASE_URL_${name.toUpperCase()}`
+              )
+            );
+            process.exit(1);
+          }
+          envList.push({ name, databaseUrl: url });
+        }
+      } else if (configEnvList.length > 0) {
+        for (const entry of configEnvList) {
+          envList.push({ name: entry.name, databaseUrl: entry.databaseUrl });
+        }
+      } else {
+        const url = project.databaseUrl ?? process.env.DATABASE_URL;
+        if (!url) {
+          console.error(chalk2.red("\u2716  No environments configured and no DATABASE_URL found."));
+          console.error(
+            chalk2.dim("   Add environments to prismaflow.config.ts or use --envs <name,name>")
+          );
+          process.exit(1);
+        }
+        envList = [{ name: "default", databaseUrl: url }];
+        if (envList.length < 2) {
+          console.error(chalk2.yellow("\u26A0  At least 2 environments are required for comparison."));
+          process.exit(1);
+        }
+      }
+      if (envList.length < 2) {
+        console.error(chalk2.yellow("\u26A0  At least 2 environments are needed for comparison."));
+        process.exit(1);
+      }
+      if (!options.json) {
+        process.stdout.write(
+          chalk2.dim(`  Comparing ${envList.map((e) => e.name).join(" vs ")}...
+`)
+        );
+      }
+      const comparison = await compareEnvironments(envList, project.schemaPath, cwd);
+      if (options.json) {
+        process.stdout.write(`${JSON.stringify(comparison, null, 2)}
+`);
+        process.exit(0);
+      }
+      console.log();
+      console.log(chalk2.bold.cyan(" \u{1F310}  Environment Comparison"));
+      console.log(chalk2.dim("\u2501".repeat(55)));
+      for (const env of comparison.environments) {
+        const reach = env.reachable ? chalk2.green("\u25CF") : chalk2.red("\xD7");
+        console.log(
+          `  ${reach} ${chalk2.bold(env.name.padEnd(15))} applied: ${env.appliedCount}, pending: ${env.pendingCount}${env.failedCount > 0 ? chalk2.red(`, failed: ${env.failedCount}`) : ""}`
+        );
+      }
+      console.log();
+      for (const diff of comparison.diffs) {
+        const icon = diff.inSync ? chalk2.green("\u2713") : chalk2.yellow("\u26A0");
+        console.log(
+          `  ${icon} ${diff.sourceEnv} \u2194 ${diff.targetEnv}: ${diff.inSync ? chalk2.green("in sync") : chalk2.yellow("out of sync")}`
+        );
+        if (!diff.inSync) {
+          if (diff.onlyInSource.length > 0) {
+            console.log(
+              `     ${chalk2.dim("Only in")} ${diff.sourceEnv}: ${diff.onlyInSource.join(", ")}`
+            );
+          }
+          if (diff.onlyInTarget.length > 0) {
+            console.log(
+              `     ${chalk2.dim("Only in")} ${diff.targetEnv}: ${diff.onlyInTarget.join(", ")}`
+            );
+          }
+          if (diff.divergencePoint) {
+            console.log(`     ${chalk2.dim("Diverged after:")} ${diff.divergencePoint}`);
+          }
+        }
+      }
+      console.log();
+      if (comparison.allInSync) {
+        console.log(chalk2.bold.green("  \u2714  All environments are in sync."));
+      } else {
+        console.log(chalk2.bold.yellow("  \u26A0  Environments are out of sync \u2014 review diffs above."));
+      }
+      console.log();
+      await Promise.all([
+        writeAuditEntry(cwd, "env.compare", "success", {
+          environments: envList.map((e) => e.name),
+          allInSync: comparison.allInSync
+        }),
+        trackEvent("compare", envList.length)
+      ]).catch(() => {
+      });
+      process.exit(comparison.allInSync ? 0 : 2);
+    } catch (err) {
+      const message = err instanceof Error ? err.message : String(err);
+      console.error(chalk2.red(`\u2716  ${message}`));
+      process.exit(1);
+    }
+  });
+}
+
+// src/commands/dashboard.ts
+import chalk3 from "chalk";
+import { Command as Command3 } from "commander";
+import open from "open";
+
+// src/server/index.ts
+import { randomBytes } from "crypto";
+import fs12 from "fs";
+import path11 from "path";
+import { fileURLToPath } from "url";
+import { serve } from "@hono/node-server";
+import { serveStatic } from "@hono/node-server/serve-static";
+import { Hono as Hono15 } from "hono";
+import { cors } from "hono/cors";
+import { secureHeaders } from "hono/secure-headers";
+
+// src/server/routes/audit.ts
+import fs6 from "fs/promises";
+import path5 from "path";
+import { Hono } from "hono";
+var app = new Hono();
+app.get("/", async (c) => {
+  const projectPath = c.get("projectPath");
+  const limit = Number.parseInt(c.req.query("limit") ?? "100", 10);
+  try {
+    const auditFile = path5.join(projectPath, ".prismaflow", "audit.jsonl");
+    try {
+      await fs6.access(auditFile);
+    } catch {
+      return c.json({ success: true, data: [] });
+    }
+    const content = await fs6.readFile(auditFile, "utf-8");
+    const lines = content.split("\n").filter((l) => l.trim().length > 0);
+    const entries = lines.map((line) => {
+      try {
+        return JSON.parse(line);
+      } catch {
+        return null;
+      }
+    }).filter(Boolean).reverse().slice(0, limit);
+    return c.json({ success: true, data: entries });
+  } catch (err) {
+    const message = err instanceof Error ? err.message : String(err);
+    return c.json({ success: false, error: message }, 500);
+  }
+});
+var audit_default = app;
+
+// src/server/routes/compare.ts
+import { Hono as Hono2 } from "hono";
+var app2 = new Hono2();
+app2.get("/", async (c) => {
+  const projectPath = c.get("projectPath");
+  try {
+    const project = await detectPrismaProject(projectPath);
+    if (!project) return c.json({ success: false, error: "No Prisma project found" }, 404);
+    const config = await getConfig(projectPath);
+    const configEnvs = config.environments ?? {};
+    const envList = [];
+    for (const [name, entry] of Object.entries(configEnvs)) {
+      if (typeof entry === "object" && entry !== null && "databaseUrl" in entry) {
+        envList.push({
+          name,
+          databaseUrl: entry.databaseUrl
+        });
+      }
+    }
+    if (envList.length < 2) {
+      return c.json(
+        {
+          success: false,
+          error: "At least 2 environments must be configured in prismaflow.config.ts"
+        },
+        400
+      );
+    }
+    const comparison = await compareEnvironments(envList, project.schemaPath, projectPath);
+    return c.json({ success: true, data: comparison });
+  } catch (err) {
+    const message = err instanceof Error ? err.message : String(err);
+    return c.json({ success: false, error: message }, 500);
+  }
+});
+var compare_default = app2;
+
+// src/server/routes/config.ts
+import { Hono as Hono3 } from "hono";
+var app3 = new Hono3();
+app3.get("/", (c) => {
+  try {
+    const config = getConfigSync();
+    const { webhooks: _webhooks, environments: _environments, ...safeConfig } = config;
+    return c.json({ success: true, data: safeConfig });
+  } catch (err) {
+    const message = err instanceof Error ? err.message : String(err);
+    return c.json({ success: false, error: message }, 500);
+  }
+});
+var config_default = app3;
+
+// src/server/routes/diff.ts
+import { Hono as Hono4 } from "hono";
+
+// src/core/schema-differ.ts
+import fs7 from "fs/promises";
+async function diffSchemaVsDatabase(schemaPath, databaseUrl, cwd) {
+  const env = { ...process.env, DATABASE_URL: databaseUrl };
+  try {
+    const { stdout } = await execPrisma(
+      cwd,
+      [
+        "migrate",
+        "diff",
+        "--from-schema-datamodel",
+        schemaPath,
+        "--to-database-url",
+        databaseUrl,
+        "--script"
+      ],
+      { env, timeout: 3e4 }
+    );
+    const diffs = parseSqlDiff(stdout);
+    return { sql: stdout, diffs };
+  } catch (err) {
+    const error = err instanceof Error ? err : new Error(String(err));
+    if ("stdout" in err) {
+      const stdout = err.stdout ?? "";
+      if (stdout.includes("The migration is empty")) {
+        return { sql: "", diffs: [] };
+      }
+    }
+    throw error;
+  }
+}
+function parseSqlDiff(sql) {
+  const diffs = [];
+  for (const line of sql.split("\n")) {
+    const trimmed = line.trim();
+    const dropTable = trimmed.match(/DROP TABLE\s+"?(\w+)"?/i);
+    if (dropTable) {
+      diffs.push({
+        type: "model_removed",
+        modelName: dropTable[1] ?? "unknown",
+        description: `Table "${dropTable[1]}" will be dropped`,
+        breaking: true
+      });
+      continue;
+    }
+    const createTable = trimmed.match(/CREATE TABLE\s+"?(\w+)"?/i);
+    if (createTable) {
+      diffs.push({
+        type: "model_added",
+        modelName: createTable[1] ?? "unknown",
+        description: `Table "${createTable[1]}" will be created`,
+        breaking: false
+      });
+      continue;
+    }
+    const addColumn = trimmed.match(/ALTER TABLE\s+"?(\w+)"?\s+ADD COLUMN\s+"?(\w+)"?\s+(\w+)/i);
+    if (addColumn) {
+      diffs.push({
+        type: "field_added",
+        modelName: addColumn[1] ?? "unknown",
+        fieldName: addColumn[2] ?? "unknown",
+        newType: addColumn[3] ?? "unknown",
+        description: `Column "${addColumn[2]}" added to "${addColumn[1]}"`,
+        breaking: false
+      });
+      continue;
+    }
+    const dropColumn = trimmed.match(/ALTER TABLE\s+"?(\w+)"?\s+DROP COLUMN\s+"?(\w+)"?/i);
+    if (dropColumn) {
+      diffs.push({
+        type: "field_removed",
+        modelName: dropColumn[1] ?? "unknown",
+        fieldName: dropColumn[2] ?? "unknown",
+        description: `Column "${dropColumn[2]}" dropped from "${dropColumn[1]}" \u2014 data lost`,
+        breaking: true
+      });
+    }
+  }
+  return diffs;
+}
+
+// src/server/routes/diff.ts
+var app4 = new Hono4();
+app4.get("/", async (c) => {
+  const projectPath = c.get("projectPath");
+  try {
+    const project = await detectPrismaProject(projectPath);
+    if (!project) return c.json({ success: false, error: "No Prisma project found" }, 404);
+    const dbUrl = c.req.query("url") ?? project.databaseUrl ?? process.env.DATABASE_URL;
+    if (!dbUrl) {
+      return c.json({ success: false, error: "No database URL available" }, 400);
+    }
+    const breakingOnly = c.req.query("breaking") === "true";
+    const { sql, diffs } = await diffSchemaVsDatabase(project.schemaPath, dbUrl, projectPath);
+    const filtered = breakingOnly ? diffs.filter((d) => d.breaking) : diffs;
+    return c.json({
+      success: true,
+      data: {
+        diffs: filtered,
+        totalDiffs: diffs.length,
+        breakingDiffs: diffs.filter((d) => d.breaking).length,
+        hasSql: sql.length > 0
+      }
+    });
+  } catch (err) {
+    const message = err instanceof Error ? err.message : String(err);
+    return c.json({ success: false, error: message }, 500);
+  }
+});
+var diff_default = app4;
+
+// src/server/routes/drift.ts
+import { Hono as Hono5 } from "hono";
+var app5 = new Hono5();
+var CACHE_TTL_MS = 1e4;
+var cacheMap = /* @__PURE__ */ new Map();
+function buildPayload(result, cachedAt) {
+  return {
+    hasDrift: result.status === "drifted",
+    driftCount: result.items.length,
+    differences: result.items,
+    cachedAt: cachedAt ? new Date(cachedAt).toISOString() : null,
+    status: result.status,
+    ...result.errorMessage !== void 0 ? { errorMessage: result.errorMessage } : {}
+  };
+}
+app5.get("/", async (c) => {
+  try {
+    const projectPath = c.get("projectPath");
+    const cached = cacheMap.get(projectPath);
+    if (!cached || Date.now() - cached.fetchedAt > CACHE_TTL_MS) {
+      const data = await detectDrift(projectPath);
+      const entry = { data, fetchedAt: Date.now() };
+      cacheMap.set(projectPath, entry);
+      return c.json({
+        success: true,
+        data: buildPayload(data, entry.fetchedAt)
+      });
+    }
+    return c.json({
+      success: true,
+      data: buildPayload(cached.data, cached.fetchedAt)
+    });
+  } catch (error) {
+    const message = error instanceof Error ? error.message : "Unknown error";
+    return c.json({ success: false, error: message }, 500);
+  }
+});
+app5.post("/check", async (c) => {
+  try {
+    const projectPath = c.get("projectPath");
+    const data = await detectDrift(projectPath);
+    const entry = { data, fetchedAt: Date.now() };
+    cacheMap.set(projectPath, entry);
+    return c.json({
+      success: true,
+      message: "Drift check completed",
+      data: buildPayload(data, entry.fetchedAt)
+    });
+  } catch (error) {
+    const message = error instanceof Error ? error.message : "Unknown error";
+    return c.json({ success: false, error: message }, 500);
+  }
+});
+var drift_default = app5;
+
+// src/server/routes/events.ts
+import { Hono as Hono6 } from "hono";
+import { streamSSE } from "hono/streaming";
+var app6 = new Hono6();
+var listeners = /* @__PURE__ */ new Set();
+app6.get("/", (c) => {
+  return streamSSE(c, async (stream) => {
+    await stream.writeSSE({
+      event: "connected",
+      data: JSON.stringify({ ts: (/* @__PURE__ */ new Date()).toISOString() })
+    });
+    const listener = async (event, data) => {
+      await stream.writeSSE({
+        event,
+        data: JSON.stringify(data)
+      });
+    };
+    listeners.add(listener);
+    const heartbeat = setInterval(async () => {
+      await stream.writeSSE({
+        event: "heartbeat",
+        data: JSON.stringify({ ts: (/* @__PURE__ */ new Date()).toISOString() })
+      });
+    }, 25e3);
+    stream.onAbort(() => {
+      clearInterval(heartbeat);
+      listeners.delete(listener);
+    });
+    await stream.sleep(Number.MAX_SAFE_INTEGER);
+  });
+});
+var events_default = app6;
+
+// src/server/routes/git.ts
+import { Hono as Hono7 } from "hono";
+
+// src/core/git-awareness.ts
+import { execFile as execFile2 } from "child_process";
+import fs8 from "fs/promises";
+import path6 from "path";
+import { promisify as promisify2 } from "util";
+import { GitAwarenessError } from "@prisma-flow/shared";
+var execAsync = promisify2(execFile2);
+async function git(args, cwd) {
+  try {
+    const { stdout } = await execAsync("git", args, { cwd, timeout: 1e4 });
+    return stdout.trim();
+  } catch (err) {
+    const error = err instanceof Error ? err : new Error(String(err));
+    throw new GitAwarenessError(error.message, error);
+  }
+}
+async function isGitRepo(cwd) {
+  try {
+    await git(["rev-parse", "--git-dir"], cwd);
+    return true;
+  } catch {
+    return false;
+  }
+}
+async function getGitMigrationInfo(migrationsDir, cwd) {
+  let entries;
+  try {
+    const raw = await fs8.readdir(migrationsDir, { withFileTypes: true });
+    entries = raw.filter((d) => d.isDirectory() && /^\d{14}_/.test(d.name)).map((d) => d.name).sort();
+  } catch {
+    return [];
+  }
+  const results = [];
+  for (const entry of entries) {
+    const migrationPath = path6.join(migrationsDir, entry, "migration.sql");
+    const relPath = path6.relative(cwd, migrationPath);
+    try {
+      const log = await git(
+        ["log", "--follow", "--diff-filter=A", "--format=%H|%an|%aI|%s", "--", relPath],
+        cwd
+      );
+      if (!log) {
+        results.push({
+          migrationName: entry,
+          committed: false
+        });
+        continue;
+      }
+      const [hash, author, date, ...subjectParts] = log.split("|");
+      const subject = subjectParts.join("|");
+      results.push({
+        migrationName: entry,
+        committed: true,
+        ...hash?.trim() ? { commitHash: hash.trim() } : {},
+        ...author?.trim() ? { commitAuthor: author.trim() } : {},
+        ...date?.trim() ? { commitDate: date.trim() } : {},
+        ...subject?.trim() ? { commitMessage: subject.trim() } : {}
+      });
+    } catch {
+      results.push({
+        migrationName: entry,
+        committed: false
+      });
+    }
+  }
+  return results;
+}
+async function detectMigrationConflicts(migrationsDir) {
+  let entries;
+  try {
+    const raw = await fs8.readdir(migrationsDir, { withFileTypes: true });
+    entries = raw.filter((d) => d.isDirectory() && /^\d{14}_/.test(d.name)).map((d) => d.name);
+  } catch {
+    return [];
+  }
+  const byTimestamp = /* @__PURE__ */ new Map();
+  for (const entry of entries) {
+    const ts = entry.slice(0, 14);
+    const existing = byTimestamp.get(ts) ?? [];
+    existing.push(entry);
+    byTimestamp.set(ts, existing);
+  }
+  const conflicts = [];
+  for (const [timestamp, names] of byTimestamp) {
+    if (names.length > 1) {
+      conflicts.push({
+        timestamp,
+        migrations: names,
+        type: "duplicate_timestamp",
+        description: `${names.length} migrations share timestamp ${timestamp} \u2014 likely from parallel branches`
+      });
+    }
+  }
+  return conflicts;
+}
+async function getUncommittedMigrations(migrationsDir, cwd) {
+  let entries;
+  try {
+    const raw = await fs8.readdir(migrationsDir, { withFileTypes: true });
+    entries = raw.filter((d) => d.isDirectory() && /^\d{14}_/.test(d.name)).map((d) => d.name).sort();
+  } catch {
+    return [];
+  }
+  const uncommitted = [];
+  try {
+    const untracked = await git(["ls-files", "--others", "--exclude-standard", migrationsDir], cwd);
+    const untrackedSet = new Set(
+      untracked.split("\n").map((s) => s.trim()).filter(Boolean)
+    );
+    for (const entry of entries) {
+      const sqlFile = path6.relative(cwd, path6.join(migrationsDir, entry, "migration.sql"));
+      if (untrackedSet.has(sqlFile)) {
+        uncommitted.push(entry);
+      }
+    }
+  } catch {
+  }
+  return uncommitted;
+}
+
+// src/server/routes/git.ts
+var app7 = new Hono7();
+app7.get("/", async (c) => {
+  const projectPath = c.get("projectPath");
+  try {
+    const project = await detectPrismaProject(projectPath);
+    if (!project) return c.json({ success: false, error: "No Prisma project found" }, 404);
+    const inRepo = await isGitRepo(projectPath);
+    if (!inRepo) {
+      return c.json({
+        success: true,
+        data: { inRepo: false, migrations: [], conflicts: [], uncommitted: [] }
+      });
+    }
+    const [migrations, conflicts, uncommitted] = await Promise.all([
+      getGitMigrationInfo(project.migrationsPath, projectPath),
+      detectMigrationConflicts(project.migrationsPath),
+      getUncommittedMigrations(project.migrationsPath, projectPath)
+    ]);
+    return c.json({
+      success: true,
+      data: { inRepo: true, migrations, conflicts, uncommitted }
+    });
+  } catch (err) {
+    const message = err instanceof Error ? err.message : String(err);
+    return c.json({ success: false, error: message }, 500);
+  }
+});
+var git_default = app7;
+
+// src/server/routes/migrations.ts
+import { Hono as Hono8 } from "hono";
+var app8 = new Hono8();
+app8.get("/", async (c) => {
+  try {
+    const projectPath = c.get("projectPath");
+    const page = Math.max(1, Number.parseInt(c.req.query("page") ?? "1", 10));
+    const limit = Math.min(100, Math.max(1, Number.parseInt(c.req.query("limit") ?? "20", 10)));
+    const all = await getMigrations(projectPath);
+    const total = all.length;
+    const start = (page - 1) * limit;
+    const items = all.slice(start, start + limit);
+    return c.json({
+      success: true,
+      data: items,
+      pagination: { page, limit, total, pages: Math.ceil(total / limit) }
+    });
+  } catch (error) {
+    const message = error instanceof Error ? error.message : "Unknown error";
+    return c.json({ success: false, error: message }, 500);
+  }
+});
+app8.get("/:name", async (c) => {
+  try {
+    const projectPath = c.get("projectPath");
+    const name = c.req.param("name");
+    const migration = await getMigrationDetails(projectPath, name);
+    if (!migration) {
+      return c.json({ success: false, error: "Migration not found" }, 404);
+    }
+    return c.json({ success: true, data: migration });
+  } catch (error) {
+    const message = error instanceof Error ? error.message : "Unknown error";
+    return c.json({ success: false, error: message }, 500);
+  }
+});
+var migrations_default = app8;
+
+// src/server/routes/repair.ts
+import { Hono as Hono9 } from "hono";
+
+// src/core/drift-recovery.ts
+import fs9 from "fs/promises";
+import path7 from "path";
+import { DriftRepairError } from "@prisma-flow/shared";
+function generateRepairSuggestions(driftItems, migrationsDir) {
+  void migrationsDir;
+  const suggestions = [];
+  for (const item of driftItems) {
+    const strategy = pickStrategy(item);
+    const repairSql = generateRepairSql(item, strategy);
+    suggestions.push({
+      driftItem: item,
+      strategy,
+      description: describeStrategy(item, strategy),
+      ...repairSql !== void 0 ? { sql: repairSql } : {},
+      automated: strategy !== "MANUAL_SQL",
+      risk: assessRisk(item)
+    });
+  }
+  return suggestions;
+}
+function pickStrategy(item) {
+  switch (item.type) {
+    case "missing_migration":
+      return "APPLY_MIGRATION";
+    case "extra_column":
+    case "extra_table":
+      return "SQUASH";
+    case "modified_migration":
+      return "MANUAL_SQL";
+    default:
+      return "MANUAL_SQL";
+  }
+}
+function describeStrategy(item, strategy) {
+  switch (strategy) {
+    case "APPLY_MIGRATION":
+      return `Apply missing migration "${item.migrationName ?? item.identifier}" to the database`;
+    case "SQUASH":
+      return `Create a new migration that incorporates the "${item.identifier}" drift (extra ${item.type.replace("extra_", "")} in DB)`;
+    case "MANUAL_SQL":
+      return `Manually review and apply SQL to reconcile "${item.identifier}" \u2014 automated repair not safe`;
+    case "IGNORE":
+      return `"${item.identifier}" is safe to ignore (documentation-only drift)`;
+    default:
+      return `Review drift for "${item.identifier}"`;
+  }
+}
+function generateRepairSql(item, strategy) {
+  if (strategy === "APPLY_MIGRATION" && item.migrationName) {
+    return `-- Run: npx prisma migrate resolve --applied "${item.migrationName}"`;
+  }
+  if (strategy === "SQUASH" && item.type === "extra_table") {
+    return `-- Extra table detected. To squash into schema:
+-- 1. Add the model to prisma/schema.prisma
+-- 2. Run: npx prisma migrate dev --name squash_${item.identifier}`;
+  }
+  if (strategy === "SQUASH" && item.type === "extra_column") {
+    const identifier = item.identifier ?? "unknown.unknown";
+    const [table, column] = identifier.split(".");
+    return `-- Extra column ${column} on ${table}. To squash:
+-- 1. Add field to model in prisma/schema.prisma
+-- 2. Run: npx prisma migrate dev --name squash_${column}_on_${table}`;
+  }
+  if (item.sql) {
+    return `-- Suggested SQL (review carefully before running):
+${item.sql}`;
+  }
+  return void 0;
+}
+function assessRisk(item) {
+  if (item.type === "modified_migration") return "high";
+  if (item.type === "extra_table") return "medium";
+  if (item.type === "extra_column") return "low";
+  if (item.type === "missing_migration") return "medium";
+  return "medium";
+}
+async function applyRepairs(suggestions, schemaPath, cwd) {
+  const results = [];
+  for (const suggestion of suggestions) {
+    if (suggestion.strategy !== "APPLY_MIGRATION") continue;
+    if (!suggestion.driftItem.migrationName) continue;
+    const name = suggestion.driftItem.migrationName;
+    try {
+      await execPrisma(cwd, ["migrate", "resolve", "--applied", name, "--schema", schemaPath], {
+        timeout: 3e4
+      });
+      results.push({ migrationName: name, success: true });
+    } catch (err) {
+      const error = err instanceof Error ? err : new Error(String(err));
+      results.push({
+        migrationName: name,
+        success: false,
+        error: error.message
+      });
+    }
+  }
+  return results;
+}
+
+// src/server/routes/repair.ts
+var app9 = new Hono9();
+app9.get("/", async (c) => {
+  const projectPath = c.get("projectPath");
+  try {
+    const project = await detectPrismaProject(projectPath);
+    if (!project) return c.json({ success: false, error: "No Prisma project found" }, 404);
+    const driftResult = await detectDrift(projectPath);
+    if (driftResult.status === "error") {
+      return c.json(
+        {
+          success: false,
+          error: driftResult.errorMessage ?? "Drift detection failed"
+        },
+        502
+      );
+    }
+    const suggestions = generateRepairSuggestions(driftResult.items, project.migrationsPath);
+    return c.json({
+      success: true,
+      data: { drifted: driftResult.status === "drifted", suggestions }
+    });
+  } catch (err) {
+    const message = err instanceof Error ? err.message : String(err);
+    return c.json({ success: false, error: message }, 500);
+  }
+});
+app9.post("/apply", async (c) => {
+  const projectPath = c.get("projectPath");
+  try {
+    const project = await detectPrismaProject(projectPath);
+    if (!project) return c.json({ success: false, error: "No Prisma project found" }, 404);
+    const driftResult = await detectDrift(projectPath);
+    if (driftResult.status === "error") {
+      return c.json(
+        {
+          success: false,
+          error: driftResult.errorMessage ?? "Drift detection failed"
+        },
+        502
+      );
+    }
+    const suggestions = generateRepairSuggestions(driftResult.items, project.migrationsPath);
+    const results = await applyRepairs(suggestions, project.schemaPath, projectPath);
+    return c.json({ success: true, data: results });
+  } catch (err) {
+    const message = err instanceof Error ? err.message : String(err);
+    return c.json({ success: false, error: message }, 500);
+  }
+});
+var repair_default = app9;
+
+// src/server/routes/risks.ts
+import { Hono as Hono10 } from "hono";
+var app10 = new Hono10();
+app10.get("/", async (c) => {
+  const projectPath = c.get("projectPath");
+  try {
+    const project = await detectPrismaProject(projectPath);
+    if (!project) {
+      return c.json({ success: false, error: "No Prisma project found" }, 404);
+    }
+    const migrations = await getMigrations(projectPath);
+    const risks = migrations.map((m) => ({
+      name: m.name,
+      timestamp: m.timestamp,
+      riskScore: m.riskScore
+    }));
+    return c.json({ success: true, data: risks });
+  } catch (err) {
+    const message = err instanceof Error ? err.message : String(err);
+    return c.json({ success: false, error: message }, 500);
+  }
+});
+app10.get("/:migration", async (c) => {
+  const projectPath = c.get("projectPath");
+  const migrationQuery = c.req.param("migration");
+  try {
+    const project = await detectPrismaProject(projectPath);
+    if (!project) return c.json({ success: false, error: "No Prisma project found" }, 404);
+    const migrations = await getMigrations(projectPath);
+    const match = migrations.find(
+      (m) => m.name === migrationQuery || m.name.startsWith(migrationQuery)
+    );
+    if (!match) return c.json({ success: false, error: "Migration not found" }, 404);
+    return c.json({ success: true, data: match.riskScore });
+  } catch (err) {
+    const message = err instanceof Error ? err.message : String(err);
+    return c.json({ success: false, error: message }, 500);
+  }
+});
+var risks_default = app10;
+
+// src/server/routes/rollback.ts
+import path9 from "path";
+import { Hono as Hono11 } from "hono";
+
+// src/core/rollback-generator.ts
+import fs11 from "fs/promises";
+import { RollbackError } from "@prisma-flow/shared";
+
+// src/core/simulator.ts
+import { execFile as execFile3 } from "child_process";
+import fs10 from "fs/promises";
+import os from "os";
+import path8 from "path";
+import { promisify as promisify3 } from "util";
+import { SimulationError } from "@prisma-flow/shared";
+var execAsync2 = promisify3(execFile3);
+var DESTRUCTIVE_PATTERNS = [
+  {
+    pattern: /drop\s+table/i,
+    warning: "Drops a table \u2014 all data will be lost"
+  },
+  {
+    pattern: /truncate\s+table/i,
+    warning: "Truncates a table \u2014 all rows will be deleted"
+  },
+  {
+    pattern: /drop\s+column/i,
+    warning: "Drops a column \u2014 data in that column will be lost"
+  },
+  {
+    pattern: /alter\s+column.*not\s+null/i,
+    warning: "Adds NOT NULL \u2014 will fail if existing rows have NULLs"
+  },
+  { pattern: /delete\s+from/i, warning: "Deletes rows \u2014 data will be lost" },
+  {
+    pattern: /drop\s+index/i,
+    warning: "Drops an index \u2014 query performance may degrade"
+  },
+  {
+    pattern: /drop\s+constraint/i,
+    warning: "Drops a constraint \u2014 data integrity may be affected"
+  }
+];
+var DDL_TYPES = [
+  { pattern: /^\s*create\s+table/i, type: "CREATE_TABLE" },
+  { pattern: /^\s*alter\s+table/i, type: "ALTER_TABLE" },
+  { pattern: /^\s*drop\s+table/i, type: "DROP_TABLE" },
+  { pattern: /^\s*create\s+(unique\s+)?index/i, type: "CREATE_INDEX" },
+  { pattern: /^\s*drop\s+index/i, type: "DROP_INDEX" },
+  { pattern: /^\s*insert\s+into/i, type: "INSERT" },
+  { pattern: /^\s*update\s+/i, type: "UPDATE" },
+  { pattern: /^\s*delete\s+from/i, type: "DELETE" },
+  { pattern: /^\s*truncate/i, type: "TRUNCATE" }
+];
+function classifyStatement(sql) {
+  for (const { pattern, type } of DDL_TYPES) {
+    if (pattern.test(sql)) return type;
+  }
+  return "OTHER";
+}
+function estimateRowsAffected(sql) {
+  if (/delete\s+from.*where/i.test(sql)) return void 0;
+  if (/delete\s+from\s+\w+\s*;?\s*$/i.test(sql)) return Number.POSITIVE_INFINITY;
+  if (/truncate/i.test(sql)) return Number.POSITIVE_INFINITY;
+  return void 0;
+}
+function splitStatements(sql) {
+  return sql.split(";").map((s) => s.trim()).filter((s) => s.length > 0 && !s.startsWith("--"));
+}
+function analyseStatically(migrationName, statements) {
+  const parsed = statements.map((sql, index) => {
+    const warnings = [];
+    for (const { pattern, warning } of DESTRUCTIVE_PATTERNS) {
+      if (pattern.test(sql)) warnings.push(warning);
+    }
+    const rowsEst = estimateRowsAffected(sql);
+    return {
+      index,
+      sql,
+      type: classifyStatement(sql),
+      isDestructive: warnings.length > 0,
+      warnings,
+      ...rowsEst !== void 0 ? { estimatedRowsAffected: rowsEst } : {}
+    };
+  });
+  const destructive = parsed.filter((s) => s.isDestructive);
+  const allWarnings = destructive.flatMap((s) => s.warnings);
+  return {
+    migrationName,
+    statements: parsed,
+    wouldSucceed: true,
+    // static analysis optimistic
+    destructiveStatements: destructive.length,
+    warnings: allWarnings,
+    simulatedAt: (/* @__PURE__ */ new Date()).toISOString(),
+    mode: "static"
+  };
+}
+async function simulateSqlite(migrationName, sqlFilePath, dbFilePath) {
+  const tmpDir = await fs10.mkdtemp(path8.join(os.tmpdir(), "prismaflow-sim-"));
+  const shadowDb = path8.join(tmpDir, "shadow.db");
+  try {
+    await fs10.copyFile(dbFilePath, shadowDb);
+    const sql = await fs10.readFile(sqlFilePath, "utf-8");
+    const statements = splitStatements(sql);
+    try {
+      await execAsync2("sqlite3", [shadowDb, sql], { timeout: 3e4 });
+      const staticResult = analyseStatically(migrationName, statements);
+      return { ...staticResult, wouldSucceed: true, mode: "shadow" };
+    } catch (err) {
+      const error = err instanceof Error ? err : new Error(String(err));
+      const staticResult = analyseStatically(migrationName, statements);
+      return {
+        ...staticResult,
+        wouldSucceed: false,
+        error: error.message,
+        mode: "shadow"
+      };
+    }
+  } catch {
+    const sql = await fs10.readFile(sqlFilePath, "utf-8").catch(() => "");
+    return analyseStatically(migrationName, splitStatements(sql));
+  } finally {
+    await fs10.rm(tmpDir, { recursive: true, force: true }).catch(() => {
+    });
+  }
+}
+async function simulate(migrationName, sqlFilePath, dbFilePath) {
+  try {
+    const sql = await fs10.readFile(sqlFilePath, "utf-8");
+    const statements = splitStatements(sql);
+    if (dbFilePath && dbFilePath !== ":memory:") {
+      try {
+        await fs10.access(dbFilePath);
+        return await simulateSqlite(migrationName, sqlFilePath, dbFilePath);
+      } catch {
+      }
+    }
+    return analyseStatically(migrationName, statements);
+  } catch (err) {
+    const error = err instanceof Error ? err : new Error(String(err));
+    throw new SimulationError(migrationName, error);
+  }
+}
+
+// src/core/rollback-generator.ts
+function invertStatement(sql) {
+  const trimmed = sql.trim();
+  const createTable = trimmed.match(/^CREATE\s+TABLE\s+(?:IF\s+NOT\s+EXISTS\s+)?["'`]?(\w+)["'`]?/i);
+  if (createTable) {
+    return {
+      sql: `DROP TABLE IF EXISTS "${createTable[1]}";`,
+      automated: true
+    };
+  }
+  const createIndex = trimmed.match(
+    /^CREATE\s+(?:UNIQUE\s+)?INDEX\s+(?:IF\s+NOT\s+EXISTS\s+)?["'`]?(\w+)["'`]?/i
+  );
+  if (createIndex) {
+    return {
+      sql: `DROP INDEX IF EXISTS "${createIndex[1]}";`,
+      automated: true
+    };
+  }
+  const addColumn = trimmed.match(
+    /^ALTER\s+TABLE\s+["'`]?(\w+)["'`]?\s+ADD\s+COLUMN\s+["'`]?(\w+)["'`]?/i
+  );
+  if (addColumn) {
+    return {
+      sql: `ALTER TABLE "${addColumn[1]}" DROP COLUMN "${addColumn[2]}";`,
+      automated: true
+    };
+  }
+  const dropColumn = trimmed.match(
+    /^ALTER\s+TABLE\s+["'`]?(\w+)["'`]?\s+DROP\s+COLUMN\s+["'`]?(\w+)["'`]?/i
+  );
+  if (dropColumn) {
+    return {
+      sql: `-- MANUAL: Restore column "${dropColumn[2]}" on table "${dropColumn[1]}" from backup`,
+      automated: false,
+      warning: `DROP COLUMN is irreversible \u2014 column "${dropColumn[2]}" data is lost unless backed up`
+    };
+  }
+  const addConstraint = trimmed.match(
+    /^ALTER\s+TABLE\s+["'`]?(\w+)["'`]?\s+ADD\s+CONSTRAINT\s+["'`]?(\w+)["'`]?/i
+  );
+  if (addConstraint) {
+    return {
+      sql: `ALTER TABLE "${addConstraint[1]}" DROP CONSTRAINT "${addConstraint[2]}";`,
+      automated: true
+    };
+  }
+  const dropTable = trimmed.match(/^DROP\s+TABLE\s+(?:IF\s+EXISTS\s+)?["'`]?(\w+)["'`]?/i);
+  if (dropTable) {
+    return {
+      sql: `-- MANUAL: Recreate table "${dropTable[1]}" and restore data from backup`,
+      automated: false,
+      warning: `DROP TABLE is irreversible \u2014 table "${dropTable[1]}" and all its data are gone unless backed up`
+    };
+  }
+  if (/^TRUNCATE/i.test(trimmed)) {
+    return {
+      sql: "-- MANUAL: Restore truncated rows from backup",
+      automated: false,
+      warning: "TRUNCATE is irreversible \u2014 all rows are deleted"
+    };
+  }
+  if (/^DELETE\s+FROM/i.test(trimmed)) {
+    return {
+      sql: "-- MANUAL: Restore deleted rows from backup",
+      automated: false,
+      warning: "DELETE is irreversible \u2014 rows are gone unless backed up"
+    };
+  }
+  if (/^INSERT\s+INTO/i.test(trimmed)) {
+    return {
+      sql: "-- MANUAL: DELETE the rows inserted by this migration (unknown primary keys)",
+      automated: false,
+      warning: "INSERT rollback requires knowing inserted primary keys"
+    };
+  }
+  if (/^UPDATE\s+/i.test(trimmed)) {
+    return {
+      sql: "-- MANUAL: Restore original column values from backup",
+      automated: false,
+      warning: "UPDATE rollback requires a snapshot of pre-update values"
+    };
+  }
+  return {
+    sql: `-- MANUAL: Undo: ${trimmed.slice(0, 80)}`,
+    automated: false,
+    warning: "Unrecognised statement \u2014 manual rollback required"
+  };
+}
+async function generateRollbackPlan(migrationName, sqlFilePath) {
+  let sql;
+  try {
+    sql = await fs11.readFile(sqlFilePath, "utf-8");
+  } catch (err) {
+    const error = err instanceof Error ? err : new Error(String(err));
+    throw new RollbackError(migrationName, `Cannot read SQL file: ${error.message}`);
+  }
+  const statements = splitStatements(sql);
+  const steps = [];
+  for (let i = 0; i < statements.length; i++) {
+    const fwd = statements[i];
+    if (!fwd) continue;
+    const inv = invertStatement(fwd);
+    steps.push({
+      index: i,
+      forwardSql: fwd,
+      rollbackSql: inv.sql,
+      automated: inv.automated,
+      ...inv.warning !== void 0 ? { warning: inv.warning } : {}
+    });
+  }
+  const reversedSteps = [...steps].reverse();
+  const manualSteps = reversedSteps.filter((s) => !s.automated);
+  const hasManualSteps = manualSteps.length > 0;
+  const warnings = reversedSteps.flatMap((s) => s.warning ? [s.warning] : []);
+  return {
+    migrationName,
+    steps: reversedSteps,
+    hasManualSteps,
+    warnings,
+    generatedAt: (/* @__PURE__ */ new Date()).toISOString(),
+    automated: !hasManualSteps
+  };
+}
+function renderRollbackSql(plan, includeManual = true) {
+  const header = [
+    `-- Rollback plan for migration: ${plan.migrationName}`,
+    `-- Generated at: ${plan.generatedAt}`,
+    `-- Steps: ${plan.steps.length} (${plan.hasManualSteps ? "contains MANUAL steps" : "fully automated"})`,
+    plan.warnings.length > 0 ? `-- Warnings:
+${plan.warnings.map((w) => `--   ! ${w}`).join("\n")}` : null,
+    ""
+  ].filter(Boolean).join("\n");
+  const body = plan.steps.filter((s) => includeManual || s.automated).map((s) => s.rollbackSql).join("\n");
+  return `${header}${body}`;
+}
+
+// src/server/routes/rollback.ts
+var app11 = new Hono11();
+app11.get("/:migration", async (c) => {
+  const projectPath = c.get("projectPath");
+  const migrationQuery = c.req.param("migration");
+  try {
+    const project = await detectPrismaProject(projectPath);
+    if (!project) return c.json({ success: false, error: "No Prisma project found" }, 404);
+    const match = project.migrations.find(
+      (m) => m.name === migrationQuery || m.name.startsWith(migrationQuery)
+    );
+    if (!match) return c.json({ success: false, error: "Migration not found" }, 404);
+    const sqlFile = path9.join(project.migrationsPath, match.name, "migration.sql");
+    const plan = await generateRollbackPlan(match.name, sqlFile);
+    const format = c.req.query("format");
+    if (format === "sql") {
+      return c.text(renderRollbackSql(plan, true), 200, {
+        "Content-Type": "text/plain",
+        "Content-Disposition": `attachment; filename="${match.name}.rollback.sql"`
+      });
+    }
+    return c.json({ success: true, data: plan });
+  } catch (err) {
+    const message = err instanceof Error ? err.message : String(err);
+    return c.json({ success: false, error: message }, 500);
+  }
+});
+var rollback_default = app11;
+
+// src/server/routes/schema.ts
+import { Hono as Hono12 } from "hono";
+
+// src/core/schema-parser.ts
+async function loadGetDMMF() {
+  const mod = await import("@prisma/internals");
+  const fn = mod.getDMMF ?? mod.default?.getDMMF;
+  if (typeof fn !== "function") {
+    throw new Error("@prisma/internals did not export getDMMF \u2014 check the installed Prisma version");
+  }
+  return fn;
+}
+async function parseSchema(cwd) {
+  const project = await detectPrismaProject(cwd);
+  if (!project) return null;
+  try {
+    const getDMMF = await loadGetDMMF();
+    const dmmf = await getDMMF({ datamodel: project.schemaContent });
+    return dmmf.datamodel;
+  } catch (err) {
+    logger.error({ err }, "Schema parse error");
+    throw err;
+  }
+}
+
+// src/server/routes/schema.ts
+var app12 = new Hono12();
+app12.get("/", async (c) => {
+  try {
+    const projectPath = c.get("projectPath");
+    const schema = await parseSchema(projectPath);
+    return c.json({ success: true, data: schema });
+  } catch (error) {
+    const message = error instanceof Error ? error.message : "Unknown error";
+    return c.json({ success: false, error: message }, 500);
+  }
+});
+var schema_default = app12;
+
+// src/server/routes/simulate.ts
+import path10 from "path";
+import { Hono as Hono13 } from "hono";
+var app13 = new Hono13();
+app13.get("/:migration", async (c) => {
+  const projectPath = c.get("projectPath");
+  const migrationQuery = c.req.param("migration");
+  try {
+    const project = await detectPrismaProject(projectPath);
+    if (!project) return c.json({ success: false, error: "No Prisma project found" }, 404);
+    const match = project.migrations.find(
+      (m) => m.name === migrationQuery || m.name.startsWith(migrationQuery)
+    );
+    if (!match) return c.json({ success: false, error: "Migration not found" }, 404);
+    const sqlFile = path10.join(project.migrationsPath, match.name, "migration.sql");
+    const dbPath = project.provider === "sqlite" && project.databaseUrl ? project.databaseUrl.replace(/^file:/, "") : void 0;
+    const result = await simulate(match.name, sqlFile, dbPath);
+    return c.json({ success: true, data: result });
+  } catch (err) {
+    const message = err instanceof Error ? err.message : String(err);
+    return c.json({ success: false, error: message }, 500);
+  }
+});
+var simulate_default = app13;
+
+// src/server/routes/status.ts
+import { Hono as Hono14 } from "hono";
+var app14 = new Hono14();
+app14.get("/", async (c) => {
+  try {
+    const projectPath = c.get("projectPath");
+    const status = await getProjectStatus(projectPath);
+    return c.json({ success: true, data: status });
+  } catch (error) {
+    const message = error instanceof Error ? error.message : "Unknown error";
+    return c.json({ success: false, error: message }, 500);
+  }
+});
+var status_default = app14;
+
+// src/server/index.ts
+var __filename = fileURLToPath(import.meta.url);
+var __dirname = path11.dirname(__filename);
+function createServer(projectPath) {
+  const app15 = new Hono15();
+  const token = randomBytes(24).toString("hex");
+  app15.use("*", secureHeaders());
+  app15.use(
+    "*",
+    cors({
+      origin: (origin) => {
+        if (!origin) return null;
+        try {
+          const url = new URL(origin);
+          if (url.hostname === "localhost" || url.hostname === "127.0.0.1") return origin;
+        } catch {
+        }
+        return null;
+      },
+      allowMethods: ["GET", "POST", "OPTIONS"],
+      allowHeaders: ["Content-Type", "Authorization"]
+    })
+  );
+  app15.use("*", async (c, next) => {
+    c.set("requestId", randomBytes(8).toString("hex"));
+    c.res.headers.set("X-Request-Id", c.get("requestId"));
+    await next();
+  });
+  app15.use("*", async (c, next) => {
+    const started = Date.now();
+    await next();
+    logger.debug(
+      {
+        method: c.req.method,
+        path: new URL(c.req.url).pathname,
+        status: c.res.status,
+        durationMs: Date.now() - started,
+        requestId: c.get("requestId")
+      },
+      "HTTP request"
+    );
+  });
+  app15.use("/api/*", async (c, next) => {
+    const authHeader = c.req.header("Authorization") ?? "";
+    const queryToken = c.req.query("token") ?? "";
+    const provided = authHeader.startsWith("Bearer ") ? authHeader.slice(7) : queryToken;
+    if (provided !== token) {
+      return c.json({ success: false, error: "Unauthorized" }, 401);
+    }
+    return next();
+  });
+  app15.use("*", async (c, next) => {
+    c.set("projectPath", projectPath);
+    await next();
+  });
+  app15.route("/api/migrations", migrations_default);
+  app15.route("/api/status", status_default);
+  app15.route("/api/schema", schema_default);
+  app15.route("/api/drift", drift_default);
+  app15.route("/api/risks", risks_default);
+  app15.route("/api/rollback", rollback_default);
+  app15.route("/api/simulate", simulate_default);
+  app15.route("/api/repair", repair_default);
+  app15.route("/api/diff", diff_default);
+  app15.route("/api/compare", compare_default);
+  app15.route("/api/git", git_default);
+  app15.route("/api/audit", audit_default);
+  app15.route("/api/config", config_default);
+  app15.route("/api/events", events_default);
+  app15.get("/health", (c) => {
+    return c.json({
+      status: "ok",
+      service: "prisma-flow",
+      version: process.env.npm_package_version ?? "0.0.0",
+      uptime: process.uptime()
+    });
+  });
+  const candidates = [
+    path11.resolve(__dirname, "../public"),
+    // dist/public
+    path11.resolve(__dirname, "../../public"),
+    // packages/cli/public (source)
+    path11.resolve(__dirname, "../../..", "packages", "cli", "public"),
+    // monorepo relative
+    path11.resolve(process.cwd(), "public"),
+    // cwd public
+    path11.resolve(process.cwd(), "packages", "cli", "public"),
+    path11.resolve(process.cwd(), "..", "packages", "cli", "public")
+  ];
+  let publicDir = null;
+  for (const cand of candidates) {
+    if (fs12.existsSync(cand)) {
+      publicDir = cand;
+      break;
+    }
+  }
+  if (!publicDir) {
+    publicDir = path11.resolve(__dirname, "../public");
+  }
+  if (!fs12.existsSync(publicDir)) {
+    logger.warn({ publicDir }, "serveStatic: public directory not found");
+  }
+  app15.use(
+    "/*",
+    serveStatic({
+      root: publicDir,
+      rewriteRequestPath: (p) => p === "/" ? "/index.html" : p
+    })
+  );
+  app15.get("*", async (c) => {
+    try {
+      const indexPath = path11.join(publicDir, "index.html");
+      if (fs12.existsSync(indexPath)) {
+        const content = await fs12.promises.readFile(indexPath, "utf-8");
+        return c.html(content);
+      }
+      return c.text("Dashboard not built \u2014 run `npm run build` first", 404);
+    } catch {
+      return c.text("Error serving dashboard", 500);
+    }
+  });
+  return { app: app15, token };
+}
+function startServer(app15, port = 5555) {
+  const server = serve({ fetch: app15.fetch, port }, (info) => {
+    logger.info({ port: info.port }, "PrismaFlow API running");
+  });
+  const shutdown = () => {
+    logger.info("Shutting down PrismaFlow server...");
+    server.close(() => {
+      logger.info("Server closed");
+      process.exit(0);
+    });
+    setTimeout(() => process.exit(1), 5e3).unref();
+  };
+  process.once("SIGTERM", shutdown);
+  process.once("SIGINT", shutdown);
+  return server;
+}
+
+// src/commands/dashboard.ts
+function dashboardCommand() {
+  return new Command3("dashboard").description("Launch PrismaFlow dashboard").option("-p, --port <port>", "Port to run dashboard on").option("--no-open", "Do not open browser automatically").action(async (options) => {
+    const cwd = process.cwd();
+    try {
+      const config = await getConfig(cwd);
+      const project = await detectPrismaProject(cwd);
+      if (!project) {
+        console.error(chalk3.red("\u2716  No Prisma project found in the current directory."));
+        console.error(chalk3.dim("   Make sure prisma/schema.prisma exists."));
+        process.exit(1);
+      }
+      const port = options.port ? Number.parseInt(options.port, 10) : config.port ?? 5555;
+      const shouldOpen = options.open !== false && config.openBrowser;
+      const { app: app15, token } = createServer(cwd);
+      const url = `http://localhost:${port}?token=${token}`;
+      startServer(app15, port);
+      console.log();
+      console.log(chalk3.bold.cyan(" \u{1F680}  PrismaFlow Dashboard"));
+      console.log(chalk3.dim("\u2501".repeat(40)));
+      console.log(`  ${chalk3.bold("URL:")} ${chalk3.underline(url)}`);
+      console.log(`  ${chalk3.bold("Project:")} ${project.schemaPath}`);
+      if (project.provider) {
+        console.log(`  ${chalk3.bold("Provider:")} ${project.provider}`);
+      }
+      console.log();
+      console.log(chalk3.dim("  Press Ctrl+C to stop the server."));
+      console.log();
+      if (shouldOpen) {
+        await open(url);
+      }
+      await Promise.all([
+        writeAuditEntry(cwd, "dashboard.start", "success", { port }),
+        trackEvent("dashboard", project.migrations.length)
+      ]).catch(() => {
+      });
+    } catch (error) {
+      const message = error instanceof Error ? error.message : String(error);
+      console.error(chalk3.red(`\u2716  Failed to start dashboard: ${message}`));
+      process.exit(1);
+    }
+  });
+}
+
+// src/commands/diff.ts
+import chalk4 from "chalk";
+import { Command as Command4 } from "commander";
+function diffCommand() {
+  return new Command4("diff").description("Show schema diff between your Prisma schema and the live database").option("--from <url>", "Source database URL (defaults to DATABASE_URL)").option("--json", "Output as JSON").option("--breaking-only", "Show only breaking changes").action(
+    async (options) => {
+      const cwd = process.cwd();
+      try {
+        const project = await detectPrismaProject(cwd);
+        if (!project) {
+          console.error(chalk4.red("\u2716  No Prisma project found."));
+          process.exit(1);
+        }
+        const dbUrl = options.from ?? project.databaseUrl ?? process.env.DATABASE_URL;
+        if (!dbUrl) {
+          console.error(chalk4.red("\u2716  No database URL found."));
+          console.error(chalk4.dim("   Set DATABASE_URL or use --from <url>"));
+          process.exit(1);
+        }
+        if (!options.json) {
+          process.stdout.write(chalk4.dim("  Computing schema diff...\n"));
+        }
+        const { sql, diffs } = await diffSchemaVsDatabase(project.schemaPath, dbUrl, cwd);
+        const filtered = options.breakingOnly ? diffs.filter((d) => d.breaking) : diffs;
+        if (options.json) {
+          process.stdout.write(`${JSON.stringify({ diffs: filtered, sql }, null, 2)}
+`);
+          process.exit(0);
+        }
+        console.log();
+        console.log(chalk4.bold.cyan(" \u{1F4D0}  Schema Diff"));
+        console.log(chalk4.dim("\u2501".repeat(50)));
+        if (filtered.length === 0) {
+          console.log(chalk4.green("  \u2714  Schema is in sync with database \u2014 no differences found."));
+          console.log();
+          process.exit(0);
+        }
+        for (const diff of filtered) {
+          const icon = diff.breaking ? chalk4.red("\u2716") : chalk4.green("+");
+          const label = diff.breaking ? chalk4.red("BREAKING") : chalk4.green("safe");
+          const name = diff.modelName ? diff.fieldName ? `${diff.modelName}.${diff.fieldName}` : diff.modelName : diff.entity ?? "unknown";
+          console.log(`  ${icon} [${label}] ${chalk4.bold(name)}`);
+          console.log(`    ${chalk4.dim(diff.description)}`);
+          if (diff.oldType || diff.newType) {
+            console.log(
+              `    ${chalk4.dim(diff.oldType ?? "?")} \u2192 ${chalk4.dim(diff.newType ?? "?")}`
+            );
+          }
+        }
+        const breaking = filtered.filter((d) => d.breaking).length;
+        console.log();
+        console.log(
+          chalk4.dim(
+            `  ${filtered.length} difference(s) found \u2014 ${breaking} breaking, ${filtered.length - breaking} safe`
+          )
+        );
+        console.log();
+        await Promise.all([
+          writeAuditEntry(cwd, "schema.diff", "success", {
+            diffs: filtered.length,
+            breaking
+          }),
+          trackEvent("diff", filtered.length)
+        ]).catch(() => {
+        });
+        process.exit(breaking > 0 ? 2 : 0);
+      } catch (err) {
+        const message = err instanceof Error ? err.message : String(err);
+        console.error(chalk4.red(`\u2716  ${message}`));
+        process.exit(1);
+      }
+    }
+  );
+}
+
+// src/commands/doctor.ts
+import { execFile as execFile4 } from "child_process";
+import fs13 from "fs/promises";
+import path12 from "path";
+import { promisify as promisify4 } from "util";
+import chalk5 from "chalk";
+import { Command as Command5 } from "commander";
+var execFileAsync2 = promisify4(execFile4);
+async function runChecks(checks) {
+  let passed = 0;
+  let failed = 0;
+  for (const check of checks) {
+    process.stdout.write(`  ${chalk5.gray("\u2022")} ${check.label} ... `);
+    try {
+      const { ok, detail } = await check.run();
+      if (ok) {
+        process.stdout.write(`${chalk5.green("OK") + (detail ? chalk5.gray(` (${detail})`) : "")}
+`);
+        passed++;
+      } else {
+        process.stdout.write(`${chalk5.red("FAIL") + (detail ? chalk5.gray(` \u2014 ${detail}`) : "")}
+`);
+        failed++;
+      }
+    } catch (err) {
+      const msg = err instanceof Error ? err.message : String(err);
+      process.stdout.write(`${chalk5.red("ERROR") + chalk5.gray(` \u2014 ${msg}`)}
+`);
+      failed++;
+    }
+  }
+  return { passed, failed };
+}
+function doctorCommand() {
+  return new Command5("doctor").description("Validate the environment and project setup").option("--json", "Output result as JSON").action(async (options) => {
+    const cwd = process.cwd();
+    let totalPassed = 0;
+    let totalFailed = 0;
+    const merge = (r) => {
+      totalPassed += r.passed;
+      totalFailed += r.failed;
+    };
+    if (!options.json) {
+      console.log();
+      console.log(chalk5.bold.cyan(" \u{1FA7A}  PrismaFlow Doctor"));
+      console.log(chalk5.dim("\u2501".repeat(50)));
+      console.log(chalk5.dim("  Checking environment..."));
+    }
+    merge(
+      await runChecks([
+        {
+          label: "Node.js version \u2265 20",
+          run: async () => {
+            const [major] = process.versions.node.split(".").map(Number);
+            return { ok: (major ?? 0) >= 20, detail: process.versions.node };
+          }
+        },
+        {
+          label: "prisma CLI available",
+          run: async () => {
+            const { stdout } = await execPrisma(cwd, ["--version"], {
+              timeout: 15e3
+            });
+            const version = stdout.match(/prisma\s+:\s+([\d.]+)/i)?.[1] ?? stdout.trim().split("\n")[0];
+            return { ok: true, detail: version ?? "unknown" };
+          }
+        }
+      ])
+    );
+    const project = await detectPrismaProject(cwd);
+    merge(
+      await runChecks([
+        {
+          label: "prisma schema found",
+          run: async () => ({
+            ok: project !== null,
+            detail: project ? path12.relative(cwd, project.schemaPath) : "not found"
+          })
+        },
+        {
+          label: "DATABASE_URL configured",
+          run: async () => ({
+            ok: Boolean(project?.databaseUrl || process.env.DATABASE_URL),
+            detail: project?.databaseUrl || process.env.DATABASE_URL ? "set" : "not found in .env or environment"
+          })
+        },
+        {
+          label: "migrations directory exists",
+          run: async () => {
+            if (!project) return { ok: false, detail: "no project" };
+            try {
+              await fs13.access(project.migrationsPath);
+              return {
+                ok: true,
+                detail: `${project.migrations.length} migration(s)`
+              };
+            } catch {
+              return {
+                ok: false,
+                detail: `${project.migrationsPath} not found`
+              };
+            }
+          }
+        },
+        {
+          label: "database provider detected",
+          run: async () => ({
+            ok: project?.provider !== null && project?.provider !== void 0,
+            detail: project?.provider ?? "unknown \u2014 check datasource block"
+          })
+        },
+        {
+          label: "prismaflow.config.ts present",
+          run: async () => {
+            const configCandidates = [
+              path12.join(cwd, "prismaflow.config.ts"),
+              path12.join(cwd, "prismaflow.config.js"),
+              path12.join(cwd, "prismaflow.config.mjs")
+            ];
+            for (const c of configCandidates) {
+              try {
+                await fs13.access(c);
+                return { ok: true, detail: path12.relative(cwd, c) };
+              } catch {
+              }
+            }
+            return { ok: false, detail: "not found \u2014 run: prisma-flow init" };
+          }
+        },
+        {
+          label: "git repository detected",
+          run: async () => {
+            try {
+              await execFileAsync2("git", ["rev-parse", "--git-dir"], {
+                cwd,
+                timeout: 5e3
+              });
+              const { stdout } = await execFileAsync2(
+                "git",
+                ["rev-parse", "--abbrev-ref", "HEAD"],
+                {
+                  cwd,
+                  timeout: 5e3
+                }
+              );
+              return { ok: true, detail: `branch: ${stdout.trim()}` };
+            } catch {
+              return {
+                ok: false,
+                detail: "not a git repo \u2014 git-awareness features unavailable"
+              };
+            }
+          }
+        }
+      ])
+    );
+    if (project) {
+      merge(
+        await runChecks([
+          {
+            label: "database reachable",
+            run: async () => {
+              try {
+                await execPrisma(cwd, ["migrate", "status", "--schema", project.schemaPath], {
+                  timeout: 2e4
+                });
+                return { ok: true, detail: "all migrations applied" };
+              } catch (err) {
+                const error = err;
+                const stderr = error.stderr ?? "";
+                const stdout = error.stdout ?? "";
+                if (stderr.includes("P1001") || stderr.includes("Can't reach database server") || stderr.includes("Connection refused")) {
+                  return {
+                    ok: false,
+                    detail: "database unreachable (P1001)"
+                  };
+                }
+                const pending = stdout.match(/have not yet been applied/i);
+                return {
+                  ok: true,
+                  detail: pending ? "connected \u2014 pending migrations exist" : "connected"
+                };
+              }
+            }
+          }
+        ])
+      );
+    } else if (!options.json) {
+      console.log(chalk5.dim("  Skipping database checks \u2014 no Prisma project found"));
+    }
+    const allOk = totalFailed === 0;
+    if (options.json) {
+      process.stdout.write(
+        `${JSON.stringify({ ok: allOk, passed: totalPassed, failed: totalFailed })}
+`
+      );
+    } else {
+      console.log(chalk5.dim("\u2501".repeat(50)));
+      if (allOk) {
+        console.log(
+          chalk5.bold.green(` \u2714  All ${totalPassed} checks passed \u2014 environment healthy`)
+        );
+      } else {
+        console.log(
+          chalk5.bold.red(` \u2716  ${totalFailed} check${totalFailed !== 1 ? "s" : ""} failed`) + chalk5.dim(` (${totalPassed} passed)`)
+        );
+      }
+      console.log();
+    }
+    await Promise.all([
+      writeAuditEntry(cwd, "doctor.run", allOk ? "success" : "warning", {
+        passed: totalPassed,
+        failed: totalFailed
+      }),
+      trackEvent("doctor", project?.migrations.length ?? 0)
+    ]).catch(() => {
+    });
+    process.exit(allOk ? 0 : 1);
+  });
+}
+
+// src/commands/history.ts
+import chalk6 from "chalk";
+import { Command as Command6 } from "commander";
+function historyCommand() {
+  return new Command6("history").description("Show migration history with risk and git metadata").option("--limit <n>", "Show last N migrations", "20").option("--json", "Output as JSON").option("--git", "Include git information (slower)").action(async (options) => {
+    const cwd = process.cwd();
+    try {
+      const project = await detectPrismaProject(cwd);
+      if (!project) {
+        console.error(chalk6.red("\u2716  No Prisma project found."));
+        process.exit(1);
+      }
+      const limit = Number.parseInt(options.limit ?? "20", 10);
+      const all = await getMigrations(cwd);
+      const migrations = all.slice(-limit).reverse();
+      const gitInfo = /* @__PURE__ */ new Map();
+      if (options.git) {
+        const inRepo = await isGitRepo(cwd);
+        if (inRepo) {
+          const raw = await getGitMigrationInfo(project.migrationsPath, cwd);
+          for (const info of raw) {
+            gitInfo.set(info.migrationName, info);
+          }
+        }
+      }
+      if (options.json) {
+        const output = migrations.map((m) => ({
+          ...m,
+          git: gitInfo.get(m.name)
+        }));
+        process.stdout.write(`${JSON.stringify(output, null, 2)}
+`);
+        process.exit(0);
+      }
+      console.log();
+      console.log(chalk6.bold.cyan(` \u{1F4DC}  Migration History (last ${limit})`));
+      console.log(chalk6.dim("\u2501".repeat(65)));
+      for (const m of migrations) {
+        const status = m.status ?? "applied";
+        const statusColor = status === "applied" ? chalk6.green : status === "pending" ? chalk6.yellow : status === "failed" ? chalk6.red : chalk6.gray;
+        const riskLabel = m.riskScore ? m.riskScore.level === "critical" || m.riskScore.level === "high" ? chalk6.red(`[${m.riskScore.level}]`) : m.riskScore.level === "medium" ? chalk6.yellow(`[${m.riskScore.level}]`) : chalk6.dim(`[${m.riskScore.level}]`) : "";
+        console.log(`  ${statusColor("\u25CF")} ${chalk6.bold(m.name)} ${riskLabel}`);
+        console.log(
+          `    ${chalk6.dim("Applied:")} ${m.appliedAt ?? m.timestamp}  ${chalk6.dim("Status:")} ${statusColor(status)}`
+        );
+        if (options.git) {
+          const git2 = gitInfo.get(m.name);
+          if (git2?.committed) {
+            console.log(
+              `    ${chalk6.dim("Author:")}  ${git2.commitAuthor ?? "unknown"}  ${chalk6.dim("Commit:")} ${git2.commitHash?.slice(0, 8) ?? "-"}`
+            );
+            if (git2.commitMessage) {
+              console.log(`    ${chalk6.dim("Message:")} ${git2.commitMessage}`);
+            }
+          } else if (git2) {
+            console.log(`    ${chalk6.yellow("\u26A0")} Not committed to git`);
+          }
+        }
+      }
+      console.log();
+      console.log(chalk6.dim(`  Showing ${migrations.length} of ${all.length} total migrations`));
+      console.log();
+      await Promise.all([
+        writeAuditEntry(cwd, "migration.history", "success", {
+          count: migrations.length
+        }),
+        trackEvent("history", migrations.length)
+      ]).catch(() => {
+      });
+      process.exit(0);
+    } catch (err) {
+      const message = err instanceof Error ? err.message : String(err);
+      console.error(chalk6.red(`\u2716  ${message}`));
+      process.exit(1);
+    }
+  });
+}
+
+// src/commands/init.ts
+import fs14 from "fs/promises";
+import path13 from "path";
+import chalk7 from "chalk";
+import { Command as Command7 } from "commander";
+var CONFIG_TEMPLATE = `import type { PrismaFlowConfig } from 'prisma-flow'
+
+const config: PrismaFlowConfig = {
+  /**
+   * Port for the local dashboard server.
+   * Can also be set via PRISMAFLOW_PORT env var.
+   */
+  port: 5555,
+
+  /**
+   * Log level: 'trace' | 'debug' | 'info' | 'warn' | 'error'
+   * Can also be set via PRISMAFLOW_LOG_LEVEL env var.
+   */
+  logLevel: 'info',
+
+  /**
+   * Automatically open the browser when the dashboard starts.
+   */
+  openBrowser: true,
+
+  /**
+   * V1 local-first feature flags. Core safety features are free.
+   */
+  features: {
+    riskAnalysis:  true,
+    simulation:    true,
+    ciAnnotations: true,
+  },
+
+  /**
+   * Named environments are reserved for the roadmap.
+   * environments: [
+   *   { name: 'staging',    databaseUrl: process.env.STAGING_DATABASE_URL! },
+   *   { name: 'production', databaseUrl: process.env.PROD_DATABASE_URL! },
+   * ],
+   */
+  environments: [],
+
+  /**
+   * Risk level that triggers warnings in CI output.
+   * One of: 'low' | 'medium' | 'high' | 'critical'
+   */
+  riskThreshold: 'medium',
+}
+
+export default config
+`;
+function initCommand() {
+  return new Command7("init").description("Create a prismaflow.config.ts in the current project").option("-f, --force", "Overwrite existing config file").action(async (options) => {
+    const cwd = process.cwd();
+    const dest = path13.join(cwd, "prismaflow.config.ts");
+    try {
+      await fs14.access(dest);
+      if (!options.force) {
+        console.log(chalk7.yellow("\u26A0  prismaflow.config.ts already exists."));
+        console.log(chalk7.dim("   Use --force to overwrite: prisma-flow init --force"));
+        process.exit(0);
+      }
+      await fs14.writeFile(dest, CONFIG_TEMPLATE, "utf-8");
+      console.log(chalk7.green("\u2714  prismaflow.config.ts overwritten."));
+    } catch {
+      try {
+        await fs14.writeFile(dest, CONFIG_TEMPLATE, "utf-8");
+        console.log(chalk7.green("\u2714  Created prismaflow.config.ts"));
+        console.log(chalk7.dim("   Edit it to customise PrismaFlow for your project."));
+        console.log();
+        console.log(chalk7.dim("   Next steps:"));
+        console.log(chalk7.dim("     1. Confirm DATABASE_URL is set"));
+        console.log(chalk7.dim("     2. Run: prisma-flow doctor"));
+        console.log(chalk7.dim("     3. Run: prisma-flow dashboard"));
+      } catch (writeErr) {
+        const message = writeErr instanceof Error ? writeErr.message : String(writeErr);
+        console.error(chalk7.red(`\u2716  Failed to write config: ${message}`));
+        process.exit(4);
+      }
+    }
+    await trackEvent("init", 0).catch(() => {
+    });
+  });
+}
+
+// src/commands/inspect.ts
+import fs15 from "fs/promises";
+import path14 from "path";
+import chalk8 from "chalk";
+import { Command as Command8 } from "commander";
+function inspectCommand() {
+  return new Command8("inspect").description("Show detailed information about a specific migration").argument("<migration>", "Migration name or timestamp prefix").option("--json", "Output as JSON").option("--sql", "Print migration SQL").option("--rollback", "Generate and show rollback plan").action(
+    async (migrationQuery, options) => {
+      const cwd = process.cwd();
+      try {
+        const project = await detectPrismaProject(cwd);
+        if (!project) {
+          console.error(chalk8.red("\u2716  No Prisma project found."));
+          process.exit(1);
+        }
+        const match = project.migrations.find(
+          (m) => m.name === migrationQuery || m.name.startsWith(migrationQuery) || m.timestamp.startsWith(migrationQuery)
+        );
+        if (!match) {
+          console.error(chalk8.red(`\u2716  Migration "${migrationQuery}" not found.`));
+          console.error(
+            chalk8.dim(`   Available: ${project.migrations.map((m) => m.name).join(", ")}`)
+          );
+          process.exit(1);
+        }
+        const sqlFile = path14.join(project.migrationsPath, match.name, "migration.sql");
+        let sql = "";
+        try {
+          sql = await fs15.readFile(sqlFile, "utf-8");
+        } catch {
+          sql = "-- SQL file not found";
+        }
+        const statements = splitStatements(sql);
+        const riskScore = scoreMigrationRisk(sql);
+        const simulation = analyseStatically(match.name, statements);
+        let rollbackPlan = null;
+        if (options.rollback) {
+          rollbackPlan = await generateRollbackPlan(match.name, sqlFile);
+        }
+        if (options.json) {
+          process.stdout.write(
+            `${JSON.stringify({ migration: match, riskScore, simulation, rollbackPlan }, null, 2)}
+`
+          );
+          process.exit(0);
+        }
+        const riskColor = riskScore.level === "critical" ? chalk8.red : riskScore.level === "high" ? chalk8.yellow : riskScore.level === "medium" ? chalk8.cyan : chalk8.green;
+        console.log();
+        console.log(chalk8.bold.cyan(` \u{1F50D}  Migration: ${match.name}`));
+        console.log(chalk8.dim("\u2501".repeat(60)));
+        console.log(`  ${chalk8.bold("Status:")}    ${chalk8.green(match.status ?? "applied")}`);
+        console.log(`  ${chalk8.bold("Applied:")}   ${match.appliedAt ?? match.timestamp}`);
+        console.log(
+          `  ${chalk8.bold("Risk:")}      ${riskColor(riskScore.level.toUpperCase())} (score: ${riskScore.score})`
+        );
+        console.log(`  ${chalk8.bold("Statements:")} ${statements.length}`);
+        if (riskScore.factors && riskScore.factors.length > 0) {
+          console.log();
+          console.log(chalk8.bold("  Risk Factors:"));
+          for (const f of riskScore.factors) {
+            console.log(`    ${chalk8.red("\u2022")} ${f.description} ${chalk8.dim(`[${f.severity}]`)}`);
+          }
+        }
+        if (simulation.warnings.length > 0) {
+          console.log();
+          console.log(chalk8.bold("  Warnings:"));
+          for (const w of simulation.warnings) {
+            console.log(`    ${chalk8.yellow("\u26A0")} ${w}`);
+          }
+        }
+        if (options.sql) {
+          console.log();
+          console.log(chalk8.bold("  SQL:"));
+          console.log(chalk8.dim(`  ${"\u2500".repeat(56)}`));
+          console.log(
+            sql.split("\n").map((l) => `  ${chalk8.gray(l)}`).join("\n")
+          );
+        }
+        if (rollbackPlan) {
+          console.log();
+          console.log(chalk8.bold("  Rollback Plan:"));
+          const auto = rollbackPlan.steps.filter((s) => s.automated).length;
+          const manual = rollbackPlan.steps.filter((s) => !s.automated).length;
+          console.log(
+            `    ${chalk8.green(`${auto} automated`)} / ${chalk8.yellow(`${manual} manual`)} steps`
+          );
+          if (rollbackPlan.warnings.length > 0) {
+            for (const w of rollbackPlan.warnings) {
+              console.log(`    ${chalk8.yellow("\u26A0")} ${w}`);
+            }
+          }
+        }
+        console.log();
+        await Promise.all([
+          writeAuditEntry(cwd, "migration.inspect", "success", {
+            migration: match.name
+          }),
+          trackEvent("inspect", 1)
+        ]).catch(() => {
+        });
+      } catch (err) {
+        const message = err instanceof Error ? err.message : String(err);
+        console.error(chalk8.red(`\u2716  ${message}`));
+        process.exit(1);
+      }
+    }
+  );
+}
+
+// src/commands/repair.ts
+import chalk9 from "chalk";
+import { Command as Command9 } from "commander";
+function repairCommand() {
+  return new Command9("repair").description("Detect drift and generate (or apply) repair suggestions").option("--apply", "Auto-apply safe repair steps (APPLY_MIGRATION only)").option("--json", "Output as JSON").action(async (options) => {
+    const cwd = process.cwd();
+    try {
+      const project = await detectPrismaProject(cwd);
+      if (!project) {
+        console.error(chalk9.red("\u2716  No Prisma project found."));
+        process.exit(1);
+      }
+      if (!options.json) {
+        process.stdout.write(chalk9.dim("  Detecting drift...\n"));
+      }
+      const driftResult = await detectDrift(cwd);
+      if (driftResult.status === "error") {
+        if (options.json) {
+          process.stdout.write(
+            `${JSON.stringify({ ok: false, error: driftResult.errorMessage })}
+`
+          );
+        } else {
+          console.error(chalk9.red(`\u2716  Drift detection failed: ${driftResult.errorMessage}`));
+        }
+        process.exit(1);
+      }
+      if (driftResult.status === "clean" || driftResult.items.length === 0) {
+        if (options.json) {
+          process.stdout.write(
+            `${JSON.stringify({ ok: true, drifted: false, suggestions: [] })}
+`
+          );
+        } else {
+          console.log(chalk9.green("  \u2714  No drift detected \u2014 database is in sync."));
+        }
+        process.exit(0);
+      }
+      const suggestions = generateRepairSuggestions(driftResult.items, project.migrationsPath);
+      if (options.json) {
+        process.stdout.write(
+          `${JSON.stringify({ ok: true, drifted: true, suggestions }, null, 2)}
+`
+        );
+        if (options.apply) {
+          const results = await applyRepairs(suggestions, project.schemaPath, cwd);
+          const out = JSON.stringify({ applied: results }, null, 2);
+          process.stdout.write(`${out}
+`);
+        }
+        process.exit(0);
+      }
+      console.log();
+      console.log(chalk9.bold.cyan(" \u{1F527}  Drift Repair"));
+      console.log(chalk9.dim("\u2501".repeat(50)));
+      console.log(
+        `  ${chalk9.bold("Drift items found:")} ${chalk9.yellow(driftResult.items.length.toString())}`
+      );
+      console.log();
+      for (const suggestion of suggestions) {
+        const riskColor = suggestion.risk === "high" ? chalk9.red : suggestion.risk === "medium" ? chalk9.yellow : chalk9.green;
+        console.log(
+          `  ${riskColor("\u25CF")} [${riskColor(suggestion.risk.toUpperCase())}] ${suggestion.description}`
+        );
+        console.log(
+          `     Strategy: ${chalk9.cyan(suggestion.strategy)} (${suggestion.automated ? chalk9.green("automated") : chalk9.yellow("manual")})`
+        );
+        if (suggestion.sql) {
+          console.log(chalk9.dim(`     ${suggestion.sql.split("\n")[0]}`));
+        }
+      }
+      if (options.apply) {
+        console.log();
+        console.log(chalk9.bold("  Applying auto-repair steps..."));
+        const results = await applyRepairs(suggestions, project.schemaPath, cwd);
+        for (const r of results) {
+          console.log(
+            `    ${r.success ? chalk9.green("\u2713") : chalk9.red("\u2716")} ${r.migrationName}${r.error ? chalk9.dim(` \u2014 ${r.error}`) : ""}`
+          );
+        }
+      } else {
+        console.log();
+        console.log(chalk9.dim("  To auto-apply safe repairs: prisma-flow repair --apply"));
+      }
+      console.log();
+      await Promise.all([
+        writeAuditEntry(cwd, "drift.repair", "success", {
+          items: driftResult.items.length,
+          applied: options.apply
+        }),
+        trackEvent("repair", driftResult.items.length)
+      ]).catch(() => {
+      });
+      process.exit(driftResult.items.length > 0 && !options.apply ? 2 : 0);
+    } catch (err) {
+      const message = err instanceof Error ? err.message : String(err);
+      console.error(chalk9.red(`\u2716  ${message}`));
+      process.exit(1);
+    }
+  });
+}
+
+// src/commands/report.ts
+import fs16 from "fs/promises";
+import path15 from "path";
+import chalk10 from "chalk";
+import { Command as Command10 } from "commander";
+function formatDate(value) {
+  if (!value) return "Not recorded";
+  const date = new Date(value);
+  if (Number.isNaN(date.getTime())) return value;
+  return date.toISOString();
+}
+function formatDuration(ms) {
+  if (ms === void 0) return "Not recorded";
+  if (ms < 1e3) return `${ms}ms`;
+  return `${(ms / 1e3).toFixed(1)}s`;
+}
+function uniqueRecommendations(factors) {
+  return Array.from(new Set(factors.map((factor) => factor.recommendation)));
+}
+function buildRecommendations(status, migrations, driftCount) {
+  const readinessActions = status.deploymentReadiness.checks.filter((check) => !check.passed).map((check) => `${check.label}: ${check.message}`);
+  const topRiskFactors = migrations.flatMap((migration) => migration.riskScore.factors).filter((factor) => factor.severity === "high" || factor.severity === "critical");
+  const recommendations = [
+    ...readinessActions,
+    ...uniqueRecommendations(topRiskFactors),
+    ...driftCount > 0 ? ["Review drift details and reconcile the Prisma schema before deployment."] : []
+  ];
+  return recommendations.length > 0 ? recommendations : ["No blocking issues detected. Keep reviewing generated SQL before production deploys."];
+}
+function renderMarkdown(report) {
+  const lines = [
+    "# PrismaFlow Report",
+    "",
+    `Generated: ${report.generatedAt}`,
+    "",
+    "## Project",
+    "",
+    `- Schema: ${report.project.schemaPath}`,
+    `- Migrations: ${report.project.migrationsPath}`,
+    `- Provider: ${report.project.provider ?? "unknown"}`,
+    `- Prisma version: ${report.project.prismaVersion ?? "unknown"}`,
+    `- Package manager: ${report.project.packageManager ?? "unknown"}`,
+    `- DATABASE_URL detected: ${report.project.hasDatabaseUrl ? "yes" : "no"}`,
+    "",
+    "## Summary",
+    "",
+    `- Database connected: ${report.summary.connected ? "yes" : "no"}`,
+    `- Applied migrations: ${report.summary.migrationsApplied}`,
+    `- Pending migrations: ${report.summary.migrationsPending}`,
+    `- Failed migrations: ${report.summary.migrationsFailed}`,
+    `- Drift: ${report.summary.driftDetected ? `${report.summary.driftCount} item(s)` : "none"}`,
+    `- Risk level: ${report.summary.riskLevel}`,
+    `- Health score: ${report.summary.healthScore}/100`,
+    `- Deployment readiness: ${report.readiness.summary} (${report.readiness.score}/100)`,
+    "",
+    "## Readiness Checks",
+    "",
+    "| Check | Status | Message |",
+    "| --- | --- | --- |",
+    ...report.readiness.checks.map(
+      (check) => `| ${check.label} | ${check.passed ? "pass" : "fail"} | ${check.message} |`
+    ),
+    "",
+    "## Migration Timeline",
+    "",
+    "| Migration | Status | Created | Applied | Duration | Risk |",
+    "| --- | --- | --- | --- | --- | --- |",
+    ...report.migrations.map(
+      (migration) => `| ${migration.name} | ${migration.status} | ${formatDate(migration.createdAt)} | ${formatDate(
+        migration.appliedAt
+      )} | ${formatDuration(migration.durationMs)} | ${migration.riskScore.level} (${migration.riskScore.score}) |`
+    ),
+    "",
+    "## Drift",
+    ""
+  ];
+  if (report.drift.items.length === 0) {
+    lines.push("No drift detected.");
+  } else {
+    for (const item of report.drift.items) {
+      lines.push(`- ${item.type}: ${item.description}`);
+    }
+  }
+  lines.push("", "## Recommendations", "");
+  for (const recommendation of report.recommendations) {
+    lines.push(`- ${recommendation}`);
+  }
+  return `${lines.join("\n")}
+`;
+}
+async function writeReport(content, outputPath) {
+  if (!outputPath) {
+    process.stdout.write(content);
+    return null;
+  }
+  const resolved = path15.resolve(process.cwd(), outputPath);
+  await fs16.mkdir(path15.dirname(resolved), { recursive: true });
+  await fs16.writeFile(resolved, content, "utf-8");
+  return resolved;
+}
+function normalizeFormat(format, json) {
+  if (json) return "json";
+  if (format === "md" || format === "markdown") return "markdown";
+  return "json";
+}
+function reportCommand() {
+  return new Command10("report").description("Generate a local PrismaFlow report for review or CI artifacts").option("--format <format>", "Output format: json or markdown", "json").option("--json", "Shortcut for --format json").option("-o, --output <path>", "Write the report to a file instead of stdout").action(async (options) => {
+    const cwd = process.cwd();
+    const format = normalizeFormat(options.format, options.json);
+    try {
+      const project = await detectPrismaProject(cwd);
+      if (!project) {
+        process.stderr.write(`${chalk10.red("\u2716 No Prisma project found.")}
+`);
+        process.exit(4);
+      }
+      const [status, migrations, drift] = await Promise.all([
+        getProjectStatus(cwd),
+        getMigrations(cwd),
+        detectDrift(cwd)
+      ]);
+      const reportMigrations = migrations.map((migration) => ({
+        name: migration.name,
+        status: migration.status,
+        ...migration.createdAt ? { createdAt: migration.createdAt } : {},
+        ...migration.appliedAt ? { appliedAt: migration.appliedAt } : {},
+        ...migration.durationMs !== void 0 ? { durationMs: migration.durationMs } : {},
+        riskScore: migration.riskScore
+      }));
+      const report = {
+        schemaVersion: "prismaflow-report/v1",
+        generatedAt: (/* @__PURE__ */ new Date()).toISOString(),
+        project: {
+          schemaPath: project.schemaPath,
+          migrationsPath: project.migrationsPath,
+          ...project.provider ? { provider: project.provider } : {},
+          ...project.prismaVersion ? { prismaVersion: project.prismaVersion } : {},
+          ...project.packageManager ? { packageManager: project.packageManager } : {},
+          hasDatabaseUrl: project.databaseUrl.length > 0
+        },
+        summary: {
+          connected: status.connected,
+          migrationsApplied: status.migrationsApplied,
+          migrationsPending: status.migrationsPending,
+          migrationsFailed: status.migrationsFailed,
+          driftDetected: status.driftDetected,
+          driftCount: status.driftCount,
+          riskLevel: status.riskLevel,
+          healthScore: status.healthScore
+        },
+        readiness: status.deploymentReadiness,
+        migrations: reportMigrations,
+        drift: {
+          status: drift.status,
+          driftCount: drift.items.length,
+          items: drift.items.map((item) => ({
+            type: item.type,
+            description: item.description,
+            ...item.identifier ? { identifier: item.identifier } : {},
+            ...item.migrationName ? { migrationName: item.migrationName } : {},
+            sql: item.sql
+          })),
+          ...drift.errorMessage ? { errorMessage: drift.errorMessage } : {}
+        },
+        recommendations: buildRecommendations(status, reportMigrations, drift.items.length)
+      };
+      const content = format === "markdown" ? renderMarkdown(report) : `${JSON.stringify(report, null, 2)}
+`;
+      const writtenPath = await writeReport(content, options.output);
+      if (writtenPath) {
+        process.stdout.write(`${chalk10.green("\u2714 Report written:")} ${writtenPath}
+`);
+      }
+    } catch (error) {
+      const message = error instanceof Error ? error.message : String(error);
+      process.stderr.write(`${chalk10.red(`\u2716 Report failed: ${message}`)}
+`);
+      process.exit(4);
+    }
+  });
+}
+
+// src/commands/rollback.ts
+import path16 from "path";
+import chalk11 from "chalk";
+import { Command as Command11 } from "commander";
+function rollbackCommand() {
+  return new Command11("rollback").description("Generate a rollback plan for a migration").argument("<migration>", "Migration name or timestamp prefix").option("--json", "Output as JSON").option("--print-sql", "Print the rollback SQL to stdout").option("--include-manual", "Include manual-only steps in SQL output", true).action(
+    async (migrationQuery, options) => {
+      const cwd = process.cwd();
+      try {
+        const project = await detectPrismaProject(cwd);
+        if (!project) {
+          console.error(chalk11.red("\u2716  No Prisma project found."));
+          process.exit(1);
+        }
+        const match = project.migrations.find(
+          (m) => m.name === migrationQuery || m.name.startsWith(migrationQuery) || m.timestamp.startsWith(migrationQuery)
+        );
+        if (!match) {
+          console.error(chalk11.red(`\u2716  Migration "${migrationQuery}" not found.`));
+          process.exit(1);
+        }
+        const sqlFile = path16.join(project.migrationsPath, match.name, "migration.sql");
+        const plan = await generateRollbackPlan(match.name, sqlFile);
+        if (options.json) {
+          process.stdout.write(`${JSON.stringify(plan, null, 2)}
+`);
+          process.exit(0);
+        }
+        if (options.printSql) {
+          process.stdout.write(`${renderRollbackSql(plan, options.includeManual !== false)}
+`);
+          process.exit(0);
+        }
+        const autoCount = plan.steps.filter((s) => s.automated).length;
+        const manualCount = plan.steps.filter((s) => !s.automated).length;
+        console.log();
+        console.log(chalk11.bold.cyan(` \u21A9  Rollback Plan: ${match.name}`));
+        console.log(chalk11.dim("\u2501".repeat(60)));
+        console.log(
+          `  ${chalk11.bold("Steps:")} ${autoCount} automated, ${manualCount > 0 ? chalk11.yellow(`${manualCount} manual`) : chalk11.green("0 manual")}`
+        );
+        console.log(
+          `  ${chalk11.bold("Fully automated:")} ${plan.automated ? chalk11.green("Yes") : chalk11.yellow("No \u2014 manual review required")}`
+        );
+        console.log();
+        for (let i = 0; i < plan.steps.length; i++) {
+          const step = plan.steps[i];
+          const icon = step.automated ? chalk11.green("\u2713") : chalk11.yellow("\u26A0");
+          const label = step.automated ? chalk11.dim("[auto]") : chalk11.yellow("[manual]");
+          console.log(`  ${icon} Step ${i + 1} ${label}`);
+          console.log(`    ${chalk11.dim("Forward:")}  ${step.forwardSql.slice(0, 60)}`);
+          console.log(`    ${chalk11.dim("Rollback:")} ${step.rollbackSql.slice(0, 60)}`);
+          if (step.warning) {
+            console.log(`    ${chalk11.yellow("\u26A0")} ${step.warning}`);
+          }
+        }
+        if (plan.warnings.length > 0) {
+          console.log();
+          console.log(chalk11.bold("  Warnings:"));
+          for (const w of plan.warnings) {
+            console.log(`    ${chalk11.yellow("\u26A0")} ${w}`);
+          }
+        }
+        console.log();
+        console.log(chalk11.dim("  To generate rollback SQL:"));
+        console.log(chalk11.dim(`    prisma-flow rollback ${match.name} --print-sql`));
+        console.log();
+        await Promise.all([
+          writeAuditEntry(cwd, "migration.rollback", "success", {
+            migration: match.name
+          }),
+          trackEvent("rollback", plan.steps.length)
+        ]).catch(() => {
+        });
+        process.exit(plan.hasManualSteps ? 1 : 0);
+      } catch (err) {
+        const message = err instanceof Error ? err.message : String(err);
+        console.error(chalk11.red(`\u2716  ${message}`));
+        process.exit(1);
+      }
+    }
+  );
+}
+
+// src/commands/simulate.ts
+import path17 from "path";
+import chalk12 from "chalk";
+import { Command as Command12 } from "commander";
+function simulateCommand() {
+  return new Command12("simulate").description("Dry-run a migration to preview its effect without applying it").argument("<migration>", "Migration name or timestamp prefix").option("--json", "Output as JSON").option("--fail-on-destructive", "Exit with code 2 if destructive statements are found").action(
+    async (migrationQuery, options) => {
+      const cwd = process.cwd();
+      try {
+        const project = await detectPrismaProject(cwd);
+        if (!project) {
+          console.error(chalk12.red("\u2716  No Prisma project found."));
+          process.exit(1);
+        }
+        const match = project.migrations.find(
+          (m) => m.name === migrationQuery || m.name.startsWith(migrationQuery) || m.timestamp.startsWith(migrationQuery)
+        );
+        if (!match) {
+          console.error(chalk12.red(`\u2716  Migration "${migrationQuery}" not found.`));
+          process.exit(1);
+        }
+        const sqlFile = path17.join(project.migrationsPath, match.name, "migration.sql");
+        const dbPath = project.provider === "sqlite" && project.databaseUrl ? project.databaseUrl.replace(/^file:/, "") : void 0;
+        const result = await simulate(match.name, sqlFile, dbPath);
+        if (options.json) {
+          process.stdout.write(`${JSON.stringify(result, null, 2)}
+`);
+          process.exit(0);
+        }
+        console.log();
+        console.log(chalk12.bold.cyan(` \u{1F52C}  Simulation: ${match.name}`));
+        console.log(chalk12.dim("\u2501".repeat(60)));
+        console.log(`  ${chalk12.bold("Mode:")}   ${result.mode}`);
+        console.log(
+          `  ${chalk12.bold("Result:")} ${result.wouldSucceed ? chalk12.green("Would succeed") : chalk12.red("Would fail")}`
+        );
+        console.log(
+          `  ${chalk12.bold("Statements:")} ${result.statements.length} (${result.destructiveStatements} destructive)`
+        );
+        console.log();
+        for (const stmt of result.statements) {
+          const icon = stmt.isDestructive ? chalk12.red("\u26A0") : chalk12.green("\u2713");
+          const typeLabel = chalk12.dim(`[${stmt.type}]`);
+          const preview = stmt.sql.slice(0, 70).replace(/\n/g, " ");
+          console.log(
+            `  ${icon} ${typeLabel} ${preview}${stmt.sql.length > 70 ? chalk12.dim("\u2026") : ""}`
+          );
+          for (const w of stmt.warnings) {
+            console.log(`      ${chalk12.yellow("\u2192")} ${chalk12.yellow(w)}`);
+          }
+        }
+        if (result.warnings.length > 0) {
+          console.log();
+          console.log(chalk12.bold("  Warnings:"));
+          for (const w of result.warnings) {
+            console.log(`    ${chalk12.yellow("\u26A0")} ${w}`);
+          }
+        }
+        if (!result.wouldSucceed && result.error) {
+          console.log();
+          console.log(chalk12.red(`  \u2716  Error: ${result.error}`));
+        }
+        console.log();
+        await Promise.all([
+          writeAuditEntry(
+            cwd,
+            "migration.simulate",
+            result.wouldSucceed ? "success" : "warning",
+            {
+              migration: match.name,
+              destructive: result.destructiveStatements
+            }
+          ),
+          trackEvent("simulate", result.statements.length)
+        ]).catch(() => {
+        });
+        if (!result.wouldSucceed) process.exit(1);
+        if (options.failOnDestructive && result.destructiveStatements > 0) process.exit(2);
+        process.exit(0);
+      } catch (err) {
+        const message = err instanceof Error ? err.message : String(err);
+        console.error(chalk12.red(`\u2716  ${message}`));
+        process.exit(1);
+      }
+    }
+  );
+}
+
+// src/commands/status.ts
+import chalk13 from "chalk";
+import { Command as Command13 } from "commander";
+function statusCommand() {
+  return new Command13("status").description("Show current migration and database status").option("--json", "Output as JSON").option("--quiet", "Suppress decorative output").action(async (options) => {
+    const cwd = process.cwd();
+    try {
+      const project = await detectPrismaProject(cwd);
+      if (!project) {
+        if (options.json) {
+          process.stdout.write(`${JSON.stringify({ error: "No Prisma project found" })}
+`);
+        } else {
+          console.error(chalk13.red("\u2716  No Prisma schema found in the current directory."));
+          console.error(chalk13.dim("   Run prisma init to create one, then try again."));
+        }
+        process.exit(1);
+      }
+      const [status, migrations] = await Promise.all([getProjectStatus(cwd), getMigrations(cwd)]);
+      if (options.json) {
+        process.stdout.write(`${JSON.stringify(status, null, 2)}
+`);
+      } else {
+        const bar = chalk13.dim("\u2501".repeat(50));
+        const riskColor = status.riskLevel === "critical" ? chalk13.red : status.riskLevel === "high" ? chalk13.red : status.riskLevel === "medium" ? chalk13.yellow : chalk13.green;
+        if (!options.quiet) console.log();
+        console.log(chalk13.bold.cyan(" \u{1F4CA}  PrismaFlow Status"));
+        console.log(bar);
+        console.log(
+          chalk13.bold(" Schema:       ") + chalk13.dim(status.schemaPath ?? project.schemaPath)
+        );
+        if (status.provider) {
+          console.log(chalk13.bold(" Provider:     ") + chalk13.cyan(status.provider));
+        }
+        console.log(
+          chalk13.bold(" Database:     "),
+          status.connected ? chalk13.green("\u2714 Connected") : chalk13.red("\u2716 Disconnected")
+        );
+        console.log(
+          chalk13.bold(" Migrations:   ") + chalk13.green(`${status.migrationsApplied} applied`) + chalk13.dim("  /  ") + (status.migrationsPending > 0 ? chalk13.yellow(`${status.migrationsPending} pending`) : chalk13.dim("0 pending")) + chalk13.dim("  /  ") + (status.migrationsFailed > 0 ? chalk13.red(`${status.migrationsFailed} failed`) : chalk13.dim("0 failed"))
+        );
+        console.log(
+          chalk13.bold(" Drift:        "),
+          status.driftDetected ? chalk13.red(
+            `\u2716 ${status.driftCount} issue${status.driftCount !== 1 ? "s" : ""} detected`
+          ) : chalk13.green("\u2714 None")
+        );
+        console.log(
+          chalk13.bold(" Risk Level:   ") + riskColor(chalk13.bold(status.riskLevel.toUpperCase()))
+        );
+        console.log(
+          chalk13.bold(" Health Score: ") + riskColor(chalk13.bold(`${status.healthScore}/100`)) + chalk13.dim(` (${status.deploymentReadiness.summary})`)
+        );
+        const lastMigration = migrations.filter((m) => m.status === "applied").pop();
+        if (lastMigration) {
+          const date = new Date(lastMigration.timestamp).toLocaleDateString(void 0, {
+            year: "numeric",
+            month: "short",
+            day: "numeric"
+          });
+          console.log(
+            chalk13.bold(" Last Applied: ") + chalk13.dim(`${lastMigration.name} (${date})`)
+          );
+        }
+        console.log(
+          chalk13.bold(" Last Sync:    ") + chalk13.dim(new Date(status.lastSync).toLocaleString())
+        );
+        console.log(bar);
+        if (status.migrationsPending > 0) {
+          console.log(chalk13.yellow(" \u26A0  Pending migrations \u2014 run: prisma migrate deploy"));
+        }
+        if (status.migrationsFailed > 0) {
+          console.log(chalk13.red(" \u2716  Failed migrations \u2014 run: prisma migrate resolve"));
+        }
+        if (status.driftDetected) {
+          console.log(chalk13.red(" \u2716  Schema drift \u2014 review the dashboard Drift page"));
+        }
+        if (status.deploymentReadiness.status === "ready") {
+          console.log(chalk13.green(" \u2714  Deployment readiness checks passed"));
+        } else {
+          for (const check of status.deploymentReadiness.checks.filter((item) => !item.passed)) {
+            console.log(chalk13.yellow(` \u26A0  ${check.label}: ${check.message}`));
+          }
+        }
+        if (!options.quiet) console.log();
+      }
+      await Promise.all([
+        writeAuditEntry(cwd, "status.check", "success", {
+          migrationsApplied: status.migrationsApplied,
+          migrationsPending: status.migrationsPending,
+          migrationsFailed: status.migrationsFailed,
+          driftDetected: status.driftDetected
+        }),
+        trackEvent("status", migrations.length)
+      ]).catch(() => {
+      });
+      process.exit(0);
+    } catch (error) {
+      const message = error instanceof Error ? error.message : String(error);
+      if (options.json) {
+        process.stdout.write(`${JSON.stringify({ error: message })}
+`);
+      } else {
+        console.error(chalk13.red(`\u2716  Error: ${message}`));
+      }
+      await writeAuditEntry(cwd, "status.check", "failure", {
+        error: message
+      }).catch(() => {
+      });
+      process.exit(1);
+    }
+  });
+}
+
+// src/index.ts
+var program = new Command14();
+program.name("prisma-flow").description("Visual Prisma migration management \u2014 safe, observable, production-ready").version(process.env.npm_package_version ?? "0.1.0");
+program.addCommand(dashboardCommand(), { isDefault: true });
+program.addCommand(statusCommand());
+program.addCommand(checkCommand());
+program.addCommand(reportCommand());
+program.addCommand(initCommand());
+program.addCommand(doctorCommand());
+program.addCommand(inspectCommand());
+program.addCommand(diffCommand());
+program.addCommand(simulateCommand());
+program.addCommand(rollbackCommand());
+program.addCommand(repairCommand());
+program.addCommand(compareCommand());
+program.addCommand(historyCommand());
+program.parse(process.argv);