@indiekitai/pg-dash 0.3.7 → 0.3.8

package/dist/cli.js

@@ -754,69 +754,519 @@ var init_advisor = __esm({
   }
 });
 
-// src/server/snapshot.ts
-var snapshot_exports = {};
-__export(snapshot_exports, {
-  diffSnapshots: () => diffSnapshots2,
-  loadSnapshot: () => loadSnapshot,
-  saveSnapshot: () => saveSnapshot
-});
-import fs4 from "fs";
-import path4 from "path";
-function normalizeIssueId(id) {
-  return id.replace(/-\d+$/, "");
+// src/server/queries/schema.ts
+async function getSchemaTables(pool) {
+  const client = await pool.connect();
+  try {
+    const r = await client.query(`
+      SELECT
+        c.relname AS name,
+        n.nspname AS schema,
+        pg_size_pretty(pg_total_relation_size(c.oid)) AS total_size,
+        pg_total_relation_size(c.oid) AS total_size_bytes,
+        pg_size_pretty(pg_relation_size(c.oid)) AS table_size,
+        pg_size_pretty(pg_total_relation_size(c.oid) - pg_relation_size(c.oid)) AS index_size,
+        s.n_live_tup AS row_count,
+        obj_description(c.oid) AS description
+      FROM pg_class c
+      JOIN pg_namespace n ON c.relnamespace = n.oid
+      LEFT JOIN pg_stat_user_tables s ON s.relid = c.oid
+      WHERE c.relkind = 'r' AND n.nspname NOT IN ('pg_catalog', 'information_schema')
+      ORDER BY pg_total_relation_size(c.oid) DESC
+    `);
+    return r.rows;
+  } finally {
+    client.release();
+  }
 }
-function saveSnapshot(snapshotPath, result) {
-  fs4.mkdirSync(path4.dirname(snapshotPath), { recursive: true });
-  const snapshot = { timestamp: (/* @__PURE__ */ new Date()).toISOString(), result };
-  fs4.writeFileSync(snapshotPath, JSON.stringify(snapshot, null, 2));
+async function getSchemaTableDetail(pool, tableName) {
+  const client = await pool.connect();
+  try {
+    const parts = tableName.split(".");
+    const schema = parts.length > 1 ? parts[0] : "public";
+    const name = parts.length > 1 ? parts[1] : parts[0];
+    const tableInfo = await client.query(`
+      SELECT
+        c.relname AS name, n.nspname AS schema,
+        pg_size_pretty(pg_total_relation_size(c.oid)) AS total_size,
+        pg_size_pretty(pg_relation_size(c.oid)) AS table_size,
+        pg_size_pretty(pg_total_relation_size(c.oid) - pg_relation_size(c.oid)) AS index_size,
+        pg_size_pretty(pg_relation_size(c.reltoastrelid)) AS toast_size,
+        s.n_live_tup AS row_count, s.n_dead_tup AS dead_tuples,
+        s.last_vacuum, s.last_autovacuum, s.last_analyze, s.last_autoanalyze,
+        s.seq_scan, s.idx_scan
+      FROM pg_class c
+      JOIN pg_namespace n ON c.relnamespace = n.oid
+      LEFT JOIN pg_stat_user_tables s ON s.relid = c.oid
+      WHERE c.relname = $1 AND n.nspname = $2 AND c.relkind = 'r'
+    `, [name, schema]);
+    if (tableInfo.rows.length === 0) return null;
+    const columns = await client.query(`
+      SELECT
+        a.attname AS name,
+        pg_catalog.format_type(a.atttypid, a.atttypmod) AS type,
+        NOT a.attnotnull AS nullable,
+        pg_get_expr(d.adbin, d.adrelid) AS default_value,
+        col_description(a.attrelid, a.attnum) AS description
+      FROM pg_attribute a
+      LEFT JOIN pg_attrdef d ON a.attrelid = d.adrelid AND a.attnum = d.adnum
+      WHERE a.attrelid = (SELECT c.oid FROM pg_class c JOIN pg_namespace n ON c.relnamespace = n.oid WHERE c.relname = $1 AND n.nspname = $2)
+        AND a.attnum > 0 AND NOT a.attisdropped
+      ORDER BY a.attnum
+    `, [name, schema]);
+    const indexes = await client.query(`
+      SELECT
+        i.relname AS name,
+        am.amname AS type,
+        pg_size_pretty(pg_relation_size(i.oid)) AS size,
+        pg_get_indexdef(idx.indexrelid) AS definition,
+        idx.indisunique AS is_unique,
+        idx.indisprimary AS is_primary,
+        s.idx_scan, s.idx_tup_read, s.idx_tup_fetch
+      FROM pg_index idx
+      JOIN pg_class i ON idx.indexrelid = i.oid
+      JOIN pg_class t ON idx.indrelid = t.oid
+      JOIN pg_namespace n ON t.relnamespace = n.oid
+      JOIN pg_am am ON i.relam = am.oid
+      LEFT JOIN pg_stat_user_indexes s ON s.indexrelid = i.oid
+      WHERE t.relname = $1 AND n.nspname = $2
+      ORDER BY i.relname
+    `, [name, schema]);
+    const constraints = await client.query(`
+      SELECT
+        conname AS name,
+        CASE contype WHEN 'p' THEN 'PRIMARY KEY' WHEN 'f' THEN 'FOREIGN KEY'
+          WHEN 'u' THEN 'UNIQUE' WHEN 'c' THEN 'CHECK' WHEN 'x' THEN 'EXCLUDE' END AS type,
+        pg_get_constraintdef(oid) AS definition
+      FROM pg_constraint
+      WHERE conrelid = (SELECT c.oid FROM pg_class c JOIN pg_namespace n ON c.relnamespace = n.oid WHERE c.relname = $1 AND n.nspname = $2)
+      ORDER BY
+        CASE contype WHEN 'p' THEN 1 WHEN 'u' THEN 2 WHEN 'f' THEN 3 WHEN 'c' THEN 4 ELSE 5 END
+    `, [name, schema]);
+    const foreignKeys = await client.query(`
+      SELECT
+        conname AS name,
+        a.attname AS column_name,
+        confrelid::regclass::text AS referenced_table,
+        af.attname AS referenced_column
+      FROM pg_constraint c
+      JOIN pg_attribute a ON a.attrelid = c.conrelid AND a.attnum = ANY(c.conkey)
+      JOIN pg_attribute af ON af.attrelid = c.confrelid AND af.attnum = ANY(c.confkey)
+      WHERE c.contype = 'f'
+        AND c.conrelid = (SELECT cl.oid FROM pg_class cl JOIN pg_namespace n ON cl.relnamespace = n.oid WHERE cl.relname = $1 AND n.nspname = $2)
+    `, [name, schema]);
+    let sampleData = [];
+    try {
+      const sample = await client.query(
+        `SELECT * FROM ${client.escapeIdentifier(schema)}.${client.escapeIdentifier(name)} LIMIT 10`
+      );
+      sampleData = sample.rows;
+    } catch (err) {
+      console.error("[schema] Error:", err.message);
+    }
+    return {
+      ...tableInfo.rows[0],
+      columns: columns.rows,
+      indexes: indexes.rows,
+      constraints: constraints.rows,
+      foreignKeys: foreignKeys.rows,
+      sampleData
+    };
+  } finally {
+    client.release();
+  }
 }
-function loadSnapshot(snapshotPath) {
-  if (!fs4.existsSync(snapshotPath)) return null;
+async function getSchemaIndexes(pool) {
+  const client = await pool.connect();
   try {
-    return JSON.parse(fs4.readFileSync(snapshotPath, "utf-8"));
-  } catch {
-    return null;
+    const r = await client.query(`
+      SELECT
+        n.nspname AS schema,
+        t.relname AS table_name,
+        i.relname AS name,
+        am.amname AS type,
+        pg_size_pretty(pg_relation_size(i.oid)) AS size,
+        pg_relation_size(i.oid) AS size_bytes,
+        pg_get_indexdef(idx.indexrelid) AS definition,
+        idx.indisunique AS is_unique,
+        idx.indisprimary AS is_primary,
+        s.idx_scan, s.idx_tup_read, s.idx_tup_fetch
+      FROM pg_index idx
+      JOIN pg_class i ON idx.indexrelid = i.oid
+      JOIN pg_class t ON idx.indrelid = t.oid
+      JOIN pg_namespace n ON t.relnamespace = n.oid
+      JOIN pg_am am ON i.relam = am.oid
+      LEFT JOIN pg_stat_user_indexes s ON s.indexrelid = i.oid
+      WHERE n.nspname NOT IN ('pg_catalog', 'information_schema')
+      ORDER BY pg_relation_size(i.oid) DESC
+    `);
+    return r.rows;
+  } finally {
+    client.release();
   }
 }
-function diffSnapshots2(prev, current) {
-  const prevNormIds = new Set(prev.issues.map((i) => normalizeIssueId(i.id)));
-  const currNormIds = new Set(current.issues.map((i) => normalizeIssueId(i.id)));
-  const newIssues = current.issues.filter((i) => !prevNormIds.has(normalizeIssueId(i.id)));
-  const resolvedIssues = prev.issues.filter((i) => !currNormIds.has(normalizeIssueId(i.id)));
-  const unchanged = current.issues.filter((i) => prevNormIds.has(normalizeIssueId(i.id)));
-  return {
-    scoreDelta: current.score - prev.score,
-    previousScore: prev.score,
-    currentScore: current.score,
-    previousGrade: prev.grade,
-    currentGrade: current.grade,
-    newIssues,
-    resolvedIssues,
-    unchanged
-  };
+async function getSchemaFunctions(pool) {
+  const client = await pool.connect();
+  try {
+    const r = await client.query(`
+      SELECT
+        n.nspname AS schema,
+        p.proname AS name,
+        pg_get_function_result(p.oid) AS return_type,
+        pg_get_function_arguments(p.oid) AS arguments,
+        l.lanname AS language,
+        p.prosrc AS source,
+        CASE p.prokind WHEN 'f' THEN 'function' WHEN 'p' THEN 'procedure' WHEN 'a' THEN 'aggregate' WHEN 'w' THEN 'window' END AS kind
+      FROM pg_proc p
+      JOIN pg_namespace n ON p.pronamespace = n.oid
+      JOIN pg_language l ON p.prolang = l.oid
+      WHERE n.nspname NOT IN ('pg_catalog', 'information_schema')
+      ORDER BY n.nspname, p.proname
+    `);
+    return r.rows;
+  } finally {
+    client.release();
+  }
 }
-var init_snapshot = __esm({
-  "src/server/snapshot.ts"() {
+async function getSchemaExtensions(pool) {
+  const client = await pool.connect();
+  try {
+    const r = await client.query(`
+      SELECT extname AS name, extversion AS installed_version,
+        n.nspname AS schema, obj_description(e.oid) AS description
+      FROM pg_extension e
+      JOIN pg_namespace n ON e.extnamespace = n.oid
+      ORDER BY extname
+    `);
+    return r.rows;
+  } finally {
+    client.release();
+  }
+}
+async function getSchemaEnums(pool) {
+  const client = await pool.connect();
+  try {
+    const r = await client.query(`
+      SELECT
+        t.typname AS name,
+        n.nspname AS schema,
+        array_agg(e.enumlabel ORDER BY e.enumsortorder) AS values
+      FROM pg_type t
+      JOIN pg_namespace n ON t.typnamespace = n.oid
+      JOIN pg_enum e ON t.oid = e.enumtypid
+      WHERE n.nspname NOT IN ('pg_catalog', 'information_schema')
+      GROUP BY t.typname, n.nspname
+      ORDER BY t.typname
+    `);
+    return r.rows;
+  } finally {
+    client.release();
+  }
+}
+var init_schema = __esm({
+  "src/server/queries/schema.ts"() {
     "use strict";
   }
 });
 
-// src/server/migration-checker.ts
-var migration_checker_exports = {};
-__export(migration_checker_exports, {
-  analyzeMigration: () => analyzeMigration
-});
-function stripComments(sql) {
-  let stripped = sql.replace(
-    /\/\*[\s\S]*?\*\//g,
-    (match) => match.replace(/[^\n]/g, " ")
-  );
-  stripped = stripped.replace(/--[^\n]*/g, (match) => " ".repeat(match.length));
-  return stripped;
-}
-function findLineNumber(sql, matchIndex) {
-  const before = sql.slice(0, matchIndex);
+// src/server/schema-diff.ts
+function diffSnapshots(oldSnap, newSnap) {
+  const changes = [];
+  const oldTableMap = new Map(oldSnap.tables.map((t) => [`${t.schema}.${t.name}`, t]));
+  const newTableMap = new Map(newSnap.tables.map((t) => [`${t.schema}.${t.name}`, t]));
+  for (const [key, t] of newTableMap) {
+    if (!oldTableMap.has(key)) {
+      changes.push({ change_type: "added", object_type: "table", table_name: key, detail: `Table ${key} added` });
+    }
+  }
+  for (const [key] of oldTableMap) {
+    if (!newTableMap.has(key)) {
+      changes.push({ change_type: "removed", object_type: "table", table_name: key, detail: `Table ${key} removed` });
+    }
+  }
+  for (const [key, newTable] of newTableMap) {
+    const oldTable = oldTableMap.get(key);
+    if (!oldTable) continue;
+    const oldCols = new Map(oldTable.columns.map((c) => [c.name, c]));
+    const newCols = new Map(newTable.columns.map((c) => [c.name, c]));
+    for (const [name, col] of newCols) {
+      const oldCol = oldCols.get(name);
+      if (!oldCol) {
+        changes.push({ change_type: "added", object_type: "column", table_name: key, detail: `Column ${name} added (${col.type})` });
+      } else {
+        if (oldCol.type !== col.type) {
+          changes.push({ change_type: "modified", object_type: "column", table_name: key, detail: `Column ${name} type changed: ${oldCol.type} \u2192 ${col.type}` });
+        }
+        if (oldCol.nullable !== col.nullable) {
+          changes.push({ change_type: "modified", object_type: "column", table_name: key, detail: `Column ${name} nullable changed: ${oldCol.nullable} \u2192 ${col.nullable}` });
+        }
+        if (oldCol.default_value !== col.default_value) {
+          changes.push({ change_type: "modified", object_type: "column", table_name: key, detail: `Column ${name} default changed: ${oldCol.default_value ?? "NULL"} \u2192 ${col.default_value ?? "NULL"}` });
+        }
+      }
+    }
+    for (const name of oldCols.keys()) {
+      if (!newCols.has(name)) {
+        changes.push({ change_type: "removed", object_type: "column", table_name: key, detail: `Column ${name} removed` });
+      }
+    }
+    const oldIdx = new Map(oldTable.indexes.map((i) => [i.name, i]));
+    const newIdx = new Map(newTable.indexes.map((i) => [i.name, i]));
+    for (const [name, idx] of newIdx) {
+      if (!oldIdx.has(name)) {
+        changes.push({ change_type: "added", object_type: "index", table_name: key, detail: `Index ${name} added` });
+      } else if (oldIdx.get(name).definition !== idx.definition) {
+        changes.push({ change_type: "modified", object_type: "index", table_name: key, detail: `Index ${name} definition changed` });
+      }
+    }
+    for (const name of oldIdx.keys()) {
+      if (!newIdx.has(name)) {
+        changes.push({ change_type: "removed", object_type: "index", table_name: key, detail: `Index ${name} removed` });
+      }
+    }
+    const oldCon = new Map(oldTable.constraints.map((c) => [c.name, c]));
+    const newCon = new Map(newTable.constraints.map((c) => [c.name, c]));
+    for (const [name, con] of newCon) {
+      if (!oldCon.has(name)) {
+        changes.push({ change_type: "added", object_type: "constraint", table_name: key, detail: `Constraint ${name} added (${con.type})` });
+      } else if (oldCon.get(name).definition !== con.definition) {
+        changes.push({ change_type: "modified", object_type: "constraint", table_name: key, detail: `Constraint ${name} definition changed` });
+      }
+    }
+    for (const name of oldCon.keys()) {
+      if (!newCon.has(name)) {
+        changes.push({ change_type: "removed", object_type: "constraint", table_name: key, detail: `Constraint ${name} removed` });
+      }
+    }
+  }
+  const oldEnums = new Map((oldSnap.enums || []).map((e) => [`${e.schema}.${e.name}`, e]));
+  const newEnums = new Map((newSnap.enums || []).map((e) => [`${e.schema}.${e.name}`, e]));
+  for (const [key, en] of newEnums) {
+    const oldEn = oldEnums.get(key);
+    if (!oldEn) {
+      changes.push({ change_type: "added", object_type: "enum", table_name: null, detail: `Enum ${key} added (${en.values.join(", ")})` });
+    } else {
+      const added = en.values.filter((v) => !oldEn.values.includes(v));
+      const removed = oldEn.values.filter((v) => !en.values.includes(v));
+      for (const v of added) {
+        changes.push({ change_type: "modified", object_type: "enum", table_name: null, detail: `Enum ${key}: value '${v}' added` });
+      }
+      for (const v of removed) {
+        changes.push({ change_type: "modified", object_type: "enum", table_name: null, detail: `Enum ${key}: value '${v}' removed` });
+      }
+    }
+  }
+  for (const key of oldEnums.keys()) {
+    if (!newEnums.has(key)) {
+      changes.push({ change_type: "removed", object_type: "enum", table_name: null, detail: `Enum ${key} removed` });
+    }
+  }
+  return changes;
+}
+var init_schema_diff = __esm({
+  "src/server/schema-diff.ts"() {
+    "use strict";
+  }
+});
+
+// src/server/schema-tracker.ts
+async function buildLiveSnapshot(pool) {
+  const tables = await getSchemaTables(pool);
+  const enums = await getSchemaEnums(pool);
+  const detailedTables = await Promise.all(
+    tables.map(async (t) => {
+      const detail = await getSchemaTableDetail(pool, `${t.schema}.${t.name}`);
+      if (!detail) return null;
+      return {
+        name: detail.name,
+        schema: detail.schema,
+        columns: detail.columns.map((c) => ({
+          name: c.name,
+          type: c.type,
+          nullable: c.nullable,
+          default_value: c.default_value
+        })),
+        indexes: detail.indexes.map((i) => ({
+          name: i.name,
+          definition: i.definition,
+          is_unique: i.is_unique,
+          is_primary: i.is_primary
+        })),
+        constraints: detail.constraints.map((c) => ({
+          name: c.name,
+          type: c.type,
+          definition: c.definition
+        }))
+      };
+    })
+  );
+  return {
+    tables: detailedTables.filter(Boolean),
+    enums: enums.map((e) => ({ name: e.name, schema: e.schema, values: e.values }))
+  };
+}
+var SchemaTracker;
+var init_schema_tracker = __esm({
+  "src/server/schema-tracker.ts"() {
+    "use strict";
+    init_schema();
+    init_schema_diff();
+    SchemaTracker = class {
+      db;
+      pool;
+      intervalMs;
+      timer = null;
+      constructor(db, pool, intervalMs = 6 * 60 * 60 * 1e3) {
+        this.db = db;
+        this.pool = pool;
+        this.intervalMs = intervalMs;
+        this.initTables();
+      }
+      initTables() {
+        this.db.exec(`
+      CREATE TABLE IF NOT EXISTS schema_snapshots (
+        id INTEGER PRIMARY KEY AUTOINCREMENT,
+        timestamp INTEGER NOT NULL,
+        snapshot TEXT NOT NULL
+      );
+      CREATE TABLE IF NOT EXISTS schema_changes (
+        id INTEGER PRIMARY KEY AUTOINCREMENT,
+        snapshot_id INTEGER NOT NULL,
+        timestamp INTEGER NOT NULL,
+        change_type TEXT NOT NULL,
+        object_type TEXT NOT NULL,
+        table_name TEXT,
+        detail TEXT NOT NULL,
+        FOREIGN KEY (snapshot_id) REFERENCES schema_snapshots(id)
+      );
+    `);
+      }
+      async takeSnapshot() {
+        const snapshot = await this.buildSnapshot();
+        const now = Date.now();
+        const json = JSON.stringify(snapshot);
+        const info = this.db.prepare("INSERT INTO schema_snapshots (timestamp, snapshot) VALUES (?, ?)").run(now, json);
+        const snapshotId = Number(info.lastInsertRowid);
+        const prev = this.db.prepare("SELECT snapshot FROM schema_snapshots WHERE id < ? ORDER BY id DESC LIMIT 1").get(snapshotId);
+        let changes = [];
+        if (prev) {
+          const oldSnap = JSON.parse(prev.snapshot);
+          changes = diffSnapshots(oldSnap, snapshot);
+          if (changes.length > 0) {
+            const insert = this.db.prepare("INSERT INTO schema_changes (snapshot_id, timestamp, change_type, object_type, table_name, detail) VALUES (?, ?, ?, ?, ?, ?)");
+            const tx = this.db.transaction((chs) => {
+              for (const c of chs) {
+                insert.run(snapshotId, now, c.change_type, c.object_type, c.table_name, c.detail);
+              }
+            });
+            tx(changes);
+          }
+        }
+        return { snapshotId, changes };
+      }
+      async buildSnapshot() {
+        return buildLiveSnapshot(this.pool);
+      }
+      start() {
+        this.takeSnapshot().catch((err) => console.error("Schema snapshot error:", err.message));
+        this.timer = setInterval(() => {
+          this.takeSnapshot().catch((err) => console.error("Schema snapshot error:", err.message));
+        }, this.intervalMs);
+      }
+      stop() {
+        if (this.timer) {
+          clearInterval(this.timer);
+          this.timer = null;
+        }
+      }
+      // API helpers
+      getHistory(limit = 30) {
+        return this.db.prepare("SELECT id, timestamp FROM schema_snapshots ORDER BY id DESC LIMIT ?").all(limit);
+      }
+      getChanges(since) {
+        if (since) {
+          return this.db.prepare("SELECT * FROM schema_changes WHERE timestamp >= ? ORDER BY timestamp DESC").all(since);
+        }
+        return this.db.prepare("SELECT * FROM schema_changes ORDER BY timestamp DESC LIMIT 100").all();
+      }
+      getLatestChanges() {
+        const latest = this.db.prepare("SELECT id FROM schema_snapshots ORDER BY id DESC LIMIT 1").get();
+        if (!latest) return [];
+        return this.db.prepare("SELECT * FROM schema_changes WHERE snapshot_id = ? ORDER BY id").all(latest.id);
+      }
+      getDiff(fromId, toId) {
+        const from = this.db.prepare("SELECT snapshot FROM schema_snapshots WHERE id = ?").get(fromId);
+        const to = this.db.prepare("SELECT snapshot FROM schema_snapshots WHERE id = ?").get(toId);
+        if (!from || !to) return null;
+        return diffSnapshots(JSON.parse(from.snapshot), JSON.parse(to.snapshot));
+      }
+    };
+  }
+});
+
+// src/server/snapshot.ts
+var snapshot_exports = {};
+__export(snapshot_exports, {
+  diffSnapshots: () => diffSnapshots2,
+  loadSnapshot: () => loadSnapshot,
+  saveSnapshot: () => saveSnapshot
+});
+import fs4 from "fs";
+import path4 from "path";
+function normalizeIssueId(id) {
+  return id.replace(/-\d+$/, "");
+}
+function saveSnapshot(snapshotPath, result) {
+  fs4.mkdirSync(path4.dirname(snapshotPath), { recursive: true });
+  const snapshot = { timestamp: (/* @__PURE__ */ new Date()).toISOString(), result };
+  fs4.writeFileSync(snapshotPath, JSON.stringify(snapshot, null, 2));
+}
+function loadSnapshot(snapshotPath) {
+  if (!fs4.existsSync(snapshotPath)) return null;
+  try {
+    return JSON.parse(fs4.readFileSync(snapshotPath, "utf-8"));
+  } catch {
+    return null;
+  }
+}
+function diffSnapshots2(prev, current) {
+  const prevNormIds = new Set(prev.issues.map((i) => normalizeIssueId(i.id)));
+  const currNormIds = new Set(current.issues.map((i) => normalizeIssueId(i.id)));
+  const newIssues = current.issues.filter((i) => !prevNormIds.has(normalizeIssueId(i.id)));
+  const resolvedIssues = prev.issues.filter((i) => !currNormIds.has(normalizeIssueId(i.id)));
+  const unchanged = current.issues.filter((i) => prevNormIds.has(normalizeIssueId(i.id)));
+  return {
+    scoreDelta: current.score - prev.score,
+    previousScore: prev.score,
+    currentScore: current.score,
+    previousGrade: prev.grade,
+    currentGrade: current.grade,
+    newIssues,
+    resolvedIssues,
+    unchanged
+  };
+}
+var init_snapshot = __esm({
+  "src/server/snapshot.ts"() {
+    "use strict";
+  }
+});
+
+// src/server/migration-checker.ts
+var migration_checker_exports = {};
+__export(migration_checker_exports, {
+  analyzeMigration: () => analyzeMigration
+});
+function stripComments(sql) {
+  let stripped = sql.replace(
+    /\/\*[\s\S]*?\*\//g,
+    (match) => match.replace(/[^\n]/g, " ")
+  );
+  stripped = stripped.replace(/--[^\n]*/g, (match) => " ".repeat(match.length));
+  return stripped;
+}
+function findLineNumber(sql, matchIndex) {
+  const before = sql.slice(0, matchIndex);
   return before.split("\n").length;
 }
 function bareTable(name) {
@@ -907,6 +1357,56 @@ function staticCheck(sql) {
       lineNumber: findLineNumber(sql, m.index)
     });
   }
+  const alterTypeRe = /\bALTER\s+TABLE\s+(?:IF\s+EXISTS\s+)?([\w."]+)\s+ALTER\s+(?:COLUMN\s+)?[\w"]+\s+TYPE\b/gi;
+  while ((m = alterTypeRe.exec(sql)) !== null) {
+    const table = bareTable(m[1]);
+    issues.push({
+      severity: "warning",
+      code: "ALTER_COLUMN_TYPE",
+      message: "ALTER COLUMN TYPE rewrites the entire table and acquires an exclusive lock.",
+      suggestion: "Consider using a new column + backfill + rename strategy to avoid downtime.",
+      lineNumber: findLineNumber(sql, m.index),
+      tableName: table
+    });
+  }
+  const dropColRe = /\bALTER\s+TABLE\s+(?:IF\s+EXISTS\s+)?([\w."]+)\s+DROP\s+(?:COLUMN\s+)(?:IF\s+EXISTS\s+)?[\w"]+\b/gi;
+  while ((m = dropColRe.exec(sql)) !== null) {
+    const table = bareTable(m[1]);
+    issues.push({
+      severity: "info",
+      code: "DROP_COLUMN",
+      message: "DROP COLUMN is safe in PostgreSQL (no table rewrite), but may break application code referencing that column.",
+      suggestion: "Ensure no application code references this column before dropping it.",
+      lineNumber: findLineNumber(sql, m.index),
+      tableName: table
+    });
+  }
+  const addConRe = /\bALTER\s+TABLE\s+(?:IF\s+EXISTS\s+)?([\w."]+)\s+ADD\s+CONSTRAINT\b[^;]*(;|$)/gi;
+  while ((m = addConRe.exec(sql)) !== null) {
+    const fragment = m[0];
+    const table = bareTable(m[1]);
+    const fragUpper = fragment.toUpperCase();
+    if (!/\bNOT\s+VALID\b/.test(fragUpper)) {
+      issues.push({
+        severity: "warning",
+        code: "ADD_CONSTRAINT_SCANS_TABLE",
+        message: "ADD CONSTRAINT validates all existing rows and holds an exclusive lock during the scan.",
+        suggestion: "Use ADD CONSTRAINT ... NOT VALID to skip validation, then VALIDATE CONSTRAINT in a separate transaction.",
+        lineNumber: findLineNumber(sql, m.index),
+        tableName: table
+      });
+    }
+  }
+  const hasTransaction = /\bBEGIN\b/i.test(sql) || /\bSTART\s+TRANSACTION\b/i.test(sql);
+  const hasConcurrently = /\bCREATE\s+(?:UNIQUE\s+)?INDEX\s+CONCURRENTLY\b/i.test(sql);
+  if (hasTransaction && hasConcurrently) {
+    issues.push({
+      severity: "error",
+      code: "CONCURRENTLY_IN_TRANSACTION",
+      message: "CREATE INDEX CONCURRENTLY cannot run inside a transaction block. It will fail at runtime.",
+      suggestion: "Remove the BEGIN/COMMIT wrapper, or use a migration tool that runs CONCURRENTLY outside transactions."
+    });
+  }
   const truncRe = /\bTRUNCATE\b/gi;
   while ((m = truncRe.exec(sql)) !== null) {
     issues.push({
@@ -1160,6 +1660,8 @@ function countSchemaDrifts(schema) {
   for (const id of schema.indexDiffs) {
     n += id.missingIndexes.length + id.extraIndexes.length;
   }
+  n += (schema.constraintDiffs ?? []).length;
+  n += (schema.enumDiffs ?? []).length;
   return n;
 }
 async function diffEnvironments(sourceConn, targetConn, options) {
@@ -1172,22 +1674,46 @@ async function diffEnvironments(sourceConn, targetConn, options) {
       sourceCols,
       targetCols,
       sourceIdxs,
-      targetIdxs
+      targetIdxs,
+      sourceSnap,
+      targetSnap
     ] = await Promise.all([
       fetchTables(sourcePool),
       fetchTables(targetPool),
       fetchColumns(sourcePool),
       fetchColumns(targetPool),
       fetchIndexes(sourcePool),
-      fetchIndexes(targetPool)
+      fetchIndexes(targetPool),
+      buildLiveSnapshot(sourcePool).catch(() => null),
+      buildLiveSnapshot(targetPool).catch(() => null)
     ]);
     const { missingTables, extraTables } = diffTables(sourceTables, targetTables);
-    const sourceSet = new Set(sourceTables);
     const targetSet = new Set(targetTables);
     const commonTables = sourceTables.filter((t) => targetSet.has(t));
     const columnDiffs = diffColumns(sourceCols, targetCols, commonTables);
     const indexDiffs = diffIndexes(sourceIdxs, targetIdxs, commonTables);
-    const schema = { missingTables, extraTables, columnDiffs, indexDiffs };
+    const constraintDiffs = [];
+    const enumDiffs = [];
+    if (sourceSnap && targetSnap) {
+      const snapChanges = diffSnapshots(sourceSnap, targetSnap);
+      for (const c of snapChanges) {
+        if (c.object_type === "constraint") {
+          constraintDiffs.push({
+            table: c.table_name ?? null,
+            type: c.change_type === "added" ? "extra" : c.change_type === "removed" ? "missing" : "modified",
+            name: c.detail.split(" ")[1] ?? c.detail,
+            detail: c.detail
+          });
+        } else if (c.object_type === "enum") {
+          enumDiffs.push({
+            type: c.change_type === "added" ? "extra" : c.change_type === "removed" ? "missing" : "modified",
+            name: c.detail.split(" ")[1] ?? c.detail,
+            detail: c.detail
+          });
+        }
+      }
+    }
+    const schema = { missingTables, extraTables, columnDiffs, indexDiffs, constraintDiffs, enumDiffs };
     const schemaDrifts = countSchemaDrifts(schema);
     let health;
     if (options?.includeHealth) {
@@ -1287,7 +1813,44 @@ function formatTextDiff(result) {
     lines.push(`  \u26A0 target has extra indexes:`);
     lines.push(...extraIdxs);
   }
-  if (schema.missingTables.length === 0 && schema.extraTables.length === 0 && schema.columnDiffs.length === 0 && schema.indexDiffs.length === 0) {
+  const missingConstraints = (schema.constraintDiffs ?? []).filter((c) => c.type === "missing");
+  const extraConstraints = (schema.constraintDiffs ?? []).filter((c) => c.type === "extra");
+  const modifiedConstraints = (schema.constraintDiffs ?? []).filter((c) => c.type === "modified");
+  if (missingConstraints.length > 0) {
+    lines.push(`  \u2717 target missing constraints:`);
+    for (const c of missingConstraints) {
+      lines.push(`      ${c.table ? c.table + ": " : ""}${c.detail}`);
+    }
+  }
+  if (extraConstraints.length > 0) {
+    lines.push(`  \u26A0 target has extra constraints:`);
+    for (const c of extraConstraints) {
+      lines.push(`      ${c.table ? c.table + ": " : ""}${c.detail}`);
+    }
+  }
+  if (modifiedConstraints.length > 0) {
+    lines.push(`  ~ constraint differences:`);
+    for (const c of modifiedConstraints) {
+      lines.push(`      ${c.table ? c.table + ": " : ""}${c.detail}`);
+    }
+  }
+  const missingEnums = (schema.enumDiffs ?? []).filter((e) => e.type === "missing");
+  const extraEnums = (schema.enumDiffs ?? []).filter((e) => e.type === "extra");
+  const modifiedEnums = (schema.enumDiffs ?? []).filter((e) => e.type === "modified");
+  if (missingEnums.length > 0) {
+    lines.push(`  \u2717 target missing enums:`);
+    for (const e of missingEnums) lines.push(`      ${e.detail}`);
+  }
+  if (extraEnums.length > 0) {
+    lines.push(`  \u26A0 target has extra enums:`);
+    for (const e of extraEnums) lines.push(`      ${e.detail}`);
+  }
+  if (modifiedEnums.length > 0) {
+    lines.push(`  ~ enum differences:`);
+    for (const e of modifiedEnums) lines.push(`      ${e.detail}`);
+  }
+  const noSchemaChanges = schema.missingTables.length === 0 && schema.extraTables.length === 0 && schema.columnDiffs.length === 0 && schema.indexDiffs.length === 0 && (schema.constraintDiffs ?? []).length === 0 && (schema.enumDiffs ?? []).length === 0;
+  if (noSchemaChanges) {
     lines.push(`  \u2713 Schemas are identical`);
   }
   if (result.health) {
@@ -1345,6 +1908,18 @@ function formatMdDiff(result) {
   }
   if (missingIdxItems.length > 0) rows.push([`\u274C Missing indexes`, missingIdxItems.join(", ")]);
   if (extraIdxItems.length > 0) rows.push([`\u26A0\uFE0F Extra indexes`, extraIdxItems.join(", ")]);
+  const missingConItems = (schema.constraintDiffs ?? []).filter((c) => c.type === "missing").map((c) => c.detail);
+  const extraConItems = (schema.constraintDiffs ?? []).filter((c) => c.type === "extra").map((c) => c.detail);
+  const modConItems = (schema.constraintDiffs ?? []).filter((c) => c.type === "modified").map((c) => c.detail);
+  if (missingConItems.length > 0) rows.push([`\u274C Missing constraints`, missingConItems.join("; ")]);
+  if (extraConItems.length > 0) rows.push([`\u26A0\uFE0F Extra constraints`, extraConItems.join("; ")]);
+  if (modConItems.length > 0) rows.push([`~ Modified constraints`, modConItems.join("; ")]);
+  const missingEnumItems = (schema.enumDiffs ?? []).filter((e) => e.type === "missing").map((e) => e.detail);
+  const extraEnumItems = (schema.enumDiffs ?? []).filter((e) => e.type === "extra").map((e) => e.detail);
+  const modEnumItems = (schema.enumDiffs ?? []).filter((e) => e.type === "modified").map((e) => e.detail);
+  if (missingEnumItems.length > 0) rows.push([`\u274C Missing enums`, missingEnumItems.join("; ")]);
+  if (extraEnumItems.length > 0) rows.push([`\u26A0\uFE0F Extra enums`, extraEnumItems.join("; ")]);
+  if (modEnumItems.length > 0) rows.push([`~ Modified enums`, modEnumItems.join("; ")]);
   if (rows.length > 0) {
     lines.push(`| Type | Details |`);
     lines.push(`|------|---------|`);
@@ -1358,814 +1933,390 @@ function formatMdDiff(result) {
     const h = result.health;
     lines.push(``);
     lines.push(`### Health Comparison`);
-    lines.push(``);
-    lines.push(`| | Score | Grade |`);
-    lines.push(`|--|-------|-------|`);
-    lines.push(`| Source | ${h.source.score}/100 | ${h.source.grade} |`);
-    lines.push(`| Target | ${h.target.score}/100 | ${h.target.grade} |`);
-    if (h.targetOnlyIssues.length > 0) {
-      lines.push(``);
-      lines.push(`**Target-only issues:**`);
-      for (const iss of h.targetOnlyIssues) lines.push(`- ${iss}`);
-    }
-    if (h.sourceOnlyIssues.length > 0) {
-      lines.push(``);
-      lines.push(`**Source-only issues:**`);
-      for (const iss of h.sourceOnlyIssues) lines.push(`- ${iss}`);
-    }
-  }
-  lines.push(``);
-  const { schemaDrifts, identical } = result.summary;
-  lines.push(`**Result: ${schemaDrifts} drift${schemaDrifts !== 1 ? "s" : ""} \u2014 environments are ${identical ? "in sync \u2713" : "NOT in sync"}**`);
-  return lines.join("\n");
-}
-var init_env_differ = __esm({
-  "src/server/env-differ.ts"() {
-    "use strict";
-    init_advisor();
-  }
-});
-
-// src/cli.ts
-import { parseArgs } from "util";
-
-// src/server/index.ts
-import { Hono } from "hono";
-import path3 from "path";
-import fs3 from "fs";
-import os3 from "os";
-import { fileURLToPath } from "url";
-import { Pool } from "pg";
-
-// src/server/queries/overview.ts
-async function getOverview(pool) {
-  const client = await pool.connect();
-  try {
-    const version = await client.query("SHOW server_version");
-    const uptime = await client.query(
-      `SELECT to_char(now() - pg_postmaster_start_time(), 'DD "d" HH24 "h" MI "m"') AS uptime`
-    );
-    const dbSize = await client.query(
-      "SELECT pg_size_pretty(pg_database_size(current_database())) AS size"
-    );
-    const dbCount = await client.query(
-      "SELECT count(*)::int AS count FROM pg_database WHERE NOT datistemplate"
-    );
-    const connections = await client.query(`
-      SELECT
-        (SELECT count(*)::int FROM pg_stat_activity WHERE state = 'active') AS active,
-        (SELECT count(*)::int FROM pg_stat_activity WHERE state = 'idle') AS idle,
-        (SELECT setting::int FROM pg_settings WHERE name = 'max_connections') AS max
-    `);
-    return {
-      version: version.rows[0].server_version,
-      uptime: uptime.rows[0].uptime,
-      dbSize: dbSize.rows[0].size,
-      databaseCount: dbCount.rows[0].count,
-      connections: connections.rows[0]
-    };
-  } finally {
-    client.release();
-  }
-}
-
-// src/server/queries/databases.ts
-async function getDatabases(pool) {
-  const client = await pool.connect();
-  try {
-    const r = await client.query(`
-      SELECT datname AS name,
-        pg_size_pretty(pg_database_size(datname)) AS size,
-        pg_database_size(datname) AS size_bytes
-      FROM pg_database
-      WHERE NOT datistemplate
-      ORDER BY pg_database_size(datname) DESC
-    `);
-    return r.rows;
-  } finally {
-    client.release();
-  }
-}
-
-// src/server/queries/tables.ts
-async function getTables(pool) {
-  const client = await pool.connect();
-  try {
-    const r = await client.query(`
-      SELECT
-        schemaname AS schema,
-        relname AS name,
-        pg_size_pretty(pg_total_relation_size(relid)) AS total_size,
-        pg_total_relation_size(relid) AS size_bytes,
-        n_live_tup AS rows,
-        n_dead_tup AS dead_tuples,
-        CASE WHEN n_live_tup > 0 
-          THEN round(n_dead_tup::numeric / n_live_tup * 100, 1) 
-          ELSE 0 END AS dead_pct
-      FROM pg_stat_user_tables
-      ORDER BY pg_total_relation_size(relid) DESC
-    `);
-    return r.rows;
-  } finally {
-    client.release();
-  }
-}
-
-// src/server/queries/activity.ts
-async function getActivity(pool) {
-  const client = await pool.connect();
-  try {
-    const r = await client.query(`
-      SELECT
-        pid,
-        COALESCE(query, '') AS query,
-        COALESCE(state, 'unknown') AS state,
-        wait_event,
-        wait_event_type,
-        CASE WHEN state = 'active' THEN (now() - query_start)::text
-             WHEN state = 'idle in transaction' THEN (now() - state_change)::text
-             ELSE NULL END AS duration,
-        client_addr::text,
-        COALESCE(application_name, '') AS application_name,
-        backend_start::text
-      FROM pg_stat_activity
-      WHERE pid != pg_backend_pid()
-        AND state IS NOT NULL
-      ORDER BY
-        CASE state
-          WHEN 'active' THEN 1
-          WHEN 'idle in transaction' THEN 2
-          ELSE 3
-        END,
-        query_start ASC NULLS LAST
-    `);
-    return r.rows;
-  } finally {
-    client.release();
-  }
-}
-
-// src/server/index.ts
-init_advisor();
-
-// src/server/timeseries.ts
-import Database2 from "better-sqlite3";
-import path2 from "path";
-import os2 from "os";
-import fs2 from "fs";
-var DEFAULT_DIR = path2.join(os2.homedir(), ".pg-dash");
-var DEFAULT_RETENTION_DAYS = 7;
-var TimeseriesStore = class {
-  db;
-  insertStmt;
-  retentionMs;
-  constructor(dbOrDir, retentionDays = DEFAULT_RETENTION_DAYS) {
-    if (dbOrDir instanceof Database2) {
-      this.db = dbOrDir;
-    } else {
-      const dir = dbOrDir || DEFAULT_DIR;
-      fs2.mkdirSync(dir, { recursive: true });
-      const dbPath = path2.join(dir, "metrics.db");
-      this.db = new Database2(dbPath);
-    }
-    this.retentionMs = retentionDays * 24 * 60 * 60 * 1e3;
-    this.db.pragma("journal_mode = WAL");
-    this.db.exec(`
-      CREATE TABLE IF NOT EXISTS metrics (
-        timestamp INTEGER NOT NULL,
-        metric TEXT NOT NULL,
-        value REAL NOT NULL
-      );
-      CREATE INDEX IF NOT EXISTS idx_metrics_metric_ts ON metrics(metric, timestamp);
-    `);
-    this.insertStmt = this.db.prepare(
-      "INSERT INTO metrics (timestamp, metric, value) VALUES (?, ?, ?)"
-    );
-  }
-  insert(metric, value, timestamp) {
-    this.insertStmt.run(timestamp ?? Date.now(), metric, value);
-  }
-  insertMany(points) {
-    const tx = this.db.transaction((pts) => {
-      for (const p of pts) {
-        this.insertStmt.run(p.timestamp, p.metric, p.value);
-      }
-    });
-    tx(points);
-  }
-  query(metric, startMs, endMs) {
-    const end = endMs ?? Date.now();
-    return this.db.prepare(
-      "SELECT timestamp, value FROM metrics WHERE metric = ? AND timestamp >= ? AND timestamp <= ? ORDER BY timestamp"
-    ).all(metric, startMs, end);
-  }
-  latest(metrics) {
-    const result = {};
-    if (metrics && metrics.length > 0) {
-      const placeholders = metrics.map(() => "?").join(",");
-      const rows = this.db.prepare(
-        `SELECT m.metric, m.timestamp, m.value FROM metrics m INNER JOIN (SELECT metric, MAX(timestamp) as max_ts FROM metrics WHERE metric IN (${placeholders}) GROUP BY metric) g ON m.metric = g.metric AND m.timestamp = g.max_ts`
-      ).all(...metrics);
-      for (const r of rows) result[r.metric] = { timestamp: r.timestamp, value: r.value };
-    } else {
-      const rows = this.db.prepare(
-        "SELECT m.metric, m.timestamp, m.value FROM metrics m INNER JOIN (SELECT metric, MAX(timestamp) as max_ts FROM metrics GROUP BY metric) g ON m.metric = g.metric AND m.timestamp = g.max_ts"
-      ).all();
-      for (const r of rows) result[r.metric] = { timestamp: r.timestamp, value: r.value };
-    }
-    return result;
-  }
-  prune() {
-    const cutoff = Date.now() - this.retentionMs;
-    const info = this.db.prepare("DELETE FROM metrics WHERE timestamp < ?").run(cutoff);
-    return info.changes;
-  }
-  close() {
-    this.db.close();
-  }
-};
-
-// src/server/collector.ts
-import { EventEmitter } from "events";
-var Collector = class extends EventEmitter {
-  constructor(pool, store, intervalMs = 3e4) {
-    super();
-    this.pool = pool;
-    this.store = store;
-    this.intervalMs = intervalMs;
-  }
-  timer = null;
-  pruneTimer = null;
-  prev = null;
-  lastSnapshot = {};
-  collectCount = 0;
-  start() {
-    this.collect().catch((err) => console.error("[collector] Initial collection failed:", err));
-    this.timer = setInterval(() => {
-      this.collect().catch((err) => console.error("[collector] Collection failed:", err));
-    }, this.intervalMs);
-    this.pruneTimer = setInterval(() => this.store.prune(), 60 * 60 * 1e3);
-  }
-  stop() {
-    if (this.timer) {
-      clearInterval(this.timer);
-      this.timer = null;
-    }
-    if (this.pruneTimer) {
-      clearInterval(this.pruneTimer);
-      this.pruneTimer = null;
-    }
-  }
-  getLastSnapshot() {
-    return { ...this.lastSnapshot };
-  }
-  async collect() {
-    const now = Date.now();
-    const snapshot = {};
-    try {
-      const client = await this.pool.connect();
-      try {
-        const connRes = await client.query(`
-          SELECT
-            count(*) FILTER (WHERE state = 'active')::int AS active,
-            count(*) FILTER (WHERE state = 'idle')::int AS idle,
-            count(*)::int AS total
-          FROM pg_stat_activity
-        `);
-        const conn = connRes.rows[0];
-        snapshot.connections_active = conn.active;
-        snapshot.connections_idle = conn.idle;
-        snapshot.connections_total = conn.total;
-        const dbRes = await client.query(`
-          SELECT
-            xact_commit, xact_rollback, deadlocks, temp_bytes,
-            tup_inserted, tup_updated, tup_deleted,
-            CASE WHEN (blks_hit + blks_read) = 0 THEN 1
-              ELSE blks_hit::float / (blks_hit + blks_read) END AS cache_ratio,
-            pg_database_size(current_database()) AS db_size
-          FROM pg_stat_database WHERE datname = current_database()
-        `);
-        const db = dbRes.rows[0];
-        if (db) {
-          snapshot.cache_hit_ratio = parseFloat(db.cache_ratio);
-          snapshot.db_size_bytes = parseInt(db.db_size);
-          const cur = {
-            timestamp: now,
-            xact_commit: parseInt(db.xact_commit),
-            xact_rollback: parseInt(db.xact_rollback),
-            deadlocks: parseInt(db.deadlocks),
-            temp_bytes: parseInt(db.temp_bytes),
-            tup_inserted: parseInt(db.tup_inserted),
-            tup_updated: parseInt(db.tup_updated),
-            tup_deleted: parseInt(db.tup_deleted)
-          };
-          if (this.prev) {
-            const dtSec = (now - this.prev.timestamp) / 1e3;
-            if (dtSec > 0) {
-              snapshot.tps_commit = Math.max(0, (cur.xact_commit - this.prev.xact_commit) / dtSec);
-              snapshot.tps_rollback = Math.max(0, (cur.xact_rollback - this.prev.xact_rollback) / dtSec);
-              snapshot.deadlocks = Math.max(0, cur.deadlocks - this.prev.deadlocks);
-              snapshot.temp_bytes = Math.max(0, cur.temp_bytes - this.prev.temp_bytes);
-              snapshot.tuple_inserted = Math.max(0, (cur.tup_inserted - this.prev.tup_inserted) / dtSec);
-              snapshot.tuple_updated = Math.max(0, (cur.tup_updated - this.prev.tup_updated) / dtSec);
-              snapshot.tuple_deleted = Math.max(0, (cur.tup_deleted - this.prev.tup_deleted) / dtSec);
-            }
-          }
-          this.prev = cur;
-        }
-        try {
-          const tsRes = await client.query(`SELECT spcname, pg_tablespace_size(oid) AS size FROM pg_tablespace`);
-          let totalTablespaceSize = 0;
-          for (const row of tsRes.rows) {
-            totalTablespaceSize += parseInt(row.size);
-          }
-          if (totalTablespaceSize > 0) {
-            snapshot.disk_used_bytes = totalTablespaceSize;
-          }
-        } catch {
-        }
-        try {
-          const repRes = await client.query(`
-            SELECT CASE WHEN pg_is_in_recovery() 
-              THEN pg_wal_lsn_diff(pg_last_wal_receive_lsn(), pg_last_wal_replay_lsn())
-              ELSE 0 END AS lag_bytes
-          `);
-          snapshot.replication_lag_bytes = parseInt(repRes.rows[0]?.lag_bytes ?? "0");
-        } catch {
-          snapshot.replication_lag_bytes = 0;
-        }
-      } finally {
-        client.release();
-      }
-    } catch (err) {
-      console.error("[collector] Error collecting metrics:", err.message);
-      return snapshot;
-    }
-    this.collectCount++;
-    if (this.collectCount % 10 === 0) {
-      try {
-        const client = await this.pool.connect();
-        try {
-          const tableRes = await client.query(`
-            SELECT schemaname, relname,
-                   pg_total_relation_size(quote_ident(schemaname) || '.' || quote_ident(relname)) as total_size
-            FROM pg_stat_user_tables
-            ORDER BY pg_total_relation_size(quote_ident(schemaname) || '.' || quote_ident(relname)) DESC
-            LIMIT 20
-          `);
-          for (const row of tableRes.rows) {
-            this.store.insert(`table_size:${row.schemaname}.${row.relname}`, parseInt(row.total_size), now);
-          }
-        } finally {
-          client.release();
-        }
-      } catch (err) {
-        console.error("[collector] Error collecting table sizes:", err.message);
-      }
-    }
-    const points = Object.entries(snapshot).map(([metric, value]) => ({
-      timestamp: now,
-      metric,
-      value
-    }));
-    if (points.length > 0) {
-      this.store.insertMany(points);
-    }
-    this.lastSnapshot = snapshot;
-    this.emit("collected", snapshot);
-    return snapshot;
-  }
-};
-
-// src/server/queries/schema.ts
-async function getSchemaTables(pool) {
-  const client = await pool.connect();
-  try {
-    const r = await client.query(`
-      SELECT
-        c.relname AS name,
-        n.nspname AS schema,
-        pg_size_pretty(pg_total_relation_size(c.oid)) AS total_size,
-        pg_total_relation_size(c.oid) AS total_size_bytes,
-        pg_size_pretty(pg_relation_size(c.oid)) AS table_size,
-        pg_size_pretty(pg_total_relation_size(c.oid) - pg_relation_size(c.oid)) AS index_size,
-        s.n_live_tup AS row_count,
-        obj_description(c.oid) AS description
-      FROM pg_class c
-      JOIN pg_namespace n ON c.relnamespace = n.oid
-      LEFT JOIN pg_stat_user_tables s ON s.relid = c.oid
-      WHERE c.relkind = 'r' AND n.nspname NOT IN ('pg_catalog', 'information_schema')
-      ORDER BY pg_total_relation_size(c.oid) DESC
-    `);
-    return r.rows;
-  } finally {
-    client.release();
-  }
-}
-async function getSchemaTableDetail(pool, tableName) {
-  const client = await pool.connect();
-  try {
-    const parts = tableName.split(".");
-    const schema = parts.length > 1 ? parts[0] : "public";
-    const name = parts.length > 1 ? parts[1] : parts[0];
-    const tableInfo = await client.query(`
-      SELECT
-        c.relname AS name, n.nspname AS schema,
-        pg_size_pretty(pg_total_relation_size(c.oid)) AS total_size,
-        pg_size_pretty(pg_relation_size(c.oid)) AS table_size,
-        pg_size_pretty(pg_total_relation_size(c.oid) - pg_relation_size(c.oid)) AS index_size,
-        pg_size_pretty(pg_relation_size(c.reltoastrelid)) AS toast_size,
-        s.n_live_tup AS row_count, s.n_dead_tup AS dead_tuples,
-        s.last_vacuum, s.last_autovacuum, s.last_analyze, s.last_autoanalyze,
-        s.seq_scan, s.idx_scan
-      FROM pg_class c
-      JOIN pg_namespace n ON c.relnamespace = n.oid
-      LEFT JOIN pg_stat_user_tables s ON s.relid = c.oid
-      WHERE c.relname = $1 AND n.nspname = $2 AND c.relkind = 'r'
-    `, [name, schema]);
-    if (tableInfo.rows.length === 0) return null;
-    const columns = await client.query(`
-      SELECT
-        a.attname AS name,
-        pg_catalog.format_type(a.atttypid, a.atttypmod) AS type,
-        NOT a.attnotnull AS nullable,
-        pg_get_expr(d.adbin, d.adrelid) AS default_value,
-        col_description(a.attrelid, a.attnum) AS description
-      FROM pg_attribute a
-      LEFT JOIN pg_attrdef d ON a.attrelid = d.adrelid AND a.attnum = d.adnum
-      WHERE a.attrelid = (SELECT c.oid FROM pg_class c JOIN pg_namespace n ON c.relnamespace = n.oid WHERE c.relname = $1 AND n.nspname = $2)
-        AND a.attnum > 0 AND NOT a.attisdropped
-      ORDER BY a.attnum
-    `, [name, schema]);
-    const indexes = await client.query(`
-      SELECT
-        i.relname AS name,
-        am.amname AS type,
-        pg_size_pretty(pg_relation_size(i.oid)) AS size,
-        pg_get_indexdef(idx.indexrelid) AS definition,
-        idx.indisunique AS is_unique,
-        idx.indisprimary AS is_primary,
-        s.idx_scan, s.idx_tup_read, s.idx_tup_fetch
-      FROM pg_index idx
-      JOIN pg_class i ON idx.indexrelid = i.oid
-      JOIN pg_class t ON idx.indrelid = t.oid
-      JOIN pg_namespace n ON t.relnamespace = n.oid
-      JOIN pg_am am ON i.relam = am.oid
-      LEFT JOIN pg_stat_user_indexes s ON s.indexrelid = i.oid
-      WHERE t.relname = $1 AND n.nspname = $2
-      ORDER BY i.relname
-    `, [name, schema]);
-    const constraints = await client.query(`
-      SELECT
-        conname AS name,
-        CASE contype WHEN 'p' THEN 'PRIMARY KEY' WHEN 'f' THEN 'FOREIGN KEY'
-          WHEN 'u' THEN 'UNIQUE' WHEN 'c' THEN 'CHECK' WHEN 'x' THEN 'EXCLUDE' END AS type,
-        pg_get_constraintdef(oid) AS definition
-      FROM pg_constraint
-      WHERE conrelid = (SELECT c.oid FROM pg_class c JOIN pg_namespace n ON c.relnamespace = n.oid WHERE c.relname = $1 AND n.nspname = $2)
-      ORDER BY
-        CASE contype WHEN 'p' THEN 1 WHEN 'u' THEN 2 WHEN 'f' THEN 3 WHEN 'c' THEN 4 ELSE 5 END
-    `, [name, schema]);
-    const foreignKeys = await client.query(`
-      SELECT
-        conname AS name,
-        a.attname AS column_name,
-        confrelid::regclass::text AS referenced_table,
-        af.attname AS referenced_column
-      FROM pg_constraint c
-      JOIN pg_attribute a ON a.attrelid = c.conrelid AND a.attnum = ANY(c.conkey)
-      JOIN pg_attribute af ON af.attrelid = c.confrelid AND af.attnum = ANY(c.confkey)
-      WHERE c.contype = 'f'
-        AND c.conrelid = (SELECT cl.oid FROM pg_class cl JOIN pg_namespace n ON cl.relnamespace = n.oid WHERE cl.relname = $1 AND n.nspname = $2)
-    `, [name, schema]);
-    let sampleData = [];
-    try {
-      const sample = await client.query(
-        `SELECT * FROM ${client.escapeIdentifier(schema)}.${client.escapeIdentifier(name)} LIMIT 10`
-      );
-      sampleData = sample.rows;
-    } catch (err) {
-      console.error("[schema] Error:", err.message);
+    lines.push(``);
+    lines.push(`| | Score | Grade |`);
+    lines.push(`|--|-------|-------|`);
+    lines.push(`| Source | ${h.source.score}/100 | ${h.source.grade} |`);
+    lines.push(`| Target | ${h.target.score}/100 | ${h.target.grade} |`);
+    if (h.targetOnlyIssues.length > 0) {
+      lines.push(``);
+      lines.push(`**Target-only issues:**`);
+      for (const iss of h.targetOnlyIssues) lines.push(`- ${iss}`);
+    }
+    if (h.sourceOnlyIssues.length > 0) {
+      lines.push(``);
+      lines.push(`**Source-only issues:**`);
+      for (const iss of h.sourceOnlyIssues) lines.push(`- ${iss}`);
     }
-    return {
-      ...tableInfo.rows[0],
-      columns: columns.rows,
-      indexes: indexes.rows,
-      constraints: constraints.rows,
-      foreignKeys: foreignKeys.rows,
-      sampleData
-    };
-  } finally {
-    client.release();
   }
+  lines.push(``);
+  const { schemaDrifts, identical } = result.summary;
+  lines.push(`**Result: ${schemaDrifts} drift${schemaDrifts !== 1 ? "s" : ""} \u2014 environments are ${identical ? "in sync \u2713" : "NOT in sync"}**`);
+  return lines.join("\n");
 }
-async function getSchemaIndexes(pool) {
+var init_env_differ = __esm({
+  "src/server/env-differ.ts"() {
+    "use strict";
+    init_advisor();
+    init_schema_tracker();
+    init_schema_diff();
+  }
+});
+
+// src/cli.ts
+import { parseArgs } from "util";
+
+// src/server/index.ts
+import { Hono } from "hono";
+import path3 from "path";
+import fs3 from "fs";
+import os3 from "os";
+import { fileURLToPath } from "url";
+import { Pool } from "pg";
+
+// src/server/queries/overview.ts
+async function getOverview(pool) {
   const client = await pool.connect();
   try {
-    const r = await client.query(`
+    const version = await client.query("SHOW server_version");
+    const uptime = await client.query(
+      `SELECT to_char(now() - pg_postmaster_start_time(), 'DD "d" HH24 "h" MI "m"') AS uptime`
+    );
+    const dbSize = await client.query(
+      "SELECT pg_size_pretty(pg_database_size(current_database())) AS size"
+    );
+    const dbCount = await client.query(
+      "SELECT count(*)::int AS count FROM pg_database WHERE NOT datistemplate"
+    );
+    const connections = await client.query(`
       SELECT
-        n.nspname AS schema,
-        t.relname AS table_name,
-        i.relname AS name,
-        am.amname AS type,
-        pg_size_pretty(pg_relation_size(i.oid)) AS size,
-        pg_relation_size(i.oid) AS size_bytes,
-        pg_get_indexdef(idx.indexrelid) AS definition,
-        idx.indisunique AS is_unique,
-        idx.indisprimary AS is_primary,
-        s.idx_scan, s.idx_tup_read, s.idx_tup_fetch
-      FROM pg_index idx
-      JOIN pg_class i ON idx.indexrelid = i.oid
-      JOIN pg_class t ON idx.indrelid = t.oid
-      JOIN pg_namespace n ON t.relnamespace = n.oid
-      JOIN pg_am am ON i.relam = am.oid
-      LEFT JOIN pg_stat_user_indexes s ON s.indexrelid = i.oid
-      WHERE n.nspname NOT IN ('pg_catalog', 'information_schema')
-      ORDER BY pg_relation_size(i.oid) DESC
+        (SELECT count(*)::int FROM pg_stat_activity WHERE state = 'active') AS active,
+        (SELECT count(*)::int FROM pg_stat_activity WHERE state = 'idle') AS idle,
+        (SELECT setting::int FROM pg_settings WHERE name = 'max_connections') AS max
     `);
-    return r.rows;
+    return {
+      version: version.rows[0].server_version,
+      uptime: uptime.rows[0].uptime,
+      dbSize: dbSize.rows[0].size,
+      databaseCount: dbCount.rows[0].count,
+      connections: connections.rows[0]
+    };
   } finally {
     client.release();
   }
 }
-async function getSchemaFunctions(pool) {
+
+// src/server/queries/databases.ts
+async function getDatabases(pool) {
   const client = await pool.connect();
   try {
     const r = await client.query(`
-      SELECT
-        n.nspname AS schema,
-        p.proname AS name,
-        pg_get_function_result(p.oid) AS return_type,
-        pg_get_function_arguments(p.oid) AS arguments,
-        l.lanname AS language,
-        p.prosrc AS source,
-        CASE p.prokind WHEN 'f' THEN 'function' WHEN 'p' THEN 'procedure' WHEN 'a' THEN 'aggregate' WHEN 'w' THEN 'window' END AS kind
-      FROM pg_proc p
-      JOIN pg_namespace n ON p.pronamespace = n.oid
-      JOIN pg_language l ON p.prolang = l.oid
-      WHERE n.nspname NOT IN ('pg_catalog', 'information_schema')
-      ORDER BY n.nspname, p.proname
+      SELECT datname AS name,
+        pg_size_pretty(pg_database_size(datname)) AS size,
+        pg_database_size(datname) AS size_bytes
+      FROM pg_database
+      WHERE NOT datistemplate
+      ORDER BY pg_database_size(datname) DESC
     `);
     return r.rows;
   } finally {
     client.release();
   }
 }
-async function getSchemaExtensions(pool) {
+
+// src/server/queries/tables.ts
+async function getTables(pool) {
   const client = await pool.connect();
   try {
     const r = await client.query(`
-      SELECT extname AS name, extversion AS installed_version,
-        n.nspname AS schema, obj_description(e.oid) AS description
-      FROM pg_extension e
-      JOIN pg_namespace n ON e.extnamespace = n.oid
-      ORDER BY extname
+      SELECT
+        schemaname AS schema,
+        relname AS name,
+        pg_size_pretty(pg_total_relation_size(relid)) AS total_size,
+        pg_total_relation_size(relid) AS size_bytes,
+        n_live_tup AS rows,
+        n_dead_tup AS dead_tuples,
+        CASE WHEN n_live_tup > 0 
+          THEN round(n_dead_tup::numeric / n_live_tup * 100, 1) 
+          ELSE 0 END AS dead_pct
+      FROM pg_stat_user_tables
+      ORDER BY pg_total_relation_size(relid) DESC
     `);
     return r.rows;
   } finally {
     client.release();
   }
 }
-async function getSchemaEnums(pool) {
+
+// src/server/queries/activity.ts
+async function getActivity(pool) {
   const client = await pool.connect();
   try {
     const r = await client.query(`
       SELECT
-        t.typname AS name,
-        n.nspname AS schema,
-        array_agg(e.enumlabel ORDER BY e.enumsortorder) AS values
-      FROM pg_type t
-      JOIN pg_namespace n ON t.typnamespace = n.oid
-      JOIN pg_enum e ON t.oid = e.enumtypid
-      WHERE n.nspname NOT IN ('pg_catalog', 'information_schema')
-      GROUP BY t.typname, n.nspname
-      ORDER BY t.typname
-    `);
-    return r.rows;
-  } finally {
-    client.release();
-  }
-}
-
-// src/server/schema-diff.ts
-function diffSnapshots(oldSnap, newSnap) {
-  const changes = [];
-  const oldTableMap = new Map(oldSnap.tables.map((t) => [`${t.schema}.${t.name}`, t]));
-  const newTableMap = new Map(newSnap.tables.map((t) => [`${t.schema}.${t.name}`, t]));
-  for (const [key, t] of newTableMap) {
-    if (!oldTableMap.has(key)) {
-      changes.push({ change_type: "added", object_type: "table", table_name: key, detail: `Table ${key} added` });
-    }
-  }
-  for (const [key] of oldTableMap) {
-    if (!newTableMap.has(key)) {
-      changes.push({ change_type: "removed", object_type: "table", table_name: key, detail: `Table ${key} removed` });
-    }
-  }
-  for (const [key, newTable] of newTableMap) {
-    const oldTable = oldTableMap.get(key);
-    if (!oldTable) continue;
-    const oldCols = new Map(oldTable.columns.map((c) => [c.name, c]));
-    const newCols = new Map(newTable.columns.map((c) => [c.name, c]));
-    for (const [name, col] of newCols) {
-      const oldCol = oldCols.get(name);
-      if (!oldCol) {
-        changes.push({ change_type: "added", object_type: "column", table_name: key, detail: `Column ${name} added (${col.type})` });
-      } else {
-        if (oldCol.type !== col.type) {
-          changes.push({ change_type: "modified", object_type: "column", table_name: key, detail: `Column ${name} type changed: ${oldCol.type} \u2192 ${col.type}` });
-        }
-        if (oldCol.nullable !== col.nullable) {
-          changes.push({ change_type: "modified", object_type: "column", table_name: key, detail: `Column ${name} nullable changed: ${oldCol.nullable} \u2192 ${col.nullable}` });
-        }
-        if (oldCol.default_value !== col.default_value) {
-          changes.push({ change_type: "modified", object_type: "column", table_name: key, detail: `Column ${name} default changed: ${oldCol.default_value ?? "NULL"} \u2192 ${col.default_value ?? "NULL"}` });
-        }
-      }
-    }
-    for (const name of oldCols.keys()) {
-      if (!newCols.has(name)) {
-        changes.push({ change_type: "removed", object_type: "column", table_name: key, detail: `Column ${name} removed` });
-      }
-    }
-    const oldIdx = new Map(oldTable.indexes.map((i) => [i.name, i]));
-    const newIdx = new Map(newTable.indexes.map((i) => [i.name, i]));
-    for (const [name, idx] of newIdx) {
-      if (!oldIdx.has(name)) {
-        changes.push({ change_type: "added", object_type: "index", table_name: key, detail: `Index ${name} added` });
-      } else if (oldIdx.get(name).definition !== idx.definition) {
-        changes.push({ change_type: "modified", object_type: "index", table_name: key, detail: `Index ${name} definition changed` });
-      }
-    }
-    for (const name of oldIdx.keys()) {
-      if (!newIdx.has(name)) {
-        changes.push({ change_type: "removed", object_type: "index", table_name: key, detail: `Index ${name} removed` });
-      }
-    }
-    const oldCon = new Map(oldTable.constraints.map((c) => [c.name, c]));
-    const newCon = new Map(newTable.constraints.map((c) => [c.name, c]));
-    for (const [name, con] of newCon) {
-      if (!oldCon.has(name)) {
-        changes.push({ change_type: "added", object_type: "constraint", table_name: key, detail: `Constraint ${name} added (${con.type})` });
-      } else if (oldCon.get(name).definition !== con.definition) {
-        changes.push({ change_type: "modified", object_type: "constraint", table_name: key, detail: `Constraint ${name} definition changed` });
-      }
-    }
-    for (const name of oldCon.keys()) {
-      if (!newCon.has(name)) {
-        changes.push({ change_type: "removed", object_type: "constraint", table_name: key, detail: `Constraint ${name} removed` });
-      }
-    }
-  }
-  const oldEnums = new Map((oldSnap.enums || []).map((e) => [`${e.schema}.${e.name}`, e]));
-  const newEnums = new Map((newSnap.enums || []).map((e) => [`${e.schema}.${e.name}`, e]));
-  for (const [key, en] of newEnums) {
-    const oldEn = oldEnums.get(key);
-    if (!oldEn) {
-      changes.push({ change_type: "added", object_type: "enum", table_name: null, detail: `Enum ${key} added (${en.values.join(", ")})` });
-    } else {
-      const added = en.values.filter((v) => !oldEn.values.includes(v));
-      const removed = oldEn.values.filter((v) => !en.values.includes(v));
-      for (const v of added) {
-        changes.push({ change_type: "modified", object_type: "enum", table_name: null, detail: `Enum ${key}: value '${v}' added` });
-      }
-      for (const v of removed) {
-        changes.push({ change_type: "modified", object_type: "enum", table_name: null, detail: `Enum ${key}: value '${v}' removed` });
-      }
-    }
-  }
-  for (const key of oldEnums.keys()) {
-    if (!newEnums.has(key)) {
-      changes.push({ change_type: "removed", object_type: "enum", table_name: null, detail: `Enum ${key} removed` });
-    }
+        pid,
+        COALESCE(query, '') AS query,
+        COALESCE(state, 'unknown') AS state,
+        wait_event,
+        wait_event_type,
+        CASE WHEN state = 'active' THEN (now() - query_start)::text
+             WHEN state = 'idle in transaction' THEN (now() - state_change)::text
+             ELSE NULL END AS duration,
+        client_addr::text,
+        COALESCE(application_name, '') AS application_name,
+        backend_start::text
+      FROM pg_stat_activity
+      WHERE pid != pg_backend_pid()
+        AND state IS NOT NULL
+      ORDER BY
+        CASE state
+          WHEN 'active' THEN 1
+          WHEN 'idle in transaction' THEN 2
+          ELSE 3
+        END,
+        query_start ASC NULLS LAST
+    `);
+    return r.rows;
+  } finally {
+    client.release();
   }
-  return changes;
 }
 
-// src/server/schema-tracker.ts
-var SchemaTracker = class {
+// src/server/index.ts
+init_advisor();
+
+// src/server/timeseries.ts
+import Database2 from "better-sqlite3";
+import path2 from "path";
+import os2 from "os";
+import fs2 from "fs";
+var DEFAULT_DIR = path2.join(os2.homedir(), ".pg-dash");
+var DEFAULT_RETENTION_DAYS = 7;
+var TimeseriesStore = class {
   db;
-  pool;
-  intervalMs;
-  timer = null;
-  constructor(db, pool, intervalMs = 6 * 60 * 60 * 1e3) {
-    this.db = db;
-    this.pool = pool;
-    this.intervalMs = intervalMs;
-    this.initTables();
-  }
-  initTables() {
+  insertStmt;
+  retentionMs;
+  constructor(dbOrDir, retentionDays = DEFAULT_RETENTION_DAYS) {
+    if (dbOrDir instanceof Database2) {
+      this.db = dbOrDir;
+    } else {
+      const dir = dbOrDir || DEFAULT_DIR;
+      fs2.mkdirSync(dir, { recursive: true });
+      const dbPath = path2.join(dir, "metrics.db");
+      this.db = new Database2(dbPath);
+    }
+    this.retentionMs = retentionDays * 24 * 60 * 60 * 1e3;
+    this.db.pragma("journal_mode = WAL");
     this.db.exec(`
-      CREATE TABLE IF NOT EXISTS schema_snapshots (
-        id INTEGER PRIMARY KEY AUTOINCREMENT,
-        timestamp INTEGER NOT NULL,
-        snapshot TEXT NOT NULL
-      );
-      CREATE TABLE IF NOT EXISTS schema_changes (
-        id INTEGER PRIMARY KEY AUTOINCREMENT,
-        snapshot_id INTEGER NOT NULL,
+      CREATE TABLE IF NOT EXISTS metrics (
         timestamp INTEGER NOT NULL,
-        change_type TEXT NOT NULL,
-        object_type TEXT NOT NULL,
-        table_name TEXT,
-        detail TEXT NOT NULL,
-        FOREIGN KEY (snapshot_id) REFERENCES schema_snapshots(id)
+        metric TEXT NOT NULL,
+        value REAL NOT NULL
       );
+      CREATE INDEX IF NOT EXISTS idx_metrics_metric_ts ON metrics(metric, timestamp);
     `);
+    this.insertStmt = this.db.prepare(
+      "INSERT INTO metrics (timestamp, metric, value) VALUES (?, ?, ?)"
+    );
   }
-  async takeSnapshot() {
-    const snapshot = await this.buildSnapshot();
-    const now = Date.now();
-    const json = JSON.stringify(snapshot);
-    const info = this.db.prepare("INSERT INTO schema_snapshots (timestamp, snapshot) VALUES (?, ?)").run(now, json);
-    const snapshotId = Number(info.lastInsertRowid);
-    const prev = this.db.prepare("SELECT snapshot FROM schema_snapshots WHERE id < ? ORDER BY id DESC LIMIT 1").get(snapshotId);
-    let changes = [];
-    if (prev) {
-      const oldSnap = JSON.parse(prev.snapshot);
-      changes = diffSnapshots(oldSnap, snapshot);
-      if (changes.length > 0) {
-        const insert = this.db.prepare("INSERT INTO schema_changes (snapshot_id, timestamp, change_type, object_type, table_name, detail) VALUES (?, ?, ?, ?, ?, ?)");
-        const tx = this.db.transaction((chs) => {
-          for (const c of chs) {
-            insert.run(snapshotId, now, c.change_type, c.object_type, c.table_name, c.detail);
-          }
-        });
-        tx(changes);
+  insert(metric, value, timestamp) {
+    this.insertStmt.run(timestamp ?? Date.now(), metric, value);
+  }
+  insertMany(points) {
+    const tx = this.db.transaction((pts) => {
+      for (const p of pts) {
+        this.insertStmt.run(p.timestamp, p.metric, p.value);
       }
+    });
+    tx(points);
+  }
+  query(metric, startMs, endMs) {
+    const end = endMs ?? Date.now();
+    return this.db.prepare(
+      "SELECT timestamp, value FROM metrics WHERE metric = ? AND timestamp >= ? AND timestamp <= ? ORDER BY timestamp"
+    ).all(metric, startMs, end);
+  }
+  latest(metrics) {
+    const result = {};
+    if (metrics && metrics.length > 0) {
+      const placeholders = metrics.map(() => "?").join(",");
+      const rows = this.db.prepare(
+        `SELECT m.metric, m.timestamp, m.value FROM metrics m INNER JOIN (SELECT metric, MAX(timestamp) as max_ts FROM metrics WHERE metric IN (${placeholders}) GROUP BY metric) g ON m.metric = g.metric AND m.timestamp = g.max_ts`
+      ).all(...metrics);
+      for (const r of rows) result[r.metric] = { timestamp: r.timestamp, value: r.value };
+    } else {
+      const rows = this.db.prepare(
+        "SELECT m.metric, m.timestamp, m.value FROM metrics m INNER JOIN (SELECT metric, MAX(timestamp) as max_ts FROM metrics GROUP BY metric) g ON m.metric = g.metric AND m.timestamp = g.max_ts"
+      ).all();
+      for (const r of rows) result[r.metric] = { timestamp: r.timestamp, value: r.value };
     }
-    return { snapshotId, changes };
-  }
-  async buildSnapshot() {
-    const tables = await getSchemaTables(this.pool);
-    const enums = await getSchemaEnums(this.pool);
-    const detailedTables = await Promise.all(
-      tables.map(async (t) => {
-        const detail = await getSchemaTableDetail(this.pool, `${t.schema}.${t.name}`);
-        if (!detail) return null;
-        return {
-          name: detail.name,
-          schema: detail.schema,
-          columns: detail.columns.map((c) => ({
-            name: c.name,
-            type: c.type,
-            nullable: c.nullable,
-            default_value: c.default_value
-          })),
-          indexes: detail.indexes.map((i) => ({
-            name: i.name,
-            definition: i.definition,
-            is_unique: i.is_unique,
-            is_primary: i.is_primary
-          })),
-          constraints: detail.constraints.map((c) => ({
-            name: c.name,
-            type: c.type,
-            definition: c.definition
-          }))
-        };
-      })
-    );
-    return {
-      tables: detailedTables.filter(Boolean),
-      enums: enums.map((e) => ({ name: e.name, schema: e.schema, values: e.values }))
-    };
+    return result;
+  }
+  prune() {
+    const cutoff = Date.now() - this.retentionMs;
+    const info = this.db.prepare("DELETE FROM metrics WHERE timestamp < ?").run(cutoff);
+    return info.changes;
+  }
+  close() {
+    this.db.close();
+  }
+};
+
+// src/server/collector.ts
+import { EventEmitter } from "events";
+var Collector = class extends EventEmitter {
+  constructor(pool, store, intervalMs = 3e4) {
+    super();
+    this.pool = pool;
+    this.store = store;
+    this.intervalMs = intervalMs;
   }
+  timer = null;
+  pruneTimer = null;
+  prev = null;
+  lastSnapshot = {};
+  collectCount = 0;
   start() {
-    this.takeSnapshot().catch((err) => console.error("Schema snapshot error:", err.message));
+    this.collect().catch((err) => console.error("[collector] Initial collection failed:", err));
     this.timer = setInterval(() => {
-      this.takeSnapshot().catch((err) => console.error("Schema snapshot error:", err.message));
+      this.collect().catch((err) => console.error("[collector] Collection failed:", err));
     }, this.intervalMs);
+    this.pruneTimer = setInterval(() => this.store.prune(), 60 * 60 * 1e3);
   }
   stop() {
     if (this.timer) {
       clearInterval(this.timer);
       this.timer = null;
     }
-  }
-  // API helpers
-  getHistory(limit = 30) {
-    return this.db.prepare("SELECT id, timestamp FROM schema_snapshots ORDER BY id DESC LIMIT ?").all(limit);
-  }
-  getChanges(since) {
-    if (since) {
-      return this.db.prepare("SELECT * FROM schema_changes WHERE timestamp >= ? ORDER BY timestamp DESC").all(since);
+    if (this.pruneTimer) {
+      clearInterval(this.pruneTimer);
+      this.pruneTimer = null;
     }
-    return this.db.prepare("SELECT * FROM schema_changes ORDER BY timestamp DESC LIMIT 100").all();
   }
-  getLatestChanges() {
-    const latest = this.db.prepare("SELECT id FROM schema_snapshots ORDER BY id DESC LIMIT 1").get();
-    if (!latest) return [];
-    return this.db.prepare("SELECT * FROM schema_changes WHERE snapshot_id = ? ORDER BY id").all(latest.id);
+  getLastSnapshot() {
+    return { ...this.lastSnapshot };
   }
-  getDiff(fromId, toId) {
-    const from = this.db.prepare("SELECT snapshot FROM schema_snapshots WHERE id = ?").get(fromId);
-    const to = this.db.prepare("SELECT snapshot FROM schema_snapshots WHERE id = ?").get(toId);
-    if (!from || !to) return null;
-    return diffSnapshots(JSON.parse(from.snapshot), JSON.parse(to.snapshot));
+  async collect() {
+    const now = Date.now();
+    const snapshot = {};
+    try {
+      const client = await this.pool.connect();
+      try {
+        const connRes = await client.query(`
+          SELECT
+            count(*) FILTER (WHERE state = 'active')::int AS active,
+            count(*) FILTER (WHERE state = 'idle')::int AS idle,
+            count(*)::int AS total
+          FROM pg_stat_activity
+        `);
+        const conn = connRes.rows[0];
+        snapshot.connections_active = conn.active;
+        snapshot.connections_idle = conn.idle;
+        snapshot.connections_total = conn.total;
+        const dbRes = await client.query(`
+          SELECT
+            xact_commit, xact_rollback, deadlocks, temp_bytes,
+            tup_inserted, tup_updated, tup_deleted,
+            CASE WHEN (blks_hit + blks_read) = 0 THEN 1
+              ELSE blks_hit::float / (blks_hit + blks_read) END AS cache_ratio,
+            pg_database_size(current_database()) AS db_size
+          FROM pg_stat_database WHERE datname = current_database()
+        `);
+        const db = dbRes.rows[0];
+        if (db) {
+          snapshot.cache_hit_ratio = parseFloat(db.cache_ratio);
+          snapshot.db_size_bytes = parseInt(db.db_size);
+          const cur = {
+            timestamp: now,
+            xact_commit: parseInt(db.xact_commit),
+            xact_rollback: parseInt(db.xact_rollback),
+            deadlocks: parseInt(db.deadlocks),
+            temp_bytes: parseInt(db.temp_bytes),
+            tup_inserted: parseInt(db.tup_inserted),
+            tup_updated: parseInt(db.tup_updated),
+            tup_deleted: parseInt(db.tup_deleted)
+          };
+          if (this.prev) {
+            const dtSec = (now - this.prev.timestamp) / 1e3;
+            if (dtSec > 0) {
+              snapshot.tps_commit = Math.max(0, (cur.xact_commit - this.prev.xact_commit) / dtSec);
+              snapshot.tps_rollback = Math.max(0, (cur.xact_rollback - this.prev.xact_rollback) / dtSec);
+              snapshot.deadlocks = Math.max(0, cur.deadlocks - this.prev.deadlocks);
+              snapshot.temp_bytes = Math.max(0, cur.temp_bytes - this.prev.temp_bytes);
+              snapshot.tuple_inserted = Math.max(0, (cur.tup_inserted - this.prev.tup_inserted) / dtSec);
+              snapshot.tuple_updated = Math.max(0, (cur.tup_updated - this.prev.tup_updated) / dtSec);
+              snapshot.tuple_deleted = Math.max(0, (cur.tup_deleted - this.prev.tup_deleted) / dtSec);
+            }
+          }
+          this.prev = cur;
+        }
+        try {
+          const tsRes = await client.query(`SELECT spcname, pg_tablespace_size(oid) AS size FROM pg_tablespace`);
+          let totalTablespaceSize = 0;
+          for (const row of tsRes.rows) {
+            totalTablespaceSize += parseInt(row.size);
+          }
+          if (totalTablespaceSize > 0) {
+            snapshot.disk_used_bytes = totalTablespaceSize;
+          }
+        } catch {
+        }
+        try {
+          const repRes = await client.query(`
+            SELECT CASE WHEN pg_is_in_recovery() 
+              THEN pg_wal_lsn_diff(pg_last_wal_receive_lsn(), pg_last_wal_replay_lsn())
+              ELSE 0 END AS lag_bytes
+          `);
+          snapshot.replication_lag_bytes = parseInt(repRes.rows[0]?.lag_bytes ?? "0");
+        } catch {
+          snapshot.replication_lag_bytes = 0;
+        }
+      } finally {
+        client.release();
+      }
+    } catch (err) {
+      console.error("[collector] Error collecting metrics:", err.message);
+      return snapshot;
+    }
+    this.collectCount++;
+    if (this.collectCount % 10 === 0) {
+      try {
+        const client = await this.pool.connect();
+        try {
+          const tableRes = await client.query(`
+            SELECT schemaname, relname,
+                   pg_total_relation_size(quote_ident(schemaname) || '.' || quote_ident(relname)) as total_size
+            FROM pg_stat_user_tables
+            ORDER BY pg_total_relation_size(quote_ident(schemaname) || '.' || quote_ident(relname)) DESC
+            LIMIT 20
+          `);
+          for (const row of tableRes.rows) {
+            this.store.insert(`table_size:${row.schemaname}.${row.relname}`, parseInt(row.total_size), now);
+          }
+        } finally {
+          client.release();
+        }
+      } catch (err) {
+        console.error("[collector] Error collecting table sizes:", err.message);
+      }
+    }
+    const points = Object.entries(snapshot).map(([metric, value]) => ({
+      timestamp: now,
+      metric,
+      value
+    }));
+    if (points.length > 0) {
+      this.store.insertMany(points);
+    }
+    this.lastSnapshot = snapshot;
+    this.emit("collected", snapshot);
+    return snapshot;
   }
 };
 
+// src/server/index.ts
+init_schema_tracker();
+
 // src/server/notifiers.ts
 var SEVERITY_COLORS = {
   critical: { hex: "#e74c3c", decimal: 15158332, emoji: "\u{1F534}" },
@@ -2648,6 +2799,7 @@ function registerAdvisorRoutes(app, pool, longQueryThreshold, store) {
 }
 
 // src/server/routes/schema.ts
+init_schema();
 function registerSchemaRoutes(app, pool, schemaTracker) {
   app.get("/api/schema/tables", async (c) => {
     try {
@@ -4185,6 +4337,14 @@ Migration check: ${filePath}`);
             console.log(`::notice::diff-env: target has extra index: ${id.table}.${idx}`);
           }
         }
+        for (const c of result.schema.constraintDiffs ?? []) {
+          const level = c.type === "missing" ? "error" : c.type === "extra" ? "notice" : "warning";
+          console.log(`::${level}::diff-env: constraint ${c.type}: ${c.detail}`);
+        }
+        for (const e of result.schema.enumDiffs ?? []) {
+          const level = e.type === "missing" ? "error" : e.type === "extra" ? "notice" : "warning";
+          console.log(`::${level}::diff-env: enum ${e.type}: ${e.detail}`);
+        }
       }
     }
     process.exit(result.summary.identical ? 0 : 1);